Forgot your password?
typodupeerror
Programming IT Technology

The Return of Ada 336

Posted by Zonk
from the lord-byron-will-be-in-the-sequel dept.
Pickens writes "Today when most people refer to Ada it's usually as a cautionary tale. The Defense Department commissioned the programming language in the late 1970s but few programmers used Ada, claiming it was difficult to use. Nonetheless many observers believe the basics of Ada are in place for wider use. Ada's stringency causes more work for programmers, but it will also make the code more secure, Ada enthusiasts say. Last fall, contractor Lockheed Martin delivered an update to ERAM, the Federal Aviation Administration's next-generation flight data air traffic control system — ahead of schedule and under budget, which is something you don't often hear about in government circles. Jeff O'Leary, an FAA software development and acquisition manager who oversaw ERAM, attributed at least part of it to the use of the Ada, used for about half the code in the system."
This discussion has been archived. No new comments can be posted.

The Return of Ada

Comments Filter:
  • I used ada.... (Score:4, Informative)

    by aldousd666 (640240) on Tuesday April 15, 2008 @12:01PM (#23079338) Journal
    In school. It wasn't actually any different from very many other languages that have huge class libraries, it's just that they were all 'included' in the langauge instead of linked in separately. It's more verbose and stuff, but I didn't see any completely foreign concepts in Ada that aren't around in most other langauges. Just more typing, from what I remember.
    • Re: (Score:2, Insightful)

      by Xipher (868293)
      I had to use Ada in my Data Structures class with John McCormick at UNI http://www.cs.uni.edu/~mccormic/ [uni.edu] This guy teaches a tough class but you end up learning a lot, and he is very big on Ada. While I haven't used it much since I did like a lot of features in the language.
      • by Teese (89081)
        yea, but mccormick was the only one who taught using Ada, practically every other class was c++ (well, except for Wallingford). Of course I was there 10 years ago, I guess I have no idea what goes on there now.
    • The great part about being a programmer for the Air Force is how easy it was to get a waiver to use a more appropriate language. ADA was used in tech school and that was about it.

      Now that I've left I STILL find ADA code running from the 70s. Upgrading it is a major bitch but If you are going to sling code for the government it would be good to know the basics.

      The ability to import java and c into ADA are a real boon.

      • Re: (Score:3, Informative)

        by aldousd666 (640240)
        They used it in real school too, I never had a java course, and I get along just fine today in 'the real world.' Admittedly I don't use Ada either, but it worked well enough for Data Structures and Algorithms classes.
      • Re:I used ada.... (Score:5, Informative)

        by SL Baur (19540) <steve@xemacs.org> on Tuesday April 15, 2008 @02:22PM (#23081190) Homepage Journal

        Now that I've left I STILL find ADA code running from the 70s.
        Ada didn't become Ada until 1983. Commercial compilers were still stabilizing five years later. So, if you had working Ada code you had a time machine and you also had a compiler from the future. See (all of the criticisms of Ada were true at the time I wrote it) http://homes.cerias.purdue.edu/~spaf/Yucks/V1/msg00096.html [purdue.edu]

        Now that I'm not forced to work with it, I feel nostalgia sometimes. I built a GNAT RPM for Turbolinux, but I don't they ever distributed it. How is GNAT nowadays?
    • Re:I used ada.... (Score:5, Insightful)

      by TargetBoy (322020) on Tuesday April 15, 2008 @12:37PM (#23079860)
      Likewise, I also used Ada in college.

      I found it very easy to work with and is only slightly more verbose than VB or PowerBuilder.

      Frankly a language that forces programmers to do the right thing up front might just be the thing to do. It's always faster to re-type something than to try to find the bug in your code after it is running.

      • Re:I used ada.... (Score:5, Interesting)

        by Not The Real Me (538784) on Tuesday April 15, 2008 @03:07PM (#23081868)
        "Likewise, I also used Ada in college."

        I too used Ada in college. Ada is a superset of Pascal. It's very similar to Borland's Delphi and Oracle's PL/SQL, which are basically their versions of Object Pascal.

        The FAA should've used Java. Then the project would've taken 3x longer and had cost overruns of 400% and/or would've gotten cancelled, like most government projects.
    • Re: (Score:3, Insightful)

      by harmonica (29841)

      It's more verbose and stuff, but I didn't see any completely foreign concepts in Ada that aren't around in most other langauges.

      However, Ada had a lot of those concepts working reliably in 1983 and 1995 (the years the first two major versions were released if I remember correctly), when most other people were using not-so-sophisticated languages, to put it mildly.

      Getting into Ada is rather complicated and time-consuming, though, so it's not surprising that it never took off in a big way.

    • Re: (Score:3, Informative)

      by Orion Blastar (457579)
      Ada is very much like Pascal, but with a black box strategy.

      Sure class libraries are not included with Ada as they are in Pascal, C++, Java, et all. But the advantage of Ada is that each team developing a part of the program can write their own piece of it and only release the APIs needed to interface with that piece of the program without seeing the source code. For example you can write functions and procedures into a class library and keep it secret so only members on your team can see the source code,
  • by thedak (833551) on Tuesday April 15, 2008 @12:05PM (#23079390) Journal
    I may just be a whippersnapper, get off my lawn and whatnot; as a Java, C, C++ coder, but the project being completed under-budget and pre-deadline and having that attributed to Ada itself seems rather misguided to me.

    As far as I'm concerned, if a competent team is hired; skilled programmers and developers, then anyone could get it done under-budget and pre-deadline. (yes, yes, military intelligence, oxymoron, but it seems to have worked out with this project)

    I think the headline could later read, "the return of C", or any other language in the future if a team manages to finish a project efficiently due to the use of skilled developers.

    Not necessarily a praise of language used is necessary, and a congratulatory beer for the team may be advised.
    • Oddly, they're saying a language which is slower for people to write, and considerably more obscure than most languages, is the reason something is done under-budget and quickly? It seems like those traits would make it more secure, but take much longer to make...
      • by Digi-John (692918) on Tuesday April 15, 2008 @12:14PM (#23079554) Journal
        Perhaps a language which is slower and a bit more difficult to write prevents programmers from dumping so many lines of semi-working crap, requiring them to put a little more thought into the code?
        • Re: (Score:3, Interesting)

          by hey! (33014)
          I think there is something to be said for this idea. Not too much, mind you, but something.

          Let's imagine a language so obscure and difficult, that 90% of working programmers cannot gain sufficient mastery of it to understand what it is saying at first glance. This sounds terrible, until you realize that every programmer at some time in his life has written code in "friendly" languages that 0% of programmers (including his future self) can understand. And maybe selecting a language that only the top 1% of
          • by naasking (94116) <naasking AT gmail DOT com> on Tuesday April 15, 2008 @02:40PM (#23081516) Homepage
            Let's imagine a language so obscure and difficult, that 90% of working programmers cannot gain sufficient mastery of it to understand what it is saying at first glance.

            Wouldn't work. C++ is just such a language for example, but this provides no such barrier to poor programmers and poor code! ;-)
        • Re: (Score:3, Insightful)

          by Abcd1234 (188840)
          Nah. "Hack it 'til it compiles" still works in a strict language. It just takes a little longer.

          The reality is, bad programmers will inevitably generate bad code. Skilled programmers, however, can always write quality code, regardless of the language, however they will also be able to utilize available language features (such as DBC, etc) to improve their work. At least, IME.
      • Re: (Score:3, Insightful)

        by larry bagina (561269)
        Aside from writing code, you also have to test it. That extra security/straightjacket can mean it works right the first time.
        • Re: (Score:3, Insightful)

          by somersault (912633)
          That's what I was thinking too. Testing should be a major part of any project - and especially one where large pieces of metal hurtling through the air are involved :p
        • Re: (Score:3, Insightful)

          by Kartoffel (30238)
          Mod parent up. Bondage and discipline prevents sloppy hack jobs, yet hinders quick hackish projects. For small projects, rapid hacks are ok. For large projects, you want thoughtful organization and testing along the way.
        • by bnenning (58349) on Tuesday April 15, 2008 @03:58PM (#23082534)
          That extra security/straightjacket can mean it works right the first time.

          Or not. I'm not quite sure why, but my Python code has a significantly higher frequency of working right the first time than my Java code, and that's after developing in Java for 10 years and Python for less than 2. My theory is that it Java's static typing and verbosity consumes a portion of my mental energy that makes it harder to focus on the actual algorithm.
          • Re: (Score:3, Interesting)

            by Samah (729132)
            I don't understand why people love dynamic typing so much. I'd much rather the compiler tell me off for misusing a variable than at runtime where it might not crop up until the code is in production. I'm not saying dynamic typing is BAD (I love Lua), just that I don't get why so many people can possibly hate static typing.
            Also I don't think you can really label Java as "verbose" when it shares mostly the same the syntax as C++ and C# (unless you assume those to be verbose too).
            Having said that, it's not
      • by everphilski (877346) on Tuesday April 15, 2008 @12:19PM (#23079616) Journal
        Oddly, they're saying a language which is slower for people to write, and considerably more obscure than most languages, is the reason something is done under-budget and quickly? It seems like those traits would make it more secure, but take much longer to make...

        You need to make a distinction: they weren't writing new code, they were updating existing code. This is a very important distinction. We are all aware of "code rot" [wikipedia.org], etc. and how over time documentation gets lost, people have to re-learn a piece of code based purely on the source, etc. However they took an older piece of code and revamped it, right on time and under budget. This is notable, and may be attributable to some of the properties of Ada [wikipedia.org].

        Maybe, maybe not, but there's a good chance it had something to do with Ada.
        • by Ephemeriis (315124) on Tuesday April 15, 2008 @01:08PM (#23080290)

          You need to make a distinction: they weren't writing new code, they were updating existing code. This is a very important distinction. We are all aware of "code rot" [wikipedia.org], etc. and how over time documentation gets lost, people have to re-learn a piece of code based purely on the source, etc. However they took an older piece of code and revamped it, right on time and under budget. This is notable, and may be attributable to some of the properties of Ada [wikipedia.org].

            Maybe, maybe not, but there's a good chance it had something to do with Ada.
          Ada is almost self-documenting. The syntax is all very verbose and human readable.

          If you have to walk in blind and maintain someone else's code, Ada is the language to do it in.
        • by cmeans (81143) <cmeans@intfa[ ]om ['r.c' in gap]> on Tuesday April 15, 2008 @03:04PM (#23081832) Homepage Journal
          Or it could simply mean that they way over budgeted for the work that was actually needed to be performed, and poorly spec'd the time it would take to do it. Normally, companies are more conservative with how long it'll take to do something (this helps bring the cost down and increases the likely hood that they'll get the work), thus, the reality tends to extend the deadline. In this case, they might have just been overly generous in their time allotment, and simply fortunate that the client was willing to pay for it.
      • by afidel (530433)
        Not necessarily, if you only get the top 10% programmers because of the job requirements then it's easy to see where a difficult to learn language could lead to better, more consistent code. I know my coding skills suck which is why I went into sysadmining instead of programming, but I would technically qualify for many programming jobs and could even stumble through making code that would pass general inspection. There really is a TON of difference between a great coder and an average or mediocre coder.
      • by Detritus (11846) on Tuesday April 15, 2008 @12:22PM (#23079658) Homepage
        One of the advantages of a language like Ada is that more problems can be detected at compile time and corrected at low cost, as opposed to languages like C that assume that you know what you're doing and are optimized for speed. Ada also has run-time checks that can catch many problems. It's usually more efficient for the project to do the work up-front, rather than to hack together something and debug it.
        • Re: (Score:2, Insightful)

          by hitmark (640295)
          and debug, debug, debug, reimplement, debug, debug, debug, reimplement, debug, debug, debug, discard/emulate on top of new hacked together system, and the pattern goes on...
      • Re: (Score:3, Insightful)

        by samkass (174571)
        Not at all. Most of the time spent between project kickoff and software delivery is NOT spent actually typing the code. If you program in a language that makes it harder to write bugs, easier to find bugs, easier to express algorithms, easier to read other people's code, and easier to do automated testing and verification you'll save huge amounts of time even if coding takes several times as long.

        Interestingly, that's one of the arguments in support of Java. Hardcore C or C++ hackers find it cumbersomely
        • Re: (Score:2, Insightful)

          by Anonymous Coward

          but it's pretty easy to read any Java coder's source code from anywhere in the world
          Only if India's on the moon.
        • by aldousd666 (640240) on Tuesday April 15, 2008 @12:40PM (#23079898) Journal
          haha in refernce to your java being easy to read by default, you're forgetting about people like this [p-nand-q.com].
        • Re: (Score:3, Insightful)

          by iamacat (583406)
          That is, for those bugs that make it past the relatively extensive automated checks that are possible because of the straightforward syntax.

          Are we talking about the same old Java that doesn't support typedefs and uses Object for all standard data structures? Generics add a bit of syntactic sugar, but do little to ensure safety. You can cast a HashMap to HashMap without any way to check if it is valid at compile OR run time. Compared to that, C++ can be used for safer programming by encapsulating all pointer
      • two words: type safety

        this one feature prevents much debugging and allows better, more automated test coverage.

        they coded slower, but took less time in QA.
      • Oddly, they're saying a language which is slower for people to write, and considerably more obscure than most languages, is the reason something is done under-budget and quickly? It seems like those traits would make it more secure, but take much longer to make...

        Ada may force more up front design and less seat of the pants hacking. This can lead to fewer bugs and less reworking of code. Some of the worst code I've seen came from otherwise intelligent people who jump write in and expeditiously write a l
      • by darkwing_bmf (178021) on Tuesday April 15, 2008 @02:58PM (#23081766)
        You could say it's slower to write, but it's not that slow.
        Ada:
        IF a AND b THEN
          c;
          d;
          e;
        END IF;

        C:
        if (a && b) {
          c;
          d;
          e;
        }

        Ada tends to use words instead of symbols. Does it take longer to type? Yeah, a little. But this doesn't make it hard or obscure. In fact, it makes it much easier for non-programmers (and new programmers) to read and understand the code.

        Why would you care about non-programmers? Because in the real world, programs are written to offer real world solutions. It helps if these programs can be reviewed by engineers, scientists, accountants, etc... who may not know every language, but can figure out the basic logic if it uses words instead of symbols. Also, the improved readability makes future changes less painful.

        What happens if a coworker used & instead of && in the C version? It's a lot harder to make those kinds of mistakes in Ada.
      • Re: (Score:3, Interesting)

        by Darinbob (1142669)
        The problem with software taking too long to write and ending up over budget has little to do with how easy it is to write a line of code. Obscurity should have zero impact on a quality team of programmers (who should all be able to switch languages at a drop of a hat). Writing slowly should have little impact as well, since most programming should rarely involve having to type as fast as you can all day.

        So why does a difference in language make an impact? If a language emphasizes good programming practi
    • by plague3106 (71849)
      I agree, given that only half of the code was Ada code. Maybe it was all the non-Ada code that saved the project from Ada.
    • by Jason King (909684) on Tuesday April 15, 2008 @12:27PM (#23079730)
      Yes, 10 uber-coders can finish a project ahead of 10 clueless coders every time. What Ada does is it makes it harder for the clueless coder to hose the whole system. Because its persnickety you don't find buffer overruns (for example) in the wild. You always get them in test or sometimes they even generate compiler errors. The earlier in the cycle you get your errors the easier they are to fix.
      • Re: (Score:3, Insightful)

        by gbjbaanb (229885)
        Actually, I think its the reason you get uber-coders in the first place.

        If you want cowboy coders, then choose the latest, coolest anguage there is. You'll soon see the muppets who couldn't hack it with an established language who had to do real work with real systems using it. By saying they work with the latest, they get to blame the language "its a learning process", or just by following where the money is.

        Coders who insist on the latest stuff are always worse than the people who are content to work in t
    • by wfstanle (1188751) on Tuesday April 15, 2008 @12:36PM (#23079846)
      You are forgetting something... Actually writing the original code takes up a small part of the total time spent on a program in its life cycle. There is debugging, testing and updating that have to be considered. I have updated programs written in Ada and in other programming languages. Have you actually had to read code the code written by others? Reading a C or C++ program is not easy. Some say that C (and all of its derivatives) are "Write only languages". At least in Ada, it is easier to make sense of the code that others write.
    • by Tired and Emotional (750842) on Tuesday April 15, 2008 @03:15PM (#23081984)
      Actually the real difference between Ada and many other langauges is that it is possible to code in a way that often guarantees that subsequent changes will either be correct or else will fail to compile. In other words, it makes modification easier. The idea is that local changes cannot have global effects. This was a design goal of the language (look up "beaujolais effect" for some history)

      For example, suppose you want to add a new value to an enumeration. As long as you adopt certain style conventions (avoiding default clauses) if you miss any places where you need to deal with it, you will get an error at compile time.

      The overloading rules work well too because the result type is also involved in overload resolution. So you can have i := foo(); and a := foo(); call different foo's if i and a are different types. If i and a start out the same type and later one of them has to change, you just change it and you will get an error message on the call to foo that you need to fix until you provide the missing implementation.

      Plus the fact that you have modules and a good system (in Ada 95) for hiding implementations, and a much better controlled system of generics than in C++ means you have better control over your system. You are never going to have your executable blow up from 10 M to 200M overnight because you added a template declaration.

      As for verbosity, it really isn't. More perhaps than C/C++ but nothing like COBOL. However it does pay to use a slightly more verbose style than is absolutely essential by always fully qualifying names, but the same is true in C++.

      The one weirdness that catches out beginners is that arrays passed as parameters retain their lower bound. So when dealing with substrings, for example, you have to be prepared for non-zero (or 1) lower bounds. But its easy to do.

    • by Darinbob (1142669) on Tuesday April 15, 2008 @03:17PM (#23082004)
      "Return of C"? Has it ever gone away? I use it all the time in places where C++ is too bloated and assembler isn't required.

      I think C is the languages that killed Ada. Ada was about code safety and correctness, and C was about being able to break the rules. Early Ada also did not give sufficient access to the underlying machine, which made it suitable for applications but not so much for systems work where C excelled. By the time Ada evolved, C was already entrenched as the system language and C++ was starting to dominate applications.

      As a language, Ada is great. Maybe a few nits I'd change, but very well grounded and building on the solid base of Pascal and Modula-II.
  • by Zordak (123132) on Tuesday April 15, 2008 @12:07PM (#23079428) Homepage Journal

    Ada's stringency causes more work for programmers, but it will also make the code more secure, Ada enthusiasts say.
    So... you're saying I should ideally program my firewall in INTERCAL?
  • Ada (Score:5, Informative)

    by nwf (25607) on Tuesday April 15, 2008 @12:11PM (#23079514)

    I took a class in Ada for a previous employer. I found it a lot like Pascal and not all that difficult. The main issue was the cost of compilers which had to go through an expensive certification process. I did find the language a but verbose for many things, e.g. here [adapower.com]

    The real issue isn't that it's hard to learn, it's that it's a little cumbersome, but more importantly, not many people know it and they typical clueless manager wants to see 10+ years of Ada experience on the resume/cv before hiring someone. Those people are few and far between, but and competent software developer can learn it.

    • Re:Ada (Score:5, Insightful)

      by Maaras (1171713) on Tuesday April 15, 2008 @12:28PM (#23079738)
      You hit the nail on the head. I wrote Ada on a defense project for about 4 years. From a purely technical standpoint, it is the best programming language that I have ever used. However, in the real world, other concerns tend to dominate. Concerns such as IDE's (AdaCore's IDE was exceptionally slow and hard to use, on Solaris, at least.) and finding developers who know Ada (or are willing to REALLY learn it) counter-balance a lot of Ada's strengths. What good is the best language on Earth if you can't get developers to use it?
  • by msgmonkey (599753) on Tuesday April 15, 2008 @12:14PM (#23079556)
    Most projects do not meet their goals and/or timeframes from bad project management. Whilst the choice of language is obviously important, I have never heard of choice of language being a major factor when reporting on contracts that are over due/over budget or plain just dont work.

    I'm just worried that some PHB will read this and go, "Hmm, Ada, we must use that!"

    Btw Ada is n't that bad a language, but does n't guarentee success. I remember being told that an Ariene rocket that exploded mid flight was written in Ada, the cause was a overflowing integer.
    • Btw Ada is n't that bad a language, but does n't guarentee success. I remember being told that an Ariene rocket that exploded mid flight was written in Ada, the cause was a overflowing integer.

      I was wondering if anyone would mention that - the first non-flight of the Ariane 5 booster [wikipedia.org].

      It's possible to program bugs in any real programming language...
    • by Mikkeles (698461)
      '...Ariene rocket that exploded mid flight...'

      That was the first Ariene V flight. Wikipedia has an article [wikipedia.org] and the accident report is here [mit.edu].

      Basically, the error was an integer overflow in code reused from the Ariene IV for which the range check had been deliberately eliminated as a performance measure since (in the Ariene IV) it could not overflow. That assumption is not valid for the Ariene V.

      To add insult to injury, the functionality provided by the component is not needed at or after liftoff, so could s

  • by r00t (33219) on Tuesday April 15, 2008 @12:19PM (#23079612) Journal
    All that vulnerable client-side code (image libraries, HTML parser, etc.) would be immune to buffer overflows if it were in Ada.

    Even better, write it in proof-carrying Ada. (while an aritrary theorem prover is impossible, one can get a theorem prover to work in practice via minor tweaks to the input)
    • Re: (Score:3, Informative)

      by dpilot (134227)
      I was grabbing someone's .sig and stuffing it into my "quotes" file, and found this relevant tidbit...

      Imagine a surgeon who discovers how much money can be saved by purchasing Xacto blades instead of using blades manufactured to more stringent standards. That is exactly the situation we are currently facing when contractors decide to use C or C++ instead of Ada. On the surface one gets the same result. It is only that superficial result that counts for the lowest bidder.

      - Richard Riehle
      • Re: (Score:3, Insightful)

        by Nimey (114278)
        Unix syscalls in Ada: like ripping your cock off to give yourself head. -- anonymous
  • Generating Ada CSDs (Score:5, Informative)

    by HockeyPuck (141947) on Tuesday April 15, 2008 @12:23PM (#23079680)
    If anyone is programming in Ada, I highly recommend the program jGRASP http://www.jgrasp.org/ [jgrasp.org]. From the site:

    jGRASP is a lightweight development environment, created specifically to provide automatic generation of software visualizations to improve the comprehensibility of software. jGRASP is implemented in Java, and runs on all platforms with a Java Virtual Machine (Java version 1.5 or higher). jGRASP produces Control Structure Diagrams (CSDs) for Java, C, C++, Objective-C, Ada, and VHDL; Complexity Profile Graphs (CPGs) for Java and Ada; UML class diagrams for Java; and has dynamic object viewers that work in conjunction with an integrated debugger and workbench for Java. The viewers include a data structure identifier mechanism which recognizes objects that represent traditional data structures such as stacks, queues, linked lists, binary trees, and hash tables, and then displays them in an intuitive textbook-like presentation view.
    Another great product from the academic community.
  • by ErichTheRed (39327) on Tuesday April 15, 2008 @12:27PM (#23079732)
    I don't think I'm the only one who has had to work with really lousy programming and IT coworkers. One of the good things about the past was that programmers had a much harder time hiding their mistakes. In the days of dual-core processors and tons of RAM, even a mediocre programmer can get Java or any of the .NET languages to produce code that works. Of course, readability, maintainability and speed aren't really a factor.

    Is going back to Ada and other similar languages a good idea? Maybe. But I think you could get the same result by just demanding better quality work out of existing languages. People have correctly pointed out that the languages aren't really to blame, because you can write garbage in just about any language.

    I sound like an old fogey, but I'd much rather see a smaller IT workforce with a very high skill set than a huge sea of mediocre IT folks. This would help combat outsourcing and the other problems affecting our jobs. Almost everyone I've heard complaining the loudest about outsourcing has been either downright lazy or just not very good at what they do.

    I'm primarily a systems engineer/administrator. There are many parallels in my branch of IT to the development branch. We've got the guys who can really pick a system apart and get into the guts of a problem to find the right answer. We also have the ones who search Google for an answer, find one that solves half the problem, and wonder why the system breaks a different way after they deploy it.

    Not sure how to solve it, but I think it's a problem that we should work on.
    • Re: (Score:3, Insightful)

      by Petaris (771874)
      Whats wrong with searching Google?

      Its a tool that can lead you to valuable information just as asking a colleague or consulting a book or other publication can. No one knows everything or has come across every issue, but there is usually a good chance someone has. Just because you have seen someone use it to find information who then did a half-assed job of fixing the issue doesn't mean the tool they used is no good or always lends itself to half-assed fixes.
      • Nothing's wrong with _starting_ your search there. I'm referring to the people who find the first word match on Google, and treat that answer like it's religion. It really takes someone who has practical experience to figure out which advice is good and which will lead you down a bad road.

        Just peruse any IT forum site for common tech questions. You will see 10 answers for the same question, some of which are totally ridiculous. However, they're not totally ridiculous to someone who hasn't worked in the fiel
  • by Alistair Hutton (889794) on Tuesday April 15, 2008 @12:28PM (#23079742) Homepage
    I'm actually quite fond of Ada as a language. Yes, it's a very verbose language but unlike, say Java or C#, the verbosity gives you a lot of stuff. It gives you good threading. It gives you a very good encapsulation. It gives you a very nice parameter system for procedures/functions That's a point, it seperates between procedures and functions. It gives very, very, very good typing. Very good typing. It's very good. I like it. It's what I want when I'm doing strong, static typing rather than the wishy-washy getting in the way mess that many other main-stream languages. When I use a type I want it to mean something. It's a good language to teach students about programming in my opinion.
  • by museumpeace (735109) on Tuesday April 15, 2008 @12:31PM (#23079790) Journal
    I make a nice living rewriting Ada systems into C++. When DoD suspended the "only quote us system development costs based on Ada" requirement, most bidders dropped Ada like a burning bag of poop. Its best advances such as exception handling have been picked up by modern system programming languages and even Java. The doctrinaire variable type enforcements have yet to be equaled but OO it really aint. Bottom line, plenty of old defense software systems have few living authors who will admit to knowing the code and upkeep is expensive, talent hard to find. This is ironic since DoD spec'd Ada in the first place because it had a maintenance nightmare of hundreds of deployed languages. So of course the managers think a more popular language with "all the features" of Ada should be a porting target. Eventually even customers demanded modernization and compatibility ports.

    I know a few die hard Ada programmers who just love it...but very few. The brilliance of the language can be debated but its moot: no talent pool to speak of.

    And besides, Ada is really French. [why did GNU make an ada compiler??????????????]

    technology market: you can't separate technical merits from market forces
    open source: your market has a small leak and is slowly collapsing.
  • by BigGar' (411008) on Tuesday April 15, 2008 @12:32PM (#23079804) Homepage
    That was my aunt's name and she passed away many years ago.

    I was running out the door with my zombie survival guide & bug out bag heading for my arctic hideout to escape the impending invasion and I noticed out of the corner of my eye a reference to programming.

    Thank god, Aunt Ada was a tad weird when she was alive, I really didn't want to meet zombie Ada.
  • 1) Ada is cumbersome, especially when you are dealing with character strings of variable length.

    2) Garbage collection is managed by hand.

    3) Poor interfacing with C++. (Well, so has most everything but C++.)

    4) Programs in Ada tend to be HUGE!!!. That's the big one. I'm talking about source code size here, not binary size, which is reasonable.

    5) If you don't know the type of data you're reading in, it's difficult to handle it. This is both a problem and an advantage.

    6) Ada's handling of inheritance is ver
    • by drxenos (573895) on Tuesday April 15, 2008 @01:20PM (#23080458)
      When is the last time you used Ada? 1) See: Ada.Strings.Unbounded 2) Ada leaves that choice up to the programmer (like C++) (see: pragma controlled). The next version of Ada will have an STL-like library, which will at least reduce the need for GC. 3) See: pragma Export(C, Foo, "foo") and Convention(C, Foo). Some compiles even support CPP in place of C, with automatic translation between C++ classes and exceptions. 5) You should always know the type of data you are dealing with (unless you are writing generics, which still has some limits for safety). 6) Ada's dispatching is based on the actual call being made. No need to mark members has virtual (C++) or to just make them all virtual (Java).
      • Re: (Score:3, Interesting)

        by HiThere (15173)
        I didn't say there weren't solutions to those problems. Merely that the problems exist.

        1) Unbounded strings is a partial solution, but it doesn't blend nicely with string constants, so it's not a good solution.

        2) I don't like C or C++ and garbage collection either. I'm considering boost C++ for a project, but I'll probably opt for some language with decent garbage collection.

        3) Exporting a C interface isn't equivalent to good support of C++. Try interfacing Qt to Ada. (It's probably been done, but I mea
    • by T.E.D. (34228)
      This is actually the best post I've seen on this topic so far. I do have some minor issues with it though

      1) Ada is cumbersome, especially when you are dealing with character strings of variable length.

      String issues are the single biggest bugaboo I've seen Cish programmers have with Ada. Ada's built in strings are fixed-sized and sized perfectly to their contents (no Cish null terminator). You'd think this would be a trivial difference, but it completely changes how (and when) you need to create and handle y

  • My first three foundation CS courses (back in 2001) were all taught in ADA. This provides the benefit of qualifying me to talk on the subject, with the drawback of providing a heavily biased opinion...

    Because of the nature of the language, you HAVE to know what you are doing to write a program in Ada. Getting something to compile in Ada pretty much guarantees you get something that will run reliably.

    Schools that train programmers starting with Java or C++ provide the benefit of making their graduates high
  • Hurray! (Score:3, Funny)

    by Zarf (5735) on Tuesday April 15, 2008 @01:11PM (#23080342) Journal
    I worked in Ada for a few years. I guess I better go and dust off my books.

    And, here I spent all that time learning Java. Sheesh.
  • Political Agenda (Score:2, Insightful)

    by David Greene (463)

    Look, can we get beyond the "government is always inefficient" meme? It's just not true. Many government projects come in on schedule and on budget. Some project are late and over budget. Guess what? It happens in the private sector too.

    Government is actually more accountable to the people than private corporations are. Numerous cost controls are in place. Public officials are elected. I have not seen the same level of scrutiny in the private sector.

    So let's move beyond the ultra conservative an

  • Back in the 70s there was a big fuss being made about something called "Structured Programming". A lot of people took notice when a big project, an indexing system for the New York Times was finished with remarkably few errors. Yet, that success did not seem to become the norm. (It's mentioned briefly in the wikipedia article on 'structured programming').

    COBOL used to be touted as a great language because it was 'self documenting'. Yet a lot of retired COBOL programmers got a last hurrah when they were
  • inevitably (Score:3, Funny)

    by fred fleenblat (463628) on Tuesday April 15, 2008 @01:52PM (#23080800) Homepage
    I think the main issue that people are afraid to talk about here is that Ada will soon be replaced by a language based entirely on cat macros.
  • Nasa...
    There was a period where any program projected to be over 50k lines had to be in Ada.

    So they did the only logical thing.. broke projects into 50k line components.

Save gas, don't use the shell.

Working...