Season's greetings from the organizers of the 28th Ada-Europe International Conference on Reliable Software Technologies (AEiC 2024), to be held 11-14 June 2024, in Barcelona, Spain!

Accepted Journal Track papers will be published in the conference's Special Issue of the Journal of Systems Architecture (JSA). Note that the Ada-Europe organization will waive the Open Access fees for the first four accepted papers, which do not already enjoy OA from other agreements with the Publisher.

www.ada-europe.org/conference2024/cfp.html#cfpjournal

#AEiC2024 #AdaEurope #AdaProgramming

Hi All.
For context, I am working on a small code challenge that saw online. Essentially, is implementing an Ulam Spiral, in CLI, using different languages. I did this for fun, and to learn new things on the way.

I am currently working on the implementation of the Ada language. Coming from Java/Python/Javascript backgrounds, was challenging and fun figuring out how Ada does things. I am also using Alire for some small dependency management I need.

In any case, I want to implement some unit testing, just for completion, and quick verification for other parts that may be wrong. I read some articles online, and found two things:

1. This git repository: https://github.com/alire-project/ada_spark_workflow shows a basic library on Ada, and shows that Unit Tests can be implemented as a separate crate
2. The documentation for AUnit (https://docs.adacore.com/live/wave/aunit/html/aunit_cb/aunit_cb.html) shows how to implement tests, suites, fixtures, etc, which seems easy enough.

However, I also came into GNATTest and how is integrated into GNATStudio (which I am using for this development). Seems that make it easier to just use it to generate the test files, while I have to provide the actual test code, asserts, etc.

I added the libadalang_tools crate as a dependency, and it compiles fine. I can even see the build binaries in a folder (location: ${project_root_folder}/alire/cache/dependencies/libadalang_tools_23.0.0_75f92679/bin). However, GNATStudio complains that the binary can not be found, which makes sense, as it is not in the PATH environment variable

Here are my questions then:

1. Can Alire set those binaries to the path? that way, when I run `alr edit`, they will be already on the path, and all will run without any issues.
2. If #1 is not possible, then how can I configure the path to the binaries for GNATest (and other tools if needed) in a way that is portable to others (or even a future me) who want to clone the repository and build/run the code?

As a workaround, I changed the command that is executed on the GNATtest generation window and hardcoded the path. It works, but did not feel that was the correct way.

Any help on this is very welcome. Let me know if you need other details.

Regards!

2023/12/10: Birthday of Lady Ada Lovelace, born in 1815. Happy Programmers' Day!

AdaProgramming #AdaBelgium

The 28th Ada-Europe International Conference on Reliable Software Technologies (AEiC 2024) will take place in Barcelona, Spain from 11 to 14 June, and comprises different tracks and co-located events.

Submission deadlines: 15 January for journal track papers; 26 February for industrial track and work-in-progress track papers, tutorial and workshop proposals. Submit early: tutorial/workshop proposals will be evaluated ASAP, with decisions from 1 January 2024!

More information on the conference site, including an extensive list of topics, and details on the call for contributions for the various tracks.

www.ada-europe.org/conference2024

#AEiC2024 #AdaEurope #AdaProgramming

TLDR: Ada is a great language!

I thought I would share. So, a PLC (Mitsubishi FX5UC) was brought to my work table yesterday. I was supposed to try to establish communication with it. I wrote a Missubishi communication driver back in 2021 for our SCADA system. In Ada, naturally, as most of our system is in Ada :)

