Schlagwort-Archive: gpl

SpringSource announces an application plattform

SpringSource recently announced the Spring Aplication Platform, and this announcement is generating a lot of fuss. Google has recently launched the Google App Engine. From an Java enterprise developers point of view it is shamelessly easy to use, deploy, etc. Well, unfortunately it only takes Python apps for now, but it is stated that there will be more languages supported in the future. But it’s Google again putting its finger into the Java EE wound (first GWT with webapps, then Android shaking the Java ME world, and now App Engine showing how runtimes should look like).

Looking at Googles App Engine I thought how nice it would be to have the deployment, packaging and runtime of Java EE applications redesigned.  Those deployment descriptors really suck. As it seems (heard it at the Jax from speakers “off the record”) Java Dynamic Modules and Java Superpackages aren’t going to make it into the next Java relase – Java 7.

From this point of view, the Spring Application Platform is bringing fresh air into the Java EE development. The Java EE dream of a runtime didn’t come through. Modularization got lost somewhere in the way. Packaging and deployment is a nightmare, and tools didn’t solve the problem. Since Java EE 5 is being adopted very slowly and Java EE 6 is really far away, this is surely the best time to drop in an alternative. Well done. Though beeing an alternative, there seems to be some level of commitment regarding Java EE deployment support.

IMHO the real shock came with the change in licensing terms. We are used to SpringSource licensing their products under the Apache 2 license. The license is clear and accepted by most companies. The Spring Application Platform is licensed under the GPL. GPL is, IMHO, the most misunderstood license we have in the OSS. I do not have nothing against the GPL, I only have a problem with the different interpretations. And if a license can be misunderstood, how can we rely on it? I won’t start another blog about how GPL works – please go read the GPL and the GPL FAQ, it’s worth it. A nice reply from Will Hartung about GPL on the TSS thread can be found here.

Does nobody actually, you know, READ these licenses?
Users who change GPL code have absolutely no, zero, zippo, big bagel, goose egg obligation to give back to “the community”.
I can take this code, make all the changes I want, sell it to my customers, and you can come knock on my door saying “I want the code, it’s GPL! Give me the code!” and I can nod and smile knowingly and tell you to pound sand. “Give me $100K and I’ll give you the software.

Thanks Will. It’s beautiful.

Rod argues that if someone takes the code, makes changes and starts selling it, this someone will, sooner or later, have to provide the source code to a major number of customers and hence the changes will be available for the community, especially for SpringSource. Rod, I hope I did quote you right, sorry if I didn’t.

Another great statement from Will comes a few postings later:

But you certainly aren’t going to take back contributions that don’t have at least shared copyright, because as soon as that happens you can’t relicense the whole under something other than GPL. So, there’s not a whole lot of value to the community there.

Later Rod makes a nice statement about what’s ok:

1. Using the platform to run closed source applications is OK. This immediately covers the vast majority of companies and developers who are end users. This would cover for example, software use by companies like Google, banks, media companies etc.
2. Modifying and extending the platform and “hiding” (closing) it is OK, unless you redistribute. So if you modify it in your own company, or you modify it and distribute your modifications in GPL open source, that’s OK. If you modify it and distribute a closed source product including those modifications, that is not OK. This would exclude Oracle, for example, from modifying the server and redistributing it as a closed source product. We believe this is a Good Thing.
3. It is fine to run closed source applications on the platform. Whether you can redistribute them as one closed product (bundling the platform) would depend if they constituted a derivative work.

I liked this one too:

Wow, 174 replies and counting, mostly about GPL, hmm, i knew I should have done law!!! ha ha
Lets stay technical please, even though it clearly doesn’t pay !!!

This is perfectly showing how GPL, although commonly used in OSS projects, is really badly misunderstood by people.

IMHO GPL licensing was a bad idea. SpringSource targets the enterprise, the enterprise dislikes GPL, that’s a fact. Linux seems to be the exception to the rule. It’ nice to see how SpringSource understands GPL – but this understanding is not binding. What if someone wakes up next week and says – “oh sorry, I think we have to rethink our GPL understanding….”

