
Introduction to Ada - jayp1418
https://learn.adacore.com/courses/intro-to-ada/index.html
======
guerby
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:

[http://www.ada-auth.org/standards/rationale12.html](http://www.ada-
auth.org/standards/rationale12.html)

I did contribute the HTML version of the Ada 1995 Rationale (first language
revision) back in the day:

[https://www.adaic.org/resources/add_content/standards/95rat/...](https://www.adaic.org/resources/add_content/standards/95rat/rat95html/rat95-contents.html)

~~~
pjmlp
It actually quite common in ISO processes, there are similar documents for C
and C++ language revisions.

~~~
_kst_
There are published rationales for C90 and C99, but not for C11.

(Actually the original rationale is for ANSI C89, which differs from ISO C90
mostly in the way the sections are numbered.)

C89:
[https://www.lysator.liu.se/c/rat/title.html](https://www.lysator.liu.se/c/rat/title.html)

C99: [http://www.open-
std.org/jtc1/sc22/wg14/www/C99RationaleV5.10...](http://www.open-
std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf)

~~~
pjmlp
Sure, and it is great the decision that ISO Ada took, I was just pointing that
there were others available.

I bet most people around here aren't aware of those ones for C.

------
jcadam
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.

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).

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 :)

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.

~~~
zerr
Ada is just a language. The 99.99% of the experience you've acquired there
perfectly transfers to any other domain or language - only uneducated HR
gatekeepers won't recognize this.

~~~
elpatoisthebest
Unfortunately in my experience that "only" represents a somewhat large
percentage of HR or hiring managers.

~~~
ithkuil
Then (after you make sure you learn enough of another language to not
embarrass yourself) be a little bit creative in your resume/CV in order to
pass that stupid filter.

~~~
ithkuil
(by which I don't suggest to lie, rather to make sure you mention you have
some experience in popular language even if your primary job didn't use it.
E.g. mentioning the side projects that made you learn C++ will let a recruiter
tick that box)

~~~
Gene_Parmesan
I agree, I see nothing unethical about tailoring your various job-related
communications to the type of person you're speaking with. Especially at large
firms, HR employees are often quite literally just looking to check off boxes.
Obviously you should not outright lie, but we engineering types have a
tendency to take these sort of questions too literally.

I use C# at work. I've programmed in Java here and there and have done some
small projects in it, but we don't use it at my office. If I apply for a Java
job, and the HR rep asks me during the 1st round phone screen if I have Java
experience, I'm going to say yes. When I speak with a more technically minded
person, I can go into the full story, because they have the background
necessary to put it in context.

------
dwheeler
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:

[https://dwheeler.com/essays/make-it-simple-
dewar.html](https://dwheeler.com/essays/make-it-simple-dewar.html)

~~~
e12e
Thank you for posting that. Especially interesting in light of Walter Bright's
comment(s) in this thread.

I didn't quite understand _why_ someone who wrote a c++ compiler would think
Ada was insurmountable - this adds some context.

In my nativité I'd have guessed that writing an Ada compiler was on par with
Pascal (but with more types and stuff). This is probably the same (wrong)
reasoning by which Mr Bright tricked himself into writing a c++ compiler ;)

Ed: note, I was introduced to Object Pascal - not plain Pascal - so that's the
comparison I'm alluding to.

~~~
Lucretia9
Oh Ada is so much more complex than Pascal. I think getting something with the
numeric types is doable in a smaller timeframe, the OO, tasking stuff would be
much harder.

You could knock out an object-Pascal / Oberon compiler in a matter of weeks
imo.

~~~
pjmlp
Oberon and Object Pascal as initially introduced yes.

On their most up to date variants, Active Oberon and Delphi/Oxygen/FreePascal
it will take much longer than just a couple of weeks.

------
1vuio0pswjnm7
The original open source Ada83 compiler that grew into GNAT for Ada95 was
written in setl.

The author of GNU setl has said he would release the source, but we're still
waiting. There are binaries here:

