Re: questions on Ada openGL binding in the GLOBE3D packages

Re: questions on Ada openGL binding in the GLOBE3D packages

[Egil Høvik]

From the OpenGL spec: 
"The declarations shown in this document apply to ANSI C. Languages such as C++ and Ada that allow passing of argument type information admit simpler declarations and fewer entry points."

So no, the names in an Ada-binding does not have to exactly match the C version.
As for GL_Begin and GL_End, they should have been called just Begin and End, but
those are reserved words in Ada.

-- 
~egilhh

Re: questions on Ada openGL binding in the GLOBE3D packages

[Nasser M. Abbasi]

On 8/2/2012 3:50 AM, Egil H�vik wrote:
>  From the OpenGL spec:
> "The declarations shown in this document apply to ANSI C.
>Languages such as C++ and Ada that allow passing of argument type information
>admit simpler declarations and fewer entry points."
>

> So no, the names in an Ada-binding does not have to exactly match the C version.

I know they do NOT HAVE TO be the same as C. That is my point.

They do NOT have to, yes, but it is _better_ if they DO.  Why not keep
the names the same?

It will make it easier to program this in Ada if the binding is the same.

> As for GL_Begin and GL_End, they should have been called just Begin and End, but
> those are reserved words in Ada.
>

NO, they should have been called the same as C. glBegin and glEnd.  No need
to make up new names. The names are already defined. Why chop off anything.

Btw, I just downloaded at the other Ada openGL now

http://adaopengl.sourceforge.net/downloads.php

and I see that the binding there is the SAME as C binding, which
is good. So I am looking at it now.

Here is an example from the file adaopengl\opengl.ads in the
above zip file:

-------------------------------
--  Copyright  (c) 2002-2003, David Holm
--  All rights reserved.
.....
    pragma Import (C, glBegin, "glBegin");
    pragma Import (C, glEnd, "glEnd");
    pragma Import (C, glVertex2d, "glVertex2d");
    pragma Import (C, glVertex2f, "glVertex2f");
----------------------------------

You can see, the Ada binding above matchs the same as the C API.
Even with the mixed case on the Ada side.

I would have liked to use the GLOBE3D openGL binding, because
my understanding it is more updated than the David Holm one which
was last updated in 2002. But it is more important for me to use
a binding which has the same exact names as C as I use C book
to learn openGL and I like the code to look the same.

This was the case with the Fortran binding as well, it have the
same exact API naming as C. So, I see no reason at all to change
the name of the functions, even though I know it is allowed.

regards,
--Nasser

Re: questions on Ada openGL binding in the GLOBE3D packages

[Niklas Holsti]

On 12-08-02 12:14 , Nasser M. Abbasi wrote:
> On 8/2/2012 3:50 AM, Egil H�vik wrote:
>>  From the OpenGL spec:
>> "The declarations shown in this document apply to ANSI C.
>> Languages such as C++ and Ada that allow passing of argument type
>> information
>> admit simpler declarations and fewer entry points."
>>
> 
>> So no, the names in an Ada-binding does not have to exactly match the
>> C version.
> 
> I know they do NOT HAVE TO be the same as C. That is my point.
> 
> They do NOT have to, yes, but it is _better_ if they DO.

Subjective opinion and matter of taste.

FWIW, I prefer the Ada-style names. The changes (at least in the
examples you showed) are so systematic and simple that it is easy to
translate in one's mind, when necessary.

>  Why not keep the names the same?

The C-style names are needlessly long and tedious. The "gl" prefix is
necessary (well, almost) in C, for name-space reasons, but unnecessary
in Ada. If you like, in your Ada code you can include the prefix by
using the GL package name to qualify the names. Adding a period to
change glVertex2d into GL.Vertex2d is hardly difficult.

IMO, it is neater and less trouble to use the same style of identifiers
for my native Ada code and for the bound libraries from other languages.
I think that is one of the desirable features of a binding, even a thin
binding.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: questions on Ada openGL binding in the GLOBE3D packages

[Nasser M. Abbasi]

On 8/2/2012 5:19 AM, Niklas Holsti wrote:
>
>
> Subjective opinion and matter of taste.
>

That is the exact reason why a thin binding should have the same
exact naming as the language being mapped to. So that nevery
one makes up a name they like on the Ada side.

> FWIW, I prefer the Ada-style names.

You prefer one style, I prefer another style, a third person prefers
another style.

So we end up with 10 different Ada programs, written by 10 different
programmers, all using the same OPEN GL.

Why not keep things standard? The standard is there. No reason to change
the names just becuase you do not like this name and I do not like that
name.