GPL, GWT, GXT, FSF, confusion

I really believe that switching to GPL did more harm then good. A forum thread of more than 50 pages is no good sign…

It is quite hard to tell how GPL works for web applications. Does sending html/css/javascript code to a browser mean I am conveying the application to the user?

What is the application in this case? As far as I remember I deployed a war file. Is my user getting the war file? Is he able to deploy the aplication? What about all of my server side business logic and settings that never get to user?

I think that what developers at GXT are demanding is wrong. As long as this isn’t clarified, GXT is a “no go”.

Or does someone want to buy a commercial license that only works on an unreleased version of GWT for a Proof-Of-Concept project? My customers definitely not.

Further reading:

Darrel quotes the mail sent by a member of the FSF foundation

Pavera argues about GPL, browser, combined work and conveyance

So my question at the end is: was it worth it?

LGPL, dynamic linking and Java

Just came across this one:

It has always been the FSF’s position that dynamically linking applications to libraries creates a single work derived from both the library code and the application code. The GPL requires that all derivative works be licensed under the GPL, an effect which can be described as “hereditary.” So, if an application links to a library licensed under the GPL, the application too must be licensed under the GPL. By contrast, libraries licensed under the GNU Lesser General Public License (LGPL) may be linked to proprietary applications.

To use a GPLed library in a product, you need the Classpath Exception:

Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination.

As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version.

If you don’t directly link to GPLed code (e.g. using JMS, SOAP or similar communication approaches) it seems to be enough to provide installation instructions, so the user can deploy the GPL libraries himself. You have to provide bridge code licensed under compatible licenses to make this possible. If your code only compiles if a given GPL library is available in the classpath (import statements, use of derived classes, etc), then you must license your code under the GPL as well…

MyGWT ist no more…

Maybe some of you already visited the project homepage of MyGWT in the last days. Yes, MyGWT is gone. The project got finally “moved” to the extjs project, something that was announced long ago.

I was surprised to see GXT getting GPLed. Or better, dual licensed. There is the open source license (GPL), and there is the commercial license. The commercial license calculated per developer anyhow touching GXT classes, what in our agile days of development practically means every single developer of the team.

Browsing the dual license page of GXT I came across this statement:

Contribute to the Open Source community by placing your application under an Open Source license (e.g. GPL v3). This option secures all users the rights to obtain the application’s full source code, modify it, and redistribute it.

IMHO, this statement wishful thinking and not implied by the GPL license. In my understanding (and I impressed to see in how many ways GPL is getting interpreted) that GPL is meant to protect the customer, not the code owner (author). In other words: I get all the code, so my future is secured. I can do whatever I want, as long as my changes and my code is GPLed as well. This means that MY CUSTOMER will get all my code and my changes:

One of the fundamental requirements of the GPL is that when you distribute object code to users, you must also provide them with a way to get the source.

I understand users here the ones getting my product. In the special case of a web-app that is not going public, the user is my customer that is deploying the web-app, and people using the services provided by the application do not get touched my the GPL.

From the GPL FAQ section:

If I know someone has a copy of a GPL-covered program, can I demand he give me a copy?

No. The GPL gives him permission to make and redistribute copies of the program if he chooses to do so. He also has the right not to redistribute the program, if that is what he chooses.

Another very interesting misunderstanding that comes woth GPL, again quoted from the GPL FAQ:

Does the GPL allow me to sell copies of the program for money?

Yes, the GPL allows everyone to do this. The right to sell copies is part of the definition of free software. Except in one special situation, there is no limit on what price you can charge. (The one exception is the required written offer to provide source code that must accompany binary-only release.)

As far as i understand GPL, I must not make my code public. I can. Expecting users to do this (”This option secures all users the rights to obtain the application’s full source code, modify it, and redistribute it.” – quoted from above) is not true, and I believe it is a violation of GPL.

Only my two cents.