Hacker News Reader

Comment by Tomte | Hacker News Reader

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.

View on HN

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

Even then there can be a question of whether your code is derivative of the runtime, or of the standard. If the latter, then you might escape the licensing quagmire

Your source code may not be a derivative of the runtime, but your object code clearly is.

I don't think you can use Ada without dependency (i.e. making a combined work) of a runtime (maybe someone knows a good way without sacrificing relevant Ada features, I don't).

The basis of derivative work, even when RMS was bullying projects with it, was whether your code was dependant on the GPL implementation, or say, could just as well be built with another vendor's library - even if that one was GPLed too, so long as it wasn't derivative of the first runtime.

Essentially a case of "coding for standard interface offered from multiple sources where the interface itself isn't GPL" vs "Your code requires rework in order to work without this specific GPLed dependency".

This is all grossly simplified, but among other things, it means that separating GPL code to another binary you talk over any form of IPC doesn't necessarily mean you're avoiding GPL.

> whether your code was dependant on the GPL implementation

It's rather "whether your work", not only your code. GNAT generates runtime library dependencies even if you are not aware of it. So the result is a "combined work", because the runtime library is linked to your code (otherwise your application wouldn't work).

See e.g. https://www.gnu.org/licenses/gpl-faq.html#GPLStaticVsDynamic

Meh, the default behavior of GNAT is to bundle the runtime in the executable anyway...

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

I am learning SPARK2014 and it is this confusion around the GPL that gives me pause in fully committing to this direction or any other GPL-licensed software, mainly due to not fully understanding how I can use the Gnat Ada 202x compiler. I am learning Zig, and it is MIT (expat) licensed, which I feel more comfortable in accepting. Rust is the same (dual-licensed MIT/Apache V2), and I think given some people comparing Ada to Rust for high-integrity software are going to gravitate to Rust instead of Ada. SPARK2014, a subset of Ada, is an amazing language for these endeavors.

You can build gnat and gnatprove yourself, including runtime exception.

This is a bit painful (intentionally so) but it can be done.

> You can build gnat and gnatprove yourself, including runtime exception.

How does that work? Are the binaries from Ada core (not FSF) intentionally distributed under GPL while the source for standardlib/run-time come with LGPL/run-time exceptions?

It was my understanding that the Ada core distribution is full GPL only, and the FSF one (lagging a few versions) was licensed more like gcc?

> It was my understanding that the Ada core distribution is full GPL only, and the FSF one (lagging a few versions) was licensed more like gcc?

Yes that's the case.

Some source on this?

this is unclear to me, what source do you need?

That if you build ada yourself your binaries later either have the runtime exception or that they do not need it.

Take as an example the gnat.sockets package from upstream gcc:

https://github.com/gcc-mirror/gcc/blob/master/gcc/ada/libgna...

Compare with the same file from the GNAT 2021 CE install:

GNAT/2021/lib/gcc/x86_64-pc-linux-gnu/10.3.1/rts-native/adainclude/g-socket.ads

you will find there are a bunch of blank lines where the runtime exception was.

But if you're going to use the FSF version, why not use fsf/distro binaries? Getting the source from Ada core still leaves you without the runtime exception? (Ada core is upstream/newer, fsf is downstream, lagging a bit behind Ada core(?)).

I might be ignorant, but you actually need the exception, otherwise it would be gpl, isnt it.

I am more of an end-user here trying to use SPARK2014 for applications, not doing any unnecessary software engineering or builds outside of using SPARK2014 and a compiler. It is this type of thing that makes it a bad choice for someone like me who doesn't have the time and sometimes the wherewithal to build my own compiler. Sure, a simple build of source without licensing restrictions, maybe, but not much above just using the PL to get a job done. This is why I will never give up C and the tools around it, well, maybe Zig or Rust, which I am playing with, but they are nowhere near SPARK2014/Ada for all that you get with them and the Gnat compiler. I was introduced to SPARK2014 with the book, "Building High Integrity Applications with Spark". I also read a fantastic book, "Analysable Real-Time Systems: Programmed in Ada" that put me on this vector. Great stuff and timely.

SPARK2014 is just a tool (gnatprove), which you don't distribute to others (would be rather pointless). Compiling can be done with gnat from your Linux distro, which usually has the Runtime Library Exception.

Is the compiling part "a bit painful" as @tobiasu comments above? Because that is what I am trying to avoid.

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.

> Your binaries will be under the GPL

And you've been wrong for decades.

All the things you write are true, except when you claim that the binaries will automatically be GPL.

The author has to make them GPL, in order to comply with the license, that's true. But they don't magically become GPL if the author refuses.

If the author doesn't comply, Adacore can sue them. They can demand that the author stops distributing non-compliant binaries. They can demand that the author pay them money.

They cannot, for example, redistribute the binaries themselves (against the author's wishes), under the theory that they "should be" GPL.

The court probably wouldn't even order the author to put the binaries under GPL, because specific performance is generally not considered by the courts, when paying damages is a workable alternative.

That's probably the worst case of nitpicking I've ever encountered in my life. Yes, you're technically correct. It's not as if you're telling anyone something new, contract law exists for a while already.

I wrote the comment because many people don't know the difference between the FSF version and Adacore's Community Version, hence will involuntarily violate the GPL.

Reply on news.ycombinator.com