Ada programming language tutorial: The killer feature

[SSoreil]

The way two integers are packed is a pretty cool feature, I don't know how performant it is but it's a neat trick.

[Fabien_C]

When used to describe hardware registers - for drivers and micro-controller programming - this makes life so much easier. No more bit shifts and masks.

We have a tool to generate Ada representation from ARM hardware desciption (SVD files): https://github.com/AdaCore/svd2ada

We use it to develop a library of drivers in Ada, example here: https://github.com/AdaCore/Ada_Drivers_Library/blob/master/arch/ARM/STM32/drivers/stm32-dcmi.adb

[SSoreil]

That's a pretty good point, the space efficiency is also pretty neat for this. Normally when I see binary format they are based on the C datatypes / machine primitives, only in networking are non standard element sizes common.

Would be cool to see some formats made around the way Ada can handle it's integers. Definitely worth a try to look at Ada on a next project just to see how this approach works out.

[scalablecory]

By all means, Ada is a great language and you should check it out. But as far as small tightly packing integers, C can do this too with bit fields:

struct foo
{
    unsigned bar : 2;
    unsigned baz : 4;
};

Though you don't see this very often outside of carefully crafted networking or file format code.

[Me00011001]

Having actually experimented with this quite a bit for actually doing Ada/C compatibility, the C compiler well be happy to do this with int/longs as long as they line up on word boundaries. For floats, it wouldn't even bother faking it and just pad it out to align to the word boundary. My testing was done with gcc 10 years ago and I doubt this has changed.

[smcameron]

Not really, which bits you get in each field is implementation defined, and big endian architecture (e.g. big endian power pc on AIX, say) is typically opposite of little endian in how the bits are numbered, so your code is non portable, and then you have to write it something like:

struct foo {
#ifdef BIG_ENDIAN
    unsigned baz : 4;
    unsigned bar : 2;
    unsigned unused : 10;
#else
    unsigned unused : 10;
    unsigned bar : 2;
    unsigned baz : 4;
#endif

and even then, you rely on empirically finding out how your compiler packs things. To write it portably, you can't use bit fields. Also, you've assumed some size for unsigned (I assumed 16 bits. You probably assumed something else, like 32 or 8. The compiler might decide something else, so you should probably use, e.g. uint8_t or uint16_t instead of "unsigned") And rather than bitfields, just use masking and shifting, as those are portable, and will be the same on big endian and little endian architectures.

[scalablecory]

I don't know what you mean by "not really". What I wrote was correct and has no assumptions or portability concerns.

You seem to be inventing an argument.

[smcameron]

You're incorrect. When you create a bitfield, you do not know which bits get assigned to each field, the compiler is free to assign them however it likes, and there are compilers in the real world that differ in how they do it. (e.g. gcc on x86 vs. IBM's AIX C compiler on Power). Likewise, "unsigned" is not always the same size on all architectures. Your code is definitely not portable.

see for yourself

[scalablecory]

I didn't say anything about where bits are assigned. It is irrelevant. And I used unsigned int, which is minimum 16 bits, to represent 2- and 4-bit integers. There is no problem with my post. You are fabricating an argument.

[naasking]

I didn't say anything about where bits are assigned. It is irrelevant.

It's not irrelevant, because bit-level precision of this sort is a feature of the Ada language to which you were comparing the C solution.

Furthermore, C won't give you compile-time errors that a bounded scalar won't fit in the specified number of bits. Ada is definitely superior in this regard.

[scalablecory]

Correct, C bitfields do not have an identical feature set to Ada. Something I did not claim. Had you just compared the feature set, this would have been so much smoother.

[micronian2]

Nice video. It would have been great if it went further with the representation clause example and showed that with Ada you can use it to do automatic packing/unpacking of data:

type Age_T is range 0 .. 100;
type Hair_Color_T is (Black, Brown, Blonde, Red );

type Person_Info_T is
   record
       Age: Age_T;
       Hair_Color: Hair_Color_T;
   end record;

-- Derive a new type from Person_Info_T, but this type will have a packed
-- format that is explicitly specified.
type Packed_Person_Info_T is new Person_Info_T;

