Portable GUI (was Re: Future with Ada)

["Mark Lundquist" <no.spam@getalife.com>]

"Marin David Condic" <dont.bother.mcondic.auntie.spam@[acm.org> wrote in
message news:9vdo2a$9h3$1@nh.pace.co.uk...
>
> I mentioned elsewhere the notion that if there were some flavor of an XML
> doohickie out there for Ada that it might be possible to use that as the
> basis for a portable, standard GUI
>

Not sure exactly what you mean by an "XML doohickie" :-), but I'd be
thinkin' something along these lines:

1) First, you write your native Ada GUI library.  This is the hard part.
Make it the very best thing you can make.  Also let it be configurable with
traits that allow it to emulate Windows-like or Motif-like LAF.

2) Next, write an XML schema to define GUI layout in terms of the primitives
that map to those of your portable GUI.  It wouldn't hurt if (1) were done
with a view to (2).  Now, you have a way for GUIs to be represented as XML
documents, instead of encoded in program source code.

3) Now we need a way for your applications to talk to these GUIs.  First
step is to define a simple object model to ride on top of some middleware:
CORBA and/or SOAP and/or Bonobo...  The semantic level of this layer is what
is left after abstracting away from all the details of appearance, layout,
perhaps even some choices of controls, etc... that are now all loaded into
the XML representation.

4) We also need a way to render the GUIs, and so we write an XML browser (in
Ada, of course) to interpret the schema.  This is trivial, since the schema
is just an XML oil-slick over the native portable Ada GUI (1).  This
component brings together (1), (2), and (3).  It's a standalone executable.
Start with Windows and Linux.

5) Write/generate the bindings to (3) in every popular language that knows
how to talk to the middleware options you support.  So now you can offer a
platform-independent GUI for C++, Perl, Python, Ada of course, and even Java
for those who find compelling advantages in this GUI over Swing (and there
would be some advantages, I think).

6) While you're at it, write a GUI-builder.  It's target-language
independent, because it doesn't have to generate program source code, only
XML and IDL (or whatever).

7) Now take what we've done, and hype the living daylights out of it, while
preserving our dignity (we might need that later on).  Sell it at a modest
price to every cross-platform developer in the world.  Get written up in all
the trendy industry rags (cover stories of course). Win a Jolt award.  Get
the schema recommended as a W3C standard. Go public.

8) Let it slip that it has "Ada inside".

9) Developers everywhere become interested in the technology behind this
wonderful creation, the killer mini-app for Ada.  They discover the joy of
programming in Ada, the new high-performance language for the '00's (you
know... what comes after the '80's and the '90's).  Ada takes over the
world.

10) In the process, people discover that the XML GUI rendering engine is
nothing but a front-end to the standard Ada native GUI library and that 98%
of the work to duplicate it would be done for them because it's just
plumbing together things from the Ada foundation library.  The jig is up.
Exercise stock options now.  The free knockoffs start to appear, but that's
OK because we knew it was coming.  Move while you still control mindshare,
and release your source code under an open source license, thereby becoming
the world's great benefactor.  Restructure the business model around support
and consulting services.

11) Now we can either (a) spend most of our time sailing in the Caribbean,
or (b) take one of the many cushy jobs that await us now that Ada has
conquered.


Whoops, I left out a step... Step (0), find an investor to $upport us while
we do the work...

:-) :-) :-)
-- mark

-------------
Reply by email to: Mark dot Lundquist at ACM dot org
Consulting services: http://home.attbi.com/~mlundquist2/consulting