All posts about the Cardano Ada cryptocurrency will be removed, and any user posting them may be banned.

Try r/cardano instead.

I'm a trained Architect (as in buildings), but have been interested in programming since I was a kid. I've been mostly focused in C and assembly on various different architectures, but have also been on the Java bandwagon. I have always been particularly interested in the actual architecture and design of large systems, such as OSs.

I've spent a lot of time perusing various open-source code bases, specifically OS kernels (FreeBSD and Linux, mostly), and I have been pretty dismayed to find far too much raw egotism/intentional obscurity, frankly lazy hacks, and poor documentation. Delving into user-land libraries can be down-right terrifying. It's not a problem of ineptitude, it's a combination of over-confidence, and the weakness of mainstream languages to properly abstract systems, and contain side-effects. When I was younger, I use to think I just wasn't "advanced enough" to understand what I was looking at. After becoming experienced, what I really found was that poor practices, both in design and implementation, are endemic in mainstream software.

A few years ago, I discovered Ada mostly by accident, while casually appeasing the aviation nerd in me (the 777 is my bias). I found the idea of safety-critical software to be very interesting. I started to look more into Ada, and what I found took my breath away. As a systems architecture enthusiast, I had never seen a language that was so carefully structured and disciplined. As a modernist, I had never seen a language that could be so aesthetically pleasing.

I devoured Barnes' "Ada 2012" book in just under a month, and nearly every page filled me with an ever deepening sense of amour. I never imagined a literal textbook could be a page-turner. I know this may sound embellished, but I'm dead serious.

About a year ago I started working with a medium-sized non-profit organization who needed help maintaining their core in-house software system, which was written in C#. It is outdated, monolithic, and chaotic.

They later decided to go through a huge re-branding process, including the design of a brand-new website. The new website was to have vastly-expanded client service capabilities. They wanted me to take on the task of interfacing this new website with the internal client-care infrastructure. I had to build an API.

Well, they didn't give me much requirements except that it had to work. I took a gamble, and I decided to implement the entire thing in Ada. It was my first real-world, large project in Ada.

The result was 99% Ada (Ada 2012-FSF GNAT-FreeBSD). I mean 99% as in I didn't use any external libraries. The only non-Ada components were some last-mile system-calls bindings written in C, to take advantage of the system headers. All JSON parsing/generation, HTTP, and TCP/IP was implemented in Ada.

What an incredible experience. Every step, end-to-end, I was consistently blown away by how elegantly Ada facilitated both architecture and implementation. How disciplined, principled, and consistent it is. And most importantly: how deeply expressive it is. Like in Architecture, abstraction is the tool for expression on the large. I have never found more enjoyment writing software than I did in Ada.

When I finally got the thing to compile (i.e. after Ada/GNAT dutifully exposed the depth of my human propensity for error), everything just worked. I have never experienced anything like it. It just worked exactly like it was supposed to. The entire system has been up for months now, and not a single bug has appeared. The performance and stability has been beyond anything I could have hoped for.

The client has been quite satisfied, and has decided to let me re-build their entire in-house system. I've already pitched and been approved for doing it all in Ada.

I've since started a business that is committed to the exclusive use Ada/SPARK Ada in the development of critical enterprise software systems. I intent to be a champion for the wide-spread adoption of Ada, and I hope we can support the Ada community by helping to bring it more mainstream.

TL;DR:

I am thoroughly convinced that Ada is exactly what the world needs now, and for the future. The mainstream software industry needs more discipline, more careful design, and less pettiness. We don't build buildings for the convenience of construction workers. I think it's a problem that we've allowed convenience to drive so much of programmer culture. We need something that fosters integrity, forethought, and care. We need to do a better job at building software, in general. I believe Ada is the best positioned language to facilitate the implementation of properly developed software, in general.

I see a lot of room for this out there. I see a silent majority of people who are fed-up with unreliable, unstable software. We need more people bringing Ada to the table. I hope to be one of many to join that cause.

P.S. I'm hiring; but I'm also a "start-up". If anyone is in Toronto and shares the same kind of passion for Ada, please PM me. Even if I'm too small for your caliber, maybe we can start something grass-roots anyways. Otherwise, It’s an honor and a pleasure to join this small but important community!

Edit: typos.

Snake game written on Ada and run on STM32F401 microcontroller.

https://github.com/godunko/snake

GtkAda version is available for desktop.

Have a fun!