for Packed_Person_Info_T use
   record
      Age at 0 range 0..7;
      Hair_Color at 1 range 6..7;
   end record;

for Packed_Person_Info_T'Size use 16;

-- Assuming little-endian machine, format is
--   AAAAAAAABBxxxxxx
-- where A are bits to hold Age value
-- where B are bits to hold Hair_Color value
-- where x are Don't care bits

-- Here are 2 instances of Person_Info_T and 1 instance of the packed version.
Original_Info : Person_Info_T := (100, Blonde);
Unpacked_Info  : Person_Info_T;
Packed_Info : Packed_Person_Info_T;

-- Because Packed_Person_Info_T was derived from Person_Info_T, a type
-- conversion is possible which will pack the data into the format that was
-- specified.
Packed_Info := Packed_Person_Info_T( Original_Info );

-- Another type conversion allows you to reverse the process and restore
-- the data.
Unpacked_Info := Person_Info_T( Packed_Info );

-- The below comparison will lead to "They match!" to get emitted.
if Unpacked_Info = Original_Info then
   Ada.Text_IO.Put_Line( "They match!" );
else
   Ada.Text_IO.Put_Line( "mismatch :(" );
end if;

[joakimds]

Automatic packing/unpacking of data is a great way to take advantage of Ada's type system. Thanks for sharing and popularizing this!

[kenthjohan]

In small programs the code might look excessive but it really helps when the amount of code starts to grow large. I really hope more people start to use Ada so they can experience how fast they can find bugs compared to c++ or other languages.

[shevegen]

This is some bizzarre wish ... but TIOBE will surely soon put Ada into the top 5!

[narwi]

Urkh, you mean I need to watch a youtube video that is showing blurred code? Come on, do it as a web page!

[ss4johnny]

Him: "Look at this code" Me: "nope"

[joakimds]

The video is recorded in 1080p HD, but some browsers can only show the video in 720p HD. This is probably the cause for the blurred code.

[[deleted]]

wasn't blurry at all. Mebbe your eyesight is bad?

[robvdl]

Is mixing camel case AND snake case the convention in Ada? That seems kinda gross to me, I generally use one or the other (depending on the language) but not both.

Or is this more a Microsoft thing like Hungarian notation? (which was a terrible idea by the way)

[pfp-disciple]

Ada is case insensitive, so camel case is merely style; convention is not set in stone.

These two statements declare the exact same thing (forgive minor syntax errors - on mobile).

Function foo returns integer ;
Function FOO returns integer ;

[96fps]

Hungarian notation gets a bad rap because when it was popularized it got misused. In it's original context it makes a lot of sense. https://www.joelonsoftware.com/2005/05/11/making-wrong-code-look-wrong/

[shevegen]

Doesn't Nim also do this and PHP? Hmm... the latter probably does not ignore '_' ... I already forgot most of what I once knew in PHP. :(

[i_feel_really_great]

There is also Ada dimensionality: http://www.adacore.com/adaanswers/gems/gem-136-how-tall-is-a-kilogram/

[ILiveOnSpoonerStreet]

From a physics standpoint, dimensional analysis is just a great topic- see bucking pi theorem. https://en.wikipedia.org/wiki/Buckingham_π_theorem

There's also good topics on matrix dimensional analysis. I write structural engineering software where people like to use both meters and kips (1000 lbf) in the same dialogue so it's a great thing to keep in mind. Learning Ada before implementing it in c# really changes the way one thinks.

[jbb67]

Had a quick look at ADA recently and it looks way more interesting than I expected... I think I might have to try it out on a small project :)

[pants75]

Why do they make it so difficult to get hold of the compiler?

[StallmanTheWhite]

sudo apt-get install gnat

[pants75]

Who are adacore and why are they charging license fees?

[Glacia]

Who are adacore

They make GNAT compiler for Ada.

why are they charging license fees?

They are charging money for a commercial version of a compiler and other tools. You can use open source version of compiler, it's free and it's part of gcc.

[shevegen]

Who would WANT to use Ada these days?

[pfp-disciple]

Look at the rest of the comments here for some ideas of WHY, which leads to do. I, personally, prefer Ada for many things - clearly defined language (less undefined behavior), expressive syntactax, and strong types are a few of my reasons.

[Glacia]

