Does Ada still competitive?

Does Ada still competitive?

[Sunny]

Hi all!
I like the programming language.
But I saw a sentence on TOIBE index definition, it said that: "Ada is hardly used for new mission-critical systems anymore." Is that true?
And does Ada still teach in university and used in works?
Thanks!
Sun

Re: Does Ada still competitive?

[tonyg]

No, its used in lots of mission critical infrastructure.

However I use it for my stuff because I am not fond of spending  eighty per cent of my time debugging. I also get to stand on the shoulders of some very clever folk who write some very useful packages. 

Re: Does Ada still competitive?

[gautier_niouzes]

Sunny:

> Hi all!
> I like the programming language.
> But I saw a sentence on TOIBE index definition, it said that: "Ada is hardly used for new mission-critical systems anymore." Is that true?

This sentence is around 10 years old, so perhaps it used to be true, then. 

> And does Ada still teach in university and used in works?

For the 2nd part of the question, here is a list:
  http://www.seas.gwu.edu/~mfeldman/ada-project-summary.html
I have introduced the technology at my work (so it makes one more new "mission-critical system" ;-) ) and the result is appreciated by users: stable and fast corporate software is not so common...
_________________________ 
Gautier's Ada programming 
http://sf.net/users/gdemont/

Re: Does Ada still competitive?

[svampab]

I don't think TOIBE index is reliable source of the use of a language.
It uses search engines to find, so it finds th most popular, that is
not always equal to most used.

In fact, I've heard that 60% of coding nowadays is COBOL.

COBOL is still the main language in banking, but those programmers
dont make noise in the Net. Something similar happens to Ada. It is
used in huge, but closed projects. I'm sure that Ada is losing share
of market, nevertheless I'm sure that there is a lot of huge, huge
projects that employ hundred of programmers and thousand of man/hours
that are almost invisible in Internet.

Re: Does Ada still competitive?

[gautier_niouzes]

svampab:

> I don't think TOIBE index is reliable source of the use of a language.

Note that they never claimed to measure the use of languages, and they make that point clear on their web page.

> It uses search engines to find, so it finds th most popular, that is
> not always equal to most used.

Exactly. Still, a popularity measure is /per se/ interesting.
I cannot resist to put an ad for my own flavour of the same idea:
  http://lang-index.sf.net

Cheers
G.

Re: Does Ada still competitive?

[anon]

No!

Ada is dying by a painful and slow death! Yes, there will always be a few 
that will try to play with Ada but the day of moving code to Ada is over and 
done with. Like, it was report here a few weeks ago, NASA is now pulling it 
Ada support. And most satellite and other companies went C in early 2000s.

One reason is the change to "Return by Type" from "Return by reference" 
which started around 2007.  The problem with "Return by Type" is that 
the "Generic package" must be compiled within the routine or package 
that uses it.  Which means the "Generic package" is a one application 
only so why use generic in the first place.  But companies like NASA 
over the years have created 1_000s of external "Generic packages" that 
are for multiple projects and at writing and compile time the "Generic 
package" has no concept of what type will be use. So the usage of 
"Return by Type" cause compiler errors on a massive scale on external. 
generic packages. This is one of many proof that Ada is not backward 
compatible. So, company like NASA are moving away from Ada to a more 
stable language that is 100% backward compatible like C. No rewrites 
on any package only compile, link and execute.


A second problem is that every year the ARG is moving Ada toward a C like 
language. An example is in Ada 2012, is functions now can use "in out" 
within the parameter list, such as

   function <name> ( <arg_1> : in out <type_1>; 
                     <arg_2> : in out <type_2> ) 
            return <return_type> ;

Which is classical C version of a procedure routine with the "return_type" 
being a error code. So, will the "Exceptions" and exception handler be 
next to be removed from Ada in 2020. That's a problem with existing Ada 
programmers, being that they may be forced to make 100s of re-writes 
to remove exceptions that no one want to do. And the ARG can not say 
for certain that exception will exist in Ada 2020 or after, until they 
vote on Ada 2020 RM sometime in 2020 or later.