When one looks at C code, all the calls are the same everywhere.

>
> The C-style names are needlessly long and tedious.

It does not matter really. It is the standard. It makes the code easier to
understand if the same names are used in Ada and C and Fortran and in
any other language. The same exact names.

Any way, that is what I think. We agree to disagree I guess.

I'll use the 2002 openGL binding to learn a little bit of Ada openGL
from, since it matches the C API. So, I am all set now :)

regards,
--Nasser

Re: questions on Ada openGL binding in the GLOBE3D packages

[Egil Høvik]

> Why not keep things standard? The standard is there. 

You seem to be confused. What you call "the standard" is
just the C binding. The standard explicitly states that
example syntax is in C, and that other languages with better
namespace handling and subprogram overloading can do things
differently.
Writing GL.Vertex is more readable than GL.glVertex2d.
Let the compiler figure out the types of your parameters, 
and how many, you specify. It will complain if it can't find 
a match.

Some people complain about Ada being too verbose; In this case,
I would say C is more verbose, why should that be a bad thing 
for Ada?


-- 
~egilhh

Re: questions on Ada openGL binding in the GLOBE3D packages

[Georg Bauhaus]

On 02.08.12 13:12, Egil H�vik wrote:
>> Why not keep things standard? The standard is there. 
> 
> You seem to be confused. What you call "the standard" is
> just the C binding. The standard explicitly states that
> example syntax is in C, and that other languages with better
> namespace handling and subprogram overloading can do things
> differently.
> Writing GL.Vertex is more readable than GL.glVertex2d.
> Let the compiler figure out the types of your parameters, 
> and how many, you specify. It will complain if it can't find 
> a match.
> 
> Some people complain about Ada being too verbose; In this case,
> I would say C is more verbose, why should that be a bad thing 
> for Ada?

Perception provides for a valid argument: If books about
OpenGL, and other material considered relevant,
use the names and example syntax, this creates
an expectation. To dispel the power of expectations,
you'd need to name a few killer features, features
that warrant deviation from what everybody else is
perceived to be doing. Or you'd demonstrate, convincingly,
that a significantly perceivable number of relevant
teams do *not* use the expected names and syntax.

There were two bindings to the OS/2 API. One binding copied
IBM's names exactly, as they were used in IBM's documentation,
reflecting the names in the C based O-O system: DosXyz123,
GpiSomeThing, WinEtcFoo. The other binding made Dos, Gpi, Win,
... into packages. Not everyone agreed with the second
approach. The argument against package might be stronger
in this case because IBM's O-O design was written in C,
IIUC, so these were the "real" names.

It there a strong technical argument in favor of
using package software in stead of names implying
packages? Better visibility control? Better compilation
performance due to separation? Better change management
by modularization?

Re: questions on Ada openGL binding in the GLOBE3D packages

[Vasiliy Molostov]

Egil Høvik <egilhovik@hotmail.com> писал(а) в своём письме Thu, 02 Aug  
2012 15:12:51 +0400:

>> Why not keep things standard? The standard is there.
>
> You seem to be confused. What you call "the standard" is
> just the C binding. The standard explicitly states that
> example syntax is in C, and that other languages with better
> namespace handling and subprogram overloading can do things
> differently.
> Writing GL.Vertex is more readable than GL.glVertex2d.
> Let the compiler figure out the types of your parameters,
> and how many, you specify. It will complain if it can't find
> a match.
>
> Some people complain about Ada being too verbose; In this case,
> I would say C is more verbose, why should that be a bad thing
> for Ada?

It seems that you probably right - there is a good reason to keep things
convenient to Ada related environment. Perhaps, interface of some sort of  
C that lie on C naming
is indeed a mangled names used to import, and is not going to be human  
convenient.

BTW, initially GL library from MS had no gl prefix.

Do we need operate mangled names in a high level language?

Which standard we should apply here?


-- 
Написано в почтовом клиенте браузера Opera: http://www.opera.com/mail/

Re: questions on Ada openGL binding in the GLOBE3D packages

[Vasiliy Molostov]

Georg Bauhaus <rm.dash-bauhaus@futureapps.de> писал(а) в своём письме Thu,  
02 Aug 2012 15:56:03 +0400:

> On 02.08.12 13:12, Egil Høvik wrote:
>>> Why not keep things standard? The standard is there.
> It there a strong technical argument in favor of
> using package software in stead of names implying
> packages? Better visibility control? Better compilation
> performance due to separation? Better change management
> by modularization?

Do we need use name prefixes while having high level tools
to organize imported procedures in a way we decide by self?

Prefix is a C "necessity", and when imported it then has nothing common  
with C.

