Teaching new tricks to an old dog (C++ -->Ada)

[Ioannis Vranos]

Well it's Ada 95 and C++ 98 - the Ada standart is a 3 years older - Wait for
Ada 2005 for a standart template library.

That's good for Ada. May I assume an improved generics mechanism too?
Something else, is this .NET enabled version of Ada compiler available
from some other site, because those mil sites do not respond at all here
(perhaps they have blocked non-US countries - I am in Greece, EU).

With such a protectionism, it is no wonder why Ada is not so much
mainstream.

One of the problems when comparing languages is that ISO standards a issued
every 10 years - so you always compare an older standard with a newer one.

In C/C++ this gives another interesting twist: C++98 does not understand the
new C99 features - as does C++2003 as it is only the mid-term bug fix.

C and C++ are different languages now. C++ is (hopefully) going to adopt
only the C99 features that make sense (hopefully the general purpose
ones), and not these that do not make sense (special interest built in
ones).


An example is std::complex vs the new built in complex type of C99. Or
VLAs vs vector/valarray.


You may check this article about some rational on this, search for the
word c99 in there.

http://www.itworld.com/AppDev/710/lw-02-stroustrup/page_1.html


Also this article is very interesting regarding silver bullets. I think
it is interesting to read it all (isn't that large).

 

[Ioannis Vranos]

The meanings of the word "standard library" are a bit different in the two
languages.

The C++ standard template library is right now much more extensive than the
Ada 2005 STL variation.

One thing to notice here is that STL is a subset (the most part) of the
C++ standard library. People confusingly use the term STL and standard
library interchangeably.

But Ada.Containers etc. is only one part of the Ada
standard library. When you need to link third party libraries in C++, you
can stay within the language in Ada:

I am not sure how this can not happen in C++.

The current Ada standard library includes for example
distributed systems,
information systems ("money computing"),
string processing,
interfaces to other languages,
real-time facilities, and
Ada subsetting definitions.

Ada 2005 adds more features to the standard, including
linear algebra support, and
more file and network I/O.

One question is, can these facilities be implemented with the language
itself, or someone has to use another language to do the real work?

 

[Vinzent 'Gadget' Hoefler]

One question is, can these facilities be implemented with the language
itself, or someone has to use another language to do the real work?

They can. Unlike Pascal, Ada does not know "magic" subroutines.


Vinzent.

 

[Pascal Obry]

One question is, can these facilities be implemented with the language
itself, or someone has to use another language to do the real work?

In some area you need to use some call to the OS (in C or C++) and you also
need some call to the OS lib to adjust the behavior across paltforms to have
the same semantics on all implementaton (read on different OS) of the
runtime. This is true for the distributed systems annex for example.

string processing, linear algebra support, information systems can be built
in plain Ada.

Interface to other languages can't, you need support in the compiler.

pragma Import (C, My_Routine);

The semantic behind this pragma must be defined somewhere.

So as you see it really depends on the nature of the library.

Pascal.

--

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

 

[Dmitry A. Kazakov]

If you want a set of pointers to Employee'class, how can do you do
it easily without templates for sets?

Exactly the same way. Access type is a type as any other. If it has to be a
member of Set_Element'Class why shouldn't it be?

type Employee_Ptr is access Employee'Class, new Set_Element;

Have you read Bertrand Meyer's comparison? What do you think?

Any link?

 

[Ioannis Vranos]

In some area you need to use some call to the OS (in C or C++) and you also
need some call to the OS lib to adjust the behavior across paltforms to have
the same semantics on all implementaton (read on different OS) of the
runtime. This is true for the distributed systems annex for example.

string processing, linear algebra support, information systems can be built
in plain Ada.

That's nice.

Interface to other languages can't, you need support in the compiler.

pragma Import (C, My_Routine);

The semantic behind this pragma must be defined somewhere.

So as you see it really depends on the nature of the library.

I had Ada template library in mind as also as "information systems
("money computing"), string processing, Ada subsetting definitions
(what's this?)" from those mentioned.

 

[Georg Bauhaus]

Georg Bauhaus wrote:
....
....

One question is, can these facilities be implemented with the language
itself, or someone has to use another language to do the real work?

As I said,
I don't see why we should, by default, assume that an implementation of
a programming language has to refer to other languages to implement its
own standard. There is reason to use OS services at some low level, and
these might be written in some other language.
You'd be programming an operating system on top of an OS just to
avoid NIH...


Georg

 

[Georg Bauhaus]

Access type is a type as any other. If it has to be a
member of Set_Element'Class why shouldn't it be?

Wrapping occurs, for example a set of ints will become a
set of int_also_set_element. As there might have to be
some implementation for int_also_set_element,
it can be much less convenient than having a set of plain
ints.

Any link?

This is a chapter in OOSC2. It's good to have a copy anyway.
http://archive.eiffel.com/doc/oosc/
From this page there is a link to a sample chapter every now
and then. See the bottom of the page.

 

[Georg Bauhaus]

Something else, is this .NET enabled version of Ada compiler available
from some other site, because those mil sites do not respond at all here
(perhaps they have blocked non-US countries - I am in Greece, EU).

Seems like some ColdFusion restructuring is happening.

ftp://ftp.usafa.af.mil/pub/dfcs/carlisle/asharp/
ftp://sunsite.informatik.rwth-aachen.de/pub/mirror/ftp.usafa.af.mil/pub/dfcs/carlisle/asharp/

 

[Ioannis Vranos]

Seems like some ColdFusion restructuring is happening.

ftp://ftp.usafa.af.mil/pub/dfcs/carlisle/asharp/

The first has not been working either.

ftp://sunsite.informatik.rwth-aachen.de/pub/mirror/ftp.usafa.af.mil/pub/dfcs/carlisle/asharp/

This works. Thanks.

 

[Dmitry A. Kazakov]

Wrapping occurs, for example a set of ints will become a
set of int_also_set_element.

What's wrong with that. Or, better: how ints could be in a set being not
elements of the set? -))

