So, I think we are on time to get a started or maybe one minute, no, it's already
0.5.
So, let's get a start.
So since we didn't have a bedroom in the past few years, a lot of people have probably
thought of as Ada just kind of being there alone, I'm not having many changes, but that's
why not true, and even within the Ada community a lot of people don't know some of the new
features that the language has gained in the past few years, so I wanted to update this a
little bit.
So, what we are going to see today is the new Ada 2022 standard that came out a couple of
years ago, the new wish compiler that we have, which has added a couple of new cool features,
some spark improvements, I will tell you what that is, some tooling improvements, and some
Ada users, some users of the language, one of which hopefully will catch your attention
quite a bit.
So, Ada 2022 new features, the language is not there, it's still in a lot of the new standard
is being worked on already, some features we gain, some functionality, some features with
some iterator filters and the reduce attribute for arrays and for for loops.
We have declare expressions, one of the things people hate about Ada is the introduction
of new variables, it is very straight where you can declare new variables and where you can
input them, the declare expressions will hopefully aid that a little bit, when you just
need a quick variable to use in a quick expression.
We also gain static expressions, so when you have a functional expression and you add the static
attribute, it's compile time evaluatable, so we also gain some basic compile time evaluation
which will be worked on in future abitions, also if you use the declare expression with
a theme, a functional expression, you can create fairly complex functions that are
compile time evaluatable.
The image attribute, that's something people don't like about Ada, the way we print values
to strings, the way we transform them, well now the compiler will automatically declare
the image attribute for all data types, even composite data types, like structures, arrays,
etc.
And if you don't like the default one, there is the input image attribute for your types,
so you can just tell your telly to use your custom printing procedure, some basic quality
of life improvements in Ada, Delta aggregates very cool feature, when you have an object
and array complex data structure and you just want to update several fields of it, instead
of having to do several assignments each different change you want to do, just use Delta,
the Delta operator and voila, you just say the small changes you want, this is going to
be used to copy data from one attribute in a new one with just a small changes, it's
a huge life improvement, index parameters for arrays and also the assignment target name,
you can now use the add symbol to refer to the left hand side, so in Ada we are, it is
well known to have very long names and people don't like to type them, so if you want
to just use a short change to your data you can use the add symbol to do that.
Also that's the changes to the syntax, we have some changes to the libraries, we gain
a big into your support, we will get a big into your talk later, it's a different
implementation for cryptography, constant time evaluation, whatever, the one in the standard
library is up to the compiler to decide, we also gain atomic operations and we already had atomic
platatimes in Ada but we didn't have a package specific to deal with them, so now we have
a support for biatic C functions, Ada is wonderful when it comes to interoperability
we see with foreground, with coval and again, you can even interface with Pascal if you
want, but one of the main points was where biatic functions as Ada does not support them,
well now there is a quality of life improvement if you have to deal with those in Ada,
the non-blocking aspect, if you are into real time operating systems, if you have high
performance stuff, like we hear games, they are very useful, if you know what profiles are,
great, if you don't, don't worry about it. And first class, a parallel support we gain
a new keyword, the parallel, it's meant to make parallel loops and iterators, etc, much faster,
just throw it around and let the compiler paralyze your code, it's still not supportive in the
compilers. All the other features are available in DCC, Genet, and GenetLBN. Actually there are
more features that are all very supportive for the new standards, going to come out, some
of them are really nice, but I didn't want to mention them today, I will let you read the
change locks of the compilers that I used to write. Also, reminder, the Ada reference manual,
the standard is free for everybody and like SQL or C++ or C, where you have to pay hundreds
of euros, this Ada, we try to make things open for everybody. So, that's all for the language,
let's go, we're going to have a VM, which, yes, one question.
So, the question was whether the app symbol is, I'm just doing this for the online people,
whether it's a textual change of the data or a reference, etc. It's just a textual
replacement of the left hand side of the assignment, simple and easy.
Yes, so if it has side effects, it will happen, though we need that we hate those, so careful
with that, but you can use the app symbol for example in function calls, so you have left hand side,
some function called app. So, yes, it will happen at the side effects. So, Gnatil VM, we have now
a new compiling in town, it's not really new, it's the Gnat, the DCC front end, bolted into the
LBN infrastructure, you may be asking yourself, why do these? Well, LVM has some features,
there are not available in DCC, mainly web assembly support and Morello sharing support,
also some cooler things that I will talk about later. And we have some people of the community
have already used the web assembly support for to create web apps and just work with them.
One of them is this little, I think I left the, it's not the interactive one.
Oh, to bring this lights, I had to use a picture because I couldn't use the website,
but you can go into the link, I have the D enough, and this is a gliding navigation system,
and it runs directly in your browser, the guide that did it is from here from Brussels,
and he runs his own glider in his Raspberry Pi in his Google Chrome browser, and it has like
real-time information from like wind providers, similar to some simulation support, it's pretty
pretty cool. As part, for those of you who do not know Spark, Spark is the very
fibrill subset of Heda, although that's no longer wide true. Spark in the past few years has
gained a lot of new features, and it's no longer done much of a subset of Heda, it's mostly
all of Heda. So in 2019, we gained the borrowed checker support, so Spark is fully memory safe,
previously you couldn't do dynamic memory in Spark, it was written now, you can't
using the borrowed checker as it takes place in Rust. Actually, there is a sliding
improvement, lifetimes are inferred because Spark is a full-param analysis, so you don't have to
annotate your things with Spark. And last year, we gained exceptional support, an exceptional
support in Spark, which was another big mission feature from Heda, so now the creation,
transmission, the handling of your exception throughout your entire program is proveable,
you can prove that you are doing things correctly, some termination analysis improvements,
that's really cool, some people are like, can proveers that show determination of programs,
well, in some cases, now they can do so automatically. And of course, some improvements to the
Provers, that they are underlying technology that does the proving for you, that they do the
have anything. Also, wonderful new, new library, Sparkly, Sparkly is basically a
formerly verified standard library, so you have maps, sets, everything, it's fully memory correct,
it's fully run, what we call a-art, so absence of runtime errors, it's fully correct, you can
formally use it, it's great, it has abandoned variants of the features, so if you want to do dynamic
stuff, you can, big names, and also a large part of the aid standard library, that's something
a lot of people don't know, in Genet, has been also formally verified, so if you do, like,
use the matrix package, everything is annotated to make sure that if you feed it correct data,
you will get correct data, it will not handle incorrect data, you will get as soon as possible
missed an error in Sparkly Provers. Tools, earlier, a lot of people don't know it, it's the
aid as package manager, it's modeled after Rust's cargo, and last year, it had our version 2.0 release,
with the earlier install commands, so now you can install your aid apperums at the system level,
it has some positive-life improvements, some tool chains, some arm, especially in the max sections,
some arm improvements there, and we are trying to get expand the arm support in our
layer, because we are using GitHub runners for edit 3 ones, these like a couple of weeks ago,
they entered public beta, so we will try to get the tool chains built as soon as possible for you,
and also again out at the end, and always help us welcome to improve the packages there.
Very news in my humble opinion, and at the core, finally, stop their distribution of the compiler,
that was discussing a lot of issues within the community, a lot of confusion, because people thought,
hey, that company is the one providing the compiler, and it's DPL on the, what's happening,
wasn't this supposed to be like the LGPL like normal GCC stuff, and that was discussing a lot of
confusion, so they decided to stop doing that, and mostly because now since we have earlier,
if you wanted to use all the tools that they provide, they have been packaged there, so now you
can just install them for your own project and go ahead with them, so great. Also, it's not like
they have stopped, a lot of the libraries they provided were GPL, they've changed their licenses
to Apache, this is a bit of a philosophical thing, but a lot of people tend to refer Apache for low-level
libraries, so that's an improvement, and of course, they have kept on improving the Genaut Studio
ID for a data language server, which also supports we are going to superfair to use it.
And of course, the rest of the community has been updating their stuff, we have embedded systems,
compilers, BHD, compilers, bullcann, bindings, et cetera, so feel free to just use whatever.
In terms of community, a lot of you may not be aware, but there is a new community website that
tries to modernize the aid experience that's aid along, and it has instructions how to quickly
get started with aid out, how to set it up, it has tutorials, it has a huge form that's
wide active, and I think a lot of us here active there, so if you have questions or anything,
please come and join and we will try to help you. Also, the aid-a user society, it's trying to be
a global institution, as Derek presented the European side of things, some people fell left out,
so we wanted to also have an institution that would provide them home to be part of and take
part in the discussions of the aid at the development. So if you have feedback for Ada, the Ada
repertoire rule, which is hosted, it's kind of close to the Ada user society, you can go into
the GitHub, I'm proposing new changes to the language, and they will discuss them with you,
and if they like them, they will propose them for you. So we are trying to also get the Ada
standard a little bit more of a community feedback. Also, last year, NSA recommended Ada, as a memory
safe programming language, which is a bit of a surprise, because Ada is not, members of Ada Spark,
however, it kind of makes sense, Ada was developed by design to be safe in a lot of areas,
not just memory safe, and the language design and the features that it has helped you get everything
correct. It has control types, limited types, these features tend to be quite advanced, and people tend
to forget the day exists, but they are in the language, and the compiler, just by the design,
types, and etc. Dynamic, implicit dynamic, and allocation in the allocation will get you quite far.
Also, memory pools, a lot of people don't know we have them, they are known as memory arenas,
in a lot of languages, we have those, custom allocators, by default, everything is in the language,
but of course, if you need 100% memory safety, just go ahead and use Spark, also you will get
runtime safety, exceptional safety, everything safety, not just memory. How many of you knew
that Nvidia was using Ada Spark? If you are using a new Nvidia graphics card, you are probably
running Spark. Since 2019, they decided to go with Ada Spark, because they need to get their hardware
under software certified for safety critical applications like self-driving cards, and they did an
assessment on what languages they should use. They looked at C, because it had some
verified tool chains, they looked at RAS2, and they decided that Spark was going to be the
Ada Spark was going to be there. They liked it so much that they even contracted
an ADICOR to develop ACCODA binding so that you can perform CUDA directly from ADA, but it's not fully
open. The libraries, you can go ahead and see what you can take a look at. There are tutorials
on how to use it, but the two things are not really that open. We know they liked it. Why?
Because Nvidia has a white hat hacker team inside their company, and they tried to break their
own software, and they went to DevCon to tell their stories on how it went to their adventures
when trying to break Ada. Their first DevCon DevCon 29, they gave up and they broke the risk
5 ISA instead. It was easier. Hardware was the weakest link. DevCon 30, they probably got
much better, and they found they started to find some issues in the ADICOR and they compared
them to safety critical secret that they had and the Spark code. You can watch the videos.
You didn't have to trust me, but they found that the quality was much better. Also, a lot of
information they gave about Spark has become updated. Although everything looks good, there are
some challenges ahead. I think we need to improve the tools wide a lot of experience, learning
experience, the tutorials, etc. It needs to be heavily improved compared to other languages,
but we are working on that. Also, if you would like to learn Ada, you don't even have to
install the compiler. It has interactive compilation boxes where you can type Ada and solve the
exercises and see how things break or not. It has some courses. They added some intermediate
courses, learning things. If you are coming from embedded team, they have a specific course for you.
Miss Rossi, C++, Yava. If you have any of those backgrounds, go ahead and look at the specific
sections because you will have a much better experience with them as they target your previous experience.
So that's everything from me. Thank you for your attention. I'm open to questions here now or my
inbox is more than an open and hopefully we'll see some of you take on the ADICOR language. Thank you.
So, we have some time for questions. If you have them, feel free to ask them. If not,
we can add a started with me here. With the next talk, which will be how to get a started with Ada
in like two minutes, five minutes. No, I know we want to start there, but in case you didn't know
the experience, especially how to get a started has become a lot easier thanks to some packages
that have been created. So, I encourage you to take on Ada. If you have issues with the language,
come to the community, we are here to help. Also, I'm a bit of an issue that the Ada community has.
We tend to just tell new people, oh, here's the standard. Go and read it and people don't like that,
especially new people because they are not used to it. Fun fact, the Ada standard has been
written in such a way that anybody can write a read it, not just compiler developers. So,
don't be afraid to use, don't be afraid to open it and go into the different sections and discover
what the language has to offer. And it has a lot of small details that most people don't know.
And that's something I'm trying to improve. Some people don't know, we have control types,
finalizable types that's coming this year, limited types. And most people don't have these features
in other languages, so they don't know, they exist in Ada. So, we are working on that to improve
your experience. Okay? So, yes, another question?
You start with your talk. I'm so good at max. So, I work with you. You have a lot of videos,
you're so pretty max. The Ada world of max is, it's a little bit. One thing.
You know, stay. Yes, stay. And there is no big data in the model. To my knowledge.
And so, I'm wondering what the thing was going on in this area, back to the left and the proper
leave in the banks and the read-up of language. So, another tool, what is the stage thing? Is there
something worth people on that? So, the question was, for the unlike people, what's the state of
Ada mode in email? Because it's a little bit broken. And the answer is yes, the container is very
old and he decided to step down. And a lot of people don't know, the Ada mode was one of the first
modes to take place. And it hasn't been, and it's architecture is ancient. It's huge, actually.
It's one of the biggest modes of the Ada of the AMAX ecosystem. We are updating it to have the new
3-seater system to use the new 3-seater system in email. It's a lighter version and we are working
for new containers. Also, I also would like to encourage people to use the new Ada language server,
the ALS, using the new Microsoft technology for language servers, which is available. You can just
install it with failure and get started with your favorite editor. So, if your editor supports
the language server, which most editors do nowadays, including Max, you can use it. The ALS has a
bit of a few bugs in it too. It's very new. The guy mounting it, it's trying not to get killed by missiles.
And you can, luckily, that things are working. Another thing I forgot to mention with
India, the reason I added in India here, it's not because it's a big large company. It is.
It's because they make it public that they use Ada. One of the biggest issues that I'm trying to
change out a lot of people that you say that don't communicate that they use Ada. And they don't want
people, no, you say that. And here, missiles in Ukraine, some of them are developed in Ada from people
Sweden. Financial systems also use Ada, but they don't necessarily, they don't want people
knowing that they use Ada. That's, it's a bit of a problem I'm trying to have that. So,
just as a as an added bonus. So, we have people working on that and things are, it's lowly
moving. So, be patient and we're looking for developers. That's mostly it. And the Ada community,
that's in open source community, it's growing slowly. Because the company, especially
some companies want to take a back seat and they want the community to come in. And that takes
time. Sorry about that, but hopefully it's a temporary, it's a transition just.
And we have one more minute if someone has any questions, if not.
Yes. I think Ada has to really pay a lot. So, use a bill, spell that one question,
what's your marketing story against us? And so, the question is, what's the marketing
story of Ada compared to us? I encourage you to stay here for the rest of the day, you just read the
code. And one of the beautiful things I'm thinking that's told me about Ada's, you don't have to
know Ada, you can read Ada. And even a bunch code, that's impressive. And I also have a
later talk, that's quite a bunch. And I encourage you to watch it because even a bunch of concepts
are very easy to understand. We have a formal proofs and that's way more powerful than just memory
safety. People don't realize that. And there is a reason why safety critical systems is still
use Ada. And in video, I encourage you to watch a video from, from media, why they did
turn to Rust and they decided to go with Ada. And that's one of the things, don't believe my
words, believe that people that actually have invested millions in this thing. So, they have
even more incentives. So, it's readability, it's actual like true correctness, not just memory
correctness, and it's very stable syntax. You can just get Ada 83, and it works today.
It's not broken. It has a slower pace of development. The features, there is a wonderful talk
from a past, either the room from 2021, from Paul Gerett, where he compares C++, the features of
C++, and Ada. And one of the greatest points you may is the Composibility of the Language.
Ada has a lot of keywords, and people think it's very verbose, but every keyword has its meaning,
and it's very concise. And you can then build your own infrastructure on top of them. And that
is a wonderful thing instead of like Rust, where you have a lot of like optionals and a lot of
syntax to do a lot of stuff. But the language is all over the place and you have like seven,
eight different types of strings, and we only have two. It's normal strings and buttons once.
I encourage you to try the language. So, time's up. Yes, and we are working on that.
And Rust, I have to say they are doing a wonderful job in terms of communication tutorials
and improvements towards disability, and we are working on that. So, thank you.