Posts and comments to the r/ada subreddit generated by an LLM system (e.g. ChatGPT, Gemini) are not allowed and will be removed.

Such generated "content" is well-known to be unreliable and too often misleading, focusing on sounding plausible, rather than on being correct.

LLMs may be referenced as an object of an Ada-related discussion. For instance: implementing an LLM in Ada, interacting with an LLM engine by an Ada program, and so on.

Thank you for your cooperation and understanding.

I picked up this beautifully preserved Ada poster recently.

Posting here because

1. This is a niche community who might find this to be a wonderful as I do. I have enjoyed digging in to the history of Ada and Gould to better appreciate it so I hoped to share this find with people who will also appreciate it.

2. I could find little information on the poster on line (google image, AI, googled text description). The best I could dig up was from the computer history museum : https://www.computerhistory.org/collections/catalog/102631311.

I added two photos, one of the poster, and another image that can be harder to see in the photo - in the black area behind the robot is a faint image of Ada Lovelace. I hope others enjoy the art and history!

Used Ada for the math kernel in a polyglot streaming system.

Not gonna lie, the first reaction is always "why Ada?" and my answer is basically "because I like sleeping at night."

Had a choice: Rust, C++, or Ada for the FFT/stats/quaternion part of this streaming system.

Rust: Safe, popular, but you still get runtime panics for out-of-range. And you gotta fight the borrow checker for math-heavy code.

C++: Fast. Absolutely can do it. But no bounds checking unless you're careful. And "careful" scales poorly.

Ada: "Range types. Compile-time overflow checking. Done."

Honestly the worst part of Ada isn't the language, it's the ecosystem is like... curated. But for a math kernel? Perfect.

Build time sucks (looking at you, Alire resolution). Full clean build takes 90sec just for Ada part.

But: When my FFT is mathematically correct and provably doesn't overflow? Worth it.

Repo: https://github.com/Wiskey009/Quad-Kernel-Streaming if anyone wants to see modern Ada in action. Contributions welcome.

I'd like to take a moment to acknowledge AdaCore's immense and generous contributions to the Ada community.

ALS, GPR, sponsorship and contributions to the alire-project, GCC, lots of open, high-quality documentation, and so on. Even a handful of "because we want to" projects like AWS.

It's refreshing to see a company operate this way, and apply the same quality considerations to their open code-bases as their proprietary ones. Even though Ada is dwarfed by other languages, I feel incredibly well supported as a FOSS contributor by many staff members at AdaCore.

I'm sure Ada would be stuck in the past without these contributions, so thanks a lot!

Will be released alongside Turbo Ada version 1.6

Joke title but this really has been my experience. Rust is a neat language but its fundamental flaw has been corralling programmers into its specific way of doing things, rather than beefing up its compiler.

Working in Rust feels like building a house of cards. At any moment the linter could throw an unintelligible error, for which the answer is either: “go disappear in a cave and study Rust monastically” or “use a third party crate”. On the other hand, Ada feels like I’m actually in charge. My job is to architect the system correctly, and the compiler’s job is to make it work.

Comedy post, I’m no expert, just an enthusiast who wants to see the community grow. Ada could be huge for game development.

Howdy!

I'm working at a small automotive startup. We use Rust *a lot*, but we know that as we transition from early proofs and research into a product focus phase, we'll have an enormous boulder to push up a hill if we want to continue putting Rust into bare-metal systems *and* achieve some degree of certification.

Personally, I like C++ a lot, C as well, but I know what a minefield they can be. And to be honest, it really seems like most of the software being run on ECUs is actually generated. People advocate for C in particular, but don't really seem to write a whole lot of it. :D

As a Rust user, Spark and Ada have come up repeatedly in conversations over the last few years as Rust gained popularity, so naturally I'm rather curious about using Ada to build reliable embedded software if we can't march along with Rust.

Trouble seems to be however that while Ada does indeed have a solid community edition, it's GPL licensed, and the commercial version of Ada offered by AdaCore... doesn't list a price. O.o

So, how expensive is the total cost of Ada? Can small companies like mine (3 embedded devs, 15 employees total) actually afford to adopt Ada as a competitive advantage?

TLDR: This is not a language comparison. It is a statement that without competition there is little drive for improvement.

When Rust 1.0 caused a disturbance in the force, millions of voices suddenly cried out in terror: "Rust is stealing our show, but it's just hype and not safe at all!". While many will admit that developing code in Rust is better than doing that in C (which is a useless statement), I've been asked on many occasions why anyone would choose Rust over Ada. Looking for an answer to that I've ended up with 4 answers:

• Many Ada hardliners have given me the same opinion about that as C hardliners: The Rust hype will blow over just like all the other hypes before (D anyone?) and Rust isn't a good choice for safety critical software.

• More moderate voices told me that Ada has had a PR and stagnation problem and Rust filled the void.

• Moderate Rust fans tell me that Ada is essentially what they wanted all along, but its tooling experience is suboptimal

• Rust hardliners will tell you that Ada has too much old baggage that gives it a very '83 feeling, the language is too verbose and worst of all, has no ownership semantics.

I personally feel like I'm in all of the above: Ada hardliner, Ada moderate, Rust moderate, Rust hardliner. Rust is hyped, Ada has a lot of baggage, Rust doesn't even have integer subtyping, Ada is making many simple things complex to program (even if hard to do wrong), ...

So back to the title. There has been no competitor for Ada ever until Rust came along. Any competitor needs to be memory safe, real time capable and error avoiding by design. C only had real time capabilites, C++ became a little more error avoiding, Java became memory safe, but lost on the other two accounts, D never took off, haskell beat everyone up in error avoidance but could never win in any race except up the ivory tower stairs, swift is iOS targeted, go isn't real time capable and its exceptional situation handling is controversial. Rust came with real time capabilities, memory safety beating Ada's in the presence of parallelism and its error avoiding scheme is in some cases better (no exceptions) and in some worse (no integer subtypes). This has lead to many discussions in the Ada community mentioning Rust earlier rather than later. It wasn't even discussions like "Rust has X, we need X, too", but "Rust has X for Y, how is our Y-experience?". Some of the discussions are about (non-language) things like versioning and distribution of libraries or how hard/annoying it is (was!) to install an Ada compiler. Others were about the discoverability of features, because Ada newbies were trying to horseshoe their C experience into Ada programs and complaining that this leads to horrible code (duh!). I've even heard of talk about introducing linear or affine types to SPARK. Not because Rust has them, but because Rust showed that there is a design space to be explored for handling ownership.

I really like the amount of insight the article provides. The quotes from various NVIDIA software security team members are especially good to read.

Some direct highlights:

1. “NVIDIA examined all aspects of their software development methodology, asking themselves which parts of it needed to evolve. They began questioning the cost of using the traditional languages and toolsets they had in place for their critical embedded applications.” “What if we simply stopped using C?”

2. “In only three months, the small Proof of Concept (POC) team was able to convert nearly all the code in both codebases from C to SPARK. In doing so, they realized major improvements in the security robustness of both applications.”

3. “Evaluating return on Investment (ROI) based on their results, the POC team concluded that the engineering costs associated with SPARK ramp-up (training, experimentation, discovery of new tools, etc.) were offset by gains in application security and verification efficiency and thus offered an attractive trade-off.”

4. “When we list our tables of common errors, like those in MITRE’s CWE list, large swaths of them are just crossed out. They’re not possible to make using this language.” — James Xu, Senior Manager for GPU Software Security, NVIDIA

5. “The high level of trust this evokes drastically reduces review burden and maintenance efforts. It’s huge for me and also for our customers.” — Cameron Buschardt, Principal Software Engineer, NVIDIA

6. “Looking at the assembly generated from SPARK, it was almost identical to that from the C code…”, “I did not see any performance difference at all. We proved all of our properties, so we didn’t need to enable runtime checks.” — Cameron Buschardt, Principal Software Engineer, NVIDIA

7. “Seeing firsthand the positive effects SPARK and formal methods have had on their work and their customer rapport, many NVIDIA engineers who were initially skeptical have become enthusiastic proponents.”

[UPDATE] My apologies. Here is a link to the article: https://www.wevolver.com/article/nvidia-adoption-of-spark-ushers-in-a-new-era-in-security-critical-software-development

It took a lot of work to get to this point, but using multithreading and simd I’ve now got pretty good performance (window title: framerate)!

Many of you probably heard the news about NIF achieving fusion ignition today (https://www.llnl.gov/news/national-ignition-facility-achieves-fusion-ignition)

Well the control systems for NIF are all in Ada: https://www-group.slac.stanford.edu/cdsoft/nlc_arch/arch_meeting/NIF%20Control%20System%20Presentation.pdf

Very proud day for Ada!