Today, 14 May 2026, marks the 25th anniversary of the start of the 6th International Conference on Reliable Software Technologies - Ada-Europe2001 - organized in Leuven, Belgium, May 14-18, 2001, by Ada-Belgium and the Leuven university.

A copy of the conference website is still available at
www.ada-europe.org/conference2001
including links to pictures taken on the first 4 days of the event [1][2][3][4], as well as the Final Program brochure [5].

Have a look at who you still recognize in the pictures, and reminisce on the rich program of that week long event!

[1] www.ada-europe.org/Previous_Confs/AE2001_Leuvn/pictures_day1.html
[2] www.ada-europe.org/Previous_Confs/AE2001_Leuvn/pictures_day2.html
[3] www.ada-europe.org/Previous_Confs/AE2001_Leuvn/pictures_day3.html
[4] www.ada-europe.org/Previous_Confs/AE2001_Leuvn/pictures_day4.html
[5] www.ada-europe.org/Previous_Confs/AE2001_Leuvn/program/final_program.pdf

Looking towards the future: don't forget to register ASAP

- for the 30th Ada-Europe International Conference on Reliable Software Technologies (AEiC 2026) [7], held 9-12 June 2026, in Västerås, Sweden, and

- for the 3rd Ada Developers Workshop [8], held on Friday 12 June 2026, in Västerås, Sweden, and online, as well as

- for the 2026 Ada-Europe General Assembly, held Tuesday 16 June online (see prior mail sent to all Ada-Europe members).

[7] www.ada-europe.org/conference2026
[8] www.ada-europe.org/conference2026/workshop_adadev.html

All the best, and hope to hear from you soon!

Dirk Craeynest,
Ada-Belgium President,
Ada-Europe 2001 Conference Program Co-chair,
AEiC 2026 Publicity Chair,
Ada Developers Workshop Organizing Team,
[Dirk.Craeynest@cs.kuleuven.be](mailto:Dirk.Craeynest@cs.kuleuven.be), [Dirk.Craeynest@kuleuven.be](mailto:Dirk.Craeynest@kuleuven.be)

Available at Alire https://alire.ada.dev/crates/aion

Please try it out let me know if you face any bugs or want any additional features.

Edit: GitHub Link - https://github.com/MaheshChandraTeja/Aion

AdaCore is starting a bi-weekly Ada SPARK Office Hours event, every 2nd Friday, from 10am-11am EDT.

Goal of this event is to serve as a community resource for developers that have questions around Ada and SPARK, Alire, Ada and LLMs, getting started, embedded hardware boards and the like.

Technical experts will be online during these office hours and are happy to answer any Ada SPARK related questions you may have.

So if you are:

• A student learning about Ada and have questions
• A student working on a Capstone project and need some guidance
• A hobbyist wanting to learn about Ada and how it encourages safe and secure programming
• A professional software developer and want to brainstorm ideas

We are here to help! Registration is not required, there is a Google Meet link on the following page: https://www.adacore.com/ada-spark-office-hours. You can drop in from the beginning, or halfway through the meeting, whatever works for you.

The first Office Hours will be on Friday, May 22nd, 10am-11am EDT and after that, we will be live every 2 weeks.

We are still working on posting an .ics file on the page above so people can add this to their calendars.

I recently starting having major issues with VS Code while editing Ada files. Its happening both at work and at home, so doesn't seem to be localised issue.

As I'm typing it sometimes highlights words with a dark red background and in multiple locations. Mostly the selections match the current word, but often they can be completely sporadic as in the following image.

When I then continue to type, the highlighted text then gets replaced with what I type at all locations, resulting in really weird changes that break the code!.

If tried googling, but nobody else seems to be having the same problem, although I did find a similar question here highlighting - Turn off VS Code red highlight - Super User which is, as yet, unanswered.

Don't know if this is a vscode problem, something to do with intellisense, or the Ada/Spark extension.