A third is the "Not null" clause that are use in routine's parameter list 
starting with Ada 2005.  That cause introduces inefficiency error checking 
at the beginning of the routine that can not be truly optimized. This is, 
just like the C like "pragma Assert" which add very inefficiency code into 
one programs. 

There are others concepts that software division in companies like NASA 
or software shops do not like the direction Ada is going in because of 
the ARG.

Plus, the number of new Ada programmers are limited. Most small schools 
only teach languages that are under the Microsoft ".NET" umbrella or JAVA 
which mean Ada is not taught. And in large Universities the cost of a 
single class is too high to experiment just to learn a language that is 
being phased out by most programming departments.



In <2667883.6.1334114293790.JavaMail.geo-discussion-forums@pblw1>, Sunny <daetalusun@gmail.com> writes:
>Hi all!
>I like the programming language.
>But I saw a sentence on TOIBE index definition, it said that: "Ada is hardly used for new mission-critical systems anymore." Is that true?
>And does Ada still teach in university and used in works?
>Thanks!
>Sun

Re: Does Ada still competitive?

[Yannick Duchêne (Hibou57)]

Le Wed, 11 Apr 2012 22:19:29 +0200, <anon@att.net> a écrit:
> One reason is the change to "Return by Type" from "Return by reference"
> which started around 2007.  The problem with "Return by Type" is that
> the "Generic package" must be compiled within the routine or package
> that uses it.  Which means the "Generic package" is a one application
> only so why use generic in the first place.
Don't bring confusion with generics and libraries. Generics are a design  
method you may compare with automatic program generation in some way,  
while libraries are something you link to. Your logic could lead to  
assertions like “this design pattern must be compiled for each use place,  
so why use design patterns at all?”. Do you see where your error is? If  
“Must not be recompiled” is not a requirement, no need to worry about. And  
compilation is the least nightmare for an enterprises like NASA is I  
believe.

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University

Re: Does Ada still competitive?

[Yannick Duchêne (Hibou57)]

Le Wed, 11 Apr 2012 22:19:29 +0200, <anon@att.net> a écrit:
> So the usage of
> "Return by Type" cause compiler errors on a massive scale on external.
> generic packages. This is one of many proof that Ada is not backward
> compatible. So, company like NASA are moving away from Ada to a more
> stable language that is 100% backward compatible like C. No rewrites
> on any package only compile, link and execute.

You meant “compile, don't check, link and execute”?

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University

Re: Does Ada still competitive?

[J-P. Rosen]

Le 11/04/2012 22:19, anon@att.net a �crit :
<anon header>This is a response to FUD spread as usual by anon, to warn
people not to believe this nonsense </anon header>

> A second problem is that every year the ARG is moving Ada toward a C like 
> language. An example is in Ada 2012, is functions now can use "in out" 
> within the parameter list
As every C programmer knows, there are no in out parameters in C
[...]

> Which is classical C version of a procedure routine with the "return_type" 
> being a error code. So, will the "Exceptions" and exception handler be 
> next to be removed from Ada in 2020. That's a problem with existing Ada 
> programmers, being that they may be forced to make 100s of re-writes 
> to remove exceptions that no one want to do. And the ARG can not say 
> for certain that exception will exist in Ada 2020 or after, until they 
> vote on Ada 2020 RM sometime in 2020 or later.
The ARG is very careful about incompatibilities, and these are
introduced only when the benefits far outweighs the cost of
incompatibility. As fas as exceptions are concerned, I challenge you to
provide a single reference that the ARG ever considered removing them.

> A third is the "Not null" clause that are use in routine's parameter list 
> starting with Ada 2005.  That cause introduces inefficiency error checking 
> at the beginning of the routine that can not be truly optimized.
On the contrary, it replaces many checks in the body of the called
subprogram by a single check at the call site.

> There are others concepts that software division in companies like NASA 
> or software shops do not like the direction Ada is going in because of 
> the ARG.
Please provide a reference to support that claim (other than your own
rambling)

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr

Re: Does Ada still competitive?

[Robert Love]

On 2012-04-12 05:56:40 +0000, J-P. Rosen said:

> 
>> There are others concepts that software division in companies like NASA
>> or software shops do not like the direction Ada is going in because of
>> the ARG.
> Please provide a reference to support that claim (other than your own
> rambling)

