Re: binding thickness indicator, was Re: GNAT, OS/2, Libraries

Re: binding thickness indicator, was Re: GNAT, OS/2, Libraries

[Bob Crispen]

tmoran@BIX.COM sez:

>I propose we use something analogous to house insulation 'R-values'
>for indicating the thickness of a binding.  R1 would be the thinnest
>possible, a la single pane window glass, like Tore's example of
>interfacing to a C routine.  R50 would indicate such thickness and
>insulation that, say, code using an R50 windowing GUI binding would be
>portable across Mac, Windows, OS/2, and X-Windows.

That's not just an idea, it's a meme!  Great analogy (at least for us
Americans).

Bob Crispen
revbob@eight-ball.hv.boeing.com

binding thickness indicator, was Re: GNAT, OS/2, Libraries

[tmoran]

I propose we use something analogous to house insulation 'R-values'
for indicating the thickness of a binding.  R1 would be the thinnest
possible, a la single pane window glass, like Tore's example of
interfacing to a C routine.  R50 would indicate such thickness and
insulation that, say, code using an R50 windowing GUI binding would be
portable across Mac, Windows, OS/2, and X-Windows.  R5 might be the
Ada flavor he mentions (type and range checked parameters, raise
exception instead of returning success/fail flag, etc) , but pretty
much still tied to the particular design, style, and widget offerings
of a particular system.  Clearly not an exact measurement, but
somewhat more specific than thick/thin.

Re: binding thickness indicator, was Re: GNAT, OS/2, Libraries

[Dale Pontius]

In article <4kjaib$bhc@news2.delphi.com>,
        tmoran@bix.com writes:
>I propose we use something analogous to house insulation 'R-values'
>for indicating the thickness of a binding.  R1 would be the thinnest
>possible, a la single pane window glass, like Tore's example of
>interfacing to a C routine.  R50 would indicate such thickness and
>insulation that, say, code using an R50 windowing GUI binding would be
>portable across Mac, Windows, OS/2, and X-Windows.  R5 might be the
>Ada flavor he mentions (type and range checked parameters, raise
>exception instead of returning success/fail flag, etc) , but pretty
>much still tied to the particular design, style, and widget offerings
>of a particular system.  Clearly not an exact measurement, but
>somewhat more specific than thick/thin.

But if you've got R50 bindings, make sure you don't install new
carpet (super-duper GUI function) unless it summertime (running
on a fast box) and you can keep the windows open. (a really fast
box) Otherwise you get 'sick building syndrome'. (super-duper
slow performance)

But seriously, folks, there was talk a month or so about Fresco,
which was capable of attacking the same problem. (and more) But
there were remarks that Fresco is slow even on a fast box.

Thick GUI bindings may well carry a rather sticky performance
penalty. (OK, OK, it is Friday, after all!) Look and see a trend
of more portable cross-platform APIs being added to various OS's.
OpenGL and Java are two examples. It turns out that right on the
tails of OpenDoc is coming a Framework spec. OpenDoc says nothing
about user interface, but the Framework spec will.

Another year or so and the thick/thin GUI issue may become less
important, as new native cross-platform APIs get added to current
OS offerings.

Dale Pontius
(NOT speaking for IBM)

Re: binding thickness indicator, was Re: GNAT, OS/2, Libraries

[Mitch Gart]

Dale Pontius (pontius@twonky.btv.ibm.com) wrote:

: Another year or so and the thick/thin GUI issue may become less
: important, as new native cross-platform APIs get added to current
: OS offerings.

I agree that cross-platform APIs are an important trend.  Not "new"
technically but "new" in the sense of having much wider acceptance
than before.

But it's not necessarily true that the thick/thin issue goes away.
Take the example of the Java AWT (Abstract Window Toolkit).  An
Ada binding to AWT can be very thin, using as closely as possible
the Java names and conventions, or could conceivably be thicker,
making changes that the person designing the binding decided were
desirable in an Ada programming interface to the AWT functionality.

- Mitch Gart

Re: binding thickness indicator, was Re: GNAT, OS/2, Libraries

[Mitch Gart]

