The vendor list is really telling of the issues with Ada's adoption:

- Of my quick scan, only AdaCore supports Ada 2012 (where a lot of the really good stuff is implemented) the rest are stuck on Ada 95.

- None of the vendors seem to list transparent pricing.

If you are only selling based on volume and through a sales rep then you are off the bat excluding most startups, SMEs, and just general bootstrap curious folks.

The Community version (based on GNAT from the FSF) is free:

https://www.adacore.com/community

https://alire.ada.dev/

But yes GNAT "just" supports Ada 2012, 2005, 95 and 83:

https://en.wikipedia.org/wiki/GNAT

You forgot Ada 2022 :) https://learn.adacore.com/courses/whats-new-in-ada-2022/inde...

Adacore technically retired the Community version a few years ago, so the most up-to-date free version would be GNAT from FSF (which is what Alire brings in automatically with `alr toolchains --select`).

Going forward there is only one GNAT, and is under Apache 2 license, also a FOSDEM talk this year.

Just clarifying for other folks.

Ada 2022 has some amazing features too - like user defined literals. You can now create custom string types : )

https://learn.adacore.com/courses/whats-new-in-ada-2022/chap...

If the price is not on the website, you can't afford it.

Predicates are great but most of the good stuff including privacy, proper subtyping and abstract data types came with Ada 83. Rust can't hold a candle even to Ada 83 imo.

Ada has practically no mindshare, Rust does. Just like say, Scala, things can be technically 'good', but without adoption it isn't going to get the attention and visibility to compete with everything that does.

Enough mindshare to keep 7 compiler vendors in business.

How many would pay for a Rust compiler?

We're talking about mindshare, not commercial incentives. There are plenty of things sold to small groups of buyers with no significant mindshare. Mindshare does not equal commercial viability or sales numbers.

As for who would pay for a Rust compiler: probably not a whole lot of people unless that compiler has something special the offer that the normal compiler does not.

The same goes for a C compiler, there are Intel compilers that are supposed to be 'better', but as it turns out, in most cases not 'better' enough for people to pay for them. But even then, I would not be surprised if more people pay for the ICC than for Ada (but I would also not be surprised if the Ada compiler sales rack up more money than the ICC sales).

I agree there's probably far more commercial support than Rust, but:

- Ada is only a small part of what Green Hills offers.

- PTC mostly isn't even a development tools company, their main products are PLM and CAD (WindChill and Creo).

- I think RR is a one-man company.

PTC still maintain PERC (for some definition of 'maintain'). At least I hope so.

It works for plenty of other products, but yeah I do conced it could be better.

There are at least two more supporting Ada 2012, if you go into their docs.

Your first point cancels out your fourth.

I don't know shit about law, but I'm assuming it's not allowed for someone to build their own compiler and make their own business out of the Ada programming language?

The specification is open, if you want to make your own implementation you can.

This sounds like a fun business to start

Why would you assume that ?

because I know nothing about the way licensing about programming languages work lol

I don't think there's anything preventing anyone to sell an Ada compiler, tooling. It's an ISO standard and you can read its spec (the holy Ada Reference Manual) and rationale for free.

I'd say the biggest hurdle is that Ada is a very complex language to implement. I've been writing Ada for more than 20 years, and writing static analysis tools for 5 years with libadalang (an amazing toolbox...) now and I still find it hard to grasp the whole combinatrics of features.

Easy to use, but very hard to implement.

How much harder would it be to implement than say, JS? 3 orders of magnitude more difficult?

I wonder if there's a deno/bun style business in here. Would be cool to see Ada compete with Go/nodejs/java etc. Or do you think that would be a terrible fit for the language?

> How much harder would it be to implement than say, JS? 3 orders of magnitude more difficult?

We can look at the size of the GCC frontends for various languages to get some idea of the complexity compared to other languages:

    gcc/ada/*.ad*     : 712194 lines (excludes C files and gcc-interface folder)
    gcc/ada/libgnat/  : 438117 lines (standard library)
    gcc/ada/libgnarl/ :  61705 lines (runtime)
    gcc/c/            :  63816 lines
    gcc/cp/           : 279732 lines
    gcc/c-family/     :  53110 lines
    gcc/d/            : 212457 lines (185253 are DMD)

This probably isn't the best metric, and I may be missing some files as I'm not very familiar with GCC internals, but if I'm getting this right then we can see that just the Ada frontend has more lines than the C, C++, and D frontends combined.

> I wonder if there's a deno/bun style business in here.

You could do this with a library without anything special in Ada. You don't need to dig deep in to the internals like you do with JS.