It seems, that a good binding can provide many benefits when imports being
organized in an ada-way, only if you are not going to provide
low-level direct 1:1 mapping to what people use in C.
Is there a benefit using 1:1 C in Ada?

-- 
Написано в почтовом клиенте браузера Opera: http://www.opera.com/mail/

Re: questions on Ada openGL binding in the GLOBE3D packages

[Brian Drummond]

On Thu, 02 Aug 2012 04:14:15 -0500, Nasser M. Abbasi wrote:

> On 8/2/2012 3:50 AM, Egil Høvik wrote:
>>  From the OpenGL spec:
>> "The declarations shown in this document apply to ANSI C.
>>Languages such as C++ and Ada that allow passing of argument type
>>information admit simpler declarations and fewer entry points."
>>
>>
>> So no, the names in an Ada-binding does not have to exactly match the C
>> version.
> 
> I know they do NOT HAVE TO be the same as C. That is my point.
> 
> They do NOT have to, yes, but it is _better_ if they DO.  Why not keep
> the names the same?

"Making code look the same as C" is ... not unambiguously better!

> It will make it easier to program this in Ada if the binding is the
> same.

No, but I'd agree it will make learning by following C examples a little 
bit easier. Which is important, up to a point.

Actually programming, and reading and maintaining such a program, is 
likely to be that much harder, as the names are longer,uglier and 
therefore less readable.

I confess I didn't watch this year's Tour de France. But I wonder, how 
many of the competitors used training wheels?

Just a point of view...

There is a long tradition among C programmers, of uglifying names as a 
poor substitute for properly indicating their type. But there is less 
than no reason to follow that tradition in Ada, where types and packages 
can be used to properly distinguish different entities.

So I would agree with Niklas' suggestion : if you must mimic the look of 
the C programs, substitute '.' for '_' and use qualified names. Ditto 
where there is any real danger of confusing a gl.Vertex2d with any other 
type of Vertex2d. But otherwise, the cleanest and simplest style will be 
best in the long run.

- Brian

Re: questions on Ada openGL binding in the GLOBE3D packages

[Robert A Duff]

Brian Drummond <brian@shapes.demon.co.uk> writes:

> "Making code look the same as C" is ... not unambiguously better!

True.

But sticking closely to the C does have the advantage that
the binding doesn't need a whole lot of documentation (which
must be maintained) -- you can just refer to the C docs.
A thick binding requires a lot of documentation.

IMHO, the name changes are so systematic in this case, that
it's close enough -- you can still refer to the C docs,
and do the trivial translation in your head.  And the Ada names
really are more readable.  I think it's the right choice,
especially since the standard actually suggests doing it
this way in languages that have a proper module system.

What if you had a system originally written in Ada (with appropriate use
of overloading), and you wanted to make a C binding?  In that case it
would be impossible to make the names the same.

I once wrote an Ada binding to some C code where every C function
returned an 'int' as an error code, with 0 meaning "success".
I did it in two layers.  A thin binding that worked the same
way, returning Interfaces.C.int.  Then a layer on top of that
that turned the error codes into raising an exception.  The second
layer is such a systematic change that I think it can still
be considered "thin" -- thin enough that the C documentation
still makes sense.

- Bob

Re: questions on Ada openGL binding in the GLOBE3D packages

[Pascal Obry]

I think a thin binding ought to be as close as the C code. This indeed
ease porting code. And from there is it possible to build think binding
the Ada way if needed.

Just my 2 cents.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|    http://www.obry.net  -  http://v2p.fr.eu.org
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver keys.gnupg.net --recv-key F949BD3B

Re: questions on Ada openGL binding in the GLOBE3D packages

[Randy Brukardt]

"Niklas Holsti" <niklas.holsti@tidorum.invalid> wrote in message 
news:a7v2ieFpstU1@mid.individual.net...
...
> IMO, it is neater and less trouble to use the same style of identifiers
> for my native Ada code and for the bound libraries from other languages.
> I think that is one of the desirable features of a binding, even a thin
> binding.