The communication can be either via UDP or TCP, somewhat similar but more complicated than Modbus (more addressing modes, more types of variables). In 2021, it took me some 10 man-days to write using the available Mitsubishi documentation (500 pages) which is so good it even contains packet samples (which I used for dry tests as at the time, I had no available Mitsubishi PLC). The result was some 80 kB source file (adb) with a small 3kB specification (ads). (I don't count changes needed to add a new communication protocol to the SCADA).

Now, after yesterday's testing I had to:

• replace calling one socket-reading function with another (mistakenly I used 'read until the output buffer is full' instead of 'read what data is available')
• add one line (multiplication by 2) handling the fact that a word register has 2 bytes
• add 'else' branch to initialize a variable
• modify 2 comments (a reference to a wrong page of Mitsubishi documentation)
• to make writing to a bit variable work, change a constant (2#0001_0000" instead of 1 as a high nibble is used for the 1st bit, low for the second bit).

That's all. After 2.5 hours I was able to read/write all the required variable types. After another 2.5 hours, I checked all the types in our driver documentation (and discovered one more typo - one of the variable types was a word instead of a bit).

I'm no great programmer and I usually generate quite a lot of mistakes, so this time I was pleasantly surprised that with a few corrections, my code actually started to work quite quickly. I think the choice of a programming language has a lot to do with it ... ;-)

This Ada library provides Unicode character strings of dynamic length.

It is now available on Alire in version 0.6.0.

Changes:

• Add string convenient subprograms: Contains, Ends_With, Starts_With, Is_Lower, Is_Upper, Is_Basic, Is_Empty, Remove, Replace.
• Add list of strings with convenient subprograms: Append_Unique, Filter, Join, Remove_Duplicates, Replace, Slice, Sort, Is_Sorted, Merge and Split on strings.

So far in UXStrings, its API are similar to those of the strings Ada standard libraries. If you find some missing, make your proposals on Github.

NB: UXStrings3 is now the default implementation.

The 28th Ada-Europe International Conference on Reliable Software Technologies (AEiC 2024) will take place in Barcelona, Spain in the week of 11-14 June.

The conference schedule comprises a journal track, an industrial track, a work-in-progress track, a vendor exhibition, parallel tutorials, and satellite workshops.

Deadlines: 15 January 2024 for journal-track papers; 26 February 2024 for industrial-track and work-in-progress-track papers, tutorial and workshop proposals.

More information is available on the conference site, including an extensive list of topics; details on the call for contributions for the various tracks will follow shortly.

www.ada-europe.org/conference2024

#AEiC2024 #AdaEurope #AdaProgramming

Introducing Cashe: a Money library written in Ada!

There's quite a bit of examples in the readme, but I also gave full code examples for almost all of the functions in the API Documentation.

The purpose of Cashe is to give Money its own high-precision datatype taking advantage of Ada's fixed type decimal system. This allows storing money, associated with a currency, at a defined precision with the choice of utilizing fuzzy or exact equality (see readme for more details).

It supports ISO Currencies as well as Custom-defined currencies, and even a working Currency Exchange.

While this is technically in pre-release, it's passing all of my unit tests and I'm working on getting the version 1.0 out and into Alire soon.

Seed7 is a programming language that is inspired by Ada and other programming languages. I have created Seed7 based on my diploma and doctoral theses. I've been working on it since 1989 and released it after several rewrites in 2005. Since then, I improve it on a regular basis.

Some links:

• Seed7 homepage
• Mirror of Seed7 homepage at GitHub
• r/seed7 at Reddit
• Seed7 at GitHub
• Download Seed7 from SF
• Seed7 installer for Windows
• Seed7 at Rosetta Code
• Installing and Using the Seed7 Programming Language in Ubuntu
• The Seed7 Programming Language.

Seed7 follows several design principles:

Can interpret scripts or compile large programs:

• The interpreter starts quickly. It can process 400000 lines per second. This allows a quick edit-test cycle. Seed7 can be compiled to efficient machine code (via a C compiler as back-end). You don't need makefiles or other build technology for Seed7 programs.

Error prevention:

• Seed7 is statically typed, memory safe, variables must always have a value, there are no pointers and there is no NULL. All errors, inclusive integer overflow, trigger an exception.

Source code portability:

• Most programming languages claim to be source code portable, but often you need considerable effort to actually write portable code. In Seed7 it is hard to write unportable code. Seed7 programs can be executed without changes. Even the path delimiter (/) and database connection strings are standardized. Seed7 has drivers for graphic, console, etc. to compensate for different operating systems.

Readability:

• Programs are more often read than written. Seed7 uses several approaches to improve readability.

Well defined behavior:

• Seed7 has a well defined behavior in all situations. Undefined behavior like in C does not exist.

Overloading:

• Functions, operators and statements are not only identified by identifiers but also via the types of their parameters. This allows overloading the same identifier for different purposes.

Extensibility:

• Every programmer can define new statements and operators. This includes new operator symbols. Even the syntax and semantics of Seed7 is defined in libraries.

Object orientation:

• There are interfaces and implementations of them. Classes are not used. This allows multiple dispatch.

Multiple dispatch:

• A method is not attached to one object (this). Instead it can be connected to several objects. This works analog to the overloading of functions.

Performance:

• Seed7 is designed to allow compilation to efficient machine code. Several high level optimizations are also done.

No virtual machine:

• Seed7 is based on the executables of the operating system. This removes another dependency.

No artificial restrictions:

• Historic programming languages have a lot of artificial restrictions. In Seed7 there is no limit for length of an identifier or string, for the number of variables or number of nesting levels, etc.

Independent of databases:

• A database independent API supports the access to SQL databases. The database drivers of Seed7 consist of 30000 lines of C. This way many differences between databases are abstracted away.

Possibility to work without IDE:

• IDEs are great, but some programming languages have been designed in a way that makes it hard to use them without IDE. Programming language features should be designed in a way that makes it possible to work with a simple text editor.

Minimal dependency on external tools:

• To compile Seed7 you just need a C compiler and a make utility. The Seed7 libraries avoid calling external tools as well.

Comprehensive libraries:

• The libraries of Seed7 cover many areas.

Own implementations of libraries:

• Many languages have no own implementation for essential library functions. Instead C, C++ or Java libraries are used. In Seed7 most of the libraries are written in Seed7. This reduces the dependency on external libraries. The source code of external libraries is sometimes hard to find and in most cases hard to read.

Reliable solutions:

• Simple and reliable solutions are preferred over complex ones that may fail for various reasons.

It would be nice to get some feedback.

Lisbon, Portugal, June 14, 2023. Ada-Europe today announced, at its 27th International Conference on Reliable Software Technologies (AEiC 2023), that the Ada 2022 Language Reference Manual (LRM) will be published by Springer in its LNCS series later this year.

Ada 2022 is the latest edition of the Ada programming language standard, technically denominated ISO/IEC 8652:2023, which was formally approved and officially published by ISO, the Geneva-based International Organization for Standardization, on May 2, 2023.

The Ada 2022 LRM is available online: www.ada-auth.org/standards/ada22.html.An overview of Ada 2022 is at: www.ada-auth.org/standards/overview22.html.

To mark this official milestone, and in continuation of its established practice, Ada-Europe undertook to support the production of the new LRM as a dedicated issue of the Springer-published LNCS series.

www.ada-europe.org/press/20230614-Ada2022-Springer.pdf

#Ada2022 #AdaEurope #AdaProgramming

Tue 13 - Fri 16 June 2023

Final call: check out rich conference, tutorial, and workshop program!
Final Program available on conference web site.
Interested in Ada or reliable software? See you in Lisbon, Portugal!

For all information: www.ada-europe.org/conference2023, and our Usenet newsgroup postings for an overview.

#AEiC2023 #AdaEurope #AdaProgramming

http://www.ada-europe.org/conference2023/

The 27th Ada-Europe International Conference on Reliable Software Technologies (AEiC 2023) returns to Portugal after 5 years, to take place in Lisbon, in the week of 13-16 June.

The conference program includes two core days with various presentations, bracketed by one day with 6 tutorials, and one day with 2 satellite events. There will be time for networking during breaks as well as social events around historic, cultural, scenic, and culinary highlights of Lisbon.

For more info and latest updates see the conference web site. You'll find there an overview of the program, the list of accepted papers and presentations, and descriptions of workshops, tutorials, keynote presentation and panel, and social events. Also check the conference site for registration, accommodation and travel information.

Online registration is open. Reduced fees for various groups. Early registration discount until 22 May.

#AEiC2023 #AdaEurope #AdaProgramming

Ada stands out among programming languages for its remarkable energy efficiency, Something that Ada Developers can be really proud of :)

Source: https://lnkd.in/eAXGvHEK

#energy #programming #developer #ada #adadeveloper

https://preview.redd.it/eljzas312hsa1.jpg?width=1026&format=pjpg&auto=webp&s=92efadb53ad56ecfac9eb24ed76ee9bb1ef16e2e

I'm an experienced C++ developer, Ada newbie, trying to port a mixed C and Ada legacy codebase to GNAT Studio. I want to compile the C and Ada sources to multiple static libraries and use them from a GtkAda executable. Actually it's a pretty complicated situation as I'll detail below.

Initially I was going to ask what is the GNAT Studio equivalent of a workspace or solution file, because I wasn't finding it. But just before posting that question, I stumbled upon the documentation section for "aggregate project" in .gpr file. Yahtzee. ("Aggregate" was the one synonym I hadn't thought to google for!)

