Slashdot Mirror

The reason we do this is largely because Ada compilers tend to be expensive, buggy or huge

Wrong, wrong, and wrong.

GNAT, the GNU Ada compiler, is Free (as in speech and beer), commercially supported, and has been integrated into mainstream GCC development. Get it. Use it. Love it.

Users of debian can simply "apt-get install gnat" (and also think about getting gnat-gps gnat-doc ada-mode and ada-reference). Other distros probably have similar packages, Others can check GNUAda.org, which has packages for Linux, NetBSD, DOS, and OS/2.

I studied CS at NYU and took a programming languages class with Robert Dewar (main author of GNAT and president of AdaCore, the company behind GNAT, among other things (SPITBOL, anyone?)). One of the best classes I've taken at college.

Gee..What we need is a language that has been around for a long time. Is ISO standardized. Supports OO. Has the power to do low level programming when required. It would actually have to be fast and efficient . It would also be good if it had run time checks on things like buffer overflows but also made them less likely by the structure of the language itself (e.g. Doing pass and array and a separate array size but have the language know about the size of the array to start with). It would be good if this language already had a free implementation. It would have to work under Windows, Linux, most other Unixs and a lot of embedded targets. It would have to have the option of easily letting the user suppress the run-time checks if required but have them basically on by default. Hopefully we could do something in the language that would at least help reduce bugs. But we have to be realistic too. We probably won't be getting rid of Windows any time soon so this made up language would also need to be able to interface easily to things like COM/DCOM for windows. It should also support things like Gtk+ and GNOME out of the box. Hmm...Sounds Like Ada. Oh but wait..It does not use ugly C syntax so programmers will never use it...Not to mention that problem with the military being involved at the beginning (but lets just overlook that for the whole internet thing)...

There is another FOSS IDE called gps. They call the unsupported version the "academic edition", but you can download the source, and a peak at a few files shows that it's GPL'd. (Their economic model is to give it away for free and sell support for those who need it.)

It's a cross-platform IDE, with binaries available for Linux, Solaris, and various versions of Windows, and in principle you should be able to build it on any *n*x system where you can get GTK2 to run.

The bad news is that language support is still limited. It has full support for Ada and partial support for C and C++, which are lower priorities for the authors. It comes with instructions for setting up support for your language, but that looks like a non-trivial task.

I've just started playing with it so I can't give a good review, but so far it has been very helpful. The features listed at their Web site are:

• Language-sensitive editor
  
• Automatic generation of body files
  
• Source code reformatting
  
• Intelligent source code navigation
  
• Context-sensitive search and replace
  
• Application builder
  
• Automatic code fixing
  
• Version control (CVS, ClearCase, etc.)
  
• Visual file comparison
  
• Graphical source-level debugger
  
• Project and program entities explorer
  
• Project wizard
  
• Types and program entities graphs
  
• Call graphs
  
• File dependency graphs
  
• Project dependency graphs

This success is typical of Ada projects, and it gives a tremendous feeling of satisfaction. Ada requires that you put in the design time up front; the consequence is that the software almost always works with little or no debugging needed.

Interestingly, one of the more visible OSS projects written is Ada is the GVD, the GNU Visual Debugger. Kind of ironic, really--an excellent choice of language nonetheless.

> I haven't used ADA, but I understand that it is somewhat designed for self-documenting code, and that as a result you are hemmed in on all sides by language rules. (ADA fans please comment here.)

In my experience Ada feels like a strait jacket when you first start using it - especially if you don't come from a Pascal background - but after you get some experience with it it starts feeling very liberating instead.

For a nontrivial program there will be lots of rigorous definitions up front, but once you've made a good set of definitions you can deal with your data very abstractly, so you end up programming at a "higher level" than you would in lots of other languages.

Unfortunately Ada is a "big" language and it will take you a while to absorb all the goodies it provides. On the plus side you can write real programs with a subset of the language that is conceptually identical to Pascal (with just a few syntactic tweaks) and bootstrap your knowledge of the language from there.

