GhosT078

And despite all that complexity, you make it work very well (I've used GNAT since about 2002).

I think there is a significant difference between choosing to use words (from some language) versus using brackets like {}, () and []. With nested brackets there are often debates over placement and it is usually less clear what scope is being ended by the closing bracket.

I agree. I've never understood or accepted the claim that Ada is verbose. It's simply clear and expressive. If there were some alternative concise syntax for "Ada" then I would not want to use it (because it would not be Ada).

This was proposed, as a joke, some years ago: https://www.adacore.com/blog/a-modern-syntax-for-ada

This is an old but good article on the topic: https://www.embedded.com/expressive-vs-permissive-languages-... Note that SPARK has changed significantly since this was written.

I have been using GNAT Studio (previously GNAT Programming Studio or GPS) on Linux for the last 15 years.

I didn't think these were hard to find:

https://ada-lang.io/

https://alire.ada.dev/

An interesting, although incomplete, list.

Ada does. It has been through 5 editions so far and backwards compatibility is always maintained except for some small things that are documented and usually easy to update.

Yes it really was quite good despite all the hate it seems to get in internet comments. I used it for several years. The feature set, particularly config specs and dynamic views, was brilliant. The product was pretty mature and complete 25 years ago. I agree that administration was complicated and performance could be slow if misconfigured. We configured right, it was very intuitive and pleasant to use. IBM has effectively killed it by continuing to charge an excessive premium while adding nothing significant since they bought Rational (for Clearcase, DOORS, Apex etc.)

Look to Ada for “headers” (i.e. specs) done right.

IBM is where good (acquired) software goes to die. RIP Clearcase.

Sane, easily readable syntax and expressive semantics. Easy to learn. Very scalable. Suitability, by design, for low level systems programming, including microcontrollers. Suitability, by design, for large, complex real-time applications. Easy to interface with C and other languages. Available as part of GCC. Stable and ongoing language evolution.

Yes

In my timeline, something 10x better than Rust came along in 1995.

SPARK is a very expressive language for implementing cryptographic applications. It is available for some LLVM targets (e.g. x86-64).

Consider exploring Ada 2022 as a capable successor to Algol. Its well supported in GCC and scales well from very small to very large projects. Some information is at https://learn.adacore.com/ and https://alire.ada.dev/

Ada is very scalable, suitable for everything from blinking LEDs on an AVR microcontroller board to controlling interplanetary spacecraft. Similarly, SPARK can be used incrementally, proving lower level or critical parts first.

A good comment except for the "it's less pretty" claim. The Rust I've looked at seems incredibly cryptic by comparison.

I disagree. SPARK is all about using formal methods to statically prove software properties. Clippy seems more comparable to parts of AdaCore's other static analysis toolset (gnatsas). See https://docs.adacore.com/live/wave/gnatsas/html/user_guide/f...

Also agree. Windows Phone 8.1 and 10 were great smartphone interfaces.

It would work better if more people and search engines understood that Ada (language) is not an acronym.

I'm a long term Ada developer who has also used SPARK in the past (SPARK was/is great). I've been looking into Rust out of curiosity. I will dispute that "Rust brings superior language ergonomics". To me, Rust's syntax is unnecessarily cryptic and ugly. In particular, Ada's syntax and semantics for exact, low-level data representation and hardware interfacing is much more ergonomic than Rust's.

A current Ada 2022 compiler is available for QNX. I think it’s used in autonomous vehicle applications.

Ada has very well thought out and proven tasking features, including clean methods of task cancellation.

Ada is also excellent for linear algebra and other numerical programming.

I'm not sure I understand your point. Is it about such an error being reported at run time versus compile time? The GNAT compiler will often provide compile time warnings that "Constraint_Error will be raised at run time" in many such scenarios. Other Ada type checks would make this scenario improbable (although it could be contrived).

This tradeoff sounds similar to the choice to use "tagged types" versus "variant records" in Ada. Ada has provided variant records since 1983 and tagged types since 1995 (and both with a very nice syntax).

If you click on your username then there is a link to all of your past comments.

Well, that will erroneously drop the ranking because NVIDIA themselves use the Ada programming language. Refer to:

https://nvidia.github.io/spark-process/

https://www.nvidia.com/en-us/on-demand/session/gtcsj20-s2112...

The term "Ada" appears in several contexts (sometimes for the same company) so keyword filters should not be used in such a simpleminded way.

Ada has been held back primary by an image problem that traces back to the high cost and poor performance of a lot of early Ada 83 compilers. Ada adoption has never really recovered from that despite its many technical advantages, and despite the low cost and good performance of several current compilers.

The GNAT Ada compiler, always open source and quite good, has been freely available since the 1990's. It has been part of GCC since about 2003.

There are plenty of open source Ada projects on GitHub and other places although not nearly as many as some other languages.

The Ada ecosystem is mature and complete, particularly the GNAT related tools supported by directly or indirectly AdaCore (https://github.com/AdaCore and https://alire.ada.dev/).

The language evolution has been stable and is still on-going. I have worked primarily with Ada for 30 years. I still work on new Ada projects on a mid-sized team. Most of us just don't participate in forums like this.

In 2010, Ada 2005 was the most bare-metal-worthy expressive language. Now that would be Ada 2022.