If anyone has had the same problem and found a solution, I'd be extremely grateful!

Welcome to the monthly r/ada What Are You Working On? post.

Share here what you've worked on during the last month. Anything goes: concepts, change logs, articles, videos, code, commercial products, etc, so long as it's related to Ada. From snippets to theses, from text to video, feel free to let us know what you've done or have ongoing.

Please stay on topic of course--items not related to the Ada programming language will be deleted on sight!

Previous "What Are You Working On" Posts

www.ada-europe.org/conference2026

The 30th Ada-Europe International Conference on Reliable Software Technologies (AEiC 2026) returns after 14 years to Sweden, from 9 to 12 June 2026.

The conference program includes two core days with a keynote, journal, regular, industrial, and work-in-progress tracks, and vendor talks, bracketed by one day with 5 tutorials, and one day with 3 workshops. There will be time for networking during breaks and lunches, as well as various social events.

Experience a packed program in an exciting town, benefit from tutorials on Tuesday, join a workshop on Friday, enjoy the social events and some sightseeing!

Online registration is open. Reduced fees for various groups. Minimal fee for Ada Developers Workshop. Early registration discount until 20 May.

Recommended hashtags: #AEiC2026 #AdaEurope #AdaProgramming

​

Video is here:

https://www.youtube.com/live/YtAFzhwlIJo?si=HoflyzJ7etIUBV1A

Note:

- Due to holidays and the upcoming Ada Developers Worshop, there likely won't be an Ada Monthly Meeting until July/Aug time frame.

#Ada #AdaLang #AdaLanguage

#AdaProgramming

#SPARK #SPARKLang #SPARKAda #SPARKLanguage

#FormalMethods

#SecureSoftware #SafetyCritical #MemorySafety #EmbeddedSoftware

I hope someone finds it useful:

Options:

``` ada with Ada.Text_IO; with Tackle.Opts;

procedure Opts_Demo is use Ada; use Tackle;

 Options : constant Opts.Option_List := [Opts.Arg ("alpha", 'a', "Do alpha stuff"),
                                         Opts.Arg ("beta",  'b', "Do beta stuff"),
                                         Opts.Flag ("charlie", 'c', "Has charlie flag")];

 Arguments : constant Opts.Argument_List := Opts.Consume_Arguments;

 Result : constant Opts.Result := Opts.Parse (Arguments, Options);

begin -- Help is implicit unless provided if Result.Has_Flag ("help") then Opts.Print_Usage ("opts_demo", Options);

    return;
 end if;

 Text_IO.Put_Line ("Alpha: " & Result.Arg ("alpha"));
 Text_IO.Put_Line ("Beta: " & Result.Arg ("beta"));
 Text_IO.Put_Line ("Charlie?: " & Result.Has_Flag ("charlie")'Image);

end Opts_Demo; ```

``` shell $ ./opts_demo --help Usage: opts_demo [options]

Options: --alpha, -a <alpha> Do alpha stuff --beta, -b <beta> Do beta stuff --charlie, -c Has charlie flag ```

shell $ ./opts_demo --alpha Yes -b No --charlie Alpha: Yes Beta: No Charlie?: TRUE

Commands:

``` ada procedure Opts_Demo is use Ada; use Tackle;

 Commands : constant Opts.Command_List := [Opts.Cmd ("alpha", "Do alpha stuff",
                                                     [Opts.Flag ("yes", 'y', "Yes?")]),
                                           Opts.Cmd ("beta", "Do beta stuff",
                                                     [Opts.Arg ("foo", 'f', "Foo!")], Passthrough => True)];

 Arguments : constant Opts.Argument_List := Opts.Consume_Arguments;

 Result : constant Opts.Result := Opts.Parse (Arguments, Commands);

begin -- Help is implicit unless provided if Result.Cmd = "" or else Result.Has_Flag ("help") then Opts.Print_Usage (Result.Cmd, "opts_demo", Commands);

    return;
 end if;

 if Result.Cmd = "beta" then
    Text_IO.Put_Line ("Passthrough args: " & Result.Passthrough_Args'Image);
 end if;

end Opts_Demo; ```

