Gnat 2021 GPL Community Edition Ada 202x compiler released

https://www.adacore.com/download

by berkeleynerd • 5 years ago

101 81 5 years ago

adacore.com

134156• 5 years ago

Just remember that all software you compile with it will be under the GPL.

lucioperca• 5 years ago

That is just wrong.

134156• 5 years ago

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.

Tomte3• 5 years ago

That's wrong, and this idea has popped up repeatedly on HN lately.

It's true that you may only use GNAT GPL for hobbyist use and GPL software.

But breaking GNAT's license doesn't make the software created GPL. It just makes you liable for damages. And cessation, of course.

Rochus7• 5 years ago

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).

e12e3• 5 years ago

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).

134156• 5 years ago

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.

533474• 5 years ago

Are you paid or are you just misinformed?, it is one of the most widespread misconceptions about GPL

Tomte3• 5 years ago

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.

134156• 5 years ago

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.

tobiasu6• 5 years ago

The downvotes are utterly ridiculous.

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

For the compiled CE releases on their website, AdaCore strips the runtime exception:

  -- As a special exception under Section 7 of GPL version 3, you are granted --
  -- additional permissions described in the GCC Runtime Library Exception,   --
  -- version 3.1, as published by the Free Software Foundation.               --

So yes, 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 are of course free to build the compiler yourself, or use the Ada compiler that comes with your distro.

The sources are available, you just don't get a tag that tells you which exact combination of files AdaCore used to build and verify their binaries.

This is a strategic PITA, and AdaCore have in recent years made some moves to improve the situation, with being active on github and responding to issues in general.

spamizbad• 5 years ago

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

bachmeier• 5 years ago

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.

Rochus7• 5 years ago

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.

jeff-davis3• 5 years ago

There's some nuance here and I don't think this is correct. However, the uncertainty around Ada licensing causes a lot of people to be hesitant to start with Ada.

claudionaoto• 5 years ago

I think this is a important point, for what I understand from some old posts, there are basically three versions of Gnat:

- FSF: Is GPL but contains an exception that allows you the create programs which are not GPL (basically the same as e.g. g++)

- AdaCore Community : Also GPL, but no exception. Hence your program is also GPL.

- AdaCore Pro: Commercial and allows you to create programs which are not GPL.

badhombres• 5 years ago

What’s different?

wiremoons• 5 years ago

Such a shame there is no macOS support for the new '2021 Community Edition', for either x64 or the newer Apple silicon (M1). As ARM is supported for other platforms (even as a cross compiler only) - not sure why the whole Apple community is being missed out in this update, for both x64 and ARM. Guess AdaCore customers don't use Apple products any more, so hence no availability for the Community Edition either..? One of the benefits of using Ada was the great cross platform support for Linux, Window, and previously macOS.

Agingcoder2• 5 years ago

There is cross-platform support - just ada-market specific ( qnx, vxworks, linux, windows, etc) and for all kinds of embedded architectures.

I don't think osx is a target market in any way : their customers are unlikely to use macs in production.

synack3• 5 years ago

There's an open source distribution of GNAT for macOS here: https://sourceforge.net/projects/gnuada/files/GNAT_GCC%20Mac...

systems• 5 years ago

This is more of a general question With the availability of free languages such as Rust, Clojure, F#, Go, Typescript, Idris, Raku You have a solid option that cover ever possible paradigm and style of programming you may fathom

Why would any one invest time or effort in a commercial language such as Ada, Eiffel or even Xojo and LispWorks, that require you to pay for Automated test support and what is considered by most standards now basic libraries

And not only that, the communities are usually tiny and support is probably very limited to the commercial support they provide, and when it comes to languages, languages with big communities, provide infinitely better support than commercial support for proprietary languages or implementations

The cost of AdaCore is not just the compiler license, its the total ecosystem cost

xvilka• 5 years ago

Rust is not yet ready for formal verification, along with some ready libraries for that purpose, unlike Ada/SPARK. Hopefully, it will be there, just not yet. It still requires tremendous multi-year effort to finish that.

galangalalgol2• 5 years ago

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.

pjmlp• 5 years ago

Lisp is a good example, instead of Allegro and LispWorks one gets to dabble in SBCL + Emacs.

Qt/Delphi/C++ Builder versus free beer GUI tooling is another.

Or doing RAD Web Applications in Outsystems or doing it all by ourselves.

Certain quality levels are only reachable when people pay for their tools.

lavezza• 5 years ago

It probably doesn't make a lot of sense for a greenfield project, but for established projects it might make sense to stay with the current technology stack. At my last job we had a team of 10+ domain experts that were expert level at a proprietary language. Replacing years of work to save $10k per developer every year would have been a bad decision.

