WEBVTT

00:00.000 --> 00:13.360
Hi everybody. I'm AJ and I'm kind of obsessed with Ada. So it started around 16 years ago

00:13.360 --> 00:19.200
when I first picked up an old 8 and 95 book at my university library and I was immediately

00:19.200 --> 00:25.120
hooked. I had just learned C++ the previous semester and with summer starting I was trying

00:25.120 --> 00:30.640
to learn as many languages as I could. I dug into everything from fourth to cobalt, but Ada's

00:30.640 --> 00:36.080
focus on structure and safety had always stuck with me. I would annoy my friends and colleagues

00:36.080 --> 00:41.600
about who always work in like C and later Python and go trying to argue in favor of Ada.

00:41.600 --> 00:47.200
In my defense, I fell in love with the language, the expressive syntax and the powerful type system.

00:47.200 --> 00:51.280
Since I could build constraints directly into the data structure, I can code my program in a

00:51.280 --> 00:55.920
declarative way without ever worrying about the underlying architecture. If low-level features

00:55.920 --> 01:00.880
would need it, well that's fine too. I could even define certain data types by how many bits

01:00.880 --> 01:05.920
it should have or where and memory it should go. I could go on all day about Ada's features

01:05.920 --> 01:11.280
from its built in multi-threading with text-safe objects to enforcing readable and correct code

01:11.280 --> 01:16.000
through its syntax, but this is a lightning talk and well now I've got less than 15 minutes.

01:16.960 --> 01:22.960
About seven years ago, I came across a post on Reddit called going all in with Ada. It was

01:22.960 --> 01:28.160
post-abiant architect who discovered Ada while nerding out on aviation. With no programming

01:28.160 --> 01:32.560
background, he taught himself to code in Ada and started a software company. This was kind of the

01:32.560 --> 01:37.200
push I needed to put my money where my mouth is and practice what I preached. I bought a copy of

01:37.200 --> 01:42.880
John Barnes programming in Ada 2012 and decided that any coding I do moving forward will be written

01:42.880 --> 01:47.760
in Ada. In the following years, I would watch another language focused on safety,

01:47.760 --> 01:53.440
memory safety exact, quickly become one of the fastest rising languages with an ever-growing

01:53.440 --> 01:59.520
community. First of all, at the same time, this language was rising. I saw Ada shrinking every

01:59.520 --> 02:05.040
single year. Yes, I'm talking about rust. Those very same friends who weren't interested in

02:05.040 --> 02:12.160
Ada, they embraced rust fully. So it seemed to be the answer that they were waiting for. So I

02:12.240 --> 02:17.120
had to ask myself, why not Ada? I spoke to several of those friends over what they found

02:17.120 --> 02:22.240
great about rust and what issues they ran into with Ada and they gave me some feedback.

02:28.800 --> 02:36.400
So, oops, there we go. So first rust was very easy to install. You could simply visit

02:36.400 --> 02:42.240
rust.rs, run a command, congratulations. You now have cargo. Ada on the other hand,

02:42.240 --> 02:47.280
well, what license do I use? What is a net pro? Community edition? What's that? What run time

02:47.280 --> 02:53.280
license? Rust, it was easy to install a new project. You just open up cargo, type in cargo,

02:53.280 --> 02:59.840
new food, CT food, cargo build. Then congratulations. Now you have a project. Library, there's an

02:59.840 --> 03:06.480
ecosystem with crates.io. And the library and the ease of creating a project,

03:06.480 --> 03:11.440
a layer actually makes that pretty easy now. So that's a solve problem, but more on that later.

03:11.440 --> 03:16.960
Must also had accessible documentation, vibrant community. And even an absolute beginner

03:16.960 --> 03:20.400
can start using rust with almost no barrier to entry.

03:30.800 --> 03:51.520
Uh oh, okay. There we go. So, like I said, many of these points have been

03:51.520 --> 03:56.720
addressed in the 2020s for Ada with the retirement of community edition and the introduction to

03:57.680 --> 04:01.600
a layer. However, when I see someone trying to learn Ada with no prior knowledge,

04:01.600 --> 04:05.520
a layer's almost never mentioned. And the first impression that you get with Ada is

04:05.520 --> 04:10.640
getting tied up with net maker GPR build. For those that do come across a layer,

04:10.640 --> 04:14.480
there are either using older versions from their package manager or they have to go through

04:14.480 --> 04:24.960
the manual installation process, such as adding things to path and such. And that's why I wrote

04:24.960 --> 04:32.000
Get Ada to try and make things try to lower that barrier to entry as easy as possible,

04:32.000 --> 04:45.760
essentially to be like how rust up works in rust. So, in this next video, I can show you how I used