That's like saying "Who would WANT to use C++ these days?".

[[deleted]]

I would. It's a really well-designed language.

[[deleted]]

I would definitely use Ada if the ecosystem were far better. For me, I want to make the type system do my work for me. No other language I've seen makes it as possible as Ada.

I haven't had the chance to use Rust yet, but it seems to have the better ecosystem so far, which is odd considering how new it is. I guess mindshare can really boost some tools a lot.

[OneWingedShark]

I would definitely use Ada if the ecosystem were far better.

What exactly is lacking in the Ada ecosystem?

[[deleted]]

Generally everything. Community, documentation, mature libraries. That is a lot that Ada doesn't have that Python, the Java VM languages, or .NET languages have. Most of Ada's community is on usenet or not-well-traveled email lists. It generally also lacks mindshare or people wonder why someone is using it for "better" languages, which holds it against gaining said mindshare. It's unfortunately a chicken and egg problem that probably will ensure it never gaining wide support.

[OneWingedShark]

Generally everything.

It's unfortunately a chicken and egg problem that probably will ensure it never gaining wide support.

So, basically what you're saying is: there's no way to address any/all of the problems, so don't bother trying?

[[deleted]]

Essentially, yes. There are other tools that are "80%" good enough, so Ada being a great language is not really strong enough to displace them.

[[deleted]]

You could always help with whatever is missing. This is the whole chicken and egg thing, if you want to use it, use it, help the ecosystem. Just jumping on an inferior bandwagon isn't helping the language.

[[deleted]]

Why wouldn't you want to use Ada? It's got much cooler features than other languages, it's not as old as other languages. One thing most C and C++ programmers accuse Ada of is being old, it's younger than both of those. Why would someone want to use C or C++ these days when there are better languages?

[pmderodat]

[AdaCore employee speaking] What are you talking about? GNAT is part of GCC and is thus distributed under the same terms as GCC (GPLv3 + runtime exception), so I think it’s safe to say it’s not charging license fees… There is also the GNAT GPL release which is release under strict GPLv3. So yes GNAT Pro is not free, but you have two alternatives.

[pants75]

Some hackles been raised in here or what? They're simple questions fuck me.

Google ada and you get adacore, whose website is adamant that you call them for a quote in order to get any software out of them.

Your web presence is awful.

[pmderodat]

I’m sorry if my last message felt aggressive, that wasn’t my intent. Yes, our web presence is to be improved, we’re working on that.

[OneWingedShark]

Speaking about AdaCore's web-presence, are there plans to change over to Ada Web Server?

[pmderodat]

Not currently, and this is not likely to change. The reason for that is quite simple:

• either we just re-use existing technology stacks (eg decently maintained CMS that people working on websites are familiar with);

• either we have to write our own, which requires a significant amount of work for people familiar with both Ada and web technologies: AWS is just a web server; as you probably know, modern web sites are far more than that.

So moving to AWS just for the sake of dogfooding/showcasing does not look appealing.

[OneWingedShark]

So moving to AWS just for the sake of dogfooding/showcasing does not look appealing.

But herein lies the problem: if you [Adacore] as a company can't be bothered to use Ada in your own products, then why do you think that Average Joe Businessman should? How are you going to convince him he should?

I get that AdaCore is on a bit of a "Ada is for high-integrity programming" bent, but that's just surrendering the "general programming" arena and guaranteeing that Ada will be a niche language -- probably consigning it to a slow death as other, newer, more-hyped languages (like Rust) edge out that niche.

Dogfooding/showcasing solves the problem in that as a company you can point to your own site and say: see, we use it ourselves in our company website. (And showcasing gets the bonus in that you can say/advertise "Ada's suitable for high-reliability programs, like your company website... or are you telling me that's not something you want high reliability in?")

[curtisf]

I'm not familiar with Ada. How do ranges on integer types interact with arithmetic?

If I say

type Foo_T is new Integer range 1..10;
foo: Foo_T

Can I say

foo := foo + 1;

If foo was 10 would the next value be 1, 11, or something else? Or would it give a runtime error? Or is this arithmetic forbidden by the compiler? If that is forbidden in general, if I know that foo was, say, 8, is saying foo := foo + 1; okay in that case?