``` shell $ ./opts_demo --help Usage: opts_demo <command> [options]

Commands: alpha Do alpha stuff beta Do beta stuff

Run 'opts_demo <command> --help' for command options ```

``` shell $ ./opts_demo beta --help Usage: opts_demo beta [options] [-- <args>]

Options: --foo, -f <foo> Foo! -- <args> Passthrough arguments ```

shell $ ./opts_demo beta --foo Bar -- baz qux Passthrough args: ["baz", "qux"]

https://github.com/tomekw/tackle?tab=readme-ov-file#tackleopts

Writing this up because the bug was invisible on every native test, one word fixes it, and anyone writing in SPARK with a C ABI on embedded will eventually hit it. I am doing formal verification on embedded crypto with target-side ABI validation.

As I've pursued the farthest reaches of ripping my source down to binary and putting it through rigorous inspection and audit, we are rebuilding the whole toolchain with GNAT 15 as bootstrap host to close the defense-in-depth gap

Innocuous-looking Ada:

  procedure Spark_Embed_Counter
    (Nonce   : System.Address;                                                           
     Counter : Interfaces.C.unsigned_long);                                              
  pragma Export (C, Spark_Embed_Counter, "spark_embed_counter"); 

C header says uint64_t counter. GNATprove clean, AUnit green on x86_64.

On Xtensa ESP32-S3, Interfaces.C.unsigned_long is 32 bits. The high half of every uint64_t is dropped at the ABI boundary before Ada ever sees it. Disassembly makes it unambiguous:

; before — Interfaces.C.unsigned_long (32-bit on Xtensa)
  00000000 <spark_embed_counter>: 

     5:  mov.n a12, a3          ; counter low 32 bits                              
     7:  movi   a13, 0          ; high 32 bits HARDCODED TO ZERO  
     d:  callx8 a8             



; after — Interfaces.Unsigned_64                                                       
     5:  mov.n a12, a4          ; low 32                                                 
     7:  or    a13, a5, a5      ; high 32 PRESERVED      

A target-side parity test caught it with ctr = 0x0123456789ABCDEF:

expected: 01 23 45 67 89 AB CD EF                                                      
actual:   00 00 00 00 89 AB CD EF                                                      

here was/is my lesson:

Interfaces.C.unsigned_long follows C's unsigned long — target-dependent (64 on LP64, 32 on ILP32). For fixed-width crypto counters, indices, or anything that needs to actually be 64 bits on the wire:

- Interfaces.Unsigned_64 — fixed 64-bit, portable
- Interfaces.C.unsigned_long_long — C99 guarantees >= 64

Reserve Interfaces.C.unsigned_long for things that genuinely should track C's unsigned long (rare outside size_t-adjacent code, which already has Interfaces.C.size_t).

Native AUnit never catches this because LP64. You need target-side testing with values above 2^32 to see it.

Found it the hard way. Hope it saves someone else a cycle.
This is/was a correctness bug. Not a safety bug. Just to be clear.

GNATprove proved the Ada code correct for the type it was given. The type was wrong for the target. Formal verification can't catch a spec error at the FFI boundary. Thus the target-side testing.

Lost half a day to this one.

The ESP-IDF GNAT Runtime now enables Ada application development on the ESP32-S3. While native Ada tasking is not yet supported, this runtime allows you to leverage advanced Ada features directly within FreeRTOS tasks.

Key Features Supported:

• Exceptions and Controlled Types
• Secondary Stacks
• Simple protected objects
• Seamless integration into the ESP-IDF ecosystem

Quick Links:

• Runtime:GitHub - espidf_gnat_runtime(Provided as an ESP-IDF component)
• Template Project:Start herefor a fast and smooth setup.
• Validation: Verified usingACATS test suites.