Not to mention that automated style-checking tools would reject/modify names 
in mixed case style. (It's a clear violation of pretty much every Ada style 
guide I've ever seen.

And personally, whenever I type identifiers, they naturally come out in the 
Ada style. On the rare occassions when they need to be in some other style 
(as in specifing link names in interfacing pragmas), I usually have to type 
them several times.

Ergo, if you want a binding to be useful to the experienced Ada programmer, 
it has to use identifiers that fit the style of experienced Ada programmers.

IMHO, I do agree with you that a binding that changes the names is not a 
"thin" binding. "Thin" bindings are unusable; they should only be used for 
temporary (one-off) code. Anything else needs at least what I call a 
"medium" binding: routines with similar semantics to the original ones, but 
an Ada-ized interface with better names, far fewer pointers, and exceptions 
rather than error codes. (The project that became Claw was originally 
intended to produce a "medium" binding for Win32. Eventually it morphed into 
Claw, a classic "thick" binding.)

(I don't want any of my code to *ever* look anything like C -- I want clean, 
elegant code, not barely intelligible symbols and loads of dangerous 
pointers. YMMV. :-)

                                                          Randy.

Re: questions on Ada openGL binding in the GLOBE3D packages

[Randy Brukardt]

"Nasser M. Abbasi" <nma@12000.org> wrote in message 
news:jvdlqa$ii5$1@speranza.aioe.org...
...
> It does not matter really. It is the standard. It makes the code easier to
> understand if the same names are used in Ada and C and Fortran and in
> any other language. The same exact names.

Many of us write almost exclusively in Ada, and mixed case C names are a lot 
harder to understand than properly formatted Ada names. You want our code to 
be much harder to understand (by us and our colleagues) so that it is easier 
to to read C code.

Sorry, as soon as an Ada programmer has to read C code in order to get their 
work done, Ada has lost. That programmer would probably have been better off 
writing the code in C in the first place. The effort of building a binding 
is not just the binding (that's usually pretty easy), but also the effort of 
creating/translating examples (and testing them), and preferably, creating 
Ada-specific documentation as well.

Given that we are forced into a mixed-language world, there's little point 
in trying to write C in Ada. Either write Ada in Ada or C in C -- and 
interface *those* larger parts.

                          Randy.

Re: questions on Ada openGL binding in the GLOBE3D packages

[Randy Brukardt]

"Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message 
news:wccpq795odd.fsf@shell01.TheWorld.com...
> Brian Drummond <brian@shapes.demon.co.uk> writes:
>
>> "Making code look the same as C" is ... not unambiguously better!
>
> True.
>
> But sticking closely to the C does have the advantage that
> the binding doesn't need a whole lot of documentation (which
> must be maintained) -- you can just refer to the C docs.
> A thick binding requires a lot of documentation.
>
> IMHO, the name changes are so systematic in this case, that
> it's close enough -- you can still refer to the C docs,
> and do the trivial translation in your head.  And the Ada names
> really are more readable.  I think it's the right choice,
> especially since the standard actually suggests doing it
> this way in languages that have a proper module system.
>
> What if you had a system originally written in Ada (with appropriate use
> of overloading), and you wanted to make a C binding?  In that case it
> would be impossible to make the names the same.
>
> I once wrote an Ada binding to some C code where every C function
> returned an 'int' as an error code, with 0 meaning "success".
> I did it in two layers.  A thin binding that worked the same
> way, returning Interfaces.C.int.  Then a layer on top of that
> that turned the error codes into raising an exception.  The second
> layer is such a systematic change that I think it can still
> be considered "thin" -- thin enough that the C documentation
> still makes sense.

I think calling that "thin" is dubious. I call the technique "medium" for a 
lack of a better term, and it has to include normalizing the names, adding 
appropriate defaults, and using Ada parameter modes appropriately (along 
with raising exceptions). But I agree that it makes reading C documentation 
easier than for a true "thick" binding -- the problem being, that no one 
should be forcing Ada programmers to read C documentation. Cost 
considerations of course make that necessary sometimes, but even then I 
would hope that there would at least be some Ada-specific documentation 
covering common use-cases.

                                          Randy.

Re: questions on Ada openGL binding in the GLOBE3D packages

[Robert A Duff]

"Randy Brukardt" <randy@rrsoftware.com> writes:

> I think calling that "thin" is dubious. I call the technique "medium" for a 
> lack of a better term, 

OK, fair enough, call it "medium".  It wasn't the thinest it could be,
but it wasn't very thick.  In this case, the binding was to some
real-time kernel, and the "thick" binding would be the Ada run-time
system built on top of it.

>...and it has to include normalizing the names, adding 
> appropriate defaults, and using Ada parameter modes appropriately

In the case I'm talking about, not much of that.  I can't remember
about the names, but no defaults, and all parameters of mode 'in',
as in C.n

>...(along 
> with raising exceptions). But I agree that it makes reading C documentation 
> easier than for a true "thick" binding -- the problem being, that no one 
> should be forcing Ada programmers to read C documentation. Cost 
> considerations of course make that necessary sometimes, but even then I 
> would hope that there would at least be some Ada-specific documentation 
> covering common use-cases.

Sure.

- Bob