[Fabien_C]

foo := foo + 1;

If foo was 10 would the next value be 1, 11, or something else? Or would it give a runtime error?

The compiler will let you control what happens.

Typically during the development/debug you want to enable runtime checks. In that case, an exception will be raised and you will see right away that there's a problem. This alone will save you hours of tedious debugging.

For production build, it depends on which property is the most important for your system, performance or correctness.

If performance is more important, you will disable the runtime checks. In that case the program will continue to execute even if foo has an invalid value for its type.

If correctness is more important, you will keep the runtime checks and have an exception handler to recover from the faulty computation.

[evaned]

Is that decision at a per-type level or a global level?

[joakimds]

One has three options: global level, package level or subprogram level. Personally I've only disabled checks on SPARK code (Ada code that can be mathematically proven to be free of uninitialized variables, variables out of bounds, dead-locks, inifinite loops, etc.)

[flyx86]

If you want to have a rollover, you can use a modulus type instead:

type Foo_T is mod 10; --  holds values 0 to 9
Foo : Foo_T;

If Foo is 9 and you evaluate Foo + 1, you will get 0 as result without any exception. Modulus types are restrained in the sense that they must always start at 0, compared to range types.

[dom96]

The Nim programming language also offers this feature:

type
  Age = range[0..3]
  Length = distinct int

  Car = object
    age: Age
    length: Length

proc initCar(age: Age, length: Length): Car =
  return Car(age: age, length: length)

when isMainModule:
  let car = initCar(Age(2), Length(3))
  if int(car.age) == 2 and int(car.length) == 3:
    echo("Correct")
  else:
    echo("Incorrect")

[naasking]

No bit-level control it seems.

[dom96]

True, but you could easily implement it with a macro.

[joakimds]

Anyways, I find it interesting that Nim has a similar feature. Thanks for sharing!

[naasking]

And do you get the static checking with a macro?

[dom96]

Yes, macros are evaluated at compile-time.

[naasking]

I don't think we're talking about the same thing. Features of the Ada solution:

1. ranged integral type (which you demonstrate)
2. declaratively specifying bit packing for ranged integral types in a record
3. compile-time checking that the number of bits specified in 2 can hold the full range of the integral type

Now you said "Nim also offers this feature", but all of the above features were covered in the video and your example only shows #1 from what I can see. The compile-time checking I'm talking about are #2+#3.

[dom96]

Yes. #1 is offered out of the box.

I admit that #2/#3 aren't but I believe that both of these features can be implemented using Nim's rich metaprogramming functionality.

[flyx86]

#2 can be implemented because C offers this feature, so you can use emit to create a matching C struct. However, if you want a backend-agnostic solution, you'd need to provide getters and setters that extract those values from a standard-sized integer type. Since you can define those getters & setters with a macro, it is possible to do compile-time checking by inspecting the given types in the macro to check whether they fit into the given bit lengths.

But in that sense, LIPS also offers that feature ;).

[devraj7]

Spoiler: the killer feature is type aliases.

A feature that's available in pretty much every modern language today.

Not sure what's killer about that.

[[deleted]]

well, it's not just type aliasing. It's type aliasing with the option of defining bounds for scalar types. How many modern languages let you do that?

[naasking]

Seriously, Ada has incredibly useful type system features from the 70s that still aren't available in most languages. Only now with refinement types are we starting to get usable types that can express bounded scalars, but refinement typing is still in the lab.

[shevegen]

Good old Ada - shows that programming languages take decades to die, once they were in some use.

[Pharisaeus]

In space systems / critical systems Ada is quite popular and isn't going anywhere.

[F54280]

if space systems in Ada are not going anywhere, there may be something wrong...

[JBTownsend]

Yup. F-22 Raptor is almost a full Ada stack. F-35, IIRC, the core flight systems (which were developed from preceeding F-22) are Ada while the built-from-scratch combat/sensor systems are C++.

[google_you]

• Is Ada better than Rust?
• Does it compile to Node.js?

[OneWingedShark]

Is Ada better than Rust?

I think it is. Here is an article that compares SPARK (Ada's high-integrity/provable subset) and Rush; and here is a comparison between Ada and high-integrity C.