Slashdot Mirror
Abstract Programming and GPL Enforcement
Headius writes "Through events of the past couple months, I've ended up as the lead developer for the Litestep
project, a several-year-old effort to write a GPL'ed shell replacement for Win32 platforms, for use in place of the standard Explorer shell. Current efforts involve a large rewrite of existing code and a complete refactoring of core services. Part of this new architecture is the abstracting of services to simple interfaces. Unfortunately, several other developers have brought up concerns that the hard work they put into developing the implementations of these interfaces (which will not have any dependency on Litestep-specific code) will be silently stolen by other (closed-source) projects in the cutthroat shell replacement arena and elsewhere. Is there any real way to protect GPL'ed code that has no interdependencies and abstracts away all the implementation details (as good OO code should)? I'm not as concerned about license violations as some, but how do I put the other devs' minds at ease? "
Thanks
Bruce
Bruce Perens.
// Good Thing
:)
...
:) ) too quickly too often, too many new devices popping out too fast.
:)
:)
:) ).
/.'ed. I could not get not on the site to review the project's technicality and specification.
The brief description appears to be Very Good Thing. It shall increase the number of applications and games on more OS's.
If it becomes phenomenally successful, your participants would have been instrumental to some large positive contributions to application spread.
Would this "historical" motivation be suficient?
// GPL is the only way
The precise reasons why all the commercial cross-UI projects fail / fall short is
The only way such a layer can be constructed is through GPL.
There are too many platforms, each of those platforms upgrades (downgrades
Any commercial limited-man team (versus the infinite manpower of GPL code resource) shall eventually be outstripped.
GPL is the only chance for a successful implementation of this.
I myself am looking forward to it both as user, and as coder.
Don't even think of anyway to "protect" commercial interests. The moment any part of it becomes "closed" (even in the form of "cannot be modified until after inconvenient beureaucracy") would hamper or destroy this project.
You shall succeed where commercial apps precisely and only because of open-ness.
// Commericial : higher level applications
How do you protect yourself against higher level applications (like games, database applications) that co-opt your code *freely* to provide our commercial applications with your functionality?
1. Credit and Appreciation
We commerical users of GPL code shall do what we always do. Accord code authors and groups with proper credit. Demonstrate our appreciation with thanks.
2. Donation
We commercial users shall thank you, after your code module demonstrates sufficient robustness, by donating actual development budget, to further fund your work.
There is precedence for this, and I do not suspect we shall change.
I shall watch your project very closely, and if I do see many other commercial developers or peers making good use of it in the future, I shall personally goad such peers into donation.
The same speaks for me. If I personally find your code base highly helpful to my commercial projects, I shall contribute what I can, even non-financially, to ensure the continual growth and support of your group.
// Commerical : lower level implementations
How do you protect yourself from commercial developers of low level layers?
The answer is you don't have a thing to worry from them.
1. GPL
That you are GPL and open, and they are closed and have limited manpower, shall easily cause your product (if organized properly, and if sufficient good code is contributed) easily to become technically superior and robust.
As I exposit above, there is no way any commercial company can keep up with all the versions of all the platforms. It shall bankrupt their payroll before this happens.
You *are* at a technological advantage.
2. Free or Pay
What if they just *copy* your layer verbatim and sell it for a profit?
As my understanding, this is exactly what GPL or Free Software is about! People are free to make profit off the code.
How shall your coders protect yourself?
Easy.
Be available to offer good friendly support to "users" (most likely higher level developers like us).
As *competitor* with the above commercial plagiarizer, you are already at an advantage:
1. Your product is free. Theirs cost money.
You are winning on the cost / price competition.
2. Your product can potentially have better technical support than theirs, if you do it right.
You have the resource of the original coders of the modules to support application developers.
They merely have plagiarizers or interpretors. Or a phone technician who did not even work on the code.
You actually have a better chance of this *protection* than Linux.
The average user or target market of Linux are lower literacy non-coders who need a lot of hand-holding ( and all the users who don't belong this category are already using Debian and not Red Hat
The target market or user of your layer are high level application technology literate commerical coders like myself, who are "easier" to support.
The scope of what you need to answer or help, would not run as wide a gamut as an entire Operating System.
// Project Scope Suggestion
I have been thinking the same thing on a much smaller scale for a very small subset of OS services that are needed by most game applications.
If this project is early on, may I suggest a smaller scope of Operating System Services?
In fact I can submit you privately a short spec of a small handful of *essential* functionality.
Besides the obvious personal bias that I am a commerical game developer, there are some gains for you as well:
1. A completed small project is better than a non-completed larger entity.
If done modularly and correctly, such completed small project can easily be grown and extended to its final ambition.
You can get to your technical proof of concept quicker. Ensuring both momentum and success.
2. Test Bed
By building your first iteration to a set of common functions, that already have quite a few applications waiting to ride on top of them, you have the fastest means to a nice group of users.
This again helps to smooth out kinks, track down bugs, proof in the pudding, kind of feedback that is hard to get by writing a "lower layer" in a "user-less" vaccuum.
// Disclaimer
Your site had been
The above is only based on what I can guess from your summary. Apologies to any misunderstanding.
In fact, it's easy to tell whether Linux contains code written by Microsoft!! The "strings" command outputs "printable" strings it finds in a stream of (binary) data; "/proc/kcore" is, in most GNU/Linux systems, a file that represents the current state of the kernel's "core", or RAM; and "grep" outputs lines containing the string on the command line that it finds in its input.
If you try the command below under Linux, you are asking for a printout of all strings containing "Copyright 2000 Microsoft" found in the your computer's RAM -- which includes the Linux kernel itself!
And, on my computer, which runs Red Hat Linux 6.1, it prints out plenty of lines before I interrupt it with Control-C!! Try it!! Doesn't it show that Linux contains W2K code?
(Yes, this is an old trick. ;-)
Practice random senselessness and act kind of beautiful.
There is no remedy for you through the GPL, but if you ever expect a remedy through the courts, you will need proof of plagiarism. As I imagine you don't have the resources to hire lawyers who could force a disclosure of the hidden code, you need a mechanism that would allow you to prove copying with only a released copy of the proprietary software in hand.
What you need to do is include a highly obfuscated trigger in your code. When a series of complicated and rare actions execute through code, a trigger message is displayed proclaiming "This code written by ABC and licensed under the GPL". That would be irrefutable proof of copying.
I believe the legal criterion to establish plagiarism is replicated *errors*. Another option is to include an intentional but, again, very obfuscated bug in your code. Either method should demonstrate beyond doubt that their product is based upon yours.
-konstant
Yes! We are all individuals! I'm not!
-konstant
Yes! We are all individuals! I'm not!
Others have said parts of this, but let me try to put them together:
Sure you can sue someone for taking your GPL code and incorporating it into a proprietary package or system. It's not stealing; you can't pursue that avenue. It is a license violation, and you could sue for that. But even better would be to take the resulting proprietary product, decompile it, and post the code publicly with specific documentation that it is now GPL code itself.
Some thoughts about this:
- The company will surely try to sue you and/or get an injunction. But then again, you were thinking about spending time in court anyway suing them, and you can surely countersue for costs and time lost. If you did your homework documenting that the code is a derivative of yours and that you were entirely within the bounds of the license that they adopted by using your code, you stand a good chance of having the case thrown out.
- By releasing their GPL code for them, you expand the market for implementation and support services. Since it's a derivative of your code, you stand to benefit from it because you're more familiar with the code. Therefore it's mostly a good thing.
This underscores the critical requirement for the legality of reverse-engineering. If click-licenses take the essential right to examine what you have purchased away from you, you have lost the right to know when or if you have been violated as a consumer or as a competitor. That's a completely unacceptable state of affairs: Imagine you buy a car with a 2.5L engine and the mfr puts a clause in the purchase agreement that licenses you the engine when you purchase the physical media of the frame and body -- and precludes you from disassembling the engine to see if they really gave you a 1.9L HO engine for which they stole the design from a competitor. It would be ludicrous, yet we accept the same arrangement in software. Why is Ferarri not worried that Chevrolet will steal their engine designs? Why are architects ok with giving their innovative structural designs to the public records office at City Hall? Why doesn't Makita worry that Dewalt will reverse-engineer their new compound-slide saw and put out a derivative work? Because these are all in mature enough industries where people realize that there's already ways to prevent misappropriation of technology (in the current legal context) without placing onerous legal restrictions on the consumer.
Not to defend them, but one can obtain patents to protect novel algorythms and innovative software. Why hide code? For example, why doesn't Microsoft publish the source for Word and sue the hell out of anyone that inappropriately uses it? One would think that the best way to defend a patent would be to openly establish ones' work as prior art by publishing the source just as every car comes with an openable hood.
Jon
I think not...(*poof*)
You could produce a manual which clearly describes the components and interfaces, and get a tiny income by selling it to that handful of developers who will be creating new modules.
You could make what you're supplying so good that nobody will want to replace it.
You could encourage replacement of components and focus on providing good parts for those components. Such as assuming that your user interface isn't the best, but you've decided that you're just making a user interface which is so flexible that it will be tuned by others to do what they need.
If I understand your project correctly, then you might not be able to release this thing, at least not under the GPL.
IIRC, use of a GPL interface, unless explicitly declared otherwise à la Linus' amendment to the GPL for Linux, generally means that the using code must also be covered by the GPL.
Historical: NeXT wanted to use gcc as their compiler, so they wrote an obj-c frontend to link to gcc statically. RMS told them that that wouldn't get around the GPL's terms, so they put the whole thing under the GPL.
Recent: I wanted to use a few Sun Java libraries in writing a GPL'd frontend for an IMAP client. RMS told me this was not allowed -- even dynamic linking is covered by the GPL.
IANAL, but you may not be able to use the GPL. This sounds like a job for the LGPL, but talking to the FSF about this would definitely be a good idea.
Cheers.
"Honey, it's not working out; I think we should make our relationship open-source."
If your code is to be stolen, it's almost impossible for you to prove it. This is an argument against all GPL'ed code, for that matter. However, there are two arguments against license violation of a GPL'ed piece: one for you, the other for those who would violate the GPL.
Firstly, there's the fact that for a freely distributed, GPL'ed work, you yourself lose nothing, those to whom you distribue lose nothing, and those who would respect your license lose nothing. There will always be freeloaders, and there will be freeloaders no matter which license you use, even a proprietary one. If you are using the GPL for the right reasons, the benefit of placing free - as in libre - code in the public sphere outweighs the irritation of having ne'er do wells use your code.
Secondly, to create a distinctive piece of software, the advantage from using GPL'ed code is greatly overweighed by the potential for legal action. A lawsuit can kill any product and even any company; the expense of a clean-room rewrite of a tainted product is so much greater than the potential benefit from using restrictively licensed code. Any corporate lawyer could make this call instantly, although I have less faith in PHB's and even less on individual coders. Still, I doubt that your prodct will be thoroughly exploited; snippets yes, the whole thing, no.
--
--
There is no premature anti-fascism. -Ernest Hemingway
In theory you can enforce the GPL in court--suing someone who pirates your code. In practice, you have no defense against somebody plagiarizing your code. Your team members are entirely correct to worry that the fruit of all their hard labor might be swiped by somebody and used in a commercial product.
You and I and the entire SlashDot community might argue about whether such plagiarism might happen--but the simple facts of history are brutally plain: without intellectual property protection that kind of plagiarism practically always occurs.
Example: consider the People's Republic of China. The PRC has paid lip service to intellectual property issues, but fundamentally there isn't any such thing. When was the last time you bought (or heard of) a piece of software developed in the PRC? It isn't because the Chinese are stupid--far from it. The ranks of American software firms (and the membership of SlashDot, I'm sure) are chock full of ethnic Chinese, and Chinese emigrants. But because anybody can peek at your work and swipe the results--and laugh at you while he's headed for the bank--most people decide that there is little reward for innovation. What innovation there is tends to be "protected" by some kind of secrecy scheme, or done because the innovator derives personal pleasure from giving his creations away.
This is a painful lesson to learn--but this is simple history, and simple economics. In some technologies there have been significant barriers to plagiarism (I can plagiarize ABB's technology for continuous-casting sheet steel--but unless I have $100 million for the machinery, not to mention sales contracts with Ford, I can't use their invention) but in software there are no barriers at all. If I can read your source code, I can use it. I may not copy it--I might just grasp the ideas and incorporate them in my next product design. And there is practically no way to prevent that from happening. The only way to protect the work that you have done (and to profit from it) is to seek refuge in the rules of intellectual property.