Other plusses are the free GNU compiler (GNAT, now rolled into GCC 3.x, but the GCC version not quite ready for prime time yet), lots of on-line reference sites, and some really nice built-in stuff like support for multi-tasking, distributed programming, and multi-lingual programming; OOP; very powerful generics; etc. There's also a first rate and well documented set of bindings for GTK+ in case you want to do some GUI programming.

But possibly the nicest thing about Ada is that its strong typing[*] moves bug-catching forward in the development process. In Ada you will catch a lot of things at compile time that would only be caught at run time in most other languages, and you'll catch things at run time that you would only catch in most other languages if you happen to notice that the output is incorrect. For me those features are priceless, and make the language well worth using even as a beginner when you still feel like the rules are too strict.

* When I say "strong typing" I'm talking about something far beyond what C++ers call "strong typing". Ada programmers laugh when they hear someone say that C++ offers strong data typing.

Callbacks irritate him.

I've used XML Ada successfully, and it uses inheritance instead of callbacks. Maybe that would irritate him less.

It's not always practical to build a tree in-memory.

I'm not sure what that means. At some point you have to grab the information you want, and that may or may not mean building a tree. But it's up to the programmer. The last time I parsed a big XML file was to convert the public Cyc knowledge base into a different format, no tree required.

I'm still not sure what advantage XML has over Lisp. I'm near certain that the hype and giddiness is overdone.

Source Navigator sucks - ugly UI, slow, and overall useless.

Insight is worthless compared to both DDD and gvd.

Both are old Cygnus products that were once state-of-the-art for Unix, but are now ancient relics.

Debuggers aren't flashy or glamorous. I don't know anybody that thinks debuggers are cool. The tools and pieces of a development environment that are going to catch a programmers eye first are what's focused on most. You look at a nicely developed IDE that's polished and slick, and you'll be impressed. It's eye candy that sells products more than anything else.

Sadly, most -programmers- even look at a development environment's debugger as an afterthought. IMHO, it's one of the single most important tools (if not THE most important) and it's what I check out first.

Have you ever used the Gnu Visual Debugger at the GNAT Libre software developers' site? It's a multi-platform (Linux/Unix/Windows), open-source debugger with a "different view" of the world. Check it out, you may be pleasantly suprised.

GVD is the GNU Visual Debugger, developed by ACT. It is entirily written in Ada using GTK+. It can debug programs generated with any of the GCC compilers in a variety of OSs. Check it out here

> Noway does Ada help avoid bugs by being a type cast unless your talking about the stupidest little bugs imaginable.

Unfortunately, stupid little bugs find their way into operational programs. But if you have a compiler that can catch them at compile time, they don't find their way into the operational program. End of story.

Also, notice that for a given programming team the number of stupid little bugs will be proportional to the size of the code base, and for 1.5MLOC that generally translates to a lot of stupid little bugs.

> ADA LACKS the debuggers and useability of C.

I used the VAX debugger with Ada [sic] over a decade ago. For OSS fans, there's GVD, the GNU Visual Debugger, with full Ada [sic] support. Don't let your prejudices lead you into making uninformed assertions.

(BTW, GVD supports C and C++ as well as Ada, and is designed to allow plug-ins to support additional languages, so give it a try if you're a C or C++ programmer and would like to have a visual debugger. I believe it's built on GDB, so its basic operations may already be familiar to many.)

> Its a hard painful language to use and learn and isnt as tried and true as C.

What is your unit of measure for "tried and true"?

> Also Im sure you can get 1.5 million lines into 1 million if you use C.

Are you sure about that? Ada [sic] does require rigorous type definitions, but once you've made them it often lets you program at a very high level of abstraction.

Please save the FUD for audiences that are unfamiliar with the subject matter.

> Ada, eh? I sincerly thought that this language was dead, along with Lisp, Fortran
and Cobol, the other dead dinosaurs-era "programming" languages.

I suppose you're trolling, but in case you aren't...

The current Ada standard is Ada 95, 7 years old. A standard for Ada 0x is under development right now.

There's a surprising lot of stuff going on in the Ada world right now. An Ada compiler will be integrated with GCC starting with version 3.1 (as an optional component, actually, as with Fortran). Also, the new GNU Visual Debugger is written in Ada; it supports languages on a plug-in basis, with plugins currently available for C, C++, and (of course) Ada.