[https://setl.org/setl/bin/](https://setl.org/setl/bin/)

(No NetBSD ones though, forcing us to use emulation)

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.

The author's dissertation on setl is a favourite of mine:

[https://web.archive.org/web/20060823004442if_/http://www.cs....](https://web.archive.org/web/20060823004442if_/http://www.cs.nyu.edu:80/~bacon/phd-
thesis/diss.pdf)

See also

[https://web.archive.org/web/20100217021505if_/http://www.set...](https://web.archive.org/web/20100217021505if_/http://www.setl-
lang.org:80/docs/setlprog.pdf)

~~~
Rochus
Interesting. Never heard of SETL before. There is even a Wikipedia entry:
[https://en.wikipedia.org/wiki/SETL](https://en.wikipedia.org/wiki/SETL).
References 1 and 2 confirm that it was indeed used to implement the first
validated Ada compiler. Didn't know that.

~~~
1vuio0pswjnm7
Another factoid: It was actually SNOBOL (later SPITBOL from Dewar, who was a
founder and president of Ada Core), not AWK, that was the first language to
offer "associative arrays", which are simply called "tables".

~~~
Rochus
I like the story why they renamed from SEXI to SNOBOL, see
[https://en.wikipedia.org/wiki/SNOBOL#Naming](https://en.wikipedia.org/wiki/SNOBOL#Naming).

------
meej
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.

~~~
pjmlp
Ironically what got me into C++ in 1993, was being able to make use of a type
system similar to Turbo Pascal's one that I got to love (I was using TP 6/TPW
1.5 by then), alongside "cheap" compilers and widespread availability on home
computers.

I just used C for a couple of months before being given a copy of Turbo C++
1.0 for MS-DOS, and since then I only used C when the option was outside of my
control.

It already felt primitive in 1992/1993 vs the alternatives, and so far C17 has
hardly changed in that regard.

------
WalterBright
I always liked Ada, from my first reading around 1980 of MIL-STD-1815. Many of
D's features were inspired by Ada.

~~~
e12e
If you have the time, I'd love to hear a bit about why you ended up creating
D, rather than writing an Ada compiler? (Seeing how you wrote a c++
compiler...).

~~~
WalterBright
At the time, I had only written a couple toys. I thought writing an Ada
compiler was impossible. It's also impossible to write a C++ compiler, but I
didn't realize that and did it anyway (several years later, after I'd written
a C compiler). I thought that C++ was just adding member functions and a few
keywords to C.

~~~
Lucretia9
Why didn't you, at least, put in Ada's numeric type system into D? You
would've had a massive edge over C++ right there.

~~~
WalterBright
Probably because I didn't have the Ada spec anymore at the time.

But D did get _ embeddable in numeric literals, a very nice feature that D
made popular and now it's normal in other languages.

------
guerby
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.

[https://en.wikipedia.org/wiki/ISO/IEC_8652](https://en.wikipedia.org/wiki/ISO/IEC_8652)

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.

------
synack
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.

~~~
supplementation
Sorry, can you elaborate? I'm skimming through the documentation and I can't
find a section on having "the storage type determined at compile time", except
for the section on arbitrary-range integers.

~~~
onox
Ada's type system allows you to separate the high-level specification of a
type (which models a problem) and its low-level representation (size,
alignment, bit/byte order, etc.). The language also requires explicit
conversions for two different types even if their underlying representation on
the hardware is the same.

Example 1:

    
    
       type Byte_Count is range 1 .. 4
         with Static_Predicate => Byte_Count in 1 | 2 | 4;  -- Aspects are Ada 2012
    
       type Component_Count is range 1 .. 4;
    
       V1 : Byte_Count      := 3;   --  compiler error: expression fails predicate check
       V2 : Component_Count := V1;  --  compiler error: requires explicit conversion
    

For these two types I'm not really concerned about how they are represented by
the hardware, but I could if I needed to.

Example 2:

Extra constraints added to some pre-defined types:

    
    
       subtype String8 is String
         with Dynamic_Predicate => String8'Length <= 8;
    
       subtype Even_Integer is Integer
         with Dynamic_Predicate => Even_Integer mod 2 = 0,
              Predicate_Failure => "Even_Integer must be a multiple of 2";
    

Example 3:

Use big-endian for some network packets:

    
    
       type Packet_Type is record
          Header : Header_Type;
          Data   : Data_Type;
       end record;
    

Low-level representation (placed in the private part of a package spec):

    
    
       for Packet_Type use record
          Header at 0 range   0 .. 255;
          Data   at 0 range 256 .. 1855;
       end record;
    
       for Packet_Type'Bit_Order use System.High_Order_First;
       for Packet_Type'Scalar_Storage_Order use System.High_Order_First;
       for Packet_Type'Size use 232 * System.Storage_Unit;

------
the_duke
I'd be very interested in someone with substantial experience in Ada/Spark
providing some insight:

* Why did Ada not manage to get a significant foothold outside of some small domains?

* What's great, what's not so great about it?

* How "modern" does the language feel, including the tooling, documentation, etc? Specifically Spark 2014. ( I see a LSP server and VSCode plugin, for example)

* 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?

* What other languages are most similar?

~~~
Lucretia9
I don't know SPARK and haven't touched it, but...I had to learn Ada9X at uni
in 1995, I've been using it for the last 15 years and have been on #Ada on
Freenode for longer.

1) The creator of #Ada, caracal, once said that when he was in the army, there
were two groups of people: i) those who were interested to learn about Ada and
ii) those who were totally against it without having seen any of the language
at all. The second group were the ones who, when they came around with the
green manuals, just refused to even read them.