04:45.760 --> 04:52.000
Get Ada to go from having absolutely nothing, Ada related on my Mac to having a fully

04:52.080 --> 05:03.440
working compile version of a world in less than two minutes. So, I visit GetAida.dev. I just copy and

05:03.440 --> 05:12.720
paste this command in my terminal. It prompts me. I select yes. It downloads and installs a layer.

05:12.720 --> 05:18.080
I have to either restart my terminal or copy and paste this environmental command to add it to

05:18.080 --> 05:23.520
the path or make sure it's added to paths. Then I see the projects, start a new project,

05:23.520 --> 05:30.080
ALR in it, been dev hello world, jump in. I'm just using the defaults here. And then

05:31.200 --> 05:38.480
it automatically goes out, grabs the latest version of that as it's my computer. And now I have a

05:38.480 --> 05:43.920
project. It sets up a little shell project for me automatically. So, now I just have to edit this

05:44.000 --> 06:06.160
file here. I can add my quick hello world. And then I save. I run aLR build. I can compile

06:06.160 --> 06:13.600
it and add it to the binary directory, bin directory, and I do hello bin hello world and it runs.

06:14.800 --> 06:25.680
And that's it. Is anyone have any questions?

06:28.800 --> 06:33.680
Sure. You mentioned that people use all the ways from decades, neither just, yes, or all the way up,

06:33.680 --> 06:38.400
just introducing what you just showed as the package into both decades.

06:38.400 --> 06:45.120
So, for the listeners, asking about saying there were older versions of the package manager,

06:45.120 --> 06:51.520
and what was the last second part? What's the hold-up of just using the one in the package manager?

06:51.520 --> 06:56.560
So, just getting what you just told me? Oh, just getting what you're in. How

06:56.560 --> 07:01.920
it looked into getting, get data into the package manager's yet? Ideally, that would be the next,

07:01.920 --> 07:07.280
the next good step to do. Yeah, the reason a lure being in the package manager's causing

07:07.280 --> 07:11.040
issues is because older versions of a lure are not getting updated, and they're not

07:11.840 --> 07:16.960
just like missing features and there's issues with the index and stuff, but getting, get data into

07:16.960 --> 07:21.280
the package manager would actually make things pretty streamlined, I think. Yes.

07:22.160 --> 07:30.160
How many defaults are doing around the unit test? How much harder it is to get the first unit test?

07:30.160 --> 07:37.760
Yes. So, there's a bit, I'm having everything automated in GitHub actions,

07:38.400 --> 07:46.720
and when everything is pushed, it is recompiled and tested on all of the available platforms,

07:46.720 --> 07:55.600
which except for ARM, which is coming soon. But yeah, it does not have a new release until

07:55.600 --> 08:01.360
everything is passing all of those tests. There are some new features in framework,

08:01.360 --> 08:06.960
or what's going on saying like, gee, I don't have to think what the kick around my unit test.

08:10.320 --> 08:13.840
I'm not too familiar with the unit tests for eight, I know there's a unit.

08:14.720 --> 08:18.800
There's a lot of, there's a whole library built around unit testing for framework for data,

08:19.760 --> 08:26.800
and I think that gets, that can be included in a lure. I think you just do ALR with a unit,

08:26.800 --> 08:34.400
and it pulls in the unit testing library, and you can also bring in a GNAT Prove and Spark,

08:34.400 --> 08:39.520
and all of that. So, anything that's available in ADA is generally available in a lure,

08:39.520 --> 08:46.640
and you can just go to alir.ataddevslashcrate.html, and there's tons of libraries that

08:46.640 --> 08:51.360
are already submitted to the alir index, and it's super easy to add a library. You just ALR with

08:51.360 --> 08:55.760
library name, and it pulls it all, and including the US tests functionality.

08:56.560 --> 09:05.760
There's a lot of libraries, but there is some irony when it's just where you can sell the

09:05.760 --> 09:10.000
labels, if that was in safety, it's a pearl, some of the spree, I could do that.

09:10.000 --> 09:20.880
That's fair, that's fair. You can download and run, get ADA from the GitHub repo if you don't

09:20.880 --> 09:28.240
want to pipe curl to shell. I'm pretty much following what rust stuff is using to get that,

09:28.240 --> 09:34.240
and for, I guess, getting, I mean, it's valid for people who are security conscious. They don't

09:34.240 --> 09:41.040
want to do that. You can just load the file and read it yourself. It's ALR is doing is pulling

09:41.040 --> 09:49.040
the installer and running it in a temporary directory, but, you know, questions or comments?

09:50.880 --> 09:54.320
Great. Well, thank you.