As there might have to be
some implementation for int_also_set_element,
it can be much less convenient than having a set of plain
ints.

I'm afraid I don't fully understand what you mean here. Probably, that the
implementation of the set will use class-wide objects instead of specific
ones. It is definitely an issue to be addressed. This is why I wish a
better ADT for Ada.

This is a chapter in OOSC2. It's good to have a copy anyway.
http://archive.eiffel.com/doc/oosc/
From this page there is a link to a sample chapter every now
and then. See the bottom of the page.

Presently it is: HOW TO FIND THE CLASSES

 

[Pascal Obry]

I had Ada template library in mind as

No problem, it is built in plain Ada.

also as "information systems ("money
computing"), string processing, Ada subsetting definitions (what's this?)"
from those mentioned.

I think this is the way to restrict the language. In some area it is very
important to avoid memory allocation, you can add a pragma like;

pragma Restrictions (No_Allocators);

Here are the current (read Ada95) set of restrictions:

* Safety and Security Restrictions
====================

1. This clause defines restrictions that can be used with pragma
Restrictions, see *Note 13.12::, these facilitate the
demonstration of program correctness by allowing tailored versions
of the run-time system.


_Static Semantics_

2. The following restrictions, the same as in *Note D.7::, apply in
this Annex: No_Task_Hierarchy, No_Abort_Statement,
No_Implicit_Heap_Allocation, Max_Task_Entries is 0,
Max_Asynchronous_Select_Nesting is 0, and Max_Tasks is 0. The last
three restrictions are checked prior to program execution.

3. The following additional restrictions apply in this Annex.

4. Tasking-related restriction:

5. No_Protected_Types

There are no declarations of protected types or protected
objects.

6. Memory-management related restrictions:

7. No_Allocators

There are no occurrences of an allocator.

8. No_Local_Allocators

Allocators are prohibited in subprograms, generic sub-programs,
tasks, and entry bodies; instantiations of generic
packages are also prohibited in these contexts.

9. No_Unchecked_Deallocation

Semantic dependence on Unchecked_Deallocation is not allowed.

10. Immediate_Reclamation

Except for storage occupied by objects created by allocators
and not deallocated via unchecked deallocation, any storage
reserved at run time for an object is immediately reclaimed
when the object no longer exists.

11. Exception-related restriction:

12. No_Exceptions