2) I went back to Ada after burning out in a shitty games company, essentially
sitting in a debugger for 19 hours straight isn't good. The only time I have
to use a debugger is when using pointers, Ada allows you to avoid pointers for
the most part.

Ada's type system, data modelling, it's unparalleled anywhere else ever.

There's not enough people working with Ada in OSS.

It's easy to burn yourself out on a big project sometimes.

3) Very modern, the docs are good, but the tooling is lacking. But then I come
from a time of command lines and no package managers.

~~~
thesuperbigfrog
Alire is an Ada package manager built around the GNAT toolchain:
[https://github.com/alire-project/alire](https://github.com/alire-
project/alire)

I have not used it, but it looks promising.

~~~
Lucretia9
Currently it's built around gnat, not looked at the source, but I hope they've
built in portability across compilers.

------
wirrbel
After having seen the C++ guidelines of the automobile industry i wish we'd
just use Ada more..

~~~
Jtsummers
I spent a lot of time circa 2009/2010 teaching myself Ada for similar reasons.
I work in avionics systems (or used to, present job is not) and Ada is grossly
underutilized. I’d be willing to wager half the bugs that I saw make it to the
testers or, worse, the field would not have happened if we’d used Ada (and
used the type system properly).

And these days, using Spark, even more bugs could be detected before
compilation even succeeds. But no one wanted to use it at any of my jobs, and
that knowledge has mostly atrophied from disuse.

~~~
zeroc8
Using Spark contracts to specify and verify low level requirements should be a
huge time saver. I too don't understand why everybody seems to use C/C++
nowadays. I guess commercial Ada is just too expensive.

~~~
EdPF
Here's a 1/2 hour webcast on the interaction of programming language and
software lifecycle costs. Not too old.
[https://www.vdcresearch.com/_documents/briefs/IoT/18-Control...](https://www.vdcresearch.com/_documents/briefs/IoT/18-Controlling-
Costs-Webcast.mp4)

Here's extensive research results based on function point analysis.
[http://www.ifpug.org/wp-
content/uploads/2017/04/IYSM.-Thirty...](http://www.ifpug.org/wp-
content/uploads/2017/04/IYSM.-Thirty-years-of-IFPUG.-Software-Economics-and-
Function-Point-Metrics-Capers-Jones.pdf)

Whole lotta' mything going on!

------
stolen_biscuit
Ada is one of those languages that I always wish I had a reason to program in

~~~
ardit33
It was my first language i learned in school... in Radford ( Virginia), before
my university switched to Java. ADA was/is popular with defense contractors,
so a lot of schools in VA teach it.