But, I still want to see this in use before I'm comfortable using it from scratch. My learning style is I learn best from examples. First I mimic, then I understand. The syntax seems simple enough, but the documentation on aggregate projects doesn't (for instance) devote any words to common conventions like whether the .gpr file is usually mixed in with the sources or at a directory level above, etc.

And the same applies to linking and calling the C code from the Ada code (or even calling the Ada lib from the exe, for that matter). As a C++ programmer (and also C#) I'm familiar with the issues (e.g. name mangling and ABI/calling conventions) with cross-language marshaling. I still want to look at a big (real) Ada project that does it.

Finally, I read that the aggregate project feature in GNAT Studio supports the same source file being included - perhaps with different interpretations - in multiple different projects. That's good news because this legacy codebase uses that model heavily to actually build EPROM (firmware) images for multiple similar-but-different circuit boards. I actually want to run all of them within the one Gtk executable (it will be a simulator or emulator, depending how you term it), so I'll have multiple different Ada libs, that used to build independent .hex or .bin files, now being combined into one executable.

Actually it's even more complicated than that. There's two legacy codebases, the second for a still-old but newer generation of the equipment, and I'm hoping to put both of those together too. (You'd select which version of the equipment you want to simulate with a radio button.) The codebases for those have different versions of the same files. If I had to I can just make that two different GtkAda programs.