tmoran@bix.com wrote:
: I propose we use something analogous to house insulation 'R-values'
: for indicating the thickness of a binding.  R1 would be the thinnest
: possible, a la single pane window glass, like Tore's example of
: interfacing to a C routine.  R50 would indicate such thickness and
: insulation that, say, code using an R50 windowing GUI binding would be
: portable across Mac, Windows, OS/2, and X-Windows.  R5 might be the
: Ada flavor he mentions (type and range checked parameters, raise
: exception instead of returning success/fail flag, etc) , but pretty
: much still tied to the particular design, style, and widget offerings
: of a particular system.  Clearly not an exact measurement, but
: somewhat more specific than thick/thin.

A good way of measuring the thickness is the size of the Ada package
bodies and supporting code relative to the Ada package specifications.
If almost everything can be done in the Ada package spec with 
type, data, constant, and interfaced subprogram declarations, the binding
is very thin.  The more code that's needed in the bodies, the thicker
the binding.  For example X11Ada, which I consider to be a thin binding,
contains 15K (non-blank, non-comment) lines in package specs and 6K
lines in package bodies.  72% of the code is in the specs.

- Mitch Gart

Re: binding thickness indicator, was Re: GNAT, OS/2, Libraries

[Ron J Theriault]

In article <4kjaib$bhc@news2.delphi.com>, tmoran@bix.com writes:
|> I propose we use something analogous to house insulation 'R-values'
|> for indicating the thickness of a binding.  R1 would be the thinnest
|> possible, a la single pane window glass, like Tore's example of
|> interfacing to a C routine.  R50 would indicate such thickness and
|> insulation that, say, code using an R50 windowing GUI binding would be
|> portable across Mac, Windows, OS/2, and X-Windows.  R5 might be the
|> Ada flavor he mentions (type and range checked parameters, raise
|> exception instead of returning success/fail flag, etc) , but pretty
|> much still tied to the particular design, style, and widget offerings
|> of a particular system.  Clearly not an exact measurement, but
|> somewhat more specific than thick/thin.

You've been watching "This Old House" too long!  :-)

If a binding is portable across Macs, X-Windows, and others, just
what is it a binding to?  It would seem to be a binding
to a platform independent graphical toolkit of your invention.
-- 
Ron Theriault              |   
CS Department              |   In a democracy, you only have to fool
Texas A&M Univ.            |   most of the people, most of the time.
ron@cs.tamu.edu            |   

Re: binding thickness indicator, was Re: GNAT, OS/2, Libraries

[David Emery]

In article <4l88ik$ed2@news.tamu.edu>, ron@cs.tamu.edu (Ron J Theriault) wrote:

> In article <4kjaib$bhc@news2.delphi.com>, tmoran@bix.com writes:
> |> I propose we use something analogous to house insulation 'R-values'
> |> for indicating the thickness of a binding.  R1 would be the thinnest
> |> possible, a la single pane window glass, like Tore's example of
> |> interfacing to a C routine.  R50 would indicate such thickness and
> |> insulation that, say, code using an R50 windowing GUI binding would be
> |> portable across Mac, Windows, OS/2, and X-Windows.  R5 might be the
> |> Ada flavor he mentions (type and range checked parameters, raise
> |> exception instead of returning success/fail flag, etc) , but pretty
> |> much still tied to the particular design, style, and widget offerings
> |> of a particular system.  Clearly not an exact measurement, but
> |> somewhat more specific than thick/thin.
> 
> You've been watching "This Old House" too long!  :-)
> 
> If a binding is portable across Macs, X-Windows, and others, just
> what is it a binding to?  It would seem to be a binding
> to a platform independent graphical toolkit of your invention.
> -- 
> Ron Theriault              |   
> CS Department              |   In a democracy, you only have to fool
> Texas A&M Univ.            |   most of the people, most of the time.
> ron@cs.tamu.edu            |   

Although I do not agree with Tmoran's "binding thickness scores" at all,
I would like to point out that there are several commercial products that
provide a uniform API to a variety of windowing platforms (e.g. X, Motif,
MS-Win, Mac, etc.)  At least one of them, XVT, has a vendor-supported Ada
binding.  For those of you attending STC next week, I strongly recommend
you take a look at this.  XVT will be there (I think they're "teaming" with
someone.)

               dave

p.s.  disclaimer:  While at MITRE, we did a "proof-of-concept" Ada binding
to XVT that demonstrated that you could use XVT to write window-system-
independent applications in Ada.