First, NASA is not a company.  NASA does have companies that work for it.

I'm the one who has bemoaned NASA/JSC giving up on Ada here in this 
forum.  Where the original poster got his information I would like to 
know.  What branch of NASA is he speaking about?  JSC is just going 
with the flow.  The software managers just know that C++ is trendy and 
their programmers already know it.  There is no trade study or 
rationale reason expressed that I know of.

Re: Does Ada still competitive?

[anon]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 11376 bytes --]


Problem with 
Backward Compatibility:

100% backwards compatible is not a cost to be calculated and weighed it 
a requirement for all languages including, the spoken and written human
languages. Only sub-sets of the language can limit the usage of any 
language or statements. And once a word or statement is added it can never 
be deleted or its initial purpose removed. 

So, for an update to any computer language, it must be 100% backwards 
compatible with the previous version of the language.  If not then the 
update is to be known as a "new" language. And this standard is understood 
by all computer language designers, or updaters, like IBM, SUN, Miscrosoft, 
etc.

One example is that FORTRAN still allows the old arithmetic "if" statement 
without any compiler options. Even though most programmers, since FORTRAN 
77 have abandon that statement for the new powerfully "if-then-else" 
statement. But in keeping the old statement does allows FORTRAN to 
maintain its 100% backwards compatible.

And another example is JAVA which complies with this standard law for 
language. Yes it will complains when compiling a JAVA 1.00 routine or 
applet on an updated compiler such as Java 6 but the routine or applet 
will still compile and run. 

Then there Ada, when Ada 83 was updated to Ada 95, first the changes were 
explained in Annex J. "Obsolescent Features". One example was the Ada 
system libraries names, while Ada 83 use parent only names, Ada 95 
introduce parent.child names. Which meant for Ada 95 to be 100% backwards 
compatible in this case that any Ada compiler either had to provide the 
addition of the Ada 83 libraries (Best programming) or just specification 
files containing the routines names with "pragma Interface" (Ada 83) that 
would allow linkage into the Ada 95 libraries using "pragma Export" 
statements on the Ada 95 side, This would also keep any new Ada 95 or future 
features out of Ada 83 code (Good programming). But GNAT just use Ada 95 
with renaming statement which could allow some Ada 95 or later features 
into Ada 83 code (Bad programming). Actually to compile an Ada 83 library 
routine using GNAT way, means that the compiler is in error. An example is 
from "Text_IO.ads":

  pragma Ada_95;
  -------------
  warning pragma is not acknowledge in Ada 83. 
  
  -- Ada 83 only reports non-standardize pragmas RM 2.8. GNAT was not 
  -- available for Ada 83 so "pragma Ada_83" is an Ada 95 implementation
  -- statement. Aka this statement must have no effect on the compiler
  -- while compiling in Ada 83 mode.
  --
  -- note: if accepted under Ada 83 it would allow all feature of 
  -- Ada 95 to be used in Ada 83. (Very Bad programming design)
  -- for any Ada 83 only code

  with Ada.Text_IO;
       -------------
       illegal package name in Ada 83

  package Text_IO renames Ada.Text_IO;
                          -----------
                          illegal package name in Ada 83


In truth using pragma Ada_83 or Ada_95 does not guarantee that the 
GNAT compiler will see the correct version of Ada. And examples of 
this is in overloading the "=" function. In GNAT compiling using Ada 
83 option or pragma Ada_83 an "=" will accept any type. But in RM 83 
( 6.7 ) states the "=" "is only allowed if both parameters are of the 
same limited type." and the result must be Boolean, this was altered 
in Ada 95 to allow any type such as access type with result being any 
type.

An example that will compile in GNAT using "-gnat83"  but Ada 83 RM 
states it should not. So, the GNAT compiler should state:

 function "=" ( Left, Right : Integer_Access ) return Integer_Access ;
                              ---------------         --------------
                           RM 6.7 not a limited type
                           -- not an Ada 83 feature

                                                     RM 6.7 not Boolean
                                                  -- not an Ada 83 feature