Because of both combining what were multiple different EPROM images into one executable, and the possibility of combining two similar-but-different sets of EPROM images, I'm wondering if and how namespace collisions are manageable in an aggregate project. I solved a similar problem combining C++ codebases associated with these two equipment generations into one application by segregating the codebases by DLL. Since a DLL only exports the names you tell it to, it doesn't matter if the same name is used for different things internally; they can still be linked into the same program.

Hi, I just happen to stumble upon these Ada2012 bindings developed by Phaser Cat Games (https://phasercat.com/) during some Google searching.

AdaOgg - https://phasercat.com/adaogg/

VulkAda - https://phasercat.com/vulkada/

​

For VulkAda, there are two blog entries from the author:

1. https://phasercat.com/the-vulkada-project/
2. https://phasercat.com/the-vulkada-project-ii/

[UPDATE] For those unfamiliar with OggVorbis and Vulkan, these are descriptions from Wikipedia:

Vorbis is a free and open-source software project headed by the Xiph.Org Foundation. The project produces an audio coding format and software reference encoder/decoder (codec) for lossy audio compression). Vorbis is most commonly used in conjunction with the Ogg container format[10] and it is therefore often referred to as Ogg Vorbis.

Vulkan is a low-overhead, cross-platform API, open standard for 3D graphics and computing. Vulkan targets high-performance real-time 3D graphics applications, such as video games and interactive media, and highly parallelized computing.

​

VS Code Extension for Ada 23.0.14

In this release:

Draft support for Alire crates

If there are alr, gprbuild and GNAT compiler in the PATH, then alire.toml in the root of workspace folder, then the extension will use Alire to configure the Ada Language Server, so navigation, tooltips, code refactoring should work out of the box without any manual configuration of the project file and scenario variables. The Ada: Reload project command calls Alire again to update setting after possible changes in crates.

But tasks like "ada: Build current project", "ada: Check current file", etc. don't take alire into account for now. To be fixed... It's possible to create a new shell task to launch alr build or alr exec gprbuild instead.

New refactoring tool Replace Type

Replaces a type in the intire project by another type provided by the user.

​

https://i.redd.it/i4fs78luiija1.gif

New refactoring tool Sort Dependencies

Sorts all with and use clauses and their associated pragmas.

​

https://i.redd.it/5epcbjpyiija1.gif

See the complete list of available refactoring tools.

Don't hesitate to report any issues on GitHub.