Slashdot Mirror

There's a lot of good stuff here: http://www.adahome.com/ and here: http://www.adaic.org/

And It's "Ada" not "ADA". The language name is not an acronym. Rather it's named after Ada Countess Lovelace, see https://en.wikipedia.org/wiki/... The choice of the name was deliberate, Ada Lovelace is commonly cited as the first computer programmer (for Babbage's Analytical Engine). And that name long pre-dates the current initiatives for "women in computing." (There were a fair number of women involved with the Ada program, such as the late Jean Sammet, quite unusual in the late 1970s/early 1980s during the initial development of the requirements and then language itself.)

3) Start writing alternatives in safer languages

Like Ada.

I expect Ada to make a comeback. It is a safe language, but without the bizarrness of a functional programming language, so it can be used to do actual work.

An especially good style guide will also include rationales for why they chose particular ways of doing things. A good example is the Ada Style Guide (it's an industry standard).

http://www.adaic.org/resources/add_content/docs/95style/95style.pdf

Guess we better all switch to Ada...

The 777 uses it for the control software - http://www.adaic.org/atwork/boeing.html [adaic.org]

Just goes to show that these guys don't take security seriously - that should at least be Boeing 775. This is just common sense, there is no excuse for such sloppiness.

It may be a niche language, but it's still really good in areas where safety is a concern. The 777 uses it for the control software - http://www.adaic.org/atwork/boeing.html

Actually, there are perfectly good languages that automatically check all buffers lengths when used (or even at compile time). That would mostly remove the human element and we wouldn't have to rail against the occasional (or even usual) developer who leaves out a check.

Instead folks insist on using crappy non-checking languages like C++. That's fine if you like C++, but don't complain about developers messing up and leaving off a buffer check, when the means for eradicating all buffer overflow errors is a simple language switch away. You knew what could happen when you picked up the gon...

Can someone explain me why we would need a new language... There are languages designed from the ground-up to allow parallel processing. Yes, structures inside de core language, not some extra libs. Just to name one: Ada, designed to allow parallel computing since before 1979 (yes, that's 30 years ago). Reference: http://www.adaic.org/whyada/multicore.html. Even on a single processor, doing stuffs memory-bound (such as a sort on a huge amount of data) parallelized can show significant improvement.

For Ada, I like WikiBooks: http://en.wikibooks.org/wiki/Ada

Also useful
http://www.adaic.org/
http://www.sigada.org/
http://www.adacore.com/
http://www.sparkada.com/
https://libre.adacore.com/ (free GPL'd Ada 2005 compiler)

What kind of Ada libraries are you looking for? There are lots of open source Ada projects on Sourceforge or on various personal developer web sites. The licenses vary, not all are GPL. Search comp.lang.ada archives or look at the links from http://www.adaic.org/links/libs.html.

and it has a damm side more features the Pascal. Have a look:

http://www.adaic.org/standards/05rm/html/RM-TTL.html
http://en.wikibooks.org/wiki/Ada_Programming

Martin

Maybe you want to have a look at it:

http://www.adaic.org/standards/05rm/html/RM-D.html

Martin

i worked in ada, late '80s, early '90s, alsn, wrote a troff clone;-) i had just learned c & chafed @ the strictness (i don't need no steenkin compile-time checks;-) but i grew to appreciate it...definitely leads to better code.

http://www.adaic.org/atwork/trains.html gives an interesting case history of the superiority of ada for teaching real-time programming:-)

" The only difference between the years in which teams succeeded in implementing their projects and those in which no team succeeded was the implementation language."

I think Ada is a language that everyone would benefit from learning. Its very useful. I have used it for years in my day job, by choice. Ada is probably the most well designed (carefully considered) general purpose language. It can and has been used for everything from GUIs and web servers to games, compilers, flight control systems, low level device drivers and everything in between. It is particularly well suited for low level hardware interfaces and for programming multi-processor systems, real-time or not, and for interfacing with other languages (C, C++, Java, Fortran). The best Ada compiler GPL licensed open-source and is freely available at https://libre.adacore.com/. It supports the latest Ada 2005 language standard. Other information is available at http://www.adaic.org/ Ada has long suffered from a lot of undeserved bad press. Don't believe it. Learn Ada - you probably won't look back.

Oh, that doesn't matter, since the software on the plane is 99% Ada!

Using the good-old Ada programming language (for which a new standard should be issued this year), you can go closer to what you're looking for (though I'm not sure your goal is realistic).

Here's a pointer to the new standard : http://adaic.org/standards/05rm/html/RM-TTL.html

With Ada:

• you can call externally-defined C/C++ functions (see annexe B);
• you get quite advanced runtime-checks;
• you have plenty of exceptions to use to catch errors (see sections 11 and section Q.4);
• you have tasking (more or less threading) implemented inside the language (see section 9);
• a specialized annexe is targetted toward distributed system (annexe E);
• specialized annexes for high-integrity systems (annexe H) and real-time systems (annexe D);
• ...and more, much more.

It probably won't solve every of your problems, but it might help.

For a free, quite strong Ada compiler, have a look at https://libre2.adacore.com/ (it's based on GCC).

Oh yes, Ada is a statically, strongly, strictly typed language (e.g. the compiler won't let you assign an integer to a float variable). My opinion is that it's a Good Thing for critical programs. Useless to restart a "type war" on this subject ;-)

Good luck.

In fact I do know a better language, Ada95/2005.
It's simply meant for threading and unconventional compiler optimizations (through the enforcement of constraints), while still being imperative and having a familiar syntax. And it's meant to be compiled unlike Java.
Here's a site about Ada and here's another one.
A good (alas not perfect) Ada95 compiler is included in GCC 3.4.

So aye, we are ready for the CMT systems.

Ada95 is an object-oriented strong-typed reliable language created for the US Department of Defense, if it's good enough for them, it's good enough for you. The language is well designed (unlike C++) and you can always expect the code to do what is written in the Ada Reference Manual. A unique feature of the language is quite an extended model of multitasking, beside that it includes modularization, polymorphism and generic programming capabilities.
Bindings for X11, SDL, OpenGL and GTK+ exist, what more do you need?
The free compiler for Ada95 is GNAT, which is included in the recent versions of GCC (stable as of 3.4.0), but you can also get an older stable version 3.15p based on GCC 2.8.1 from here.
The compiler won't generate code as fast as that of C and C++ compilers but since you're probably not writing Doom4 it's perfectly acceptable.

AdaPower

AdaIC

GNAT, free GNU Ada)