Besides the overloading "=" error there is removal of a number of 
pragma statement in Ada 95, which were used by Cray and others in Ada 83. 
So, since Ada 95 is not 100% backwards compatible, so, Ada 95 should be 
classified as a new language that must complete with its predecessor 
Ada 83 but never replace it. 

And a number of changes in "Ada 2005" alters the Ada 95 statements 
which delete the 100% backwards compatible, so Ada 20056 is a new 
language.  And then there "Ada 2012 Corrigendum 1" also know as the 
"correction of errors" for Ada but instead of correcting some error it 
alters external Generic packages a big plus for Ada by replacing the 
"return by reference" by "return by type" causes existing re-usable  
external Generic packages to nolonger compile makes "Ada 2012" a completely 
100% new language that can never be 100% backwards compatible with any 
predecessor Ada 2005, Ada 95 or Ada 83.

So The ARG has not turn Ada language into four similar by different 
languages.

  Ada 83,   (adopted 1987)
  Ada 95,   (adopted 1995)
  Ada 2005, (adopted 2007)
  Ada 2012, (adopted 201?)

And No the ARG can not just pull Ada 83. Once a language has been 
created it there until the end of time. The ARG can only state that it is 
nolonger officially being supported any more by the ARG. But others like 
IBM for one can pick it up. IBM has done this for other languages.

The ARG says that each new Ada is only an upgrade. If that was the case,
then every statement every used in prior Ada version would still be 
operational in the updated version. Like "return by reference", would 
still be usable. And with almost every aspect of Ada now being optional, 
there is no true base standard that one can rely upon to use for the 
language.



Problem with 
Optimization:

Reference any and all "Software Optimization Reference Manual" or any 
chapters in a CPU designer manual's set that deals with Optimization. For 
Intel they use a manual, that can be download from Intel web site. 

 "Intel� 64 and IA-32 Architectures Optimization Reference Manual"

It states that any interruption in the execution stream, such as 
unnecessary verification checks decrease cpu performance and optimization.
Because it can cause the instruction pipelining as well as the memory 
caches to be flushed. And these type of statements can be found in SUN, 
SGI, IBM, and all others CPU manual set. And the "not null" feature is 
unnecessary aka a wasted code if the programmer designs his code 
correctly. Which makes the "not null" more of a high school teaching 
concept that should never be allowed in a language or production line 
compiler or language translator.

But since a number of ARG members are directly associated with Adacore. 
It seams ARG are not too concern with optimization because the 
optimization for GNAT, which is normally in the "Middle End" of a compiler 
is actually performed by the GCC backend which is not apart of GNAT Ada 
code. Plus secondary problem is that Adacode can not guarantee what code 
will be produce by GCC "backend" routines.

And why is this a problem, well through the years a number of GCC versions 
have had issues with processor and code optimization. You can find a few 
papers on file at some major university libraries and a couple on the 
internet. As an example you can find an articles on GCC versions and 
the 128/256-bit multi-precision math packages, stating the package is not 
being optimized correctly on some version of GCC. 

So, should GNAT use GCC backend or should GNAT bypass GCC "backend" and 
have its own "Middle and Back End" routines. For the issue of Ada 
optimization it seams that GNAT should bypass GCC. Because Ada contains 
two options for optimization one is for "Space" and "Time" which both could 
be handled initially in the "Middle end". Where the uncalled routines could 
be removed and then the remaining AST code could be optimize for Time.  
Then later in the binder ("gnatbind") could remove any dead code from 
precompiled Ada library packages, while linking that package, unlike most 
other linkers which just copy the dead code into the program. But in order 
to remove the dead code the binder ("gnatbind") would have to bypass calling 
GCC linkers and preform the link/editing itself while removing the dead code 
from the library packages. And course this removes the constant updating
of GNAT to every new version of GCC, which saves money and time.


As for 2020 and exceptions.

Taff S. Tucker stated in a number of speeches in the mid 1980s that he 
did not like the Ada exceptions he preferred the return code of the C 
procedure which is now apart of Ada 2012 function. So, it goes that Tucker 
may try to talk the ARG into removing exception data type altogether. 
Especially since 2020 might be his last chance to update Ada. And since 
most of the new Ada programmers are those moving from C they have little 
experience in using Ada exceptions so with the C like procedure aka Ada 
function they will not ever miss the power and performance of Ada exceptions 
and handlers.