Raise_statements and exception_handlers are not allowed. No
language-defined run-time checks are generated; however, a
run-time check performed automatically by the hardware is
permitted.

13. Other restrictions:

14. No_Floating_Point

Uses of predefined floating point types and operations, and
declarations of new floating point types, are not allowed.

15. No_Fixed_Point

Uses of predefined fixed point types and operations, and
declarations of new fixed point types, are not allowed.

16. No_Unchecked_Conversion

Semantic dependence on the predefined generic
Unchecked_Conversion is not allowed.

17. No_Access_Subprograms

The declaration of access-to-subprogram types is not allowed.

18. No_Unchecked_Access

The Unchecked_Access attribute is not allowed.

19. No_Dispatch

Occurrences of T'Class are not allowed, for any (tagged)
subtype T.

20. No_IO

Semantic dependence on any of the library units
Sequential_IO, Direct_IO, Text_IO, Wide_Text_IO, or Stream_IO
is not allowed.

21. No_Delay

Delay_Statements and semantic dependence on package Calendar
are not allowed.

22. No_Recursion

As part of the execution of a subprogram, the same subprogram
is not invoked.

23. No_Reentrancy

During the execution of a subprogram by a task, no other task
invokes the same subprogram.


* The Tasking Restrictions
====================

1. This clause defines restrictions that can be used with a pragma
Restrictions, see *Note 13.12::, to facilitate the construction of
highly efficient tasking run-time systems.


_Static Semantics_

2. The following restriction_identifiers are language defined:

3. No_Task_Hierarchy

All (nonenvironment) tasks depend directly on the environment
task of the partition.

4. No_Nested_Finalization

Objects with controlled parts and access types that designate
such objects shall be declared only at library level.

5. No_Abort_Statements

There are no abort_statements, and there are no calls on
Task_Identification.Abort_Task.

6. No_Terminate_Alternatives

There are no selective_accepts with terminate_alternatives.

7. No_Task_Allocators

There are no allocators for task types or types containing
task subcomponents.

8. No_Implicit_Heap_Allocations

There are no operations that implicitly require heap storage
allocation to be performed by the implementation. The
operations that implicitly require heap storage allocation
are implementation defined.

9. No_Dynamic_Priorities

There are no semantic dependences on the package
Dynamic_Priorities.

10. No_Asynchronous_Control

There are no semantic dependences on the package
Asynchronous_Task_Control.

11. The following restriction_parameter_identifiers are language
defined:

12. Max_Select_Alternatives

Specifies the maximum number of alternatives in a
selective_accept.

13. Max_Task_Entries

Specifies the maximum number of entries per task. The bounds
of every entry family of a task unit shall be static, or
shall be defined by a discriminant of a subtype whose
corresponding bound is static. A value of zero indicates
that no rendezvous are possible.

14. Max_Protected_Entries

Specifies the maximum number of entries per protected type.
The bounds of every entry family of a protected unit shall be
static, or shall be defined by a discriminant of a subtype
whose corresponding bound is static.


_Dynamic Semantics_

15. If the following restrictions are violated, the behavior is
implementation defined. If an implementation chooses to detect
such a violation, Storage_Error should be raised.

16. The following restriction_parameter_identifiers are language
defined:

17. Max_Storage_At_Blocking

Specifies the maximum portion (in storage elements) of a
task's Storage_Size that can be retained by a blocked task.

18. Max_Asynchronous_Select_Nesting

Specifies the maximum dynamic nesting level of
asynchronous_selects. A value of zero prevents the use of any
asynchronous_select.

19. Max_Tasks

Specifies the maximum number of task creations that may be
executed over the lifetime of a partition, not counting the
creation of the environment task.

20. It is implementation defined whether the use of pragma Restrictions
results in a reduction in executable program size, storage
requirements, or execution time. If possible, the implementation
should provide quantitative descriptions of such effects for each
restriction.


Pascal.

--

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

 

[Georg Bauhaus]

