Gnat 2021 GPL Community Edition Ada 202x compiler released (opens in new tab)

You seem to have various misconceptions; I suggest you consult your legal advisor.

> Unlike other parts of GCC, GNAT copyright is held by AdaCore due to some special arrangement with the FSF.

Adacore holds at least the copyright of their own contributions and therefore can decide whether they want to release their version of GNAT with or without the runtime library exception; the FSF version eventually inherits also the contributions of Adacore, but the Adacore version is more current.

> So yes, binaries compiled with that particular compiler are de-facto under GPLv3, and you have to abide by its terms

This doesn't have anything to do with source or binary version. The reason is that the binaries provided by Adacore are compiled from their (most recent) source version which they publish under GPL without the runtime library exception. For this (and only this) reason you create a "combined work" when you link your code with the Adacore version of the runtime library. This doesn't change in any way if you compile the GNAT version of Adacore by yourself; you still don't have the runtime libary exception which only Adacore can give for their contributions.

Are you saying if I compile my own GNAT (from source), this exception stays in place and binaries will not be automatically GPL'd?

> binaries compiled with that particular compiler are de-facto under GPLv3, and you have to abide by its terms (eg. if a customer using these binaries requests the source code)

You'll be violating the terms that allow you to use the compiler if your source code isn't GPL licensed. That doesn't mean your source code is automatically converted to GPL. It just means you don't have a right to use the compiler or to distribute the binaries you've produced with it.

Using a compiler whose code is under GPL doesn't make your code GPL. But using the GPL runtime library might be an issue. The FSF GNAT version has a runtime library exception which allows you to use the runtime library in non GPL code. The Adacore version has no such exception (at least it didn't when I checked last time).

> But breaking GNAT's license doesn't make the software created GPL

If you do not comply with the terms of the GPL license you're no longer allowed to use the code/software licensed under GPL. Under GPL 2, you can continue to use the code/software after the license violation is removed. Under GPL 3 the copyright holder might terminate your license (see section 8 of GPL 3).

> breaking GNAT's license doesn't make the software created GPL

This is an important distinction.

But it's still true, that using the Ada core GPL Ada compiler, which does not come with lgpl/run-time exception - you can only legally distribute binaries under the GPL (or commercial license).

This does not matter much if you don't distribute code to others (eg: break system of a car - gpl/commercial; build a web server to sell/stream movies - gpl/internal use).

I still think it's probably a mistake to have the fsf and Ada core version be so similar, yet differently licensed (because it is confusing - most are used to gpl compilers comming with lgpl/runtime exception, like gcc).

This issue has been discussed for decades over and over and there are still people like you claim that I'm wrong.

I am not wrong. The runtime of the Adacore Community edition is under GPL, as are many libraries included in the Adacore edition that are not included in the FSF edition. Your binaries will be under the GPL. (Technically speaking, you could compile executables with this version of GNAT that are not under GPL by writing your own runtime. Practically, this is pretty much impossible and nobody has ever done it.)

The FSF edition allows you to compile executables without license encumbering, because it is licensed under the mGPL.

I'm neither paid not misinformed. There is no runtime exception for the Adacore Community version, it is under GPL including the runtime, hence every executable produced with it is also under GPLv3.

If you want mGPL (with the runtime exception) you need to wait for the FSF version.

This is well-known in the Ada community, but I thought I'd mention it because occasionally people don't know the license conditions of various GNAT versions very well. Such as you.

My pet theory is that tech people tend to see this as a constraint-solving problem.

"If the resulting software were GPL, all those nasty contradictions would go away. Let's assign GPL to the software and the problem is solved."

Unfortunately, the law doesn't work that way.

No, it's not. It's the difference between the FSF version and this GNAT 2021 Community Edition by Adacore. The FSF version is under mGPL, this edition is under GPLv3 including the runtime which is included in every binary.

I mentioned it precisely because people get it wrong so often.

And to be clear they also support C on GCC, so our gcc bugs go there too. Also very very happy with AdaCore's tech support. Response within the day, help and patience in reproducing problems, and almost always with a quick workaround. Often citing the reference manual. You also often have an expert jumping in to help, or to answer a question, or to implement some optimization :-)