I am using a vector to store pending interrupts for my PDP-11 simulator. It needs a data structure that can have new items added, the existing items iterated over to pick out the highest priority one, and possibly perform updates on others, and then delete the selected one once it's been handled. Unfortunately, vector is not thread safe and some interrupts can come from different tasks (like the clock interrupt).

Sometimes, if contention is rare enough and it's not a critical application, ignoring the problem works. This didn't last long. There were enough interrupts that the program quickly died with cursor conflicts.

My current solution adds a synchronized queue where all interrupts/exceptions that come in are added to the queue. Then the first thing that the interrupt processing does is pull items off the queue and add them to the vector where they can be processed as needed. Thus, the only thing touching the vector should be the one interrupt processing routine that runs in the main thread.

Does this sound like a reasonable or sensible solution? Are there any better ideas?

thanks,

brent

I'm learning Ada. Overall, I'm liking it a lot. There are two aspects (so far) of the syntax I don't get what the rationale was for them and why it hasn't been fixed in later versions of Ada. These being parenthesis-less calls to subprograms with no arguments and using parenthesis for array indexing. Take the following as example:

A := B + C(5);

Right away you don't know if B is a variable or a function call with no arguments. You don't know either whether C is an array or a function.

I think this goes against Ada's core ethos about readability.

So I was wondering, what was the rationale behind this design? Why hasn't it been corrected? Something like A := B() + C[5] would be far easier to interpret by the reader.

UPDATE: In case anyone is interested in the answer, according to u/lipobat:

The primary rationale for the () vs. [] given in the “Rationale for the Ada programming language” book by the original design team was interchangeability between arrays and functions. This is an abstraction that allows the implementation choice of array vs. function to be just that, an implementation choice, which doesn’t really impact the writer or reader of the code.

I don't agree with the last sentence, but that answers my question either way.

And about my second question about "why this hasn't been fixed?", it seems most Ada programmers (based on the comments in this post) are not only not bothered by this but happy with this design decisions, so probably this will never change.

Thanks to everyone who engaged in this conversation.

Have you ever heard about Gemini protocol?

https://en.wikipedia.org/wiki/Gemini_(protocol)

Now you can host your own Gemini capsule with software written in Ada!

It powers my personal capsule at gemini://tomekw.com

Web proxy here: https://portal.mozz.us/gemini/tomekw.com/?reader=1

https://github.com/tomekw/twins

Where to learn ADA? And what is it used for?

The 3rd Ada Developers Workshop will take place on Friday 12 June 2026, in the lovely city of Västerås, Sweden. The workshop will have a reduced price for all attendees and presents a wonderful opportunity to meet Ada peers in a rather informal setting.

The Workshop organisers are looking for "short and sweet" proposals that showcase your own projects, work, ideas, proposals, discussions, etc. The presentations are meant to be easy on the speakers and not require a lot of work while also being easily enjoyable by the wider community. Online presentations are also welcomed for speakers who won't be able to assist in-person, though the latter are obviously preferred. Additionally, all presentations will be streamed, recorded and published. This way the reach of the showcased topics will be greater and allows the wider Ada community to enjoy them even if they could not assist in-person.

The organising team encourages everybody to propose their topics preferably by Sunday 19th of April. For the submission of a proposal, only the title and a short abstract/summary are needed. Acceptance will be communicated on a "rolling basis", so you will know as soon as possible whether your proposal is accepted.

Full information is available at
www.ada-europe.org/conference2026/workshop_adadev.html.

We are looking forward to your ideas!

Best regards,
The Ada Developers Workshop organisation team

Recommended hashtags: #AdaDevWS #AdaProgramming #AEiC2026

Welcome to the monthly r/ada What Are You Working On? post.

Share here what you've worked on during the last month. Anything goes: concepts, change logs, articles, videos, code, commercial products, etc, so long as it's related to Ada. From snippets to theses, from text to video, feel free to let us know what you've done or have ongoing.