GNU Ada in gcc

...in the past thinking like this has resulted in things like Ada.

Yes, this is true. Ada was devised as the result of 4 groups competing against each other, and the best of em (though opinions vary) selected as the Mandated Language for the DOD.

The whole process is described thusly:

The driving concern of the HOLWG was to assure that the design was guided by a responsible principle investigator, and to preclude "design by committee". On the other hand, picking a single contractor to do the job and trusting to luck would have been imprudent. The procurement was through multiple competitive contracts, with the best products to be selected for continuation to full rigorous definition and developmental implementation.

And it was a disaster from the Defence Contractor's viewpoint. Firms fell over themselves trying to get exemptions from using it, ANYTHING was better. Because Ada had

• Objects
• Exceptions
• Generics (templates)
• Multiple-threading/Tasking
• Strong Typing

So yes, had compatibility been mandated in the past, we might all have systems far more reliable and robust. But Microsoft wouldn't have $40 Billion and a number of tame Congresscritters.

Someone hit me with a clue-by-four if I'm talking out of my arse or if not, tell me what decent compiled languages exist out there =)

No, you're not talking anally, it's a good question.Try Ada-95, or one of its proper subsets if you want embedded systems.

Rather than give lots of religious arguments, unverified opinions and hot air, here's some resources and quotes:

From Crosstalk (March 2002) :

There is now compelling evidence that development methods that focus on bug prevention rather than bug detection can both raise quality and save time and money. A recent, large avionics project reported a four-fold productivity and 10-fold quality improvement by adopting such methods. A key ingredient of correctness by construction is the use of unambiguous programming languages that allow rigorous analysis very early in the development process.

SPARK code was found to have only 10 percent of the residual errors of full Ada; Ada was found to have only 10 percent of the residual errors of code written in C. This is an interesting counter to those who maintain that choice of programming language does not matter, and that critical code can be written correctly in any language: The claim may be true in principle but clearly is not commonly achieved in practice. (emphasis added by me)

Parenthetically, I get a little miffed when I see so much unsupported balderdash being purveyed in Ye Greatte Language Warres. Try looking at the experiments people, you know, data, numbers etc? The Scientific method? But I digress, back to the stuff useful to you.

Another Crosstalk article, proving fairly conclusively that a working Ada programs's easier to write than a working C program, at least in some problem domains (high performance, real-time).

Ada for C and C++ programmers shows you how to do what you want, if you know C.

The LRM - Language Reference Manual, ISO-8652 (yes, it's an ISO standard). This version is the one with annotations.

Oh yes, there's an open-source compiler, GNAT available for free download. Like GCC, it's industrial-strength.

Finally, I'll echo my own experiences with the C++ STL: namely, that implementations differ markedly, portability is not a possibility, and performing surgery deep in their bowels is like unravelling rancid spaghetti. But YMMV I guess. Code Warrior 7 and MVC++5 were not compatible for anything other than trivial examples.

A bit of detective work on google found the following info from trying to implement Ada on the 2200 36-bit architecture:

We are working with Unisys on an Ada 95 implementation for the 2200 series machines. Those machines are 36-bit, 1's complement machines.
Originally, we did not think there was a problem here. After all, the C compiler supports a full 36-bit unsigned type. We would just copy that implementation. However, on further inspection, that turns out not to be so easy. The C compiler had major problems with the unsigned type. Ultimately, two versions of the C compiler were built, one to pass the C validation tests, and one to actually use. To pass the C validation tests, Unisys built a compiler which emulated 2's complement math for this machine! That was done by doing all operations as 72 bit operations, and then reducing the result. Obviously, they did not want to use that implementation for production use.

In summary, if you read the Ada article it seems there are a whole lot of issues with a 36-bit machine, like having to do everything at 72-bit so you can divide by 8 again!

At this rate it's no wonder Emacs turned out so bl**dy complicated!

He's right. Learning some things will definitely help the way you think about things. The incredibly strong typing of something like pascal will definitely kick your *ss if you've been doing nothing but C for a while, and I think that's actually a Good Thing. Learning Eiffel if you already know smalltalk is a very different experience.

Even something like Algol will probably change your views and get you closer to the hardware in many respects (not that you can get Algol to run on most machines anymore....;-)

What about Ada? Programming by Contract really will teach you something serious about how you actually interact with the rest of your application, and while you'll curse it ("I KNOW what I'm trying to do and it's correct, dammit!") you'll be happier for learning it. Older, but happier.

And as long as the languages keep coming, there'll pretty much never be a chance to really run out.

My list would include:

• C
• C++
• Pascal& lt;/a>
• Lisp (anything but eLisp)
• Python
• Perl
• Smalltalk
• ML
• prolog&l t;/a>
• Eiffel
• Ada
• a RISC Assembler
• Cobol (those who do not learn from history are doomed to repeat it)
• Java
• BASIC (the non-Visual kind).