It is very safe language, being both static typed, and strong typed. It was
originally a procedural language, but later they added some OO to it. (to
folks that don't know what a imperative language is, think of a language where
all methods are like Java Static methods, and you store data in some global
space).

It can get a bit wordy to program with it, but I also like the lack of '{'
bracket use everywhere that C like syntax has. With some modifications, ADA
can be transformed into a great/fun language.

Anyway, due to its small echosystem and adoption, I think it will remain a
'defense/aeronautic industry' only type of language.

This is a simple program, and I think it is fairly elegant, but a bit wordy:

    
    
      with Ada.Text_IO; use Ada.Text_IO;
      with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
    
      procedure Check_Positive is
         N : Integer;
      begin
         Put ("Enter an integer value: ");  -- Put a String
         Get (N);  --  Read in an integer value
         if N > 0 then
            Put (N);  --  Put an Integer
            Put_Line (" is a positive number");
         end if;
      end Check_Positive;

~~~
Lucretia9
People need to stop using "wordy" when they mean "readable."

~~~
bluGill
Readable is a matter of education. As a C++ programmer I've learned what {}
means, and so that is more readable than begin/end which happens to not be the
block symbol in any language I know well. Considering all the languages I know
I've concluded that block symbols are important enough to be worth learning as
a separate symbol (Looking at python where it is white space). Of course I can
learn begin/end, but it isn't worth typing those extra letters of the word
when something that common can be done in one.

Note too that {} graphically indicate the open/close in a way that begin/end
is another reason not to like begin/end.

~~~
Lucretia9
I've done plenty of C and C++, so I know what {} means, it's just that braces
are harder to see, especially when there's a lot of them.

------
pietroppeter
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.

[https://nim-lang.org/](https://nim-lang.org/) [https://nim-
lang.org/blog/2020/06/08/static-analysis.html](https://nim-
lang.org/blog/2020/06/08/static-analysis.html)

------
niho
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.

------
Ice_cream_suit
Their marketing folks should introduce Ada certification.

Many developers would jump through hoops to get any dodgy certification. I
have seen dubious FEMA certifications and NFA certifications on some LinkedIn
pages.

~~~
non-entity
The domains Ada is used in are probably some of the few that would care about
some certification too.

------
MaxBarraclough
Looks like a good tutorial, but it doesn't go into much depth on memory-
management. The _More About Types_ 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 _gnatcoll-core_ [1].

Can anyone comment on memory-management in Ada?

