decoration decoration

When you want to know more...
For layout only
Site Map
About Groklaw
Legal Research
ApplevSamsung p.2
Cast: Lawyers
Comes v. MS
Gordon v MS
IV v. Google
Legal Docs
MS Litigations
News Picks
Novell v. MS
Novell-MS Deal
OOXML Appeals
Quote Database
Red Hat v SCO
Salus Book
SCEA v Hotz
SCO Appeals
SCO Bankruptcy
SCO Financials
SCO Overview
SCO v Novell
Sean Daly
Software Patents
Switch to Linux
Unix Books
Your contributions keep Groklaw going.
To donate to Groklaw 2.0:

Groklaw Gear

Click here to send an email to the editor of this weblog.

To read comments to this article, go here
Stallman and Gosling on Java and the GPL
Wednesday, April 14 2004 @ 07:28 AM EDT

Richard Stallman has written an article on Java, "Free but shackled: The Java trap," and Sun's Dr. James Gosling didn't much care for it or all the speculation about Sun that he's been reading about in the media, so he has also written an article, reproduced on Newsforge, which he thinks refutes it. What it really does is show what Sun's problem is with the FOSS community.

Richard's is free to republish verbatim as long as the notice at the end is preserved, so I am republishing it in full. Dr. Gosling's is silent on that issue, so that means it's copyrighted and only fair use would be allowed. And that pretty much tells you the story. It's a metaphor.

Oh, and one other thing: Gosling calls the GPL "viral".

Because Gosling's is a reactive piece, I'll place relevant snips from it after Stallman's and you can make up your own mind. I've certainly made up mine, and so you don't have to guess, I will repeat what I told Sun's PR guy the other day when he asked me why the community has issues with Sun: it's the GPL. They don't support it and they don't get it. When you consider that it's been estimated that 75% to 80% of all FOSS is under the GPL, that tells you exactly where the lines are drawn, and if Gosling's piece represents Sun's position, Sun isn't on the FOSS side. How could they not know that attacking the GPL would alienate the community? Either they are so out of touch they don't know or they don't care. Either way, it's not looking very good. Which raises the question: what to do about Java?


Free but shackled: The Java trap
~ by Richard M. Stallman