(what's this?)"

Use language defined pragmas to declare that your program
doesn't use some parts of Ada. These are instructions to
the compilation system. Then, the run-time system
can be tailored to meet the restricted set of requirements.
In addition, some formal properties of the program are
easier to demonstrate.
For example, a program might not need protected types,
a program may have no nested tasks, or it may have no
allocators (no "new"), or no unchecked_access.

Georg

 

[Ioannis Vranos]

Seems like some ColdFusion restructuring is happening.

ftp://ftp.usafa.af.mil/pub/dfcs/carlisle/asharp/
ftp://sunsite.informatik.rwth-aachen.de/pub/mirror/ftp.usafa.af.mil/pub/dfcs/carlisle/asharp/

Perhaps you may help. How may I setup a .NET Ada development environment?


I have downloaded from various sites so far:

7.266.221 adagide-install.exe
30.259.357 asharp-setup.exe

19.146.036 gnat-3.15p-nt.exe
5.752.374 rapid301.zip


I suppose the last two should not be needed. Are the first two the only
needed? adagide asked for gnat, while asharp (mgnat) was installed.


In this cache:
http://66.102.9.104/search?q=cache:...c_html/a_sharp.html+A#&hl=el&client=firefox-a

it says that AdaGIDE integrates fully with A#.


I am providing the cache here because as I said the original site is not
accessible.


Not to mention that I receive anonymous security error for the site
provided here:

"If you do not have GNAT 3.11p (or later), get it from:
ftp://ftp.cs.nyu.edu/pub/gnat/winnt

AdaGIDE uses features specific to GNAT 3.11"


So much security, and my interest of Ada has already declined to almost 0.


Being amused by this "paranoia", I checked to some local sites and found
the latest GNAT here (just to help if someone else is interested in Ada):

ftp://ftp.ntua.gr/pub/lang/gnat/3.15p/winnt/


Any guidance for setting an Ada .NET development environment?

 

[Martin Krischik]

One question is, can these facilities be implemented with the language
itself, or someone has to use another language to do the real work?

In theory all features could be programmed in Ada itself as the Ada ISO
standart contains system programming and "inline assembler" in one of the
optional Anex.

In Praxis it depends on the target operating system. If you have a Linux
distribution you you can check the "praxis" part yourself - just install
the GCC sources and check the "gcc/ada" directory - there are 34 C files
and 755 ada files there. That's for the library and the compiler.

Martin

 

[Georg Bauhaus]

"If you do not have GNAT 3.11p (or later), get it from:
ftp://ftp.cs.nyu.edu/pub/gnat/winnt

AdaGIDE uses features specific to GNAT 3.11"


So much security, and my interest of Ada has already declined to almost 0.

Not sure it has anything to do with a programming language.
The sftp at cs.nyu.edu is new, and affects the whole site.

Try http://libre.act-europe.fr/
Also, there is a mirror at ftp.informatik.rwth-aachen.de

Any guidance for setting an Ada .NET development environment?

Depends on what you define to be a .NET DE. You can get the GNAT
Programming System (GPS), supporting Ada (and C++) in various ways.
You have AdaGIDE, it seems. I like GLIDE which is based on Emacs
and speedbar. Use whatever else you have for WIMP.NET programming
when needed.

 

[Ioannis Vranos]

Not sure it has anything to do with a programming language.
The sftp at cs.nyu.edu is new, and affects the whole site.

Try http://libre.act-europe.fr/
Also, there is a mirror at ftp.informatik.rwth-aachen.de

OK, thanks for the links.

Depends on what you define to be a .NET DE.

An editor (with a Designer - aka RAD - preferably), that works with "A#"
(and not only for Win32 API).

 

[Jerry Coffin]

Randy Brukardt wrote:

[ the AJPO delegating testing authority before it was shut down ... ]

I don't know whether it was done formally or not; I wasn't involved
with that.

Such a thing was either one formally, or not at all.

In any case, it is irrelevant to the existence of the ACAA, operated
under the requirements of an ISO standard, for performing conformity
assessment of Ada compilers. Or do you want to deny that I actually
exist, that the ACAA and its websites, test suites, and authorized
laboratories, exists?

The question is not one of existence. The original claim, however, was
one of their being "official" authorities. The claim that this testing
is somehow "officia" seems to be based on two claims: one, that the
AJPO delegated the authority before it was shut down, and 2) that to
some extent or other, you're acting as part of, under the saction of,
or are in some other way connected with the ISO (e.g. "Although the Ada
tool vendors finance it through the ARA, the ACAA's real boss is the
ISO" (from http://www.adaic.com/compilers/acaa.html).

At this point, it seems quite doubtful to me that the AJPO did any such
thing.

The ISO has this to say:

ISO itself does not carry out conformity assessment. However,
in partnership with IEC (International Electrotechnical
Commission), ISO develops ISO/IEC guides and standards to be
used by organizations which carry out conformity assessment
activities. The voluntary criteria contained in these guides
and standards represent an international consensus on what
constitutes best practice.

(taken from:
http://www.iso.org/iso/en/aboutiso/introduction/index.html).

The bottom line seems to be that the ISO will take responsibility for
the fact that they wrote the standard you claim to follow -- but that
they disavow any and all other involvement with, or any more than the
most peripheral knowledge of you.

So, 1) one of the statements on your web site is probably outright
false, and another is saved from outright falsehood primarily by being
sufficiently vague as to only qualify as "misleading" 2) your claim
about my making a false statement was _probably_ itself false, and at
best certainly devoid of support 3) your statements about the quality
of an Ada compiler are no more "official" than mine or anybody else's.

