Sun has put its TestingComatiblityKit (TCK) for Java under a “Read-Only-License”. This means that you are allowed to look at the source-code but you are not allowed to modify or compile it. For more information, a couple of Sun people’s blogs address the subject here and here.
For a perspective from outside Sun, see here and here.
Read the license here. And retrieve the source code of the TCK here.
I think this is a really good example of how people can view source without getting any of the bonuses that you get from BSD etc. This is very fair and square, now noone can complain about possible bugs and security riscs in another software, nor will we see the GPL problem with software getting forked a 1000 times.
Good job Sun
and how exactly are they going to punish those that modify it???
This is not OSS (open source software), this is RSS (read-only source software), and heavens forbid: It’s only TCK
I wonder if Solaris will be released under “Read-Only-Parts-We-Wanted-To-Share-License”. I wonder how Scwartz will post in his blog about this. Probably something like: “Redhat with its GPL license is gaining (in his words it would be something like enslaving community to do free work for them) on work of others, we don’t like that and so we introduced Read-Only license.”
I think this is a really good example of how people can view source without getting any of the bonuses that you get from BSD etc. This is very fair and square,
—-
no. its a very poor way to do things
Its like… You can look at the car engine’s oil and water as long as you don’t change it!
You can carry a spare but not alowed to change it!
So developers are able to view the source (and thereby put themselves at risk of being sued by Sun later on if they develop anything Sun might consider a related or derivative work), but they can’t actually make modifications to it or submit their own fixes.
Sounds like the worst of both worlds to me… 🙁
BTW — code forking in an open source project (be it GPL’d, BSDL’d, or released under another license) is usually seen as a distinct benefit, not a problem. It lets individuals or groups custom-tailor the software for their own needs if the main development tree isn’t taking the road they require.
I think this is a really good example of how people can view source without getting any of the bonuses that you get from BSD etc. This is very fair and square, now noone can complain about possible bugs and security riscs in another software […]
When it comes to security, the problem with this kind of license is that it is possible for the bad-guys to find exploitable bugs, but it is not possible for the good-guys to fix them. Why? Because compiling the software is not allowed. The bad-guys of course does not care about that compilation is forbidden. The good-guys, however, cannot compile the code as they risk being sued by Sun if they do. Therefore, they cannot test the code for exploitable bugs, much less fix them.
A published bugfix would violate both the compilation and the modification prohibition.
”
BTW — code forking in an open source project (be it GPL’d, BSDL’d, or released under another license) is usually seen as a distinct benefit, not a problem. It lets individuals or groups custom-tailor the software for their own needs if the main development tree isn’t taking the road they require.”
if sun is worried about forks it should just apply for a ISO or ECMA standard for java instead of creating FUD
This license lets you view their JCK, for those who are perhaps interested in one aspect of how Sun judges compatability.
However, you can not compile or run this test suite. So, you can’t test your code with it.
You also can not use it to write your own test suite.
But if you’re interested in how a large test suite is written or structured, you can use any knowledge that you like that you learned from viewing this test suite any way you want (residual rights).
If you were developing a J2SE implementation, I imagine that you have your low hanging fruit figured out to ensure compatability. But if there is some nagging detail that you as a developer are not sure how it would be tested to ensure compatability, you can look at this JCK, and understand their methodology, which can give you a better chance of passing the JCK later on, when you DO license the kit.
For example, the Classpath folks can use this to clarify any questions they have in the spec for some of their code and how it should behave (the JCK, ideally, will tell you how it should behave).
However, with that new understanding, you should then contrive your own test on your system to verify that your code works, and not simply lift the tests out of here.
Obviously there are going to be edge cases (for like truly brain dead tests), but since you can’t call anything “Java” without passing the official, licensed, $$$, blah blah blah JCK anyway, I think this is more a help for J2SE implementors than a hinderance.
>>Its like… You can look at the car engine’s oil and water as long as you don’t change it!
You can carry a spare but not alowed to change it!
It is more like: “Use the engine, but dont modify it”.
“: “Use the engine, but dont modify it”.”
that doesnt cut it either. you cant use the source code. just look at it.
the best way to describe it is “read only”. look but dont touch.
i remembe reading someone on here saying ‘i should have the rights to look at the source for any product i buy’ well here you go. Sun has a right not to OSS their products. But now as a bonus their are letting you look at their source and this is a bad thing? You are getting a free oppurtunity to look and you bitch about it?!? This also lets you find the code that code be buggy anf report it too them for them to fix.
This is the only way to allow the community to interact with a proprietary product.
i saw this sig immediately after posting
“Being able to read *other people’s* source code is a nice thing, not a ‘fundamental freedom’.”
http://bsd.slashdot.org/comments.pl?sid=132867&cid=11096066
good source of anti-BSD FUD too!
> But now as a bonus their are letting you look at their
> source and this is a bad thing? You are getting a free
> oppurtunity to look and you bitch about it?!?
I don’t know if it’s true, but many voices say that taking a look is already too much since you *could* possibly re-use code you saw in your own programs and violate copyright and the license by that. If that is true, then in fact you don’t get the opportunity to look because it means the risk to be sued. Even worse, you could be sued even if you did not look at the code at all.
Apart from that, they wrote the code so let them do with it what they want. Nobody has to use their stuff if he doesn’t agree with the license.
You can’t even compile it?!
Oh, wow, /that’s/ helpful.
Hey, its a compadiblity kit! you just use it to test if your VM/compiler implementation works. If you could change it, then why use it? The point of the software is to make sure that everyone’s VM is compadible! sheesh. Sun Released it so ALL developers would be able to test their VM/compiler compadiblity (say gcj or the few other open source java compilers) instead of having to sign your life away (and become a “partner”) to get ahold of it. I think this is a BIG move for open source java compilers, and the open source java movement!
This means that you are allowed to look at the source-code but you are not allowed to modify or compile it.
I’m not sure how this can help out non-Sun java compilers, if you cannot compile the compiler test suite. Although I also see compiling to be a read-only process anyway, so perhaps there is no conflict here.
For those concerned:
From Graham Hamilton’s blog:
http://weblogs.java.net/blog/kgh/archive/2004/12/j2se_compatibil.ht…
mentioned in the article, btw:
—
There is no “tainting”. Once you delete your copy of the JCK, you aren’t constrained in your future actions. To try to make this really clear, we included a section explicitly granting what the lawyers call “residual rights”, which basically means that stuff that sticks in your head is OK to use in the future.
—
Looks pretty clear to me..
That is a great link, I’d say thanks but I’m guessing you are paid for posting… but great link none the less.
Here is the important quote and the one thing you *MUST* read:
[quote]
We’ve released the complete J2SE technology Compatibility Kit (JCK) sources under a read-only license, including the sources for all the tests and the sources for the test harness. This is intended to let people read and evaluate the tests.
In order to keep the license simple, we have restricted it to be strictly “read only”. I want to emphasize this. The license does not allow you to compile or run the tests (If you want to do that, you can get a different, more complicated, license, see below). We did this because otherwise the license would have blossomed into a twenty page legal document. But we have tried to make sure the license meets the reasonable needs of developers who want to evaluate the JCK sources:
[/quote]
So basically they created this license so that you could look at the could without having a lawyer dig through 20 bazillion pages. If you are legitimately writing a JVM then apparently you can apply for a scholarship. I think is to solve a problem with companies like JBoss creating commercial products that fly-under the radar since they are open-source, IIRC there was some scandal regarding that.
So developers are able to view the source (and thereby put themselves at risk of being sued by Sun later on if they develop anything Sun might consider a related or derivative work), but they can’t actually make modifications to it or submit their own fixes.
Sounds like the worst of both worlds to me… 🙁
BTW — code forking in an open source project (be it GPL’d, BSDL’d, or released under another license) is usually seen as a distinct benefit, not a problem. It lets individuals or groups custom-tailor the software for their own needs if the main development tree isn’t taking the road they require.
According to Graham Hamiltion’s java.net blog, linked above, your first concern is probably a non-issue:
“There is no “tainting”. Once you delete your copy of the JCK, you aren’t constrained in your future actions. To try to make this really clear, we included a section explicitly granting what the lawyers call “residual rights”, which basically means that stuff that sticks in your head is OK to use in the future.”
As for the second concern, I would suggest that forking makes no sense at all for an standards-compliance validation suite like this one, and in fact running a forked version would be worse than useless, since you may come under the impression that you meet a standard that you actually do not meet.
Same with the idea that the no-changes provision makes this ridiculous–it does not. Why would you want a standards-compliance test that might no longer test for compliance?
To me it seems like this isnt a bad deal. Get a good idea of how the standards checking works without paying Sun a dime.
I don’t see the point of it other than developing better.
I’d rather be able to modify it but not distribute it rather than just being able to look at it.
It’s a corporation though, do not expect much open source from companies although sun is like the #1 open source company (contribution wise)
sun is like the #1 open source company (contribution wise)
—–
where is the statistics?.
Its like… You can look at the car engine’s oil and water as long as you don’t change it!
You can carry a spare but not alowed to change it!
Actually it would be more like expecting GM to just hand over the blueprints and foundries for the LS1 small block and letting you do whatever the hell you pleased with them.
If a company allows you to look at the source but not touch then abide by the agreement. If you can’t handle it then write your own f*cking platform/vm whatever from scratch and set your own terms.
I really don’t have any intention on changing/forking Java, however this really doesn’t ensure the safety of Java. This doesn’t answer the question “If Sun gets bought out / bankruptcy, What happens to Java?” If it was Open Sourced, we could know that Java would not die with our company’s business model that utilizes it.
”
I think this is a really good example of how people can view source without getting any of the bonuses that you get from BSD etc. This is very fair and square, now noone can complain about possible bugs and security riscs in another software, nor will we see the GPL problem with software getting forked a 1000 times.
Good job Sun
”
Oh really, name me 5 projects that have been forked over 1000 times? Or even 100 times? 50 times? 25 times? Also, the forking problem applies to the BSD license too (OpenBSD was a fork of NetBSD/DragonFlyBSD was a fork from FreeBSD). Honestly, how does forking cause problems??? Let’s say Sun decides to halt development on OpenOffice, all you have to do is fork the latest code released under the LGPL. It guarantees the code will always be free. One fork will eventually be superior, as was shown with the X.Org fork. XFree86 changed their licensing, and there were about 5 forks. Fairly quickly, the other 4 died off and X.Org is now basicially the standard and almost all of the distros are migrating to it. Jeez…major version bonanza there Sun! (Referring to Shwartz’s comment about versions bonanzas constantly happening with GPL/BSD programs)
So explain to me how exactly forking is more burdensome than it is helpful??? If someone forks a project just because they feel like it, no one will use the fork and it will die. No big loss there. No burden. Forks generally happen for a very specific reason, such as the XFree86 incident.
Sun’s arguement about version bonanzas is ridiculous…no matter which version of the linux kernel i am using (or which distro btw) my StarOffice will still run unmodified, as well as firefox, thunderbird, sunbird, Skype, Adobe Acrobat Reader, RealPlayer and numerous others. I have never had to download a specific version of a program to run on kernel 2.6.7.3.4 as opposed to 2.6.7.3.1 (using fake numbers btw) or on XFree86 instead of X.Org.
So again, where exactly is the problem?
”
If a company allows you to look at the source but not touch then abide by the agreement. If you can’t handle it then write your own f*cking platform/vm whatever from scratch and set your own terms.
”
Let’s say with the Linux kernel you have 5000 people searching for security holes to fix them and 500 searching for them to exploit them. Well now with this you have how ever many people searching for exploits to use them and 0 people searching for them to fix them (excluding Sun). I just think its stupid. Your comment is also kinda dumb, IBM is doing just that. FSF is also working on classpath (or w/e its called). People aren’t sitting there bitching and crying and doing nothing about it. They are just saying how stupid the license is.
this is a good deal if you ask me, people who is building virtual machines and such might learn a lot from this testing structure and the code itself, they do not necessarily use or copy the code. i see that people who critisizes this license just love spoon feeding. and please note that this is the test code licese agreement, not the mechanism to be tested.
…that Sun doesn’t really “get” open source.
Are you serious man?
Sun has made more open source contributions than any other commercial company! You need to research this for yourself as if I just throw stats at you without backup of many websites it would likely not convince you.
you need to do your own research.
Interesting, Sun released plenty of software under various licenses like the GPL. I guess they just don’t think open source should exist throughout the company. a mix of the 2.
research it
”
Sun has made more open source contributions than any other commercial company! You need to research this for yourself as if I just throw stats at you without backup of many websites it would likely not convince you.
you need to do your own research.
”
I am dead serious. If you claim it prove it. you shouldnt claim such things in a off hand manner. whats the proof?
number of projects?
lines of code?
“you need to do your own research. ”
no. you need to stop claiming stuff you cannot support
“Sun released plenty of software under various licenses like the GPL”
other than dual licensed openofficed under lgpl and sun license with copyright transfer there is very few projects if any that has been gpl’ed from scratch from sun
If Java is really a standard and the JCP is a real standards body, everyone should have access to the TCK on an equal footing. Scholarships shouldn’t be given for the TCK, because then Sun can arbitrarily choose to grant or deny the scholarship. If you wrote your own VM from scratch, it shouldn’t matter whether you are open source, commercial, or both.
So developers are able to view the source (and thereby put themselves at risk of being sued by Sun later on if they develop anything Sun might consider a related or derivative work), but they can’t actually make modifications to it or submit their own fixes.
Its pretty much similar to Microsoft’s shared source, or OpenVMS its license.
I’m wondering though, will this mean open source Java implementations will have a less hard time (Sun certainly likes that, given they love open standards)? I though Java was already open source under a different license (SISL or something?) Oh well…
Read Only is pointless. If your looking at the code most likley you plan to modify it..?
You know what happens if you stare at the Sun dont you.
-Nx
“Read Only is pointless. If your looking at the code most likley you plan to modify it..? ”
Uhm, NO it’s a compatibilty test!!! – you don’t change anything at all
” I’d say thanks but I’m guessing you are paid for posting…”
My impression, at least, is that I’m paid for coding =)
Also, the link I mentioned was the first link in the original post. So I guess not many did CTFL (clicked the f… links).
Uhm, NO it’s a compatibilty test!!! – you don’t change anything at all
—–
why didnt they release the compatibility test under a free software license;?
Well, it’s kind of hard to say something that isn’t cynical in the context of a ‘You are not allowed to use this software’ software license. Save one thing: it’s actually quite a big jump for Sun. It’s a real chunk of progress. Congratulations!
All of Sun’s licenses for J2SE technologies are completely absurd. Without exception. SCSL, JDL, JRL, BCL, Read-only license … they are all pretty good examples of how to write an inherently broken and bogus software license.
The major step that Sun made with the ‘Read only’ license is that this JCK license is a just a little more than absurd and useless. All the other licenses listed above are absurd and useless, too, but on top of that dangerously wide open to interpretation, and due to their extremely asymetrical nature (Sun gets all rights to sue the skin off you, you get almost none) a pretty straightforward invitation to end up in court with Sun’s team of lawyers wiping the floor with you & your company, should Sun ever so desire.
So, I can understand the excitement Graham shares in his blog. Getting rid of the excessive amount of pretty bogus clauses that pestered all the other J2SE technology license is a major feat. Compared to the SCSL the Read only license must feel like a giant step for Sun, if you’re inside Sun.
It’s the first ever Java technology license from Sun that is actually readable and largely understandable by mere mortals. That the license is useless is just a negligible side effect, if one sees it positively: it shows that with enough practice, Sun may one day, far far in the future, accidentaly stumble over a license for the TCK that’s neither bogus nor broken. There is hope, at last.
It’s just such a small step for runtime developers outside Sun, who have been implementing nice little test suites like Mauve and JACKS as free software for years now.
I’m sure Sun will catch up with us one day, though. They will be most welcome, when they finally do.
cheers,
dalibor topic