Part of what's driving things like GPS and GVD is the maturation of GtkAda, a "thick" Ada binding of GTK+. This is a very polished free {beer,speech} product: it comes with 475 pages of PostScript documentation. (The bindings are also fully OO.)

I won't bother commenting on the pros and cons of Ada as a language, since everyone knows "My language is best!" -- regardless of who the speaker is.

> [Ada] is not at all dead or outdated. It was updated in 1995...

And the '0X version is under development right now.

> Its even going to be included in the gcc tool chain in v3.1.

FWIW, about two weeks ago I downloaded gcc 3.1 from the cvs snapshot and tried it out. I didn't have time to download/run the test suite, but it worked fine on several of my programs which I did try out. IIRC, the 3.1 branch was supposed to fork off a week or so ago, and the target release date is only a couple of months from now.

Also notice that the GNU Visual Debugger is written in Ada. It currently works for Ada, C, and C++, but is designed to handle additional languages as plugins.

> Simplified GUI - there's a variety of bindings to various APIs, from X-windows to SWING to W32.

Increasingly popular for Ada is GtkAda, a thick, well-documented, OO binding for Gtk+. It is portable between *n*x and Windows.

> Garbage Collection ... When you want dynamic allocation, you can choose to rely on the compiler's garbage collection, if it exists, but you're also given tools for explicit disposal of garbage.

IIRC, the language spec makes garbage collection optional, and almost no one implements it.

> So why isn't Ada-95 used by anyone? Because ... it's designed by a committee (like Linux - one really good designer Jean Ichbiah, then peer review) ...

"Designed by committed" is the sort of argument prejudice evokes when there aren't any real arguments. People use stuff designed by committee all the time withoug whingeing about it. The argument ought to be about the design, not about the designer(s).

I know that suggesting a different programming language usually gets the same kind of reception that suggesting swapping underwear would, but why not consider writing it in Ada 95?

The learning slope will be very steep at first, but once you get the hang of it it will pay off in spades. Ada is a software engineering language, and it makes you do a good bit more thinking before you start spilling code, but over the long haul you end up spending most of your time in the think-program cycle rather than in the more popular but IMO less satisfying program-debug cycle.

Pros:

• Ada is designed for large software projects.
  
• Bullet-proof against buffer overflows and such.
  
• Supported by GVD (the visual version of gdb).
  
• Very strong portability properties.
  
