One thing I liked about Ada is that the authors of the language also wrote why they choose things the way they are, what was rejected, etc... Their is a document about this called "The Ada Rationale" available on the web:<p><a href="http://www.ada-auth.org/standards/rationale12.html" rel="nofollow">http://www.ada-auth.org/standards/rationale12.html</a><p>I did contribute the HTML version of the Ada 1995 Rationale (first language revision) back in the day:<p><a href="https://www.adaic.org/resources/add_content/standards/95rat/rat95html/rat95-contents.html" rel="nofollow">https://www.adaic.org/resources/add_content/standards/95rat/...</a>
I spent about 4 years of my early career working with Ada in the aerospace industry (specifically, I worked on the GPS satellite program). It was rather career-limiting because I ended up as a young engineer with a lot of experience in an extremely niche language.<p>It took a while, but I was finally able to escape and start working with more modern technology (involved a lot of self-learning on side projects and finally finding a rare employer that believed engineers are capable of learning new skills).<p>I do occasionally get emails from recruiters looking for Ada programmers - they're exclusively for legacy maintenance. Fortunately, I'm in a position to ignore them now :)<p>As a language, Ada isn't bad. I'd prefer it over C++ or Golang for sure, but there just isn't enough interesting work going on using Ada to warrant investing time in learning the language.
The GNAT Ada compiler is open source, generates good code, and has really good error messages. There's a story behind its development, which I tried to summarize here:<p><a href="https://dwheeler.com/essays/make-it-simple-dewar.html" rel="nofollow">https://dwheeler.com/essays/make-it-simple-dewar.html</a>
The original open source Ada83 compiler that grew into GNAT for Ada95 was written in setl.<p>The author of GNU setl has said he would release the source, but we're still waiting. There are binaries here:<p><a href="https://setl.org/setl/bin/" rel="nofollow">https://setl.org/setl/bin/</a><p>(No NetBSD ones though, forcing us to use emulation)<p>Ada reminds me of spitbol, and setl can be written in spitbol. R K Dewar's spitbol, written in a portable assembly language called MINIMAL, has been open-sourced. There's a version of setl written in spitbol, too. Hopefully we will have the source for setl one day.<p>The author's dissertation on setl is a favourite of mine:<p><a href="https://web.archive.org/web/20060823004442if_/http://www.cs.nyu.edu:80/~bacon/phd-thesis/diss.pdf" rel="nofollow">https://web.archive.org/web/20060823004442if_/http://www.cs....</a><p>See also<p><a href="https://web.archive.org/web/20100217021505if_/http://www.setl-lang.org:80/docs/setlprog.pdf" rel="nofollow">https://web.archive.org/web/20100217021505if_/http://www.set...</a>
I got to use Ada for eight months in 1997, on a co-op at Rockwell-Collins in their General Aviation department. I learned and wrote a lot of Ada and I loved it. When I had to go back to school in the fall, I was no longer interested in writing C++ and it kind of bummed me out to have to use it again.
Another thing is that the language backers made sure the ISO standard was available at no cost which was not obvious in the eighties so students could read it.<p><a href="https://en.wikipedia.org/wiki/ISO/IEC_8652" rel="nofollow">https://en.wikipedia.org/wiki/ISO/IEC_8652</a><p>I was told that the Ada guyes fought with ISO to have a per paragraph numbering to ease translations and references, ISO (at the time, don't know now) was line numbered, but they lost.
I wish Rust had Ada's type system. It makes a lot of sense to define types specific to your algorithms and have the storage type determined at compile time.
I'd be very interested in someone with substantial experience in Ada/Spark providing some insight:<p>* Why did Ada not manage to get a significant foothold outside of some small domains?<p>* What's great, what's not so great about it?<p>* How "modern" does the language feel, including the tooling, documentation, etc? Specifically Spark 2014. ( I see a LSP server and VSCode plugin, for example)<p>* Spark2014 seems to be open source, with a GPLv3 license. Is this what most companies use, or are there significant closed source parts that must be bought?
Are most companies still on older versions?<p>* What other languages are most similar?
Looks like a good tutorial, but it doesn't go into much depth on memory-management. The <i>More About Types</i> section has a little. It mentions that automated reference-counting is available through the GNATCOLL library, which seems to have since been broken apart into three different packages [0], so it now resides in <i>gnatcoll-core</i> [1].<p>Can anyone comment on memory-management in Ada?<p>[0] <a href="https://github.com/AdaCore/gnatcoll" rel="nofollow">https://github.com/AdaCore/gnatcoll</a><p>[1] <a href="https://github.com/AdaCore/gnatcoll-core/blob/master/src/gnatcoll-refcount.ads" rel="nofollow">https://github.com/AdaCore/gnatcoll-core/blob/master/src/gna...</a>
Fun fact GNAT (GCC Ada front-end) will use a biased representation for range type when packing tight:<p><pre><code> with Ada.Text_IO; use Ada.Text_IO;
procedure T is
type T1 is range 16..19;
type T2 is range -7..0;
type R is record
A : T1;
B,C : T2;
end record;
for R use
record
A at 0 range 0 .. 1;
B at 0 range 2 .. 4;
C at 0 range 5 .. 7;
end record;
X : R := (17,-2,-3);
begin
Put_Line(X'Size'Image); -- 8 bits
end T;</code></pre>
Very nice introduction. For those interested in a modern language that has a strong type system as in Ada and it is also growing safety capabilities à la SPARK, you might want to check out Nim.<p><a href="https://nim-lang.org/" rel="nofollow">https://nim-lang.org/</a>
<a href="https://nim-lang.org/blog/2020/06/08/static-analysis.html" rel="nofollow">https://nim-lang.org/blog/2020/06/08/static-analysis.html</a>
Ada was the first language I learned at university back in 2003 (I had previously taught myself C/C++, Assembler and VB). It had a huge impact on me and influenced my entire career and how I approach software engineering. These days languages like Erlang and Haskell are carrying on some of the ideas (modularity, type safety, concurrency, etc.) in more modern incarnations. But there is still something special about Ada.
Their marketing folks should introduce Ada certification.<p>Many developers would jump through hoops to get any dodgy certification. I have seen dubious FEMA certifications and NFA certifications on some LinkedIn pages.
Petty and inconsequential as this sounds, I'm convinced Ada go have gone farther if it didn't have capitals and underscores in all their libs, and long keywords like `procedure`. All that shift-key action makes Ada a physically painful language to work in.
There are many industries that could benefit from Ada, but one in particular is the games industry, but then, they'd also have to start designing stuff, stop feature creep and changing every little thing all the time, and crunch.
I like that the primitives types are so refined in Ada. That's something that is missing in a lot of languages. You can define subtypes or different types and ranges from the integer type for example.<p>A few years ago, I wrote a little blog entry about it: <a href="https://www.dialectical-computing.de/blog/blog/2011/05/08/dear-language-designers-do-not-forget-ada/" rel="nofollow">https://www.dialectical-computing.de/blog/blog/2011/05/08/de...</a>
Does any other programming language use “Ada case” identifiers (mixing uppercase and underscores like "XML_HTTP_Request") instead of camel case ("XMLHTTPRequest" or "XMLHTTPRequest") or snake case ("xml_http_request")? Ada case avoids the ambiguity of lowercasing acronyms or smooshing together of words.<p>(Yes, I know the actual capitalization of my example identifier in JavaScript is "XMLHTTPRequest". That’s what makes it such a good example. :)
BTW this satellite was launched yesterday coded in ada :<p><a href="https://blog.adacore.com/using-ada-for-a-spanish-satellite-project" rel="nofollow">https://blog.adacore.com/using-ada-for-a-spanish-satellite-p...</a>
Maybe somebody remembers better, but I remember when I looked into it over a decade ago, GNAT had the problem that it didnt have a GNU library linking exception or so. Does anybody remember the history?<p>Also I still find the whole environment confusing for windows. GNAT Programming Studio IDE seems to be useful, but what ballpark is the pricing for the commercial version. Anybody has an idea?
I was a freshman CS student in 2007 and this was the language that I learned in CS 101. I wonder how common that was.<p>Frankly, that was my first exposure to programming, and I thought the language was strange enough and the prof wasn't good enough, so switched majors. Still the only formal programming education I've had.
Totally unfamiliar with Ada, but reading below it seems that type safety and concurrency are big selling points of it. In which way would this better than a modern functional language, say F#?
My comments on Ada: <a href="https://news.ycombinator.com/item?id=23808305" rel="nofollow">https://news.ycombinator.com/item?id=23808305</a>
I've been intrigued by Ada for some years, but never really dived into it too much. I dont mind the language, but the tooling always seemed weird to me and it feels like any real world use of the language seems like its been relegated to legacy maintenance. Most of the time if I see Ada in a job description, it makes it seems like its something that's nice to know because there's a sliver of a chance you might have to rewrite or modify it, but majority of work will be done in something like C++, which is a shame.
Shame that the tools for Ada go from bad to worse even in the best case scenario. It's no wonder nobody really wants to use the language when other languages have all sorts of tools and ecosystems around them that make everything a breeze.