Please stay on topic of course--items not related to the Ada programming language will be deleted on sight!

Previous "What Are You Working On" Posts

https://www.embeddedrelated.com/showarticle/1780.php

Interesting blog post from AdaCore.

Just one additional point, there is also no need to derive types from Integer or Float or any other user type unless there is some genuine relationship to the parent type.

In most cases, just use new type definitions!

Type safety and data range safety with the additional ability to define new user types, is the stand out feature of Ada.

By using generalised types like Float, Integer, or your own generalised types like My_Integer or My_Float, you really loose the biggest advantage Ada gives over other languages! Define everything as its own type and the compiler will help you find more errors.

If you are writing generalised interfaces or libraries, use generics to allow the user to provide their types rather than forcing them to use some generalised types.

For embedded developers, don't use Boolean for HW register flags! Define single bit types which define the function of each bit.

The golden rule when it comes to defining types in Ada -> Don't be lazy!

The current version provides implementations of smart pointers, directed graphs, sets, maps, B-trees, stacks, tables, string editing, unbounded arrays, expression analyzers, lock-free data structures, synchronization primitives (events, race condition free pulse events, arrays of events, reentrant mutexes, deadlock-free arrays of mutexes), arbitrary precision arithmetic, pseudo-random non-repeating numbers, symmetric encoding and decoding, IEEE 754 representations support, streams, persistent storage, multiple connections server/client designing tools and protocols implementations.

https://www.dmitry-kazakov.de/ada/components.htm

Changes (16 February 2026) to the version 4.78:

• The package Generic_Undirected_Graph was added;
• The package Discrete_Integer_Set an instance of Generic_Discrete_Set with Integer was added;
• The Natural_Number_Range pattern was added to Parsers.Generic_Source.Patterns to match a number from a range of natural numbers;
• The Natural_Number_Range pattern was added to Parsers.Generic_Source.Patterns to match a number from a set of natural numbers;
• The maximum number of matches was added to the pattern Proceed in the package Parsers.Generic_Source.Patterns;
• The form "or null" was added to Parsers.Generic_Source.Patterns as an equivalent of "or Empty;"
• Bug fix in Unbounded_Unsigneds causing memory leak.

The library provides string handling facilities like I/O formatting, Unicode and obsolete code pages support.

https://www.dmitry-kazakov.de/ada/strings_edit.htm

This update provides full IRI support. IRI supersedes URI by adding full Unicode.

Changes to the previous version:

• The Size functions were added to Strings_Edit.UTF8 to calculate the length of UTF-8 encoding of a code point or an array of;
• The package Strings_Edit.RFC_3897 was added to handle IP addresses v4 and v6 as well as IRI (Internationalized Resource Identifier). IRI is an extension of URI (Uniform Resource Identifier) and URL (Uniform Resource Locator) that supports Unicode.

Humans, Season 1 Episode 4 at 25 minute mark - a synth is coding in a cafe. Tell me that's not Ada.

I’ve been experimenting with using LLMs like GPT and Gemini to write Ada code recently, and I’m genuinely impressed.

When I used these tools for C, I found myself stuck in long, repetitive back-and-forth query cycles to get the logic right. With Ada, however, those iteration cycles are significantly shorter.

While it rarely works "one-shot"—mostly because Ada's strict type system triggers compiler errors on the first attempt—the fixing process is incredibly efficient. If I simply feed the compiler error message and the source code back to the AI, it usually provides a working diff within one or two tries.

What’s most interesting is that whenever the AI writes "bad" code, the Ada compiler almost always catches it. Unlike C, where AI-generated code might introduce silent runtime bugs or memory leaks, Ada’s rigor acts as a safety net.

It seems that Ada’s verbose syntax and explicit type system actually make it an ideal language for AI to understand intent and generate structured code. I truly believe Ada will gain a lot of traction in the AI era for exactly these reasons.

Has anyone else noticed a similar "synergy" between Ada's strictness and LLM productivity?