I still have fond memories of (the sadly late) Robert Dewar answering a ticket of mine 'this is so slow, whyyyyyyy?' with a 'we have implemented a change that should improve the performance of your code' so fast I hadn't had the time to go talk to our local Ada guy for an alternative idea.

They also have world experts in formal methods like Yannick Moy and Claire Dross who will help you prove you jump-start a Spark project and are pushing the state of the art every year (proof of floating point code, pointer/ownership...).

Money well spent.

And to be clear: not from AdaCore, just a customer.

In addition to lacking formal verification tools, I'm worried about compiler certification with a language that changes as fast as rust, and c++, and even c now do. Yes you cannstick to a version, but the world and bug fixes, and libraries will pass you by. Which brings up another problem with rust for safety critical. The stdlib is so very thin, that doing almost anything requies a dependency tree of a dozen or more crates by different authors. You need to certify all those as well. Its a nightmare of an ecosystem from the safety cert perspective.

Correct.

Here is the Ada 2012 standard: http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-TOC.htm...

If you create a programming language that meets all of the Ada standard requirements, you will have your own Ada implementation.

You could use whatever backend suits your needs (or write your own) and license it accordingly.

>> Perhaps companies and individual with an interest in a permissively licensed Ada ecosystem should step up and create it? Build it on top of LLVM and call it, say, alang.

If it is an Ada implementation, why wouldn't they call it Ada rather than alang?

If the language implements the Ada standard (http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-TOC.htm...), it is Ada, regardless of how the particular implementation is licensed.

Interestingly there was, in the first days of clang, an Ada 'compiler', through dragonegg. The original author meant to write an Ada compiler on top of llvm and translated (iirc) gcc's gimple to llvm, with some success.

The fun part is that dragonegg became an important part of clang/llvm for years (before it was phased out) to compile fortran (before flang) and to compare clang results and gcc's. I seem to remember other interesting uses but my memory is failing me.

Duncan Sands (the original author I think?) is an outstanding engineer and very fun person to talk to.

Well... There's GNATLLVM [0] a project to have the GNAT frontend output LLVM. From... AdaCore. Someone has already beat me to a first wasm example [1] and there's also a first wasm-based Android one [2]...

[0] https://blog.adacore.com/combining-gnat-with-llvm [1] https://blog.adacore.com/use-of-gnat-llvm-to-translate-ada-a... [2] https://blog.adacore.com/android-application-with-ada-and-we...

"Conventions are implementation defined and would require patches to the compiler to add new ones."

Is the implementation of a Convention isolated enough that it would make sense to be extensible?

One thing I had in mind is something like Postgres. Some functions in Postgres are called in a specific way that converts arguments into an array first, and handles SQL NULL values. If I were to define this as a new Convention, it would inherit a lot from the "C" Convention, but would do some transformations first.

If it could handle a longjmp() as well, then the new Convention would also do whatever setup (manipulate some global variables and call setjmp()) so that the caller doesn't have to worry about the longjmp().

The challenge with handling longjmp() in rust is that you can't call setjmp() as a normal FFI function (because it can return twice, like fork(), which is not a normal control flow). Also, longjmp()ing into rust code is just not defined behavior, even if it "works" for now. I assume there are similar challenges in Ada.

Can attest to that. C++ is also OK. You still have to write the 'binding' but the compiler can generate a good part for you. Then you can 'hide' all the C-like things (like 'a pointer is an address', 'an enumerated type is an integer', 'you have to call our free() when you're done'...) behind opaque types, controlled types, etc.

As a simple example you can lookup what the compiler generates as a low-level binding [0] that is wrapped in a higher level API [1].

BTW you can also bind Ada to Java (although support is a bit limited I know places where it's in prod). Don't remember if it's a commercial product or oss.

And for the python people, my company financed a first version of ada-py-bind, inspired by the great pybind11. Still a lot of code to write (or generate) but it works fine.

Thanks onox for those two links!

[0] https://github.com/persan/zeromq-Ada/blob/651ca44cce831c2d71...

[1] https://github.com/persan/zeromq-Ada/blob/651ca44cce831c2d71...