The basic idea of an "official" verification process is that the
testing be done by a disinterested party -- one who gains _only_ by the
tests being accurate, NOT by them producing any particular result. What
we have here seems to be exactly the opposite: the Ada vendors have put
together a couple of puppet groups to give an illusion of there being
some distance between themselves and the testers, but in reality the
testers realize full well exactly where all their money comes from, and
at least some of them are even still directly associated with the very
Ada vendors they claim to be policing!

That isn't intended to imply, nor do I claim, that any of the testing
involved has ever been falsified or even mildly inaccurate. OTOH, it
throws considerable doubt on the claim that these tests should be
trusted because they're conducted by an "official" authority operating
with the ISO as its boss.

So, the question is not one of whether you exist -- but of whether you
and/or your testing should be trusted. In my view, your own posts have
thrown this into considerable doubt (at best).

 

[Randy Brukardt]

....

So, the question is not one of whether you exist -- but of whether you
and/or your testing should be trusted. In my view, your own posts have
thrown this into considerable doubt (at best).

The reason Jerry comes to this conclusion is based on a single summary
statement from a 5 year-old summary article; he never looks at the testing
procedures or the ISO standard that governs those procedures. Moreover, he
seems to claim reasons for this conclusion that are clearly stated in the
article (at least I hope they're clear; I'm not that great a writer...).