[0] [https://github.com/AdaCore/gnatcoll](https://github.com/AdaCore/gnatcoll)

[1] [https://github.com/AdaCore/gnatcoll-
core/blob/master/src/gna...](https://github.com/AdaCore/gnatcoll-
core/blob/master/src/gnatcoll-refcount.ads)

~~~
Raphael_Amiard
Hello Max!

We agree that it's a hole in the current curriculum, that we intend to fill at
some stage with the advanced lessons.

State of memory management in Ada is:

\- You have a lot of facilities to stack allocate/not heap allocate tons of
stuff that you would heap allocate in pretty much any other low level
languages.

\- When that doesn't cover you, in Ada you're basically at the level of C++:
You have refcounted pointers, unique pointers (which are enforced via limited
types) in GNATCOLL, managed containers in the stdlib, and manual memory
management. You have storage pools which, with the 2012 additions, are roughly
similar to custom allocators in C++/Rust.

\- In SPARK we have ownership pointer that are roughly similar to pointers in
Rust: [https://blog.adacore.com/using-pointers-in-
spark](https://blog.adacore.com/using-pointers-in-spark)

Anecdotally, I have a friend/colleague working on a fun side project,
[https://github.com/Roldak/AGC](https://github.com/Roldak/AGC), meant to plug
a garbage collector into Ada, since the language is much more amenable to that
than C or C++. (completely prototype/for fun project, hence why I'm not
including it in the "serious" options at your disposal above)

~~~
MaxBarraclough
Great answer, thanks.

------
khazhoux
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.

~~~
synack
One of the "Steelman" requirements that Ada was built to satisfy was that any
program should be able to be represented with a subset of ASCII that would be
compatible with the largest range of terminals, teletypes, and punched cards
as possible. Less relevant today, but that's why Ada has so many keywords in
it's syntax.

~~~
khazhoux
Just found this:

[https://blog.adacore.com/a-modern-syntax-for-
ada](https://blog.adacore.com/a-modern-syntax-for-ada)

~~~
synack
That was an April Fools' joke.

~~~
burfog
Seriously, the curly braces are a huge improvement. That's no joke.

The "fn" and ":" are good too.

I'm less sure about "include", because I doubt Ada does textual inclusion. If
it does, then that is good too. Otherwise, better choices might be: using,
use, require, requires, depend, depends, external, library, unit, module...

~~~
Lucretia9
I don't get this whole need to shorten keywords to 2 letters when the IDE will
just autocomplete them, it's really stupid.

~~~
kwhitefoot
Not everyone wants to write code in an IDE. Quite a lot of people prefer a
text editor of some kind.

~~~
pjmlp
The wonderful programming experience of UNIX V6.

~~~
Lucretia9
ed?

------
pjmlp
Just as a heads up that although Ada Core is the most well known and FOSS
friendly Ada vendor, there are still around 5 compilers vendors.

~~~
webmobdev
Who are the others?

~~~
EdPF
PTC, Green Hills, R&R, DDC-I. That's all I can think of at the moment.

~~~
pjmlp
Yep, alongside Ada Core, it makes the "about 5" :)

------
Lucretia9
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.

------
Kototama
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.

A few years ago, I wrote a little blog entry about it:
[https://www.dialectical-
computing.de/blog/blog/2011/05/08/de...](https://www.dialectical-
computing.de/blog/blog/2011/05/08/dear-language-designers-do-not-forget-ada/)

~~~
mayama
Any recent popular languages with similar support for types of Ada? Is such
type system being costly to implement the reason not many other languages pick
up the feature?

~~~
Kototama
Ada is peculiar because the checks for the ranges are done at runtime. This
mean you need a small runtime. A lot of languages are inspired by C and C++
and the types are simple in these languages so it could be an explanation.

Haskell has `Numeric.Natural` but I don't think you can define an integer
constrained to a range. It probably goes beyond what the type system can do
(statically). I think it's possible with Dependent Types (in Idris) but this
is rather new.

~~~
xentropy
Runtime checks are compiler implementation issue rather than language issue
itself. With static analysis compiler could eliminate redundant runtime
checks.

For example, if SPARK (Ada subset) is used and absense of runtime errors can
be proved by GNATprove, then runtime check generation can be disabled in Ada
compiler.

~~~
Kototama
Thanks for clarification. Which underlying (type) theory is used in GNATprove?

~~~
xentropy
I don't know details.

GNATprove generates verification conditions (conjectures) from SPARK code and
assertations. Then it feeds these verification conditions to proof tool (Why3,
Alt-Ergo, CVC4 or Z3).

[https://github.com/AdaCore/spark2014](https://github.com/AdaCore/spark2014)

------
non-entity
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.

------
guerby
Fun fact GNAT (GCC Ada front-end) will use a biased representation for range
type when packing tight:

    
    
      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;

~~~
henrikeh
For those not familiar with Ada and bit representations, the compiler is
exploiting the fact that types in Ada can have constraints that limit their
size.

T1 is a type of integer ranging from 16 to 19 (inclusive). Thus, it can only
be four distinct values (16, 17, 18, 19). Two bits is enough to represent
these four distinct values and thus the binary representation of the type (in
record R) can be reduced to 2 bits.

~~~
guerby
I heard that the only reason Ada had an "Integer" type as opposed to just have
range types with user provided bounds was because of String index needing it -
String is just a standard array of character in Ada.

~~~
renox
Ada is older than Unicode..

------
cpeterso
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.

(Yes, I know the actual capitalization of my example identifier in JavaScript
is "XMLHTTPRequest". That’s what makes it such a good example. :)

~~~
atombender
Indeed. It always bugged me that languages like Rust chose snake_case for
lowercase identifier, but CamelCase for the rest. Surely it should be
Camel_Case.

~~~
cpeterso
I agree. It's ugly, but there is precedent for CamelCase type names and
snake_case function names from Python and Ruby.

------
TedDallas
Nice documentation. Ada looks a lot like Pascal. It is interesting that SPARK
is a subset of subset of Ada.

~~~
Lucretia9
It's Pascal _inspired_ but certainly not any of Wirth's syntaxes, like 1/2
line if's, semi colons in weird places making blocks look odd. Ada has a more
inclusive syntax, whereby "is" or "begin" and "end" encases what is inside it.
Compare Modula's:

    
    
        MODULE X;
            ...
        END MODULE X.
    

and Ada's:

    
    
        package X is
           ...
        end X;
    

Ada's package feels like one statement containing others, whereby Modula's
looks like it ends on the first line.

~~~
EdPF
That difference may be due to ";" being considered a statement separator in
Pascal, and a statement terminator in Ada.
[https://wiki.haskell.org/Terminator_vs._separator](https://wiki.haskell.org/Terminator_vs._separator)

------
andi999
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?

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?

~~~
renox
There are several GNAT compiler versions the FSF version has a linking
exception, the Adacore pro version requires a commercial license. IMHO they
should have renamed the FSF GNAT (1) to clarify the situation..

1: I suggest FAda :-)

------
clircle
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.

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.

------
jayp1418
BTW this satellite was launched yesterday coded in ada :

[https://blog.adacore.com/using-ada-for-a-spanish-
satellite-p...](https://blog.adacore.com/using-ada-for-a-spanish-satellite-
project)

~~~
jayp1418
Interesting project :

[https://github.com/jrmarino/draco](https://github.com/jrmarino/draco)

------
galacticdessert
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#?

------
johnisgood
My comments on Ada:
[https://news.ycombinator.com/item?id=23808305](https://news.ycombinator.com/item?id=23808305)

------
throwaway889900
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.

~~~
gmfawcett
> Shame that the tools for Ada go from bad to worse even in the best case
> scenario.

What does that sentence even mean?

------
aronpye
What an ugly, unintuitive language. Are there any benefits to Ada over
something like c++?

~~~
thesuperbigfrog
An advanced type system: [https://learn.adacore.com/courses/intro-to-
ada/chapters/stro...](https://learn.adacore.com/courses/intro-to-
ada/chapters/strongly_typed_language.html#derived-types)

Built-in concurrency and concurrent-safe data passing:
[https://learn.adacore.com/courses/intro-to-
ada/chapters/task...](https://learn.adacore.com/courses/intro-to-
ada/chapters/tasking.html)

Design-by-contract programming: [https://learn.adacore.com/courses/intro-to-
ada/chapters/cont...](https://learn.adacore.com/courses/intro-to-
ada/chapters/contracts.html)

Provably safe programs if you use the SPARK subset of Ada:
[https://learn.adacore.com/courses/intro-to-
spark/chapters/03...](https://learn.adacore.com/courses/intro-to-
spark/chapters/03_Proof_Of_Program_Integrity.html)

~~~
msla
> An advanced type system:

Not compared to Haskell.

Ada has a strong type system for an Algol-derived language, but the world has
moved on without it in terms of type systems in general.

~~~
Jtsummers
Almost every language has a less advanced type system than Haskell. But
compared to most mainstream languages, Ada's type system is still quite
advanced.

~~~
msla
So Ada's type system is better than an "average" language but not as good as a
good language. Therefore, if I'm looking to trade up from an "average"
language, it's in my interest to leapfrog Ada and go with a good language.

~~~
gmfawcett
Actually, using Ada + SPARK, there are many static properties that can be
verified which would be unverifiable in Haskell, and would be awkward to
verify even in Agda or Idris.

But you've got your mind made up already -- please just enjoy your tools, and
let others enjoy theirs.