A program is free software if its users have certain crucial freedoms. Roughly speaking, they are: the freedom to run the program, the freedom to study and change the source, the freedom to redistribute the source and binaries, and the freedom to publish improved versions. (See Whether any given program is free software depends solely on the meaning of its license.

Whether the program can be used in the Free World, used by people who mean to live in freedom, is a more complex question. This is not determined by the program's own license, because no program works in isolation. Every program depends on other programs. For instance, a program needs to be compiled or interpreted, so it depends on a compiler or interpreter. If compiled into byte code, it depends on a byte code interpreter. Moreover, it needs libraries in order to run, and it may also invoke other separate programs that run in other processes. All of these programs are dependencies. Dependencies may be necessary for the program to run at all, or they may be necessary only for certain features. Either way, all or part of the program cannot operate without the dependencies.

If some of a program's dependencies are non-free, this means that all or part of the program is unable to run in an entirely free system--it is unusable in the Free World. Sure, we could redistribute the program and have copies on our machines, but that's not much good if it won't run. That program is free software, but it is effectively shackled by its non-free dependencies.

This problem can occur in any kind of software, in any language. For instance, a free program that only runs on Microsoft Windows is clearly useless in the Free World. But software that runs on GNU/Linux can also be useless if it depends on other non-free software. In the past, Motif (before we had LessTif) and Qt (before its developers made it free software) were major causes of this problem. Most 3D video cards work fully only with non-free drivers, which also cause this problem. But the major source of this problem today is Java, because people who write free software often feel Java is sexy. Blinded by their attraction to the language, they overlook the issue of dependencies, and they fall into the Java Trap.

Sun's implementation of Java is non-free. Blackdown is also non-free; it is an adaptation of Sun's proprietary code. The standard Java libraries are non-free also. We do have free implementations of Java, such as the GNU Java Compiler and GNU Classpath, but they don't support all the features yet. We are still catching up.

If you develop a Java program on Sun's Java platform, you are liable to use Sun-only features without even noticing. By the time you find this out, you may have been using them for months, and redoing the work could take more months. You might say, "It's too much work to start over." Then your program will have fallen into the Java Trap; it will be unusable in the Free World.

The reliable way to avoid the Java Trap is to have only a free implementation of Java on your system. Then if you use a Java feature or library that free software does not yet support, you will find out straightaway, and you can rewrite that code immediately.

Sun continues to develop additional "standard" Java libraries, and nearly all of them are non-free; in many cases, even library's specification is a trade secret, and Sun's latest license for these specifications prohibits release of anything less than a full implementation of the specification. (See and, for examples.

Fortunately, that specification license does permit releasing an implementation as free software; others who receive the library can be allowed to change it and are not required to adhere to the specification. But the requirement has the effect of prohibiting the use of a collaborative development model to produce the free implementation. Use of that model would entail publishing incomplete versions, which those who have read the spec are not allowed to do.

In the early days of the Free Software Movement, it was impossible to avoid depending on non-free programs. Before we had the GNU C compiler, every C program (free or not) depended on a non-free C compiler. Before we had the GNU C library, every program depended on a non-free C library. Before we had Linux, the first free kernel, every program depended on a non-free kernel. Before we had Bash, every shell script had to be interpreted by a non-free shell. It was inevitable that our first programs would initially be hampered by these dependencies, but we accepted this because our plan included rescuing them subsequently. Our overall goal, a self-hosting GNU operating system, included free replacements for all those dependencies; if we reached the goal, all our programs would be rescued. Thus it happened: with the GNU/Linux system, we can now run these programs on free platforms.

The situation is different today. We now have powerful free operating systems and many free programming tools. Whatever job you want to do, you can do it on a free platform; there is no need to accept a non-free dependency even temporarily. The main reason people fall into the trap today is because they are not thinking about it. The easiest solution to the problem of the Java Trap is to teach people not to fall into it.

To keep your Java code safe from the Java Trap, install a free Java development environment and use it. More generally, whatever language you use, keep your eyes open, and check the free status of programs your code depends on. The easiest way to verify that program is free is by looking for it in the Free Software Directory ( If a program is not in the directory, you can check its license(s) against the list of free software licenses (

We are trying to rescue the trapped Java programs, so if you like the Java language, we invite you to help in developing GNU Classpath. Trying your programs with the the GJC Compiler and GNU Classpath, and reporting any problems you encounter in classes already implemented, is also useful. However, finishing GNU Classpath will take time; if more non-free libraries continue to be added, we may never have all the latest ones. So please don't put your free software in shackles. When you write an application program today, write it to run on free facilities from the start.

Copyright 2004 Richard Stallman
Verbatim copying and distribution of this entire article are permitted worldwide without royalty in any medium provided this notice is preserved.


Here is the relevant snip from Dr. Gosling's article:

"As for Richard Stallman's Free but shackled: The Java trap , it's hard to know where to begin. He has his own rather peculiar definition of 'Free' that I think violates the First Law of Thermodynamics (energy is conserved): developers put a huge amount of energy into creating software and if they can't get that energy back in a way that balances, then the system falls apart. I've been in this discussion countless times and I'd like to avoid landing there again. GPL software is not 'free': it comes with a license that has a strong political agenda. Like GPL software, the Java platform is 'free' in many senses: you don't have to pay anything for the runtime or developers kit and you can get the sources for everything. Unlike GPLd software, the Java sources don't come with a viral infection clause that requires you to apply the GPL to your own code. But the sources for the JDK do come with a license that has a different catch: redistribution requires compatibility testing.

"This is just context for the real point I want to make: when you have platform software like Linux or the JDK, the platform interface (in the case of Java, the VM and API specifications) divides the world of developers into two groups: those who work under the interface to implement it, and those who work above the interface and build applications based on it. These two communities have needs that conflict. In particular, a blanket freedom for developers under the interface, to do whatever they damn well please, is incredibly disruptive and damaging to developers above the interface. The catch in the Sun Java source license is all about defending the needs of developers who work above the interface. This ends up being constraining to folks who work under the interface, but in a way that is hugely beneficial to those who work above. We believe that for a developer who has built a Java application they have a right to trust that when some other developer says 'I have a Java VM for you to use', that their application will work.

"So yes, like the GPL, our source license does have an agenda. It's not a hidden one, and we believe it's a very beneficial one (at least, to application developers!)."

Obviously he hasn't got a clue how offensive this is to anyone who cares about freedom for software. There are alternatives to Sun's Java, particularly if IBM were to decide to throw some resources to the GNU Classpath project, which I sincerely hope they do.

IBM's current JDK is based on Sun's code in part, I believe. What if IBM took the parts it does own, combined it with Kaffe and threw some resources at Classpath? Wouldn't that work? Somebody needs to do something, because if this is indicative of Sun's position, it doesn't look good.

Viral indeed. It's a license that cares about freedom to modify, distribute and copy. It cares about those freedoms for users as well as developers, not just the interests of those writing an application who wish to tightly control its direction thereafter and make some money from their software. That's the way the world used to be, but it's not the future.

So it's a culture clash. Sun folks are probably perfectly nice people if you met them at a party. But they don't see that the world has changed. Gosling's sentence about developers needing something back tells it all: "developers put a huge amount of energy into creating software and if they can't get that energy back in a way that balances, then the system falls apart". Except FOSS proves it doesn't. That argument is so yesterday. It's funny, because he writes earlier in his article about how liberating it is if hardware can be commoditized:

"Where this relates to Java and Sun is that because such a huge fraction of customer applications that run on Sun hardware is written in Java, we can treat CPUs (and even operating systems) as commodities, in the same way we treat disk drives. We can use whatever underlying CPU technology (x86/x86-64/Sparc/...) or OS technology (Solaris/Linux/...) is most suitable for the situation at hand. We aren't constrained by the instruction set or OS interface that is baked into our customers' applications. This is hugely liberating for hardware design."

He just can't connect the dots that commoditizing software is liberating too. If you have a proprietary interest, it's hard to see the benefits to others of you letting go, I suppose. Gosling is a Sun Microsystems fellow who managed the group that created Java in the early 1990s. Java is "free in many senses," he writes. Yes, but not the one that matters to us. Sun and Gosling are free to cling to the old ways as long as they can. And they can believe that you can make money from software and that the old ways were best and software should not be commoditized. But the world is moving on. History doesn't care what you prefer.

If Sun wants to know why the community does not trust it, that is the answer: We are users, most of us. In the old days, the community was mostly programmers. Maybe then Gosling's argument made more sense. But the community is users too now. The GPL benefits us. The argument between programmers above and below the interface isn't relevant to us. There is a public policy argument that needs to be addressed. Software has become too important to leave it an argument between types of programmers. And we users have a choice. We naturally will choose a license that cares about us. That would be the GPL.

The GPL also protects us from the SCO's of this world. SCO has made me allergic to proprietary code, because I see now what can happen if proprietary code falls into the wrong hands. It doesn't matter to me, personally, if a developer wants to write an application and release it as proprietary software. I buy and sometimes use such specialty software. But I care if a language is proprietary. I care if an operating system is proprietary. I care if the proprietor has the power to seriously disrupt everything for everybody just to make a buck for his selfish self. That isn't politics. If Sun chose to do a SCO, is there anything to stop them? That's a real question. And the real answer is that if Java were under the GPL, they would be blocked.

If that's viral, I want to catch it.

  View Printable Version

Groklaw © Copyright 2003-2013 Pamela Jones.
All trademarks and copyrights on this page are owned by their respective owners.
Comments are owned by the individual posters.

PJ's articles are licensed under a Creative Commons License. ( Details )