I'm always amazed at the lengths that some opponents of Ada will go in order
to discredit any advantage of the language. Is this because they feel
threatened by the language? (I can't imagine why.) Or they have a deep
seated hatred of things that start with 'A'? I don't know. You can't please
(or even reason with) all of the people all of the time.

Anyway, for the benefit.of anyone else still reading this thread, I'll
explain how the testing is done, and why it can be trusted. (Whether such
testing has value in any case is another issue that could be argued forever,
but that's not the question.)

The testing process is an instantiation of the ISO testing standard (ISO/IEC
18009). The detailed procedures that are followed are available on the AdaIC
website, along with the test suite itself. They were developed from the
preexisting AJPO procedures with the oversight of a panel of users,
laboratories, and vendors.

Actual testing is done by testing laboratories (ACALs). These have to be
independent of any Ada vendor. Vendors contract directly with the
laboratories for testing; this part of the process is unchanged from when
AJPO and NIST ran it.

The ACAA is the oversight agency. We provide maintenance to the test suite,
and judge disputes between the vendors and the testing labs. We also spot
check the laboratories work to insure that they have followed the
procedures. This is the role that previously was handled by AJPO (in an
office called the AVO).

The only real difference (other than the ISO standard, which codified the
rules that AJPO had followed) is that the ACAA is funded in part by the ARA.
The ACAA is primarily funded by certificate fees, but the ARA does make up
any shortfall. The ARA is an association of Ada product vendors (not just
compiler vendors).

While there is a potential conflict of interest, it is irrelevant in
practice for three reasons:
(1) The ACAA is only a judge. Moreover, technical issues are resolved by
discussion with a panel of Ada experts; if that is not satisfactory, the
ruling can be appealed to the ARG (the Ada standard maintenance group within
the Ada working group of ISO/IEC SC22 WG9). At most, the ACAA can influence
this process, not decide it.
(2) ARA includes most of the major Ada vendors. It would be hard to have
an conformity issue that they all would agree on that would not also be in
the interest of all Ada vendors.
(3) The testing in question is conformity assessment. It is not about
testing usability in any way, so it has little to do with the factors on
which vendors compete. The testing is designed to provide a yes/no answer
(well, it's a little more nuanced than that) as to whether a compiler is
compliant. There isn't a lot of leeway in this process for outside
influence.

While I could imagine an outcome from this process that would favor Ada
vendors over Ada users, that would seem to be counter-productive (why hurt
your customers?). Moreover, as the testing is about conformity and not
usability, most issues that matter to users don't even fall under the
testing umbrella. Of course, the main question (Does this compiler properly
implement the Ada Standard?) is of significant interest to users,
particularly those that will need to use more than one compiler over the
life of their project.

As to whether someone could cheat in the process, I would say it would not
be the least bit hard. The results of the tests are always handled by the
vendors before the testers see them, so there is always the possibility of
games. There is nothing new about this possibility (I know or suspect
several cases where results were falsied under the AJPO testing). I think it
actually would be harder now, because (1) I've been on the other side of the
fence, so I have some idea of what to look for; and (2) we require more
information in the test report than AJPO did. We also post the test reports
publically, so anyone can check on them. (The only AJPO test reports I ever
saw, before I was sent several cartons of old AVO material, were the ones we
had done.) We even have a public test results dispute procedure (which
thankfully never has been used), its unclear if AJPO even had one.

In any event, the real benefit is that there is a *single* conformity test
suite that *all* Ada vendors use for testing. That means that there can be
no confusion about what has and has not been tested. Most differences
between Ada compilers (beyond those allowed by the Standard) are those that
come from untested combinations of Ada features.

Randy Brukardt

 

[Jerry Coffin]

Randy Brukardt wrote:

[ ... ]

The reason Jerry comes to this conclusion is based on a single
summary statement from a 5 year-old summary article;

First of all, I came to no solid conclusions. Second, there was far
more reasoning behind what I said than you admit here. Fortunately,
anybody who wishes to do so can easily go back and read about the
federal register -- wihch is available for searching by essentially
anybody who wishes to do so. If your statements are really true, why
don't you quit trying to put words in my mouth and simply show the
proof?

[ ... ]

Moreover, he
seems to claim reasons for this conclusion that are clearly stated
in the article (at least I hope they're clear; I'm not that great a
writer...).

Except for the part about your (lack of) writing ability, I have no
idea what this sentence is even attempting to say. Commenting on your
own writing ability would _seem_ to imply that you're discussing the
writing on your web site, though. If that's the case, I have to wonder
about the logic involved -- it _sounds_ more or less as if you may be
attempting to offer your own statements on your own web site as
providing "proof" of the statements you've made here!

I'm always amazed at the lengths that some opponents of Ada will go
in order to discredit any advantage of the language. Is this because
they feel threatened by the language? (I can't imagine why.) Or they
have a deep seated hatred of things that start with 'A'? I don't'
know.

This has nothing to do with discrediting the language.

Consider, for example, buying ICs. I can not only find not only who
made the ICs, but exactly which fabrication facility they were made at.
I can find ISO 900x certification(s) on that facility, and I can find
out who did that certification. I can find who they use as a failure
analysis lab, whether they're ISO 900x certified, and if so who
certified THEM. In short, I don't simply depend on their own claims --
I can find a chain of documentation that leads to people they hope I
trust.

The question is the degree to which that situation holds here. Thus
far, you've provided essentially nothing in the way of independent
corroboration of any of your statements at all. You make a statement
here, and then offer your own statement on your own web site as the
"corroborating evidence."

You can't please
(or even reason with) all of the people all of the time.

At least in this thread, you don't seem to have even attempted to
_reason_ with anybody at all. You've made unsupported claims, and when
perfectly legitimate concerns are raised, you've resorted to suggesting
that they result from fear and/or irrational hatred.