And at the movement no one can say what changes will occur between adoption 
of 2012 and the adoption of 2020. But with the "return by type" change no
one want to bet on what will not be there.


These are three of a few reason why Ada has become "Obsolete" to most 
software shops and schools.



In <jm5qqp$n1g$1@dont-email.me>, "J-P. Rosen" <rosen@adalog.fr> writes:
>Le 11/04/2012 22:19, anon@att.net a �crit :
><anon header>This is a response to FUD spread as usual by anon, to warn
>people not to believe this nonsense </anon header>
>
>> A second problem is that every year the ARG is moving Ada toward a C like 
>> language. An example is in Ada 2012, is functions now can use "in out" 
>> within the parameter list
>As every C programmer knows, there are no in out parameters in C
>[...]
>
>> Which is classical C version of a procedure routine with the "return_type" 
>> being a error code. So, will the "Exceptions" and exception handler be 
>> next to be removed from Ada in 2020. That's a problem with existing Ada 
>> programmers, being that they may be forced to make 100s of re-writes 
>> to remove exceptions that no one want to do. And the ARG can not say 
>> for certain that exception will exist in Ada 2020 or after, until they 
>> vote on Ada 2020 RM sometime in 2020 or later.
>The ARG is very careful about incompatibilities, and these are
>introduced only when the benefits far outweighs the cost of
>incompatibility. As fas as exceptions are concerned, I challenge you to
>provide a single reference that the ARG ever considered removing them.
>
>> A third is the "Not null" clause that are use in routine's parameter list 
>> starting with Ada 2005.  That cause introduces inefficiency error checking 
>> at the beginning of the routine that can not be truly optimized.
>On the contrary, it replaces many checks in the body of the called
>subprogram by a single check at the call site.
>
>> There are others concepts that software division in companies like NASA 
>> or software shops do not like the direction Ada is going in because of 
>> the ARG.
>Please provide a reference to support that claim (other than your own
>rambling)
>
>-- 
>J-P. Rosen
>Adalog
>2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
>Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
>http://www.adalog.fr

Re: Does Ada still competitive?

[Ludovic Brenta]

anon writes on comp.lang.ada:
> Problem with 
> Backward Compatibility:
> 
> 100% backwards compatible is not a cost to be calculated and weighed
> is a requirement for all languages including, the spoken and written
> human languages.

Read Beowulf or even Shakespeare's sonnets and tell me English is
backward compatible.

BS.

-- 
Ludovic Brenta.

Re: Does Ada still competitive?

[Georg Bauhaus]

On 13.04.12 14:12, Ludovic Brenta wrote:
> anon writes on comp.lang.ada:
>> Problem with 
>> Backward Compatibility:
>>
>> 100% backwards compatible is not a cost to be calculated and weighed
>> is a requirement for all languages including, the spoken and written
>> human languages.
> 
> Read Beowulf or even Shakespeare's sonnets and tell me English is
> backward compatible.

Interestingly, there have been heated discussions about
parts of C99 that are not compatible with C89.

Microsoft compilers for C# version N do not accept programs
written for and using features of C# version N+1.

IMHO, this whole backwards compatibility business is
based on FUD. They sell translators for Ada 2005 that
target a number of programming languages, such as C and
a host of assembly languages. And they of all would not be
capable of targeting a programming language such as Ada 95?

I'd rather expect them to have a shop keeper's interest in not
selling an Ada 2005 -> Ada 95 translator, but to also persuade
the customers to give up their Ada 95 compiler and enter
an entirely new business relationship.

Re: Does Ada still competitive?

[Mark Lorenzen]

I won't comment on all your rambling, but focus on a feature of GNAT.

On 13 Apr., 11:06, a...@att.net wrote:
>
> Then later in the binder ("gnatbind") could remove any dead code from
> precompiled Ada library packages, while linking that package, unlike most
> other linkers which just copy the dead code into the program. But in order
> to remove the dead code the binder ("gnatbind") would have to bypass calling
> GCC linkers and preform the link/editing itself while removing the dead code
> from the library packages. And course this removes the constant updating
> of GNAT to every new version of GCC, which saves money and time.