• Supports both high-level and low-level programming. (OO, generics, etc. all the way down to in-line machine code. But all are optional; you can write simple code when that's what the problem calls for.)
  
• Built-in support for multitasking and distributed computing, if you want it. (And distributed might be the way to go for a big-game server.)
  
• If you need a GUI there are thick bindings for GTK+, portable between UNIX and Windows. These bindings are OO, so you can create custom widgets by inheritance.
  
• Everything mentioned above is available for free.

• The aforementioned learning curve.
  
• Probably fewer volunteers on the project once it gets big.
  

I know that suggesting a different programming language usually gets the same kind of reception that suggesting swapping underwear would, but why not consider writing it in Ada 95?

The learning slope will be very steep at first, but once you get the hang of it it will pay off in spades. Ada is a software engineering language, and it makes you do a good bit more thinking before you start spilling code, but over the long haul you end up spending most of your time in the think-program cycle rather than in the more popular but IMO less satisfying program-debug cycle.

Pros:

• Ada is designed for large software projects.
  
• Bullet-proof against buffer overflows and such.
  
• Supported by GVD (the visual version of gdb).
  
• Very strong portability properties.
  
• Supports both high-level and low-level programming. (OO, generics, etc. all the way down to in-line machine code. But all are optional; you can write simple code when that's what the problem calls for.)
  
• Built-in support for multitasking and distributed computing, if you want it. (And distributed might be the way to go for a big-game server.)
  
• If you need a GUI there are thick bindings for GTK+, portable between UNIX and Windows. These bindings are OO, so you can create custom widgets by inheritance.
  
• Everything mentioned above is available for free.

• The aforementioned learning curve.
  
• Probably fewer volunteers on the project once it gets big.
  

> The biggest problem at the moment is that none of these "safer" languages has yet developed the same raw expressive power of C++.

Take a look at Ada. Extremely safe, extremely powerful, extremely unpopular. Go figure.

It's object-oriented, it supports generic classes ("packages", in Ada terminology), it has built-in support for multitasking and distributed programming, it lets you (optionally) specify even such details as numeric representations for the ultimate in portability, and it has a set of first-class and well-documented bindings for GTK+.

There's a free compiler called GNAT, which is built on gcc and will actually be rolled in to gcc 3.1 or thereabouts. There's also a Linux-specific site for gathering and distributing component packages.

And pace ESR, it wasn't designed by a committee.

> As for Ada, I suppose you could, but I don't know of any such applications

Granted, there aren't many in the OSS world right now. One gnotable exception is the GNU Visual Debugger, which may well become a "standard" application once word about it gets out a bit more.

FWIW, it supposedly runs under Windows too.

--

GVD, the GNU Visual Debugger, incorporates all the features of regular debugger GUIs and is complemented with data display and visualization capabilities more powerful than those offered by DDD (the Data Display Debugger). GVD provides the ability to debug multi-process/multi-threaded applications in the same debugging session.

Links for those interested in Ada and GVD:

• Ada for Linux
• Ada Power
• GVD: GNU Visual Debugger

GVD, the GNU Visual Debugger, incorporates all the features of regular debugger GUIs and is complemented with data display and visualization capabilities more powerful than those offered by DDD (the Data Display Debugger). GVD provides the ability to debug multi-process/multi-threaded applications in the same debugging session.

Links for those interested in Ada and GVD:

• Ada for Linux
• Ada Power
• GVD: GNU Visual Debugger

GVD, the GNU Visual Debugger, incorporates all the features of regular debugger GUIs and is complemented with data display and visualization capabilities more powerful than those offered by DDD (the Data Display Debugger). GVD provides the ability to debug multi-process/multi-threaded applications in the same debugging session.

Links for those interested in Ada and GVD:

• Ada for Linux
• Ada Power
• GVD: GNU Visual Debugger

GVD, the GNU Visual Debugger, incorporates all the features of regular debugger GUIs and is complemented with data display and visualization capabilities more powerful than those offered by DDD (the Data Display Debugger). GVD provides the ability to debug multi-process/multi-threaded applications in the same debugging session.

Links for those interested in Ada and GVD:

• Ada for Linux
• Ada Power
• GVD: GNU Visual Debugger

Why we chose GtkAda instead of Gtk+... Another reason was to reduce the time we spent developing GVD. Using GtkAda and GNAT, we can decrease time to market by a factor of two to four over any other language/compiler.

Note that might want to have a look at the Ada 95 language, it has pretty good support for portable multi-threading (aka tasking, builtin into the language) and a very good compiler: GNAT.

Laurent

I've been usign GVD for a couple of weeks and works well with multithreaded programs:

http://www.act-europe.fr/gvd"

And it also supports native and cross debuggers (VxWorks, LynxOS, JVM, ...), remote launching of debuggers, different languages, etc.

--
To visit or not to visit: findusclub.com

On the other hand, I've experienced that LinuxThreads (the thread implementation provided by GNU libc) and GDB don't mix too well. Maybe you can try another pthreads implementation, for example the one from Florida State University (FSU Threads).

The gnu visual debugger is based on gdb, and claims to have much-improved support for multithreaded code. I haven't used it myself, though.

If you're considering a different language, Ada is worth a look. Gnat is a complete and stable compiler in a way that g++ is not, and the language was designed for multithreading from the start.

Not strictly an IDE, but you might be interested in GVD, the brand-new Gnu Visual Debugger.

It's written in Ada, but more importantly for you, it currently supports debugging for Ada and C. Other languages are supposed to follow.

--

Note that the DoD did require the GPL when they funded the development of the GNU Ada front-end to GCC, aka GNAT, a while ago (circa 1995).

Now GNAT is of course still free software and ACT and ACT Europe are continuing the development and offer paying support services. Up to now they released sources from time to time, but it looks like the Ada front-end sources will be included soon in the CVS GCC repository, see the discussions on the GCC mailing list.

Disclaimer: I worked for ACT, but I no longer do, and at work I'm a client of ACT support services.