Re: Ada 'hello world' for Android; success!

[Stephen Leake <stephen_leake@stephe-leake.org>]

Georg Bauhaus <rm.dash-bauhaus@futureapps.de> writes:

> On 29.10.11 15:37, Stephen Leake wrote:
>> Anatoly Chernyshev<achernyshev@gmail.com>  writes:
>>
>>> Looks like a Pyrrhic victory to me. All elegance of Ada is suddenly
>>> dissipated.
>>
>> I gather you feel that Android is inelegant in some way; can you be more
>> specific?
>
> The example is a little non-Ada, IMHO. 

In one sense, any trivial program is non-Ada, since Ada is meant for
complexity :).

> I don't know Anatoly's reasons, but to me the example has an air of
> "Fortran in any language", except that one has to replace Fortran with
> pointers or Java-with-covers-removed, viz. explicit access A.B.C.Typ
> all over the place.

Part of that is style. In examples like this, I tend to not use 'use',
to make it very clear what is going on.

But most of the "non-Ada" feel comes from the fact that it is a GUI
program. 

Interestingly, I could not find a true GUI hello world example for Gtk;
'hello world' in the Gtk tutorial uses Ada.Text_IO.Put_Line!

Here's Qt:

with Qt_Ada.Application;
with Qt4.Push_Buttons.Constructors;
with Qt4.Strings;

procedure Main is
begin
   Qt_Ada.Application.Initialize;

   declare
      Hello : constant not null access Qt4.Push_Buttons.Q_Push_Button'Class
        := Qt4.Push_Buttons.Constructors.Create
            (Qt4.Strings.From_Utf_16 ("Hello world!"));

   begin
      Hello.Resize (100, 30);
      Hello.Show;
      Qt_Ada.Application.Execute;
   end;
end Main;

The string 'hello world' is actually present in this source; it is not
in my example. As I said, that's because I plan to use the 'resource'
features of Android; that's how internationalization is implemented. I'm
not clear how Qt does internationalization. 

> FWIW, the programs I have once written using SofCheck's version
> of Ada on JVMs looked and felt more like Ada and a less
> like explicit anonymous pointer to A.B.C.Typ everywhere.
> Note that the thorny appearance of the HelloWorld example
> isn't present in Java, which allows O-O without forcing
> the programmers to write pointers, pointers, pointers.

Here's the Java source for 'hello world':

package com.example.helloandroid;

import android.app.Activity;
import android.os.Bundle;

public class HelloAndroid extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

And here is the Ada version (just the package body):

package body Hello is

   overriding procedure OnCreate
     (This               : access Typ;
      savedInstanceState : access Standard.Android.Os.Bundle.Typ'class)
   is
      type Super_Ref is access all Android.App.Activity.Typ;
   begin
      Android.App.Activity.Oncreate (Super_Ref (This), savedInstanceState);

      Android.App.Activity.SetContentView (Android.App.Activity.Ref (This), 16#7f030000#);
   end OnCreate;

end Hello;

By defintion, every non-scalar type in Java _is_ a pointer; Bundle and
'this' are pointers. The fact that the code doesn't say 'access' just
hides that fact. Java also hides the existence of 'this'. Making those
features explicit is definitely the Ada way. So I don't think the Ada
version is "non-Ada" because it uses pointers!

We could try to define "Typ" to be an access type, so the words "access"
would be replaced by "in" above. That issue has been discussed elsewhere
(for my take on it, see
http://www.stephe-leake.org/ada/access_vs_object.html). 

In brief, _any_ framework that uses dispatching on class-wide
objects needs reference semantics. In Ada, that is indicated by the
explicit word 'access'. In Java, it is implicit. I prefer explicit.

> BTW, is it possible in the Android model to have an
> equivalent of Ada's
>
>    procedure Op (This : access constant Typ);
>
> where a programmer can state the intent of read-only
> access?

Certainly, as long as all uses of This treat it that way. 

However, since Java lacks this feature, none of the imported Android
APIs will have the 'constant' keyword. It would be possible (but
error-prone and tedious) to add 'constant' in appropriate places in the
generated API; that would make the system better. It might even be worth
adding a feature to jvm2ada to automate that, given a hand-generated
list of subprogram args that should be labeled 'constant'. The hard part
would be figuring out if a particular argument is in fact treated as a
constant.

> Is the traditional O-O model of Ada impossible to support
> in a compiler for Android devices or is it just that no one
> is paying for such a compiler? 

I don't know what you mean. The Ada I'm using is fully Ada 2005
compliant. Any 'non-OO'ness you see is because of the Android design,
not because of the compiler.

> So that the best we can do is juggle the pointers that the other
> languages can hide?

Yes. And as I said above, that's a Good Thing.

-- 
-- Stephe