The GNU linker that is shipped with GNAT is perfectly able to remove
unused subprograms and unused data from the executable. See
http://docs.adacore.com/gnat-unw-docs/html/gnat_ugn_8.html#SEC103

Regards

Mark L

Re: Does Ada still competitive?

[Rugxulo]

Hi,

On Apr 13, 8:15 am, Mark Lorenzen <mark.loren...@gmail.com> wrote:
>
> I won't comment on all your rambling, but focus on a feature of GNAT.
>
> On 13 Apr., 11:06, a...@att.net wrote:
>
> > Then later in the binder ("gnatbind") could remove any dead code from
> > precompiled Ada library packages, while linking that package, unlike most
> > other linkers which just copy the dead code into the program. But in order
> > to remove the dead code the binder ("gnatbind") would have to bypass calling
> > GCC linkers and preform the link/editing itself while removing the dead code
> > from the library packages. And course this removes the constant updating
> > of GNAT to every new version of GCC, which saves money and time.
>
> The GNU linker that is shipped with GNAT is perfectly able to remove
> unused subprograms and unused data from the executable. See
> http://docs.adacore.com/gnat-unw-docs/html/gnat_ugn_8.html#SEC103

This only works for ELF, I think. At least it doesn't work for DJGPP
COFF. Maybe your point was that it does (sometimes) work and could
work in all places, but that doesn't change the fact that it's not a
universal solution, sadly.

Perhaps the best workaround is just to put each subprogram in its own
separate file, and put all those compiled objects into a library. I
think others (FPC??) do similar on some targets. (And all the above is
probably doing is putting each subprogram in its own named section in
the object, stripping it at link time, e.g. XDS.)

Re: Does Ada still competitive?

[BrianG]

On 04/13/2012 06:02 PM, Rugxulo wrote:
> Hi,
>
> On Apr 13, 8:15 am, Mark Lorenzen<mark.loren...@gmail.com>  wrote:
>>
>> I won't comment on all your rambling, but focus on a feature of GNAT.
>>
>> On 13 Apr., 11:06, a...@att.net wrote:
>>
>>> Then later in the binder ("gnatbind") could remove any dead code from
>>> precompiled Ada library packages, while linking that package, unlike most
>>> other linkers which just copy the dead code into the program. But in order
>>> to remove the dead code the binder ("gnatbind") would have to bypass calling
>>> GCC linkers and preform the link/editing itself while removing the dead code
>>> from the library packages. And course this removes the constant updating
>>> of GNAT to every new version of GCC, which saves money and time.
>>
>> The GNU linker that is shipped with GNAT is perfectly able to remove
>> unused subprograms and unused data from the executable. See
>> http://docs.adacore.com/gnat-unw-docs/html/gnat_ugn_8.html#SEC103
>
> This only works for ELF, I think. At least it doesn't work for DJGPP
> COFF.

Does current, or even remotely recent, GNAT support DJGPP?  I haven't 
heard of a version since around 3.15.  Could that be the problem?

>       Maybe your point was that it does (sometimes) work and could
> work in all places, but that doesn't change the fact that it's not a
> universal solution, sadly.