Jtsummers• 5 years ago

Ada isn't a commercial language, though AdaCore's implementation is. Just like Green Hills compiler implementations cost money, sometimes the commercial implementations offer features/guarantees/support the open source implementations do not.

thesuperbigfrog3• 5 years ago

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.

jabl2• 5 years ago

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.

thesuperbigfrog3• 5 years ago

> 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.

touisteur6• 5 years ago

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...

touisteur6• 5 years ago

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.

Agingcoder2• 5 years ago

Ada is not a a commercial language. It's free, and the standard is free as well.

Adacore's support is excellent - you're talking directly to gcc/gdb devs. There is no intermediate layer. I've hit a number of nasty technical issues ( compiler bugs mostly), usually fixed within 48h. They then provide you with what they call a 'wavefront' which is essentially a patched version of the compiler which is supported as well.

It is true that the ada community is small, but there is no real other contender in that space ( embedded, formal verification, qualified toolchains, etc).

Edit: nvidia uses spark/ada (from adacore), it's not clear to me what other options they might have given what they want to do (video presentation in the link)

"AdaCore + NVIDIA Partnership | AdaCore" https://www.adacore.com/company/partners/nvidia

touisteur6• 5 years ago

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.

dragonwriter• 5 years ago

This is more of a general question With the availability of free languages such as Rust, Clojure, F#, Go, Typescript, Idris, Raku You have a solid option that cover ever possible paradigm and style of programming you may fathom
Why would any one invest time or effort in a commercial language such as Ada,

(1) Ada isn’t a commercial language

(2) What other free language covers the style and paradigm Ada addresses? Rust maybe (I haven't really done a detailed analysis) now subsumes Ada, but has a different focus and a lot of cognitive overhead related to that focus. Haskell or another static functional language with a robust type system might provide an alternative approach to some similar benefits, but not the same style and paradigm.

bdavis__• 5 years ago

to add to the ada saga, RHEL has dropped providing FSF gnat since redhat 6.

very big loss to not have ada on one of the big linux distributions.

(build your own! yes, it can be done...)

edit. fixed wrong word

jeff-davis3• 5 years ago

I'm half-obsessed with C interoperability in a variety of languages. I know Ada (or GNAT) has a C FFI, and I've done a little investigation/experimentation but not much.

Here are a few questions, which probably don't have an answer in the Ada standard but might in specific implementations:

* Is there a way to declare data layouts to have compatibility with C, similar to #[repr(C)] in rust?

* Is there a way to catch C++ exceptions?

* Is there a way to catch C longjmps()?

* Is there a way to have some kind of custom control over ABI issues, e.g. define custom FFIs to langauges with a different ABI? Or anything close to this? For that matter, does any language have something like this or does it not make sense?

onox3• 5 years ago

The C interoperability of Ada is very good, you can import/export functions and specify whether records (structs) and arrays must have a C convention. I use it often to access libc and Linux kernel functions/syscalls [1][2].

[1] https://github.com/onox/inotify-ada [2] https://github.com/onox/evdev-ada

touisteur6• 5 years ago

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...

synack3• 5 years ago

* Is there a way to declare data layouts to have compatibility with C, similar to #[repr(C)] in rust?

Yes, and if you have a C header file, gcc can even translate most struct definitions for you. Here's an example of a "thin" binding generated that way: https://github.com/JeremyGrosser/notcursesada/blob/master/sr...

* Is there a way to catch C++ exceptions?

Yes. https://www.adacore.com/gems/gem-114-ada-and-c-exceptions

* Is there a way to catch C longjmps()?

By default, the GNAT runtime uses setjmp/longjmp to implement exceptions. I'm not sure how you'd connect that to a C library's setjmp though.

ABIs are selected with the Convention aspect. Conventions are implementation defined and would require patches to the compiler to add new ones. GNAT currently supports Assembler, C, CPP, COBOL, and Fortran calling conventions.

jeff-davis3• 5 years ago

"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.

onox3• 5 years ago

To anyone who has a Linux distro and wants to try Ada (2012 on some):

Debian/Ubuntu: sudo apt install gnat gprbuild

Arch Linux: sudo pacman -S gcc-ada (get gprbuild from the AUR)

NixOS: https://github.com/fluffynukeit/adaspark/

I think it's also available on Fedora IIRC.

And then go to https://learn.adacore.com/ :)

kitd• 5 years ago

Anyone know why the linux x86 binary is >3 times the size of the Risc or Arm ones?

Gnat 2021 GPL Community Edition Ada 202x compiler released

Related Stories