-- 
---
BrianG
000
@[Google's email domain]
.com

Re: Does Ada still competitive?

[gautier_niouzes]

Am Mittwoch, 18. April 2012 03:50:48 UTC+2 schrieb BrianG:
> Does current, or even remotely recent, GNAT support DJGPP?  I haven't 
> heard of a version since around 3.15.

It's the reverse: DJGPP supports GNAT - see the ada* files there:
http://www.delorie.com/pub/djgpp/current/v2gnu/

Last time I've tried it worked fine (in a DOSBox, 1-2 years ago).
_________________________ 
Gautier's Ada programming 
http://sf.net/users/gdemont/

Re: Does Ada still competitive?

[Yannick Duchêne (Hibou57)]

Le Wed, 18 Apr 2012 08:51:14 +0200, <gautier_niouzes@hotmail.com> a écrit:

> Am Mittwoch, 18. April 2012 03:50:48 UTC+2 schrieb BrianG:
>> Does current, or even remotely recent, GNAT support DJGPP?  I haven't
>> heard of a version since around 3.15.
>
> It's the reverse: DJGPP supports GNAT - see the ada* files there:
> http://www.delorie.com/pub/djgpp/current/v2gnu/
>
> Last time I've tried it worked fine (in a DOSBox, 1-2 years ago).
> _________________________
> Gautier's Ada programming
> http://sf.net/users/gdemont/

Who use DJGPP and for which reasons?

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University

Re: Does Ada still competitive?

[Fritz Wuehler]

> Who use DJGPP and for which reasons?

people who use DOS

because they can

although gcc is so bloated it is hard to use anything related to it on DOS

Re: Does Ada still competitive?

[gautier_niouzes]

Fritz:

> people who use DOS
> because they can
> although gcc is so bloated it is hard to use anything related to it on DOS

DJGPP and most programming systems developped for DOS since ~1990 are using some 32-bit DOS extender, so no 640KB limitation there - if you are referring to memory limitations.
_________________________ 
Gautier's Ada programming 
http://sf.net/users/gdemont/

Re: Does Ada still competitive?

[BrianG]

On 04/18/2012 02:51 AM, gautier_niouzes@hotmail.com wrote:
> Am Mittwoch, 18. April 2012 03:50:48 UTC+2 schrieb BrianG:
>> Does current, or even remotely recent, GNAT support DJGPP?  I haven't
>> heard of a version since around 3.15.
>
> It's the reverse: DJGPP supports GNAT - see the ada* files there:
> http://www.delorie.com/pub/djgpp/current/v2gnu/
>
> Last time I've tried it worked fine (in a DOSBox, 1-2 years ago).

Then, apparently, it doesn't support the stated "feature" of GNAT (the 
linker removing unused programs and data).  Is this a GNAT problem (as 
stated in the post I referenced), or a problem/limitation in DJGPP?  (Of 
course, I don't know what any of this has to do with Ada features.)
> _________________________
> Gautier's Ada programming
> http://sf.net/users/gdemont/


-- 
---
BrianG
000
@[Google's email domain]
.com

Re: Does Ada still competitive?

[Pascal Obry]

Le 21/04/2012 02:52, BrianG a �crit :
> Then, apparently, it doesn't support the stated "feature" of GNAT (the
> linker removing unused programs and data).  Is this a GNAT problem (as
> stated in the post I referenced), or a problem/limitation in DJGPP?  (Of
> course, I don't know what any of this has to do with Ada features.)

I think this is a current binutils linker limitation which does not
support --gc-sections option on pe-coff target. So nothing to do with
GCC or GNAT. AFAIK, there is some work to support this.

Pascal.

-- 

--|------------------------------------------------------
--| 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: Does Ada still competitive?

[Pascal Obry]

Le 21/04/2012 02:52, BrianG a �crit :
> Then, apparently, it doesn't support the stated "feature" of GNAT (the
> linker removing unused programs and data).  Is this a GNAT problem (as
> stated in the post I referenced), or a problem/limitation in DJGPP?  (Of
> course, I don't know what any of this has to do with Ada features.)

I think this is a current binutils linker limitation which does not
support --gc-sections option on pe-coff target. So nothing to do with
GCC or GNAT. AFAIK, there is some work to support this.

Pascal.

-- 

--|------------------------------------------------------
--| 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: Does Ada still competitive?

[J-P. Rosen]

Le 13/04/2012 11:06, anon@att.net a �crit :
> Taff S. Tucker stated in a number of speeches in the mid 1980s that he 
> did not like the Ada exceptions he preferred the return code of the C 
> procedure which is now apart of Ada 2012 function. So, it goes that Tucker 
> may try to talk the ARG into removing exception data type altogether.
So, your line of reasoning is:

Tucker said something 30 years ago
=> he still believes it
   => he is willing to fight for it
      => he may be pushing the ARG
         => he is pushing the ARG
            => the ARG will remove exceptions

Come on!

Short answer: this did not happen. Full stop.

-- 
J-P. Rosen
Adalog
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00
http://www.adalog.fr