Slashdot Mirror
Claimed Proof That UNIX Code Was Copied Into Linux
walterbyrd writes "SCO's ex-CEO's brother, a lawyer named Kevin McBride, has finally revealed some of the UNIX code that SCO claimed was copied into Linux. Scroll down to the comments where it reads: 'SCO submitted a very material amount of literal copying from UNIX to Linux in the SCO v. IBM case. For example, see the following excerpts from SCO's evidence submission in Dec. 2005 in the SCO v. IBM case:' There are a number of links to PDF files containing UNIX code that SCO claimed was copied into Linux (until they lost the battle by losing ownership of UNIX)." Many of the snippets I looked at are pretty generic. Others, like this one (PDF), would require an extremely liberal view of the term "copy and paste."
Also, we find out more about streams, and how SCOsource was bogus.
How dare they copy/paste those blank lines!
So finally they revealed the lines with the comments "copied" into Linux.... //check this later...
Like:
Yeah, because open-source developers can just see and copy the proprietary closed-source code - oh wait...
"In a blog post dated July 10th, 2010, Kevin McBride has leaked almost 50 of the code comparisons that were submitted in evidence in SCO vs Novell. You can download the archive.
Read on to view individual files if you don't want to download the whole thing.
Linux STREAMS
We also learned that the whole STREAMS fuss was not about linux, but about a product distributed by gcom, a provider of legacy solutions.
Their Linux STREAMS (LiS) product provides a couple of loadable drivers that would intercept calls to the old streams api and convert them. In other words, far from the allegations that the linux kernel contained code that infringed streams, it's evident from the need of an add-on loadable module that the linux kernel does not contain any STREAMS code.
Of particular note, and probably a source of much consternation to SCO and their proponents, is that LiS itself doesn't implement streams either, just does protocol translation. So neither linux nor LiS contains infringing code.
The whole end-user $699 license was a scam
So according to Kevin McBride, one of the lawyers who worked on the case, there was no reason for end users to take out a license. It's logical to conclude that SCOsource was a protection scam. So what happened? To me, it looks like SCO lawyer-shopped until they found attorneys who were willing to go along with the scheme for a price - everyone has their price, and in this case, it was $30,000,000.00.
The Appeal of SCO's loss to Novell - Novell will probably win.
So it's pretty much as we suspected all along.
I'm a bit curious what the result would be if you fed both into one of the cheat detectors a lot of college's and universities use to detect plagiarism. If anyone has access to one they should give it a go, for science.
Let this shit die already. SCO has nothing.
I, for one, am looking forward to the inevitable
I find it rather funny that the Linux code is well commented but the SVR4 code has little to no comments at all. Just because the function names are the same doesn't mean it was copied. It just means that the coders implemented functions with the same names (and I bet that the Linux versions worked rather differently than the original SVR4 code).
I'm really sorry, but there was some code that was already written that was just too good to pass up for the project I was on:
#include
int main(int argc, char* argv[])
{
printf("Hello World!\n");
return 0;
}
Now that I'm using Java, it won't happen again.
Seriously, is that him? Or some troll? It seems bizarre that he would make public comments like that.
Also, remember that a lot of the code was declared "Public Domain" many decades ago, because of pre-1968 copyright registration errors.
Die, Monster, Die!
Just because you have a PDF doesnt mean anything. If you have 2 declarations that basically do the same thing on two systems, and two different programmers just happen to be using the same "case" (ieCamel,Caps, lower, first letter etc) --- what are the chances that they will name them the same thing? my RPG struct Attributes { int str; int intel; int agi; }; so how many rpg's out there use strength agility and intelligence stats?
I actually find it ironic that libelf was picked as an example of infringement. I can tell you first hand that the (more standard) UNIX/Solaris libelf is NOT compatible with the Linux/libc libelf. And I can also tell you that after pointing this out to Ulrich Drepper he really didn't give a shit... (I think his approximate words were "It's been like that for a while, too late, I won't change it").
Their only mistake was actually naming it "libelf"... since it is most definitely NOT the same library...
Not if you go through the details. Look at the ElfData structure, for example. Also the fact that it is a header file.
You're not a programmer are you. The header files are pretty much just a bunch of definitions. there is no programming to speak of in either of those files. From reading the Posix standards you will end up with the same code but with your own comments. The header files are a lot like the ingredients section of a recipe. So it's like looking at two recipes for omelets then complaining that both have eggs listed in the ingredients section.
It's a header file for a standardized interface. All this stuff needs to be the same for any *NIX-like operating system to be *NIX-like, otherwise, you're making an incompatible operating system. To make source-compatible operating systems you need to have common interfaces, and those interfaces lie in the header files. Saying that this is copyright infringement is like saying that they patented a hole in the wall as a way of getting in and out of a room.
Obviously, is isn't identical now, though it is possible that the Red Hat copy (right side) started out as the UNIX copy (left side). Clearly, the Red Hat version has additional features (additional translation types, c++ defines, function prototypes, commenting, etc). Then again, maybe they were both implementing from some shared prototypical document.
In case you are not trolling, virtually all of the allegedly copied code is boilerplate stuff defining types and structs or function interfaces. These have to be the same for Linux to be posix compatible. The little actual code there is, it isn't similar at all. Copyright can't keep you from writing a function that acts like another, that is for software patents, there should be actual copying and for such tiny functions it would be pretty hard to demonstrate (!s) was copied from (s==NULL).
I still think the jury, knowing nothing about computers, would have ruled against Linux, but the claims were ridiculous.
If that's the one I'm looking at it's a header file for handling ELF executables.
All that's in there are the names, arguments and return types of ELF functions, and constants used.
All the names, values and return types of those functions are defined in the ELF standard, as are the constants. Of course they're going to be the same, they HAVE to be, and the ELF standard wasn't a proprietary Unix thing.
Note that the actual implementation of these functions is not in question, because it's not the same code
Of course it looks rearranged. It's a header file. Some of the ELF constants come straight from the ELF spec. The #ifndef stuff is bog standard code, there are a finite number of ways of writing that and the one presented happens to be the most common. The #include is another "duh" - of course you have to #include the right header, that doesn't mean it's copied. The header file is presumably deliberately compatible with the original, hence the function definitions are prototype-compatible (while being considerably different in style).
There is nothing indicative of code copying in that PDF. The Linux header is just about as different as it can be while remaining source-compatible, as it should be.
Computer programs pose unique problems for the application of the "idea/expression distinction" that determines the extent of copyright protection. To the extent that there are many possible ways of accomplishing a given task or fulfilling a particular market demand, the programmer's choice of program structure and design may be highly creative and idiosyncratic. However, computer programs are, in essence, utilitarian articles -- articles that accomplish tasks. As such, they contain many logical, structural, and visual display elements that are dictated by external factors such as compatibility requirements and industry demands... In some circumstances, even the exact set of commands used by the programmer is deemed functional rather than creative for the purposes of copyright. When specific instructions, even though previously copyrighted, are the only and essential means of accomplishing a given task, their later use by another will not amount to infringement.
It is nearly impossible to win a copyright suit over a header file. The only chance you would have would be if it was a straight copy-and-paste which this was clearly not. The reason for this is that there is just not much room for creative expression in header files. Likewise, you can't copyright a word or a short sentence.
There are a very limited number of ways to declare functions. If someone was allowed to copyright certain function declarations then they would have control over a large segment of the software industry. Likewise, if someone was allowed to copyright particular words, they would have control over a segment of the publishing industry.
We don't see the world as it is, we see it as we are.
-- Anais Nin
Nah it's a joke. The only thing highlighted were the function / subroutine definitions and not even across the board. Just because 2 programs have hooks or functions called "ReadX" does not mean there was any copying involved. They even highlighted include statements and data structures. It's almost like suing an author for starting with "Once upon a time". I guess they just figured no judge would be able to clue in on this kind of stuff and they would be able to sift through junk like this for decades. Hell they could use the same reasoning against pretty much any software and win if that is all the proof he needed. I guess Unix was truly the precursor to all the code ever written so Novell can truly say "all your base are belong to us".
A loop, by its nature, continues. If that didn't make sense, start reading this sentence again.
I went and looked through a handful of the pdfs, most of what he's claiming are just variable declarations with intuitive naming (as they well should be). Really? What's next, someone claiming copyright infringement based on using the letter i as a temporary variable? Thank god for copyright law, or else people might just get away with such atrocious fraud... Furthermore, if it takes that many red lines to elucidate the copy&pasting, surely that's visual indication enough that you're clutching at straws.
I see nothing of proprietary value here... It's just a whole bunch of references to functions and type definitions .. in a stupid header file.
I am going to patent that solution and be soo rich, just you wait!
No, read the POSIX interface standard (or in this case specifically the ELF executable standard).
You have to give your functions certain names to be compliant to the specification. The code shown is interface code, the implementation is somewhere else. Interface code simply names the functions, parameters and variables. As the functions must have certain names and parameters to fit the standard you will get the exact same line that declares a function. Any C programmer could recreate that same block of code with just a list of functions names and parameters that must be declared.
eg. If you have to have a global function called elf_version with return of unsigned int and parameter of the version you'll get the line
extern unsigned in elf_version( unsigned int __version );
We see that same line of code in both files as they both implement the same specification. I'm sure there's a ton of other UNIXes out there that have the same line of code.
(same AC) Actually, I've been programming for just over twenty years. I think a better analogy is why two recipes for omelets call for eastern Australian ostriche eggs. Please explain to me why the enum LABELS are exactly the same. The replies that this source is something from a POSIX/ANSI/ISO specification, rather than just merely personally attacking me, were a bit more helpful.
Give us the diffs.
Giving us a pdf with red bold lines marked all over it will probably look a lot more incriminating than if there is a diff file removing all the lines in the original file and adding all the lines in the file in question.
More news about imaginary property. How much time and money does our society waste on propping up this outdated concept that you can own an idea? "#include " constitutes copy and pasting? I guess every program on earth violates the copyright of the guy who first wrote "int main(", and whoever started the convention of naming C++ files cpp or cxx should be hiring a lawyer about now. Money is to be made.
Great Intellect...
Comparing a variable named elf_t_arname to one names elf_c_arname is not very convincing. The suffix is generic, the prefix is activity specific, and the middle letter is presumably some datatype indicator.
Where it gets dicey is when there are structs and every variable in the struct has a somewhat similarly named variable in the other one. This does arouse suspicion. even if you forget the variable names for a moment, any pattern like bool,real,real, *real, int, *char,*char,*bool,.... that is identical between two structs would be an improbable occurence. and when you see it in back to back structs it becomes nearly impossible to happen by chance.
The key question then is if there is some structural reason why the two might share an identical stuct? for example, is there an elf spec that defines a protocol for communication or the way a record on disk is serialized (i.e. packed)? if so then of course these will occur like this. Or perhaps both are derived from a common BSD ancestor so both vary only slightly.
if the answer is no, there was no reference implementation and no ancestor then I'd say that for examples like 251, Mcbride has some evidence.
However for most of the ones he cites there is no there, there.
Some drink at the fountain of knowledge. Others just gargle.
All I see is SCO clearly copied Linux! ;D
oops I meant document 331 not 251. (251 is an example of McBride seeing things). 331 is much more interesting.
Some drink at the fountain of knowledge. Others just gargle.
Well lets see.
"ELF_C_..." - each of these is the name of a type in C. I don't see how this is even a bit creative. I had a very similar enum in a program I wrote, except with data types from a 3D engine. My guess is that ELF_C means it would be the ELF binary format's C data type. Nothing to see here.
"ELF_K/ELF_T" - It says in the open source one that these are descriptors as well. More or less the same; universal concepts if you're going to be programming a C compiler. I bet you can find an enum just like this in visual C++.
Hmm... beyond the headings, that's really all that is in that file. If you really have been a programmer for 20 years, you have without question violated thousands of copyrights... if that file does.
Great Intellect...
Towards end of the PDFs (like 412 on), the examples do show actual lifting of code fragments. It's still all in the libelf code, so it could have been fixed in 25 minutes of rewriting. That would assume good faith on SCO's part.
Isn't this completely moot since SCO released a LINUX based UNIX? Once they distributed the GNU work, they implicitly sanctioned the copying.
Slightly rearranged? That much rearrangement (plus adding comments and making sure it all still worked properly) would have taken more effort than just writing the damn thing from scratch!
(same AC) Again, 20 years programming experience, no experience with some, apparently very important for *NIX, POSIX IEE document. If this is a published standard, obviously they'll be similar. I just didn't understand why every function definition from line 138 to 176 is copied verbatim. With the same cryptic series of letters which obviously imply meaning (strptr, newscn, getshdr, getphdr, newehdr, elf_flagelf, elf32_faize) are VERBATIM. I think a more effective summary would have been to link to the public domain specification with these exact terms mentioned in the document so we could all laugh at how their only evidence is a public spec-based implementation.
Instead I see a long list of identical function names, enum types, enum labels, and identically named structure fields. When I google the relationship between POSIX ELF I don't exactly get any hints , for something that's supposed to be (I'm assuming its relating to http://en.wikipedia.org/wiki/Executable_and_Linkable_Format)
How much touching up, commenting, refactoring, general massaging is necessary for it to become "unique" code? I think if you got a jury that wasn't as studied as me, you're right, Linux would have been screwed without a little more explanation..
I've never done that (replaced a url with another) in my life - nice try. Next time, try to be at least a bit more credible by not posting as a lying A.C.
this fiaSCO has been running on for nearly 8 years - what the hell is up with the courts that they keep this bullshit alive. /dev/null
Kill -9 all | sort >
Pain is merely failure leaving the body
Ho-hum.
I'm not a coder. I couldn't create a kernel if my life depended on it. I couldn't code a hungry cat to catch a mouse. 1/2 or more of what I read in code is gibberish to me.
But, one thing is pretty sure. Linus Torvalds wrote Linux, and his programming background came directly from Unix. OF COURSE he is going to write the same commands he has used a thousand times in the same way. OF COURSE there are going to be lines that look very much the same, sometimes even identical.
Now, open any dozen books that are 50,000 words in length. Search for strings that are duplicated between the books. Entire sentences, or phrases, it hardly matters. Just do the search. Anyone who is used to playing with databases can probably search those dozen books, and find numerous instances of phrases that were copy/pasted from one author's book to another. In fact, I'll bet that technical and factual books will have a higher incidence of matching phrases and sentences than works of fiction - but fiction will have it's share as well.
And, before we do this data base mining, we need to set up some method of assigning a variable string for proper names. In the wife's romance novels, we would be looking for " $ kissed $ ". It will be repeated so often that you can't help seeing the plegiarism. One author after another rips it from his predecessors.
50 instances are claimed for "copying". Out of how many lines of code? Good grief. I guess it should have been mandatory that Linus write any code not only in a different programming language, but in a different language than English. Then, he MIGHT have been safe. Maybe. Not likely though, because SCO can probably read Chinese, or hire some scumbag lawyer who can.
"Windows is like the faint smell of piss in a subway: it's there, and there's nothing you can do about it." - Charlie Br
It is true that anyone who slams Microsoft for not innovating, while simultaneously claiming that Linux is innovative, is an idiot. Neither is particularly innovative. (Nor is OS X for that matter.)
The difference is that Linux openly admits it's just a solid, free implementation of the tried-and-tested UNIX design, while Microsoft spouts so much bullshit about "innovation" that the word has become practically meaningless.
That's talking about the Linux kernel, of course. Some projects commonly used with Linux, such as Gnome and KDE, are actually very innovative. The only problem is that every time they try something new, half the community slams them for being too different from Windows and the other half slams them for being too similar to Windows. It's tough to innovate when everyone actually wants everything to stay exactly the same forever.
Just don't forget to pay your SCO licensing fees you cock-smoking teabaggers!
Okay. Now I'm really confused. What does Sarah Palin have to do with SCO???
Wollt ihr den totalen Krieg?
This code was the last big unknown in this long sorry saga. Even if SCO owned the copyrights, (and hadn't distributed it under the GPL, and hadn't signed the UnitedLinux agreement, etc.) it is now crystal clear that SCO's Microsoft-funded anti-Linux campaign was based on a stack of frivolous law suits.
I think Darl's brother is scrambling to cover his backside so that when the disbarments and criminal charges come down, he has a chance to escape.
Groklaw (of course) has IBM's response to SCO's claims that these paltry examples are worth BILLIONS of dollars in copyright damages. None of the code they offered is protectable under copyright law. Some of it is BSD code that everyone is free to use however they want (if they include the copyright notice). A lot of it is header files that were not copy-and-pasted which are nearly impossible to protect under copyright law. Then they have some snippets of generic code. Given the size of the source code for Linux, it would be astounding if there weren't some similar snippets. The idea that this is proof that Linux violated any Unix copyrights is totally absurd. The idea that these generic snippets are what made Linux enterprise-ready is beyond insane.
The recent SCO v. Novell case decided that SCO never even owned the copyrights it was suing about. And then instead of the millions of lines of code they claimed were infringing, they presented this meager collection of totally unprotectable snippets. I sure hope SCO's lawyers get severely punished for perpetrating this fraud on the court for the past seven years.
We don't see the world as it is, we see it as we are.
-- Anais Nin
I haven't really been following this of late, but is all that SCO has, or do they have anything that actually amounts to real evidence of copying (i.e.: two source code files that are the same aside from non-code elements like comments, whitespace, etc.)? The example shown isn't even a reach, it's just ridiculous.
"Only two things are infinite, the universe and human stupidity, and I'm not sure about the former." --Albert Einstein
It's not even that. It's plain old rewriting a library to remain compatible.
Here's an example of some end-user programs that use those very enumerations. The ELF_Type enumeration is used on page 37 in an end user application and ELF_T_WORD value is assigned to it on page 45.
http://elftoolchain.sourceforge.net/for-review/libelf-by-example-20100112.pdf
There's no coincidence involved. If you write applications that use the ELF_Type enumeration and you decided to write a new elf library to support that app you'd end up having the same enumeration names to maintain compatibility.
Copyright allows you to recreate something that's compatible as long as it isn't copied directly.
...also the fact that it is a header file.
<sarcasm>I'm relieved that header files arent' considered code. This is one more thing I don't have to pay programmers for!</sarcasm>
... duke nukem forever will be released. Seriously? They are still at this?
No one cares whether it's a public spec or not (it may be, I do not know). It's a OS header file. The functions have to be named the same way in order for end-user programs to be source-compatible. If you've been programming for 20 years, this shouldn't be too hard to grasp.
If SCO were allowed to claim copyright over this, then it would be simply impossible for Linux to provide a compatible libelf. This means you'd essentially prevent anyone from ever making compatible OS libraries, as they'd be infringing on the original author's copyright. That would be ridiculous. Public function names and prototypes (documented or not, standardized or not) are not considered copyrightable.
Another example: is Wine, according to you, a humongous violation of Microsoft's copyrights? After all, it implements the Windows API with identical function names and prototypes, undocumented features and all (which is nowhere near a published standard of any sort).
The Dead Parrot Sketch was presented by talented people, and it was funny. This is more like listening to Rod Stewart.
I've seen cases where me and another person are working on code independently, and when it came time to merge, we had both ended up creating the same variable names, and pretty much the same code.
About the only difference was in indentation - mine is "always put the opening brace on the same line, one true tab, else in same column as if, no braces for any single-line condition to a control structure (for, if, else, while, etc)". Even the comments were pretty much the same.
In this case, though, some of the code is from BSD - which is perfectly fine.
It is total BS, has been debunked completely here and on Groklaw for almost a decade now. Give it a rest.
And here, see? They're both using inline comments. Inline comments are an innovation by us. This is a rip-off!
What a nonsense.
ELF which is a file format, and is pretty stright forward to implement, and also have some functions and names directly embeded in the standard specification. It is not any proof.
FUD again.
I'm sure there's a ton of other UNIXes out there that have the same line of code.
And they all infringe our copyrights!
- SCO
Interface names needed for interoperability are fair game. Interfaces once published are public domain. The specific document is not.
Software is copyrightable but it is not a work of fiction where more protection is given. Writing a book on physics protects the specific wording in that book but it doesn't keep others from using the word "relativity" with the same meaning or your specific name for the speed of light -c- to explain the same exact phenomenon your original book described.
Guess what? Wine contains a function named MessageBoxW and I can't remember the parameter types, but I assure you they are the same as in Windows source. That Microsoft hasn't done anything about it, should tell you how much legal standing a suit on struct member names or function behavior would have.
Seriously, whoever made that pdf, it's unreadable. How about using different colors so I can tell the lines apart? I would actually read it if you had done so.... Like this it's just illegible.
Ell given that everything in a header file is public if you want source compatibility they have to have the same names.
I, admittedly, didn't read 100% of all of the links, but the slightly more then skimming I did do did not show me anything that was the same that couldn't have been for achieving source compatibility.
It would be like complaining that glibc defines EXIT_SUCCESS...
Of course it looks rearranged. It's a header file. Some of the ELF constants come straight from the ELF spec. The #ifndef stuff is bog standard code, there are a finite number of ways of writing that and the one presented happens to be the most common. The #include is another "duh" - of course you have to #include the right header, that doesn't mean it's copied. The header file is presumably deliberately compatible with the original, hence the function definitions are prototype-compatible (while being considerably different in style).
There is nothing indicative of code copying in that PDF. The Linux header is just about as different as it can be while remaining source-compatible, as it should be.
Commenting further on that, here is a link to the System V Reference Specs, one of which is the ELF Tool Interface Standard Specification. This contains not only several constants, structures, and function names, but suggests function prototypes and programming style.
Like you said, any author wishing to build an ELF-capable system would almost have to have that exact same code. There are only so many ways to build an enum or struct following the exact TIS specifications, and there is no virtue in paraphrasing C code.
Much of the rest of the code is libc and POSIX prototypes (and more headers), all of which are covered in the System V ABI specification. Anybody wishing to build a POSIX-compatible system would have to define those prototypes.
Several of the function implementations with similarities are very basic functions. Most of the similarities are in the constant names (rather than the specific implementation of those simple functions), and the constant names are defined by ... the TIS spec. The remainder is a no-brainer. See, for example, Tab 422. This is a simple accessor method. There are only so many ways to retrieve a value from a structure...
"until they lost the battle by losing ownership of UNIX" Those are all the words you needed to read. You cannot loose ownership of that which you never did own. SCOs gambit was to gain ownership by bamboozling everyone. You know when one party is blowing smoke in these issues when they refuse to point to the infringing code outside of court. If the quote included is to be believed, they lost on appeal and now that they have filed yet another appeal they are suddenly going to show us all the holy grail of "infringing" code. In each case where they've brought up "infringing" code, it was either released by themselves, or was code they didn't own in the first place.
We've suffered this case for how many years and this is their evidence? Someone tell me that they actually had a software engineer with extensive multi-generation and cross platform software development experience testify. Code like "if (foo->bar == 0) return 0; return foo->bar;" simply DOES NOT qualify as duplicated code. This is their evidence? Come on.
Even with the specific allegations being invalid, it's a valid point that you could do that.
Would you mind satisfying my curiosity as to why you're using your sig to post the link rather than putting it in comment text?
Just because Linux and Unix have some of the same lines of code, does NOT mean that linux copied the code from unix.
The code could have come from BSD for example and in fact there are several instances where linux and Unix share (or shared) the same BSD code.
The code could also have come from implementing the Posix Standard. The PDF linked to seems to be an implementation of errno.h which I believe is part of the POSIX standard.
So again just because the code appears in Unix, does NOT mean that Unix had copyright ownership of that code.
To prove its case SCO would have had to prove that:
a) Linux had lines of code that were substantially similar to Unix. (some minor examples provided but even that was not definitive)
In fact the judge who supervised the discovery kept asking for details and at the end of the multi year discovery process, said, "Is this all you've got?"
b) Unix had copyrights to the code in question (again not proven)
c) SCO owned the Unix copyrights (again not proven)
d) SCO never granted the rights to use that code in any way. In fact Caldera (aka SCO) distributed a version of Linux under the GPL which in effect granted GPL license to any of their code that happened to be in Linux.
So even if all of a, b, and c were true,
they STILL did not have a case for infringement.
I almost wish that SCO had owned the UNIX copyrights, because then this whole issue would have been resolved by now, instead of relying on Novell.
softcoder.
I learned perl from someone who named all his variables with variations on "foo" and "bar". Back in those days, if I was writing something short and simple enough, it was hard for me to break the habit of naming things $foo, $bar, $boo, $far, $foofoo, etc. I'll bet a lot of our code looked like it was from the same person :)
The CB App. What's your 20?
1. break down the plaintiff’s program into its constituent structural parts (“abstraction”);
2. examine each part for incorporated “ideas,” elements taken from the public domain, methods of operation, processes or procedures, or otherwise unprotected material (“filtration”); and
3. compare the remaining kernel of creative expression, if any, to the work alleged to infringe at each level of abstraction (“comparison”).
They further explain:
The scenes à faire doctrine is often applied in software cases because it is frequently impossible to write a program in a particular computing environment without employing certain standard programming techniques and design elements. This is because certain functions, data elements, and the order of operation of a program can be dictated by such things as the type of computer on which the program will run, the programming language used, the operating system environment, governmental requirements, industry demands and standards, and widely accepted programming practices.
I suspect the reason SCO didn't filter this code is because if they did, there would be nothing at all left to present to the court as their fig leaf to avoid being charged with perpetrating a fraud on the court.
We don't see the world as it is, we see it as we are.
-- Anais Nin
There are plenty of things I could do ... doesn't mean I would.
I changed my mouse a few days ago and it's causing me nothing but grief - including random clicks where they don't belong, back/forward browser motion at random, and cut-n-paste when and where I don't want it. The link got eaten by one of those - it's happened many times today - most of the time I catch it. This time I didn't - which is why I reposted with both the link and more info - such as McBride's comments about STREAMS and SCO losing the next appeal.
I'm going to be cleaning off the sensors on the old mouse and hoping it works okay because this is just not working (though it works fine as a second mouse with my laptop ... go figure).
Must have been the cocaine, booze, illegal and perscription drugs, and wild Gay orgies on the Riveria that did it! Right! Err..... No!
They just did not have the brain cells, intelliect, understanding, training, intelliectual capacity for communicating in the English Language.
This case and the linked cases can be referred to as, Dumb and Dumber!
We also learned that the whole STREAMS fuss was not about linux
In other news: fire is hot, and bears shit in the woods.
It's well known that Caldera programmers attempted to get STREAMS accepted into the kernel mainline, and the linux devs (most notably Alan Cox) said "no fscking way."
The news isn't that it's not about Linux, but that Kevin McBride is a raving psychotic who claims that because someone else (Gcom) shipped Caldera's GPLed STREAMS implementation, that means that "Linux infringes SCO[X]'s copyrights."
I think the patent system is the greatest achievement of the human race.
Or they both legitimately got it from BSD, or linux got it from the standard.
We know from the AT&T settlement that there's a lot of BSD in AT&T Unix, and that even some of the non-BSD AT&T stuff simply isn't protectable by copyright.
Exactly. Everyone knows they're full of shit and they're grasping at straws. Hopefully any judge they bring this shit to will tell them to fuck off and diaf.
The stories and info posted here are artistic works of fiction and falsehood.
Only fools would take it as fact.
i can put it on look.at.datfukkendog.com
extern unsigned in elf_version( unsigned int __version );
Build error: unknown data type 'in' :-)
I spent several years as a Unix kernel hacker, working extensively with AT&T source code. I also went to law school and was one bad case of writer's block away from becoming a copyright lawyer. Thus I found those code snippets quite interesting, both from my Unix kernel hacker persepective and my almost-became-a-copyright-laywer perspective.
My conclusion, from the half dozen or so of his samples that I looked at? They show nothing remotely resembling copyright violation.
Copyright covers expression, not ideas. What that means when dealing with functional works, such as computer programs, is that things that anyone implementing that functionality will have to do are unlikely to be covered by copyright.
All of the functions I saw that were allegedly copied were very simple functions. All they did was check arguments to make sure they were legal, return the expected error code if not, or return some very simply value otherwise.
Even if the corresponding functions in Linux were exact matches to the SCO code, it would probably not be enough to support an inference of copying, because there just aren't a lot of ways to reasonably express such simple functions. And they were not exact matches. One would check for a null pointer by comparing to NULL, one would use if(!p), for instance.
The header files are more similar, so copying is more believable there. The problem with SCO's case there is that the elements in the header files I looked at are entirely dictated by compatibility requirements. There's no copyrightable expression in them.
To summarize, SCO's claims appear to fall into two groups. First, things where the implementation is so simple that it is not possible to infer copying from similarity since the similarity is imposed by the nature of the function. Second, things where there may have been copying--of things that aren't protected by copyright.
Except that gcom didn't ship Caldera's STREAMS implementation. They shipped a loadable module (driver) that intercepted calls made by legacy apps to the STREAMS api and translated them to calls that linux could fulfill. In other words, no STREAMS code necessary in either the LiS product or in linux, and not even code to emulate STREAMS - just translate the call and forward it.
Since we have to rely on this PDF , and there is no way to prove that that code was actually in UNIX at the moment ( as it's closed , there's no way to check ) .
I am left to conclude that it's much easier to copy from Linux (which is open ) , than from UNIX ( which is closed ).
In other words , using this PDF , i could also claim to SCO stole from Linux , and then implemented it in their commercial product , thus violating the GPL .
Slipping shoelaces ?
man....if that's the case, they can go after ANY software company that used/uses C++....even Microsoft.
seriously, that's like saying someone copied your letter because they started their letter with a "Dear Sir".
Plus, wasn't there some sort of law/precedent that exempted data structures from it? (aka the "struct", etc.) especially if it's for interoperability.
And some of those lines seem to reference (link) to external library functions too.
Claiming that as infringement is similar to Coca-Cola claiming that Pepsi-Cola is infringing because they use the word "Cola."
man...why won't SCO just shrivel up and disappear already? they are worse than crabs and I don't mean seafood!
All that PDF shows is that McBride violated Adobe's copyright.
Just don't forget to pay your SCO licensing fees you cock-smoking teabaggers!
Okay. Now I'm really confused. What does Sarah Palin have to do with SCO???
The approximate IQ of the management.
In Gates v Bando the Tenth Circuit established the abstraction-filtration-comparison test that would become the standard in software copyright infringement. Specifically in the filtration step, all elements which are not protected by copyright must be removed from consideration. In this case, most of the code falls under scenes a faire: "expressions that are standard, stock, or common to a particular topic or that necessarily follow from a common theme or setting . .these external factors may include: hardware standards and mechanical specifications." Most of the code were simply declarations needed for compatibility and cannot be copyrighted.
Well, there's spam egg sausage and spam, that's not got much spam in it.
Header files are public - but they seldom contains any advanced functionality. They are just a definition of the calls available, defined data types and constants.
If the header files didn't contain the same (or very similar) definitions then the API wouldn't work. I expect the same header definitions to reappear in many other operating systems with minor differences - many even in Windows (Which do have a Posix API)
But of course - a lawyer wouldn't understand that, it's just a question of money.
If builders built buildings the way programmers wrote programs, then the first woodpecker would destroy civilization.
No, read the POSIX interface standard (or in this case specifically the ELF executable standard).
...which isn't part of POSIX (OS X, for example, uses Mach-O, not ELF, but is still not only POSIX-compliant but licensed UNIX(R).
If they worked for IBM or SGI, two large contributers to the Linux kernel, they could. SGI at one point contributed UNIX derived code.
There are some actual similarities beyond API necessities. This PDF contains a striking example of that:
http://www.mcbride-law.com/wp-content/uploads/2010/07/Tab-247.pdf
But there's a reason why the copyright headers are missing in that PDF---they say that this code is under University of California copyright, so both System V and GNU/Linux copied it.
The pdf linked in the document is a snippet for what looks like a struct for the elf API interface. This specification is open and judging by the code they are using it exactly as intended.
I'm going to guess the majority of their findings are specifically computer generated. They may have known first hand what the code was or even where it came from. However, if pressed to say how they discovered these violations I'm quite sure they would fall back on "the program made the mistake your honor." This would generate a plausible stance when the foundation began to crumble.
Going further on a limb I'm also guessing this is why they would never release any of the alleged violations. In days a website similar to groklaw would be up in for everyone to review, identify and mark the source of the "violation." ie, this is a struct for the elf library specification or this is a header of a BSD library. (Remember that BSD ancestry is likely still there in large chunks)
All of this happening in the court room and they had to know there were big holes in the allegations. Even a cursory glance reveals that some of the crap submitted is just that. This was a court room poker face with a huge bluff that many parties would just settle. I suppose it worked because too many people rolled over and handed out free cash.
"You should always go to other people's funerals; otherwise, they won't come to yours." -- Yogi Berra
mine is "always put the opening brace on the same line, one true tab, else in same column as if, no braces for any single-line condition to a control structure (for, if, else, while, etc)"
Coding style like this makes me cringe, particularly the thing about no braces for single-line conditionals -- it makes it far too easy to make mistakes because you indent code and forget that indentation doesn't mean it's part of the conditional (unless you are using python, of course).
Ask me about repetitive DNA
while (horse = "dead")
{
beat (horse);
}
I'm not a coder. I couldn't create a kernel if my life depended on it. I couldn't code a hungry cat to catch a mouse. 1/2 or more of what I read in code is gibberish to me.
But, one thing is pretty sure. Linus Torvalds wrote Linux, and his programming background came directly from Unix. OF COURSE he is going to write the same commands he has used a thousand times in the same way. OF COURSE there are going to be lines that look very much the same, sometimes even identical.
Linus Torvalds started linux; out of the current code he authored a few percent. Linux is now massive, and this is a pretty large amount of it for one guy to have written, but his main job these days is on managing code submissions from others. This case is really unrelated to Torvalds; if submitted code was plagiarized he wouldn't have been responsible or known about it, and it's really fairly unrelated to Linux; if SCO were to have succeeded Linux wouldn't disappear, but certain companies like IBM, SGI, etc, would have needed to pay some cash and redo some code.
Torvalds is not on trial here.
Also, as a guy who had his own code plagiarized, I am very wary of special pleading to try and excuse such behavior. We need to look at the facts of the case; we can still use Linux (I do) and at the same time be completely, absolutely opposed to it being tainted with plagiarized code.
The truth is that code was reused (if not copied, exactly, in the same way you don't submit a copied essay which you've taken from a classmate) from a UNIX derivative, which is now (somewhat disputably) owned by SCO.
That is understandable (even if illegal and arguably inethical); there's a dying version of UNIX which no-one seems to be the definite owner of, why not reuse useful snippets from it for the sake of compatibility and efficiency? Well this whole mess is exactly why; when in doubt write your own goddamn code, always.
We should be just as mad at SGI and IBM for being lazy and careless as we are annoyed that a company like SCO exists only to litigate and not do anything useful.
But please do not try and excuse or downplay this behavior. Linux is not going away, and we want justice to always be done because next time it'll be some other company using code from Linux (or one of your projects).
These are not small words like "kissing" that are under dispute, this is not about reusing some very common routines that everyone uses, that's just silly. Rather it's about companies wanting to maintain compatibility with legacy versions of UNIX and doing so by referring directly to the legacy UNIX at best, and plagiarizing their code at worst.
Trying to imply that this is some nonsense that should be dismissed just because you like Linux is like playing down and ridiculing the evidence of the murder of Hans Reiser's wife because you like ReiserFS. It's even sillier in some ways because Linux isn't at stake in the case like ReiserFS was. (An extreme analogy I know, but valid).
Always support justice, always maintain strict ethics when using your code as you would expect others to for your own code. If everyone did that companies like SCO couldn't exist, and more money would go to coders and less to lawyers.
// MD_Update(&m,buf,j);
Darl deliberately drove the company he was supposed to be running into the brick wall that is IBM and funneled money out of the company into his brothers pocket. Linux was just the "angle" of this two man scam.
There was also a lot of stock pumping and dumping going on.
And heres the Magic. Linus learned his style by closely reading Andrew Tanenbaum's books, and reading the Minix code. Which of course is what your supposed to do with Minix. So have most OS coders who had their education back then.
The end result of course is that everyones code ends up looking like Tanenbaums , which is not a bad thing, the guy is up there with the gods in terms of importance to O/S theory.
Excuse the Unicode crap in my posts. That's an apostrophe, and slashdot is busted.
I think Darl's brother is scrambling to cover his backside so that when the disbarments and criminal charges come down, he has a chance to escape.
He posted this info in response to a response to an off-topic response to an interesting and informative blog post. I hardly think that CYA action... It was more like adding important, original source material to a discussion that seems to be marked from both sides by mud-slinging and vague, emotionally charged assertions.
I wanted to reply to several of Mr. Mcbride's responses just to say how glad I was that he wasn't falling for some of the flame-bait a couple people managed to get in the replies. I'm tired of the immature way people on the Linux side have been prone to approaching this whole thing. We get it. SCO is wrong. Mcbride is, by extension wrong. By yelling at him and calling him names, we gain nothing. He has seen the evidence and believes it points toward SCO being right. However, engaging in real, calm discussion, we gain a lot. We got to see (some) of SCO's evidence, and he (and we) got to point out (somewhere in one of the replies) how some code he (and SCO) thought was SCO's was actually BSD originally. It sounds like he's going to actually look into it, and we may have been able to change someone (sorta-kinda-not-really-important-but-could-cause-some-great-thanksgiving-day-table-conversation) else's mind.
And all it took was treating another intelligent person as an intelligent person, instead of hearing "SCO" and immediately turning into an ass.
/rant
If this paragraph is indicative of your general level of knowledge about the history of Unix, you might want to look into ELF and how it got into Unix. I can tell you this however: it didn't came from Berkeley. The various BSD derivatives got it from SysV long after the fact.
Also you might want to spend about ten more seconds checking out the PDFs at the linked site, not just the one linked by the knucklehead kdawson. It's not simply header files. There is actual code. The similarities in code flow, layout, variable names, filenames, etc. are conclusive. The linux contributor didn't implement this code clean room-style based on the specification, plainly having used the Unix implementation as the source.
Nice of them to skip over the (c) on that file in glibc. Let me paste its beginning here: /*
* Copyright (c) 1982, 1986, 1988, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
(etc)
Though, I do agree that it looks like copying. I do not think (having read the ELF spec and implemented it), that code would look that similar in general (some of the duplicated enums are not in the ELF spec (which funny enough is published by SCO)), however, I was under the impression that header files where not copyrightable since they only describe an interface.
If there were any reason to implement source level compatibility with SCO, i think this would be allowed (though IANAL). Ridiculous is to bring in the dlopen header, this is implemented on every UNIX-like system, and headers are needed for compatibility, which is explicitly allowed by most copyright laws around the world (the same headers are also in OS X, BSD, Solaris), the important part, if you want to determine whether code was copied is the code, not the headers.
From the looks of it, the ELF code was actually copied, and I do not think that you need any liberal notion of copying for seeing that, I have seen this kind of copying by students earlier, and they usually rightfully get into troubles for it.
"Civis Europaeus sum!"
Sure, they copied all those those blank lines, and in at least one case (tab 247) they also copied the BSD copyright header. Shocking! Funnily enough SCOX removed those lines on both sides. Kind of them.
They also copied strn?casecmp definition (tab 241). For quite astonishing values of "copied":
-SCOX
+RedHat glibc
-38: int strcasecmp();
-39: int strncasecmp();
+53: /* Compare S1 and S2, ignoring case. */ /* Compare no more than N chars of S1 and S2, ignoring case. */
+54: extern int strcasecmp (__const char *__s1, __const char *__s2)
+55: __THROW __attribute_pure__;
+57:
+58: extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
+59: __THROW __attribute_pure__;
This is clearly an extremely grave violation. However, it is interesting to note that SCOX did not complain about the definitions of all the other string functions. Maybe because the header of their file specifies
In addition, portions of such source code were derived from Berkeley
4.3 BSD under license from the Regents of the University of
California.
Presumably the other string functions came from BSD, and ignoring character case was a UNIX improvement that BSD couldn't have thought of by themselves. Right? Right??
Actually, at the time Linus was writing Linux, there was a fully printed generic Minix implementation in the back of a text that was used for teaching purposes on Unix, and it included most if not all of a Unix kernel. On one hand, Linus was admittedly at the same university where it was used and could have obtained it if he wanted, on the other, the author of that source has stated that he didn't copy it and there is no formal accusation, and Linus denies ever seeing the code. There was a grey document several years back that discussed this accusation and there are refutations. I've read through them and I was not convinced either way. The most damning evidence was that Linus cranked out the kernel in a relatively short period of time producing the same interfaces that you see in the Minix book, while the author of the "Unix" blue book took many years to write it. I am NOT saying that Linus didn't write it - in the worst case, he probably saw the example code in the text under academic circumstances and then went home and wrote his own perceptions of what it should do. In the best case, he was unaware of it entirely and brilliantly cranked out a kernel in a short period of time (I have a tough time accepting it, but it is possible). The truth is somewhere in between and we will never know what really happened.
Further reading:
http://www.cs.vu.nl/~ast/brown/
Yes, foo, bar, baz, are the traditional metavariables. Now tell me why we use i,j,k... so often.
Ostriches aren't Australian, they're African. Omelettes can be made from emu eggs and I have tasted one. It really wasn't any different to one prepared from hen's eggs. It looked no different to this observer. Compare an emu egg to a hen's egg and they are quite different in size, colour and even texture internally and externally. The formula (recipe) however was just for a standard omelette that we would all recognise by sight instantly. Interestingly, it tasted like one prepared from hen's eggs as well. Couldn't tell the finished product apart.
Posix header files also look remarkably similar to this observer. If code is being written to a required formula so that it interacts correctly with other code (a standard) then there should be little surprise that it looks the same.
Egg analogies make me hungry.
...Chuck McBride, a Texas beef farmer and brother to the SCO CEO, has made claims that Linux is responsible for the still-births of two of his calves this year...
Gentoo Linux - another day, another USE flag.
It's a header file for a standardized interface. All this stuff needs to be the same for any *NIX-like operating system to be *NIX-like, otherwise, you're making an incompatible operating system. To make source-compatible operating systems you need to have common interfaces, and those interfaces lie in the header files. Saying that this is copyright infringement is like saying that they patented a hole in the wall as a way of getting in and out of a room.
You know what? You just gave me a great idea....
OK, the file called Tab 409, is basically given by SCO in their ELF documentation, they cannot possibly claim that this is illegal copying since all the defines and structs are given by the documentation which scream out: Please implement me!
Anyone who implements ELF will write those lines of code.
"Civis Europaeus sum!"
In a country with fair laws, since .h defines interfaces, and interfaces sould be ok-territory (it sould be OK to create a program with the same interface a different program, and make it exempt from any intelectual property law), then this snip is ok. If your country has horrible laws, and is against the law to have the saem interface (shocket).. but that would be stupid, Imagine if every electric machine use a different interface to take the electricity it need.
So, to me, this means nothing. Show me some .c, and we are walking.
-Woof woof woof!
Too many similarities - some of those tabs *all* variable names are identical, and no new variables, and none removed,. Technically could be coincidence in one our two header files, but not it dozens.
Loop counters, duh.
Wait, was that a trick question?
Every sinle one I looked at the copied values were variable names. It makes no sense to just copy the variable names unless you're providing a compatible public interface. Since this is part of the elf library I imagine this is what they're doing. If so they had no choice but to do it in exactly the same way.
Another file was the header for a kenrel implementation of the strings library. This is based of the ANSI specification.
Every copied line I saw was one of the following:
SCO was blowing smoke.
Why i,j,k and not a,b,c?
Since SCO had a distribution of Linux at one time, I'm more concerned with who put the code in Linux as much as wondering how much is in it. Remember Open Linux 2.3? I still have a copy. This is pre lawsuit. I've been keeping the boxed copy as a buffer against legal challanges. I bought the infringing code from them before they became trolls.
http://linux.omnipotent.net/article.php?article_id=4448
The truth shall set you free!
Foobar is a WW2 acronym for F*%&'d up beyond all recognition. (Typically referring to the military situation (See "The Longest Day").
Now get off my lawn.
Sent from my ASR33 using ASCII
What are you talking about? Look at Jack Thompson. Look at the list of disbarments on the wiki article.
http://en.wikipedia.org/wiki/Disbarment
Presenting a case to the last legal straw has never resulted in a disbarment. He has in fact fulfilled his duty to the justice system by leaving no stone unturned.
Hope isn't going to do it. Say hello to democracy and get involved in changing legislation if you want to ever see that.
I will recommend you switch to using braces for single-line conditions/structures, at least if you're using C. You have no guarantee that any preprocessor macro expansion will remain on one logical line or otherwise not futz the scope of it if you do not explicitly brace it.
This is not an issue in other languages which use parsers made after the 1970s ;)
Reverse engineering for compatibility is allowed (at least where I live). Thus, headers cannot be considered code, since they are only expressing an interface, essential for compatibility.
If you want to be compatible with say int foo(int, float), then you actually need to write that exact sequence in your own headers, since the header define the symbol name and the calling convention for the functions. You do also, by the way need to name the header the same as in the system you are emulating for compatibility reasons, as otherwise the programs that you want to run on your system will not compile.
"Civis Europaeus sum!"
The truth is that code was reused from a UNIX derivative, which is now (somewhat disputably) owned by SCO.
Did I miss a verdict here?
As far as I know, it is right now only a claim, not yet proven.
And using the terms "truth" and "SCO" in one sentence... well, it just feels wrong.
POSIX (pronounced /pzks/ POZ-iks) or "Portable Operating System Interface [for Unix]" is the name of a family of related standards specified by the IEEE
Its a public standard for operating systems as published by the American Institute for Electrical and Electronic Engineers. Linux is and has for a long time
mentioned that its a POSIX compliant operating system. So when buddy says "see, its kinda similar to Unix n stuff", what he means is that POSIX compliant
operating systems are somewhat similar. ...go figure. When I was in university, I had a Computer Science prof. accuse several students of plagarism. The
program requirements were very small, and the programming language was assembly. They asked "is it possible that there is more than one correct solution
(in mathematical terms, they are asking if the possibility of a tautology exists). He replied, No, there is only one correct solution. He then dropped his complaint. Hello SCO
You SCO guys are as brilliant as a sack of hammers!
fubar.
snafu. (situation normal, all effed up.)
I'll save you a place on the porch at the old folks home, for when you get here.
I'm all for strict ethical standards, and I won't claim to have gone through more than a half dozen of these PDF's checking them.
That said - the six or so files I looked at were exclusively issues about some fairly well established naming conventions, the repetition of which is about as unlikely as finding an elm street and sycamore street 'coincidentally' close to each other in both our home towns and calling it 'evidence' the city planner of one stole the plans of the city planner of the other.
I've heard people claim in several posts that "Well, if you looked at the PDF's that weren't cherry picked for ridiculousness ..." there are 'obvious' copying of code. That may be, but I'd like someone to actually link to a pdf with this obvious copying of code - burying the evidence in bullshit data is what you do when the evidence is against you and you *don't* want the other side to find it, not when it's in your favor and you're trying to make your case.
At a minimum, the fact that he has buried his 'evidence' in with other bs data doesn't make it very clear he knows what actual evidence of copying would look like.
Pug
An Invisible Entity of Vast Power whose existence must be taken on faith alone: Liberal Media
I did see the code - and the filenames, but the majority of that was header files that are containing definitions that have to be identical for portability reasons.
And the few code snippets that did contain actual functions didn't contain any real and obvious surprises. The working code was hardly something that you can call "advanced" by itself.
And then there is the issue of which way some code actually did go. From Unix to Linux or the opposite way.
If builders built buildings the way programmers wrote programs, then the first woodpecker would destroy civilization.
They both had a common parent which was public with those structures. Remember these were public APIs, no one is disputing that the structures were similar. The question is whether the implementations were copyright violations.
"it was certainly a matter of one window with unix source to read from, the other window with linux source to write"
Hell no. That's a bullshit accusation.
Here we likely have a programmer who has never seen the SCO code (was it even released publicly back then?) but knows that applications can call functionY from libraryX from the interface documentation. If he creates a new libraryX containing a compatible functionY he isn't violating copyright. It is established that creating code with a compatible API interface isn't a copyright violation unless you actually do copy the code.
Indeed it appears this is exactly what is happening in the linked elflib files. The filenames are the same because they have to be (note both the redhat_libelf.h and SCO_libelf.h are actually referred to by just libelf.h in code and elflib.h is what applications need to link to) and the functions are the same because they have to be or else applications will be calling functions that don't exist.
This also happens with the WINE project. People there are creating the same header filenames and inside those headers the exact same function names. They aren't working off a split screen setup and blatantly copying Microsofts closed source code. They are merely recreating the functions that applications can call in Windows.
A similar thing happened years ago with Compaqs IBM compatible BIOS. Compaq re-created the IBM BIOS to get around having to buy the IBM BIOS. Both BIOSes responded to the same application calls in the same way with the same return values and messages. Despite this Compaq didn't break copyright because they still re-wrote the code. In fact Compaq hired engineers specifically for the fact they had never seen IBM BIOS code. This way it could be easily established that they didn't copy the code but instead just wrote the same code that performed the same task.
oops, mods have no sense of humor..
OF COURSE he is going to write the same commands he has used a thousand times in the same way
I'm sure this is one of the reasons it's best to call the system GNU: Linus didn't write any of the "commands". Linus wrote a kernel and GNU ended up adopting it. The GNU project wrote the system "commands".
Just do the search.
Trivia: Actually, the people at exbiblio found that there is very little repetition of text in literature. Any four or five word sequence in a common magazine article is likely to appear in very few or no other texts. That fact is foundational to their technology.
Presumably this is a holdover from when coding was dominated by applications of linear algebra (I'm thinking here of von Neumann). I imagine the first code for a loop through each element of a matrix was preceded by a thought along the lines of:
"In the direction of i, from 1 to n; in the direction of j, from 1 to m"
One function per file, and the same name for the file as the function, is actually damn good C coding practice. Nothing else.
Religion is what happens when nature strikes and groupthink goes wrong.
Because i used to stand for "incremental".
Just because 2 programs have hooks or functions called "ReadX" does not mean there was any copying involved.
On the other hand...
The PDFs provided seem pretty damning.
Let me guess, you're neither a programmer nor a lawyer. Am I right?
I clicked on the "damning" evidence linked to.
Once I'd scrolled past the #defines, the prototypes for required API calls, the typedefs for certain structs, etc. I then found nothing else.
Seriously, the submitter should learn how to code and what it means to reimplement existing, public, standard, API's, and then they should have the difference between an *interface* and actual *code* explained to them.
... a hole in the wall as a way of getting in and out of a room.
... or a lady.
Yeah... But half of the names in the C are offcouse the same as in the H because they
were defined there, so those don't count, since they had to be the same (see parent)
In the C files (and the H files) empty lines are regulary used as proof off copy, i mean the .h, so they have to be the same. And then the resulting if block-code is completely different.
more big red lines you put in your >proofed_kind and ELF_K_AR are defined in
I mean, look at those files, WITHOUT the thick big red lines screeming injustice and tell me they
look the same...
If you don't like my sig then don't read it.
I've looked through the pdfs, and scary red lines which prove nothing aside (OMG, their header files have identically-named functions?? Think about it.), I just don't see plagarism there.
Clicking on these I find a lot of .h files implementing POSIX and BSD standards (here is a choice one that is such an absurd claim of copyright violation that I can't believe they did it: http://www.mcbride-law.com/wp-content/uploads/2010/07/Tab-2421.pdf) Most of the others are not quite that bad.
So you don't waste your time, after quite a lot of clicking I finally found some actual code: http://www.mcbride-law.com/wp-content/uploads/2010/07/Tab-415.pdf
Here we see that they both used the name "elf" to name a pointer to the ELF structure! Why the chances of two programmers deciding to do that must be astronomical!
I stared at this thing for quite awhile trying to match up the code as it certainly is different. Finally figured it out: the Unix code goes to the i'th field in the structure and returns it if and only if the "index" field in it is equal to i. The Linux code instead searches and returns the first field with the index field equal to i, whether or not it is at i. Umm, this seems to be a pretty significant difference!
This is such a load of bullshit that mr Mc Bride should be ashamed.
On another subject, some years back now there was a Slashdot Interview where we were requested to submit questions to SCO. Strangely I don't recall seeing answers to them. I had one regarding the awarding of stock options to several people on the board two days prior to the announcement of the lawsuit. Since they're still dredging all this shit up, I don't suppose they could dredge up their response to those questions and send them along? I'm sure it'd be good for a chuckle...
I'm trying to teach myself to set people on fire with my mind... Is it hot in here?
"I'm not a coder. I couldn't create a kernel if my life depended on it."
Huh?! Do what most armchair kernel programmers do here at /., lie about that fact.
OK show me something that is not a header, non obvious, and not found in an open common variant such as BSD. post should be modded ignorant.
Because in mathematics, i, j and k are traditional notation for, e.g. summations. I can't do formula embedding here but think of the big Sigma: sum for all i, integer i ranges from 0 to infinity, that sort of thing. Fortran is FORmula TRANslation language.
The thing that makes me angriest about this is that SCO's lawyers probably used GNU diff to analyze all that code.
Still, all they came up with were a few single-function definitions that probably couldn't be written any other way. Instead of rejoicing in compatibility and interoperability like any normal F/OSS programmer, the capitalists frown upon it; in their minds nothing can improve upon their "perfect" [30+ year old] code.
That's another thing that's bothering me about this; that code is so very very old that the amount of software rot is almost unthinkable. Can they even truly call it a "product" that they "own" if the damn thing won't even compile? If it won't run, well... then it's just a bunch of meaningless code.
"Ubuntu" - an African word meaning "Slackware is too hard for me."
You only missed a verdict if you haven't looked up for seven years! Recently a jury in Utah confirmed what a judge found in a bench trial: Caldera (later SCO Group) did not get, and was not entitled to get, the UNIX copyrights in the 1995 deal they did with Novell. Unless you think that the jury was unreasonable in that finding (and guess what, SCOG and its lawyers do), SCOG does not 'own' UNIX in any useful sense.
Decompiling binary cannot be copyright violation because they have different copyrights. If you haven't seen the source code with its copyright, but only the derived binary, then you can't infringe the copyright by decompiling to source, even if it happens to come out to identical code.
Much like if you work out the words or chords or guitar tabs, etc of a song you have a copy of you have not committed copyright infringement, but if you copy the released words, chords, guitar tabs, etc, you have.
Since we have to rely on this PDF , and there is no way to prove that that code was actually in UNIX at the moment ( as it's closed , there's no way to check ) .
I am left to conclude that it's much easier to copy from Linux (which is open ) , than from UNIX ( which is closed ). In other words , using this PDF , i could also claim to SCO stole from Linux , and then implemented it in their commercial product , thus violating the GPL .
While I disagree with the SCO case, your assertion that its impossible to check is wrong - UNIX may be 'closed' but that doesn't mean that the code base is impossible to get hold of. One of the licenses you could buy was full source code access, and many companies and academic institutes took this license (I for example have seen the code base to AIX and HPUX several times at different places).
'Closed' doesn't always mean 'you can never have the source code', it can just mean 'you can't do what you want with the source code'. UNIX is one of these cases.
Because in FORTRAN, variable names beginning with letters I through N meant integers, and all other meant floating-point. For those with some FORTRAN experience, naming the first 6 loop counters "i,j,k,l,m,n" is automatic.
Please, if you don't have a grasp of the history, don't post stuff that just confuses the issue. Novell bought the entirety of UNIX from AT&T. Caldera did a deal to acquire the UNIX licensing business from Novell. Caldera changed its name to SCO. The courts have decided that the UNIX copyrights still belong to Novell.
I think that this is part of the ELF code. See analysis here: http://www.groklaw.net/articlebasic.php?story=20040722135616439
Now, open any dozen books that are 50,000 words in length. Search for strings that are duplicated between the books. Entire sentences, or phrases, it hardly matters. Just do the search. Anyone who is used to playing with databases can probably search those dozen books, and find numerous instances of phrases that were copy/pasted from one author's book to another. In fact, I'll bet that technical and factual books will have a higher incidence of matching phrases and sentences than works of fiction - but fiction will have it's share as well.
Actually, that's not true. There is some evidence to suggest you only need a remarkably short string of words to uniquely identify a piece of English prose - it's this kind of thing that cheating-detection algorithms rely on.
But we're talking about a structured programming language - with far more structure and rules than the English language - and the things that are at issue are by and large implementations of existing standards. The final link in TFS is a comparison of ELF utility header files, FFS. They've got to look fairly similar or they won't be any use for dealing with ELF executables! Even then they're sufficiently different that it would probably have been easier to write from scratch than it would be to execute the "copy/paste/obfuscate" cycle that is being alleged.
Yup, this is the right answer. God I feel old today...
IMPLICIT DOUBLE PRECISION (A-H,O-Z)
Could you point out where to a place where the "code flow" is damningly similar in a situation where there are several ways to do what the function by definition needs to do? I can't find a single one.
You say it's pretty damning so you obviously found something more interesting. Please list the worst infringements so the rest of us can confirm.
SCO must really hate *nix to run it into the ground like this. Are we sure they're not somehow a subterfuge branch of MS, or Apple? I smell, well, not necessarily a conspiracy, but certainly a reasonable line of questioning as to their motive. It doesn't seem like genuine patent trolling to me....
These are not small words like "kissing" that are under dispute, this is not about reusing some very common routines that everyone uses, that's just silly. Rather it's about companies wanting to maintain compatibility with legacy versions of UNIX and doing so by referring directly to the legacy UNIX at best, and plagiarizing their code at worst.
Except it's not about that at all. It's about implementing standard interfaces that are defined by POSIX. POSIX defines things down to the variable type so it's natural that the resulting header files will look similar. In fact, some of the differences I'm seeing in these files are from SCO not implementing POSIX properly ex return type int where it should be size_t.
You also need to keep in mind that SCO's predecessor (AT&T) was itself caught copying code from Berkely.
There was exactly one case where there was copying shown between SCO and Linux. In that case the code was from Berkely (licensed open source) copied into SCO and copied into Linux by SGI as one of their internal filesystem driver headers. The code was determined to be non infringing due to it's history but deleted because it was old and reimplemented in a better way elsewhere.
From working with the Linux kernel maintainers I know they take copyright very seriously and investigate even the possibility that code was copied and you owe them an huge apology for that uninformed set of accusations.
Okay. Now I'm really confused. What does Sarah Palin have to do with SCO???
An even better question would be: What does Sarah Palin really have to do with the "tea party" movement?
(Besides the fact that she wants as much air time as possible, I mean...)
("Tea Party Express" sort-of has something to do with the "tea party" movement, but not strongly. Largely, it's a degenerate Republican cheer squad. The rest of the movement embraces fiscal responsibility, not blind adherence to a political party.)
I won't join Slashcott. OTOH, If Beta goes live, I just won't be back until it's fixed. Sorry Dice.
Is that so? Let's see if we take a phrase from your own comment: "a higher incidence of matching phrases". One hit. Not bothering with linking to them all, but how about "rips it from his predecessors"? One hit. "strings that are duplicated between the books"? One hit. "his programming background came directly from Unix"? One hit. "open any dozen books"? One.
I have, of course, duplicated them in this comment, meaning there will be two hits very soon. BTW, these are all the strings I searched for, giving your comment a 100% originality rating (admittedly, I didn't search for "I'm not a coder", which I expect would show up several times).
Duplication of whole sentences in ordinary human language is actually quite uncommon for all but the most trivial declarations and stock phrases ("Just do the search" gives 3 million hits; "Just do the twist" gives 105 000).
The PDFs are machine generated. I ran the same program using a copy of Moby Dick and the Microsoft EULA, it produced damning evidence that the programmers had copied them word for word into their source code.
No sig today...
> The similarities in code flow, layout, variable names, filenames, etc. are conclusive.
I did look at the code on the linked site and what I saw looked entirely like a clean room implementation to me. The similarities were superficial and much less impressive than similarities I have seen in code that I know was written independently (because I wrote it). Two programmers working on the same problem can easily come up with strikingly similar looking solutions which a non-programmer (or an inexperienced programmer) would never believe was independent. I was astounded at how pathetic the supposed similarities were.
http://rareformnewmedia.com/
For those not logged in who don't see the download url in my sig
Or those who are logged in and block sigs, of course.
It's official. Most of you are morons.
In theory, having a problem that only accepts a single solution by definition would preclude the creativity inherent in a copyrightable work.
Which doesn't even address the fact that SCO made contributions to the kernel under the GPL.
Any so-called infringement is fully licensed.
I was under the impression that header files where not copyrightable since they only describe an interface.
where != were
ex:
"Where were you going?"
"The mints were where the toffees were."
Have you ever read the ELF specification?
Syllable : It's an Operating System
In the pdf document, code snippets are compared. But it doesn't make clear in which direction they were copied, if they are copies. The linux snippets have useful comments, the unix snippets don't. In a copying process, isn't it more likely that comments are stripped, rather than have them magically appear?
no, I don't have a sig
Just don't forget to pay your SCO licensing fees you cock-smoking teabaggers!
Okay. Now I'm really confused. What does Sarah Palin have to do with SCO???
The approximate IQ of the management.
Sarah Palin has an IQ? I thought she was a computer animated automaton invented by the Fox News Channel to amuse it's viewers?
As long as the comments going with the code are not copied verbatim, I don't really see an issue.
Atari rules... ermm... ruled.
That's the kind of analogy that Hitler would have made.
If you were blocking sigs, you wouldn't have to read this.
I hate you, so, so much. Please never touch a compiler/interpreter again.
No it didn't.
Variables starting with I through N (INt) were integers in FORTRAN.
If you don't know the answer, keep your mouth shut.
E
I hope they took the other person's then.
Never mix tabs and spaces.
That was probably the only good thing in his coding style...
That's why you use automatic grammar-parsing indentation, allowing you to see with a glance the block structure of the code.
Forget magic. Any technology distinguishable from divine power is insufficiently advanced.
From http://email.gcom.com/home/linux/lis/
Of course LiS does protocol translation - that's what STREAMS is, a framework for doing protocol translation.
As to whether LiS is infringing I couldn't say - I've never seen the SVR4 code to STREAMS.
Watch this Heartland Institute video
You're an idiot and I hate people like you.
Yes, but unless a time machine was involved none from FreeBSD 2.2.6.
Watch this Heartland Institute video
So essentially Darl McBride took over a failing company, employed his brother as counsel. Then proceeded to embark on a huge programme of litigation until the company was dead. Thus transferring assets from SCO to his family.
To what extent is this legitimate?
SURELY NOT!!!!!
Interesting. I just figured that it was because i was short for iterator, and if you needed more than one you went with the next letter. Maybe thats part of it as well. I've just always done it since the example code I first looked at when I learned my first language did it that way.
Posted by a Debian GNU/Linux user
It does come across as incredibly desperate, and I'm surprised they even released it. Anyone who's done even a little coding will doubtless look at this and thing variations on the theme of "meh". Maybe it's the kind of thing you can use in court to try and fudge the opinions of judge and jury (although a reasonably competent technical expert would shoot it down in short order), but releasing it to the general public is just going to expose their desperation on a much wider scale (although maybe at this point they feel there's nothing to lose).
The PDFs look an awful lot like they were made using a2ps....
Can you be Even More Awesome?!
typical of the open sores hippies to copy other peoples work
No-one is saying this should just be dismissed because it's Linux. Check out the linked PDF - they are claiming than something is 'copied' that's part of the ELF file format. Most of it is ifdefs and constant declarations, no actual algorithmic code. Calling that copying is like saying one dictionary is copied from another because it contains the same words, whilst ignoring that the definitions are different.
>But we're talking about a structured programming language - with far more structure and rules than the English language
Not to mention a far smaller vocabulary, the complete absense of abstract forms of speech (no metaphors, similes)and in fact of even fundemental sentences.
The vast majority of sentences in a programming language are verb(subject); THAT'S it, a rare few have an "object" (e.g. substr(S1,S2)) but at heart, that's 99% of the lines in a program. Simple commands. There are identifiers, control concepts (loops and conditionals) and structural stuff (classes, functions and the like) but these make up very little of the bulk. The implementation section consists of commands and variables for them to act on.
Thus for the same algorythmic task, barring minor changes in indentation and identifier naming (which will be minor because both are matters on whic standards exist and within organisations some or other standard is usually enforced) the statistical likelihood of two programmers writing and identical solution to the problem is very high. After all, programming is maths and there is only so many ways you can calculate the same equation - which is basically all any algorithm does.
You need a lot more than a few functions with identical structures to prove copyright violation when the scope for individual change is that much more limited. Creativity in programming is VERY rarely coming up with a NEW algorythm for an old task. Nearly always it lies in how we combine algorythms with one another to solve the bigger problems. The bits and pieces of code are like nuts and bolts, every engine has a million of them and they all look pretty much the same.
Unicode killed the ASCII-art *
heh, if it was a joke it was brutally trollish, the old post anonymous is there for a reason
>In other news: fire is hot, and bears shit in the woods.
Stay tuned for the 11-o-clock news however when there won't be any bears left, or woods for them to shit in.
This is news, it only has to be true till the end of the show.
Unicode killed the ASCII-art *
Because i,j,k, were integers by default in fortran, and IIRC a,b,c were floating point. By using the defaults, you didn't have to explicitly declare them. There were lazy coders in the 60-80's, too.
About libelf - 6 years ago Groklaw closed this "issue": http://www.groklaw.net/articlebasic.php?story=20040722135616439 The varable names are the same in both headers, because they correspond to Tool Interface Standard (TIS) 1.1 (Oct 1993). http://webster.cs.ucr.edu/Page_TechDocs/pfmt11.pdf
And using the terms "truth" and "SCO" in one sentence... well, it just feels wrong.
The why did you do it?
.sig withheld by request
No they didn't. ELF originated in AT&T SysV Unix.
I read the part in Groklaw about discovery in SCO v. IBM. They spent a year in discovery to see if there was similar code and once the infringing code was revealed, the response from the judge was "Is that all ya got?" After some pretty detailed analysis and dissection of the code in court, I think the result amounted to 230 lines of code out of several million.
Since they couldn't find examples of literal copying, SCO really wanted to go after methods and concepts as if that was protected by copyright. And they might have done it if they had been more forthcoming. But they were always late, delaying discovery as much as possible out of fear that any code revealed would be code removed from Linux. In a sense, they wanted a permanent tax on Linux without revealing the code so that it couldn't be removed.
Since you write code and you appear to have greater ethics than SCO, you wouldn't do what SCO did in order to recoup your investment in your code. What SCO did was try to reach something far beyond copyright enforcement in any reasonable sense of what the law actually says. And that was without owning the copyrights.
Having said all that, I can say that I am too, opposed to plagiarism in Linux. But I am also fairly confident that plagiarism isn't a problem in Linux since the code is open for anyone to see, and vetted by hundreds if not thousands of other programmers.
The far more compelling case of copyright infringement will come out in the counterclaims that IBM has against SCO. Right now, that giant is sleeping, but when it wakes, it's going to keep Boise Schiller very busy.
The diversity and expression of human opinion is essential to human survival.
Do lambda functions not count as metaphors?
When our name is on the back of your car, we're behind you all the way!
In other news: fire is hot, and bears shit in the woods.
No no! The Pope shits in the woods, and bears are Catholic!
That's simple enough to fix - put an extra pair of parenthesis around your macros definitions.
So use a REAL tab character in your code like $DIETY intended, and set your editor to "show tab character". We have wide screens now - there's NO excuse for using anything except a real tab any more.
That's true, but in the push to get UNIX into the commercial space the SysV interfaces were released as an open specification. This was actually covered during the trial.
The fact of the matter was that the Linux folk didn't copy code, something that would have been obvious to any observer following it's development. The idea that there were vast amounts of stolen code was ludicrous if you knew anything at all about the internal structure of the two operating systems.
There was always the possibility of code that got injected during the large commercial code donations by e.g. IBM or SGI, and in fact the only piece of code that showed actual derivation came from SGI ... But it turned out to be both a very small amount of code and buggy to boot. As soon as people got a look at it they excised it in favor of working, original, code.
I personally expected it to go more the way of the AT&T veresus BSD case, where it turned out that AT&T had stolen tons of code from BSD, not the other way around. The Linux emulation layer in SCO UNIX seemed a particularly likely candidate. Either that turned out not to be the case or IBM simply didn't push the issue (perhaps because SCO was having so much trouble proving anything in their claims) though.
SCO's strategy always seemed to me to be a shakedown, scare companies into license agreements. Why they went after one of the deepsest pockets first is beyond me, IBM was very likely to fight given their investment, but it was clear early on that management was not very competent.
jim frost
jimf@frostbytes.com
It's certainly not copy-paste if the diff is larger than either version.
If ELF is a standard format, it is going to have many "scenes a fair", standard functions, and standard names for calling things. It's as if they declared that using standard English grammar was a violation of their copyrights.
Except that Linus claims never to have seen original Unix code (presumably the copyrighted stuff we are talking about). Tough to copy what you've never seen.
If SCOX really thought it had a case, it would have traced the lines of code back to contributors and diposed them. Or at least a few of them. Or at least Linus.
The fact they didn't is telling.
My favorite example is the RS-232 port, or maybe it should be a USB port now ... how many different ways can you write the explanation of what each pin does, and still write comprehensible English?
... yes, this was the idea behind my comment: trivial functions are not very interesting in this context because of the reason you stated and more importantly because it's difficult to tell infringement from two separate implementations. I couldn't find a non-trivial example so I asked the GP to mention a case so I could look.
The truth is that code was reused (if not copied, exactly, in the same way you don't submit a copied essay which you've taken from a classmate) from a UNIX derivative, which is now (somewhat disputably) owned by SCO.
No, this is not the truth - it is pretty much the exact opposite of "truth".
'Closed' doesn't always mean 'you can never have the source code', it can just mean 'you can't do what you want with the source code'. UNIX is one of these cases.
As is Windows, for that matter.
Breakfast served all day!
The truth is that code was reused (if not copied, exactly, in the same way you don't submit a copied essay which you've taken from a classmate) from a UNIX derivative, which is now (somewhat disputably) owned by SCO.
The truth is that SCO does not own the copyrights to UNIX code, as ruled by a judge, a jury and a second judge in Utah.
Beyond that, SCO already turned over all their evidence to IBM several years ago, where it was analyzed by an expert named Dr. Brian W. Kernighan (if the name doesn't ring a bell, you're not qualifed to be commenting on this topic), and he examined the comparisons and came to the conclusion that no illegal copying had taken place. Note, that's not "no copying", but "no illegal copying". UNIX is based on a number of sources. Most famously, they stole (and I use that word advisedly, since they removed copyright notices, which was illegal) from BSD. They also contributed parts of UNIX to public standards, including the ELF standard which is one of the examples shown here.
The problem is that you seem to think there's a single copyright to UNIX. There isn't. The three biggest stakeholders are Novell (inherited from AT&T), the University of Cal. regents (all the BSD code in UNIX), and Sun, but IBM and SGI also own largish chunks. The people you're accusing of being "lazy and careless" actually own parts of the code you're claiming they illegally copied. Do you know who actually owns the parts in question? I don't, but no evidence of illegal copying has been shown in court!
Releasing this thoroughly debunked information at this late date can only be a desperate attempt to spread FUD. Don't fall for it. I'm sorry that you once had your code plagiarized, but this case is nothing like yours.
You also need to keep in mind that SCO's predecessor (AT&T) was itself caught copying code from Berkely.
There was exactly one case where there was copying shown between SCO and Linux. In that case the code was from Berkely (licensed open source) copied into SCO and copied into Linux by SGI as one of their internal filesystem driver headers. The code was determined to be non infringing due to it's history but deleted because it was old and reimplemented in a better way elsewhere.
Hold it, either the code was copied or it wasn't. Unless the file contained the required BSD license and probably at that point advertisement clause it was infringing. If it was copied, then there is no exclusion for history, possibly a lack of responsibility, but definitely not a lack of infringement.
The truth is that code was reused (if not copied, exactly, in the same way you don't submit a copied essay which you've taken from a classmate) from a UNIX derivative, which is now (somewhat disputably) owned by SCO.
Um, citation needed? Nothing in TFA suggests to me any code reuse.
Don't mistake writing for the same API as "code reuse". You seem to have no clue that APIs are not a subject of copyright protection -- either you're badly underinformed, or you're a troll.
If you write for given API, where variable/parameter/function/field names are either part of the API or are a de-facto standard, there is no helping creating structures that look the same, creating same function declarations that look the same, etc.
Again, let there be no mistake: in my opinion, there is no code "reuse" or "plagiarism" in any of the samples TFA refers to. So most of your rant is a waste of steam. The fact that Linux-is-a-UNIX makes certain things look similar, but that's simply because to be a UNIX, you must implement a bunch of APIs, and by necessity functions and structs will have same signatures, and there will be a bunch of C macros that are same as well, perhaps to the letter. When it comes to C macros, sometimes there is only one way to write them correctly, save for whitespace, and function dictates form, to the letter. This does not imply any reuse of code, merely implementing same thing.
What code of yours was plagiarized, again?
A successful API design takes a mixture of software design and pedagogy.
And the idea that this key book to early '80s PC tech (still worryingly relevant today!) was somehow missing from all the bookshelves reachable by the Compaq BIOS writing department is just silly.
You don't know what you're talking about. I was there at the time: Compaq had administrative staff remove the BIOS listings from all IBM tech ref manuals before they were given to the engineers. (This was especially easy to do because they came in the form of ring binders.)
At one point, since I didn't work on writing BIOS code, I was assigned to be the one designated guy who could disassemble the IBM BIOS for a certain model. When the BIOS developers got stumped by a compatibility problem, they could send me a question, and I was allowed to poke around in the IBM ROM and then give a "Magic 8 Ball" type vague answer.
Here's a bit of trivia: A few PC applications wouldn't work unless the ID string "IBM" appeared at a certain address within the BIOS code. Compaq developers worked out a way to make those bytes at that address appear in part of an actual executable code sequence instead.
All the essence of SCO's claims can be expressed as http://omploader.org/vNHdubw ;)
Wow... sounds like a really efficient code shop...
I guess that explains why the EULA is so long and why no one bothers to read it.
I prefer rogues to imbeciles because they sometimes take a rest.
You've no idea what you're talking about. The variable names in the PDFs posted sometimes are the same, but when they are the variable names are almost always short (usually one-word) and typically are heavily implied by the use (e.g. Elf *elf. What else would you call it?). Any variable seen in an argument list can be presumed to be an API variable an is likely to be 100% identical to other implementation that referred to the same spec.
I want my Cowboyneal
"Given the size of the source code for Linux, it would be astounding if there weren't some similar snippets."
The amount of source code is completely and utterly irrelevant, its naive to say otherwise.
The comparison must only be made in functionally equivalent modules, libraries.
Thanks for the link to the ELF specs. Kevin McBride wrote in the comments linked to in the summary:
SCO has convincing evidence that IBM made ELF an ostensible “industry standard” without SCO’s approval during Project Monterey. IBM needed the rights to ELF standard in order to make its Linux strategy work. IBM claimed ELF was going to be used for the joint Project Monterey code base, but then gave the standard to other third parties to re-write for Linux. This “industry standard” was never meant for the enterprise Linux market.
My thoughts on the SCO fuster cluck at this point:
"If they blew him up, put his head in a blender, and mailed the rest of the pieces to Norway, he'd still return from the grave."
dragonhawk@iname.microsoft.com
I do not like Microsoft. Remove them from my email address.
For some reason I'm imagining a flame carrying a turd between trees.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
Well, the military acronym is FUBAR, which morphed into FooBar in programming because F00 is a hexadecimal number. There are a lot of military acronyms like that; the B-52 is nicknamed the BUF, short for "Big Ugly Fucker". FUBAR is "fucked up beyond all recognition", and usually these acronyms can be cleaned up; "fouled up beyong all recognition" and "Big Ugly Fellow", for instance.
For a better movie mentioning FUBAR, Saving Private Ryan, where FUBAR is mentioned several times and the guy who speaks French and German thinks "Foo Bar" is a German word he can't find in his dictionary, until someone spells it out for him.
Free Martian Whores!
Thank you for the clarification - I'd thought that Gcom shipped an actual STREAMS implementation, not just an API translator.
Still, just makes my point even further - Kevin claiming that Linux infringes SCOX's copyrights because it "included" STREAMS is just batshit insane.
No, bears are blue. It's the sky that's a Catholic.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
It must have been during the "fascist totalitarianism" days of Reaganism when it was completely impossible to get hold of books which weren't in some specific location on some specially designated shelf.
The books were rather obscure and very pricey. They most likely weren't in libraries, and the only way for a typical 20-something developer to get one would be to buy it. I don't know anybody who would plunk down a huge chunk of change to buy their own copy of one of those books, especially when reverse engineering was plenty fun work anyway. It was like solving a puzzle.
At any rate, I have no doubt that IBM had their lawyers pore over every byte of the Compaq BIOS looking for evidence of copying. If there had been any, they would have stomped Compaq off the map.
You seem pretty unappreciative for someone who benefits greatly from reverse engineering efforts. If none of that had happened anywhere, all systems from different vendors would still be totally incompatible and proprietary, and you might still be shelling out the equivalent of $10,000 in 2010 dollars for a crappy midrange personal computer.
You just reminded me of something amusing. Back in the early 1980's I met the guy who was in charge of the Unix business at AT&T. He told me that they had a problem - because they were a regulated utility, they were not allowed to make a profit on Unix. But of course, they also wanted it to pay for itself. But the lower the price they put on it, the more companies bought licenses, so the revenues went up instead of down!
-- not logging in because it's too much hassle for one comment.
which is now (somewhat disputably) owned by SCO.
It was just proved yet again to *not* be owned by SCO at all, despite their claims to the contrary.
Basically, SCO tried to plagiarize then entire Unix operating system. I would hope that your are "completely, absolutely opposed" to that behavior.
You appear to have a typo in your article title. As far as I can tell, it should read "Claimed proof that all McBrides are morons".
Obviously, these douche bags have never heard of an interface. That's what a header file is for. It is very generic, and the implementations can vary significantly. This IS NOT proof. Accept fate, SCO - you are DOA!
But, one thing is pretty sure. Linus Torvalds wrote Linux, and his programming background came directly from Unix. OF COURSE he is going to write the same commands he has used a thousand times in the same way. OF COURSE there are going to be lines that look very much the same, sometimes even identical.
Well, maybe (uh, Minux), but he pwns it now. Your description reminds me of when John Fogerty's record company unsuccessfully sued him after he left and released more albums. They based the suit on how, allegedly, he sounded similar on his subsequent records to how he sounded on the records owned by his previous record company. They were suing him because his new music sounded too much like John Fogerty.
The Admin and the Engineer
The shock! Here are a couple of lines of code that were BLATANTLY copied from Unix into Linux:
Here's one shocking example:
#include
and another:
return(0);
I can't believe the audacity of Linux developers to just shamelessly steal this code from Unix.
"I personally expected it to go more the way of the AT&T veresus BSD case, where it turned out that AT&T had stolen tons of code from BSD..."
Indeed. An interesting question might be; 'Would Xenix, OpenServer, and there ilk even have ever existed if BSD hadn't existed?'
Python: 'And then suddenly you have a language which says "we're all stuck with whatever the whiniest coder wants".'
The books were rather obscure and very pricey.
Obscure in what sense? Everyone knew about them, and anyone who wanted to do any serious low-level work with the IBM PC would have an original copy or get ready for this a photocopy of relevant parts. You (or, more accurately, the person you're playing on the Internet) had access, and you know it.
especially when reverse engineering was plenty fun work anyway. It was like solving a puzzle.
Oh, well, of course, businesses routinely tell their employees to make their work harder and more error-prone because it's "plenty fun" and "like solving a puzzle".
Look. You read the original code. You admit to reading the original code. You observed techniques in the original code. You observed quirks in the original code. You then admit that (behind closed doors) you liaised with people who wrote a derived version of that code. It is completely dishonest to claim other than you produced a derived work of the IBM BIOS.
At any rate, I have no doubt that IBM had their lawyers pore over every byte of the Compaq BIOS looking for evidence of copying. If there had been any, they would have stomped Compaq off the map.
It's quite easy to produce something which looks byte-for-byte quite different while essentially being a copy of original code - but you have to look at the original to do this. If you don't look at original code, you are going to quite incidentally and accidentally produce very similar routines (see the Linux vs SCO fiasco) by the nature of coding.
Anyway, lawyers are not programmers and IBM may not have wanted to stop Compaq. Your persona is just a lowly engineer and has no special insight into the ties between the firms.
If none of that had happened anywhere, all systems from different vendors would still be totally incompatible and proprietary
The dominance of the IBM PC architecture is probably one of the worst things to happen to computing and there were so many better architectures (some of them quite open) which could have won over. Thanks for nothing.
It's kind of like asking some bridge engineers, "How many different bridges can be built from Point A to Point B, for a reasonable amount of money, meeting all laws in the jurisdiction, and satisfying a fixed set of performance requirements?" and being surprised when you get a number of superficially similar structures.
Of course, in law (in any jurisdiction), things aren't as straightforward. That's what happens when things like physics and narrow constraints don't define the desired outcome (winning the case for your client).
Sure I'm paranoid, but am I paranoid enough?
And using the terms "truth" and "SCO" in one sentence... well, it just feels wrong.
Not so. Consider the following counterexample:
"Do not expect any truth from SCO"
Actually, there is an exclusion for history due to the fact that the BSD code is licensed to be Open Source for all, for free. Therefore that code is allowed to be copied due to it's history of being free for use.
http://en.wikibooks.org/wiki/Fortran/Fortran_variables
Because variables beginning with i..n are in teger variables in FORTRAN.
the preceding comment is my own and in no way reflects the opinion of the Joint Chiefs of Staff
God is real, unless you declare it to be an integer.
I think his a lawyer.
(same AC)
Prove it.
Actually, I've been programming for just over twenty years.
Prove it.
"I don't care about the Constitution!" --Bill O'Reilly, November 17, 2009
"OO" stands for "Up"? Close, but no cigar.
FUBAR is the acronym you're looking for.
The origins of FOO are murky at best, but may also have been related to the military.
It's reasonable to assume that FOOBAR is a corruption / combination of the two.
Ostriches aren't Australian, they're African. Omelettes can be made from emu eggs and I have tasted one. It really wasn't any different to one prepared from hen's eggs. It looked no different to this observer. Compare an emu egg to a hen's egg and they are quite different in size, colour and even texture internally and externally. The formula (recipe) however was just for a standard omelette that we would all recognise by sight instantly....
Egg analogies make me hungry.
...und keine Eier.
"I don't care about the Constitution!" --Bill O'Reilly, November 17, 2009
Back in the day, my University had the source code for VAX/VMS 4.2 or so on microfiche. Endless lines of Macro-32 and BLISS. We had some of the the AT&T Unix materials as well. It wasn't that difficult to arrange, if you were a higher ed institution or a customer of a certain size.
You know - for SCO over the course of this case it was the best of times, it was the worst of times but for the life of me, I can't see your point.
I personally use something like "cc" or "index" for a counting variable (depending on the language). I hate it when programmers use single letters because they're hard to search for.
Slashdot: Where people pretend to be twice as smart as they really are by behaving like children.
Secondly, a lot of code in Linux is created to follow POSIX standards. There is code in SCO Unix and Linux which looks very similar, but the source for the material is the IEEE Posix standard, not SCO Unix source code.
Actually it is even simpler than that. The code in the PDF I saw for for ELF. .h files where. You could tell exactly what each variable in the type def did. It also looked like a lot of my own code when I am having a good day. .h files! they are not functional code blocks just definitions. Of course the definitions for the typedefs of a well documented file format will look a lot alike!
They where all typedefs. Elf is a well documented format and not of the code that shows copying was actual functional code.
As I was reading the code I was thinking just how trivial the example was but also how well written both
Also these are
It is a huge duh but an attorney that knows nothing about programing might not understand that.
If this was an example of the infringement I would say the court did a great job when they tossed it out.
See my blog http://ilovecookes.blogspot.com/ for light hearted technical information.
Look. You read the original code. You admit to reading the original code.
I said *disassembled*, with a debugger. That's not reading the source code in the books, which I had no access to.
Look, you're either a troll or know nothing about this topic. Go play with your "other architectures".
Ah, that's why COBOL programming examples also use i as counting variable?
Yes and for some reason most programing teachers of a certain age seemed to be old Fortran coders.
My first programing language was Pascal and I took it in 82/83. My teacher was gung ho about structured programing and using long descriptive variable names.
However he learned Fortran back in college so every for loop he showed was used i as the index.
I now write in Java, C++, PHP, Perl, and Objective C... and my loops use i for the index variable even though I know that is bad form.
Habits are hard to break.
See my blog http://ilovecookes.blogspot.com/ for light hearted technical information.
I've got news for ya... DNF contains SCO code.
the preceding comment is my own and in no way reflects the opinion of the Joint Chiefs of Staff
(same AC)
Again, prove it, Spartacus.
Again, 20 years programming experience, no experience with some, apparently very important for *NIX, POSIX IEE document.
Clearly. I have 0 years professional programming experience and even I can see how full of shit you are.
If this is a published standard, obviously they'll be similar. I just didn't understand why every function definition from line 138 to 176 is copied verbatim. With the same cryptic series of letters which obviously imply meaning (strptr, newscn, getshdr, getphdr, newehdr, elf_flagelf, elf32_faize) are VERBATIM.
Ok genius, you tell me how to right a header file containing a structure named struct_type and declaring a function to deal with said structures that will allow source like the following:
struct_type foo; char blah="fred"; foo.sillynamedfield3 = 7; strcpy(foo.nameofthestruct,blah); functionxx(foo);
to still compile unaltered, if my field names and function name must be changed? If sillynamedfield3 can't be named sillynamedfield3 anymore, and functionxx can't be functionxx, then *every* *single* *program* compiled against this library will break until rewritten for these changes. The very stuff that must be verbatim for implementing the same API to work is the stuff you are criticizing for being verbatim. Furthermore, if you actually read the lines in both documents instead of just looking to see that they're red, you'd know none of the lines you claim are "copied verbatim" actually are. The Linux file adds extern and also declares the name of the arguments, as well as the goofy markup of "_(("/"))" being instead the normal "("&")". In other words, everything that could possibly be different while making the code still work properly is different.
"I don't care about the Constitution!" --Bill O'Reilly, November 17, 2009
These code samples are ridiculous, obviously. Pointing to the protective #ifdef at the top of a header file? This had to be generated by a diff tool. At that level of granularity any two coders are going to write some matching code when doing similar things, especially when there are standards and protocols they're both following.
But more than that, this demonstrates nicely why I've said before, and will say again, that I don't believe copyright is a good fit for computer code.
1) The information is very functional (as opposed to expressive) in nature. I question whether programs should be considered "works of authorship" within the meaning of U.S.C. Title 17, Chapter 1, Sec 102; it certainly doesn't seem to fit in. (Yes, I'm aware that the law specifically mentions computer programs in its current form; I'm questioning not whether it does, but whether it should.)
2) Arguably entire lines of code are really like words or even just characters in actual English (or other natural-language) works.
Taken together, this seems no different than if, say, GPS manufacturers were to claim copyright infringement over phrases like "in 2 miles", "turn left", "keep right", etc.
To the extent that the resulting program is expressive, you might argue differently... typically we might be talking about games with a cinematic element. Characters and distinct images may be trademarked, the game mechanics are AFAIK nigh on impossible to protect, and if anything the story behind the game could be under copyright.
It's almost like suing an author for starting with "Once upon a time".
Ah ha! You used the phrase "Once upon a time" in a /. post! Expect to hear from my lawyer promptly, copyright thief!
"I don't care about the Constitution!" --Bill O'Reilly, November 17, 2009
Comment removed based on user account deletion
Because I, J, K, L, M, or variable names beginnning with them, are integers in Fortran
I am afraid the tradition is much older than that. "i", "j", and "k" are standard subscript variables in math and physics, almost as common as "x", "y", and "z".
"some of the differences I'm seeing in these files are from SCO not implementing POSIX properly"
You really think SCO wrote any of that code?
"(The story sometimes is described as: group A saw the code, wrote up a description of the code, then showed only the description to group B. This is at least approaching honest.)"
That's more than just a story and this is lore only to people who hadn't lived it. It was not hard to find programmers who hadn't seen the tech ref manual. What WAS hard was getting decent code out of them. It wasn't just Compaq that clean-roomed a BIOS.
But of course - a lawyer wouldn't understand that, it's just a question of money.
Well, clearly enough lawyers understood enough of it for SCO to get judgments against it.
"I don't care about the Constitution!" --Bill O'Reilly, November 17, 2009
Header files are public - but they seldom contains any advanced functionality. They are just a definition of the calls available, defined data types and constants.
But of course - a lawyer wouldn't understand that, it's just a question of money.
Any lawyer versed in the relevant law would understand that. A lawyer may be able to pretend they don't understand for the sake of their client; I'm not sure but wouldn't that run afoul of rules regarding legal practice? It's certainly possible Kevin really doesn't understand, and even avoided learning so he could in all sincerity advise his client with the bad advice they wanted.
In any case, the judge understood, which is why back when they submitted this evidence, the judge correctly ruled that necessary API definitions didn't by themselves constitute copyright violation. Besides, what with them being necessary APIs, there's no way to say they were copied from UNIX versus any other implementation which would also have the same headers.
This is a sad, pathetic attempt to claim that there really was something to the UNIX-code-in-Linux accusation. Especially sad because as they admit this evidence was already submitted, examined, and rejected as valid evidence of what they claim.
The enemies of Democracy are
Get a better programming environment. In VS.Net, you can right click, "Find all References". Which will give you a nice list of every use of a specific variable, or function. There should be not need to do a search for variable names, especially ones with such a small scope such as loop counters.
Anthropic principle: We see the universe the way it is because if it were different we would not be here to see it.
Just don't forget to pay your SCO licensing fees you cock-smoking teabaggers!
Okay. Now I'm really confused. What does Sarah Palin have to do with SCO???
One is a copyright troll, the other is a talking-point troll.
"I don't care about the Constitution!" --Bill O'Reilly, November 17, 2009
"the people at exbiblio found that there is very little repetition of text in literature"
And in that particular GP is almost certainly wrong, but in spirit what GP is saying is still valid.
There are more constraints making one piece of code look like another, than there are making one piece of literature look like another. (Maybe I'm trying to say there are more things that can vary more freely in literature; I'm kind of struggling for the right word or phrase.)
1) A coder might be trying to conform to patterns, style guidelines, standards, protocols, and (obviously) the basic syntax of the language. Some forms of literature have conventions they follow, but generally an author is motivated to be creative and original in respects that would render software useless.
2) Literature is written in natural languages with massive vocabularies and complex gramaatical structures with countless variations. Computer programs are written in made-up languages most of which consider it a virtue to be compact in their vocabulary and structural rules. (Insert your favorite joke about how huge modern programming languages are getting here, but then reflect on the size of those language compared to English.)
Foobar is a WW2 acronym for F*%&'d up beyond all recognition.
Bull crap.
BSD actually got it from the standard, as did Linux. The ELF standard actually had header
Of course, where all this falling apart is the ELF standard was specifically released as an open standard. 'The TIS Committee grants you a non-exclusive, worldwide, royalty-free license to use the information disclosed in this Specification to make your software TIS-compliant; no other license, express or implied, is granted or intended hereby.'
And it was, obviously, owned by the TIS committee, not the SysV copyright holders, although they were part of that committee. And this standard had all the headers and a good portion of the actual code that SCO claims was 'copied' in it.
IBM actually submitted a brief with the court quoting email where Linux developers were asked to implement ELF, by the current SysV copyright owners, as part of their general 'standardize Unix' push.
If corporations are people, aren't stockholders guilty of slavery?
Actually, it's more like claiming copying by pointing out the second page of a book has the exact same placement of the title, an 'if you purchased this book without a cover' warning, an identical disclaimer about the work being a work of fiction, a (slightly modified) copyright line, an 'All right reserved' line, publisher information, the ISBN. In almost exactly the same order, at that!
Um, yeah.
If corporations are people, aren't stockholders guilty of slavery?
That's more than just a story and this is lore only to people who hadn't lived it.
Which is why I said it's "at least approaching honest". I can read the Bible and give you a blow-by-blow account; a story you create based on the account will still be a derived work, no matter how much you lie about how irrelevant and vague my account was.
It was not hard to find programmers who hadn't seen the tech ref manual.
How did you find them? "Right, you seem good for this job... but before we hire you and pay you a very good wage, tell me, have you read this book? Try not to let the fact that a 'yes' will deny you the job influence the answer."
(The weird thing is that both reading the book and disassembling the binary imply creating a derived work. Back to the Bible example, "I only read the published Harry Potter book, not Rowling's drafts," isn't a rational defence to the accusation that you created a derived work.)
I was already laughing after reading this 3 word introduction "SCO's ex-CEO's brother, ..."
Because in Fortran IV variable names beginning with i-n (I think) were by default integer values, the rest were by default float. And it wasn't originally standard to declare all of your variables. That came in with Algol.
I think we've pushed this "anyone can grow up to be president" thing too far.
You're not a programmer, are you?
Reading the man pages for (random example) memcpy tells you how to define it. It also describes what it does. Tell me how you'd re-implement this function without your header definition being identical to SCO's (and yes, the definition is included verbatim right there):
NAME
memcpy - copy memory area
SYNOPSIS
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);
DESCRIPTION
The memcpy() function copies n bytes from memory area src to memory area
dest. The memory areas should not overlap. Use memmove(3) if the memory
areas do overlap.
- Michael T. Babcock (Yes, I blog)
Is it because "i" stands for "integer" and the others follow on from that?
Michael Reed, freelance tech writer.
That's the kind of analogy that Hitler would have made.
"My strength is as the strength of ten men, for I am wired to the eyeballs on espresso."
YES!!
*BOTH* Santa Cruz Operations and Caldera had decent coders, and much of what Caldera coded did end up in Linux. It was licensed under the GPL. (I'm not sure about Santa Cruz Operations. It's code would have been Unix, and possibly BSD licensed, though I'm not sure. But they wrote very good code.)
It's only in the last seven years that SCOx has become a destructive parasite. (Mind you, Caldera was failing because, though they had a business mind set, they didn't understand the FOSS community...to the point where they tried to sell their version of Linux with a per-seat license.)
I think we've pushed this "anyone can grow up to be president" thing too far.
although he did use minix in the early days, he actually did most of his coding based on Design of the Unix Operating System by Maurice Bach.
FUBAR is a WW2 acronym. Foobar is an adaptation.
Did SCO really set out to make themselves look like idiots or did they actually define the strings.h headers and invent the test for null pointers. I would be more surprised if two implementations of the same spec had different return values and function names since at least one would almost certainly not be implementing the spec
Holy shit.
So you're saying that only source code is forbidden, but compiled code is free game?
IBM's work was stolen.
Plain and simple.
You seem pretty unappreciative for someone who benefits greatly from reverse engineering efforts. If none of that had happened anywhere, all systems from different vendors would still be totally incompatible and proprietary, and you might still be shelling out the equivalent of $10,000 in 2010 dollars for a crappy midrange personal computer.
... or a "Macintosh," as I like to call them.
I prefer aa, bb, cc, and xx, yy, zz. Easy to search for, and more easily to distinguish visually than i,j,k,l at high resolutions.
I didn't say it was impossible to check at all, but it's not possible from a PDF.
You might as well create a PDF that only says " I'm right , you are wrong " , it would basically be the same thing , if you couldn't check it anywhere else .
If you would be able to check the repository ( with all changes and timestamps ) of UNIX , and compared it to the repository of Linux , then , by checking the timestamps , it might be possible to verify who copied what.
(if version management existed at that time )
And offcourse, that's assuming no one altered the repository to make it look like they were the first to implement it.
Slipping shoelaces ?
For gods' sake--never use tabs ever!
Copying code is not automatically and universally infringing. When the history of the code in question indicates that the code was placed in the public domain, there most certainly is a reason the history of the code is important in determining whether or not there was infringement.
And the particular code that SGI placed in the kernel, that the post you are responding to was talking about, was apparently placed in the public domain:
"Notably, it appears that most or all of the System V code fragments we found had previously been placed in the public domain, meaning it is very doubtful that the SCO Group has any proprietary claim to these code fragments in any case." - http://oss.sgi.com/letter_100103.txt
So use a REAL tab character in your code like $DIETY intended, and set your editor to "show tab character". We have wide screens now - there's NO excuse for using anything except a real tab any more.
Actually, there are several huge reasons for not using real tab.
1) Tab means different things to different people. Even when you spell it out, people interpret it differently. In the original sense (i.e. old Underwood typewriters, and the like), tab meant to release the carriage and let it move thanks to the spring, until it was stopped by a tab stop. This means that if you set your tab stop at position 5, and 60, and you pressed tab when positioned anywhere from position 1 to 4, it skipped to 5. Pressing tab when positioned at 5 through 59 (in this example) skipped you to position 60. So, in it's original sense, tab relied on tab stops (literally tiny "tabs" on the top of the typewriter). However, there are few standard document formats (especially for source code) that define the tab stops. You don't see a line in an ASCII or Unicode source code file that says "the tabs for this document are at position 5 and 60". There's no common convention for this.
So people invented arbitrary tab stop conventions. Like "tab stops are every 4 characters" or "tab stops are every 8 characters". But a small difference like this can change the meaning of your document! If you line up code and comments with "real tab characters" every 4 characters, and then someone opens your document with tab stops every eight characters, then the issue is NOT just that things are moved right. The issue is that things do not line up! If I create a nice comment section with a table explaining something, and use tab characters counting on a tab stop every 4 characters, and you open it with tab stops every 8 characters, the MEANING of the comments may change.
Example:
/* Here is a table of all the fields and whether they are changed by this function:
[tab][tab]Passed to function[tab]Returned from function[tab]Changed by function
[tab][tab]------------------[tab]----------------------[tab]-------------------
A[tab][tab][space][space][space]Yes[tab][tab][tab][space][space][space]Yes
longer[tab][tab][space][space][space]Yes
*/
These comments will mean different things depending on the tab stop assumptions!
2) The designers of some editors mis-understood how tab-stops worked, and instead, some made tabs equivalent to a fixed number of spaces. For instance, for some editors a tab is instantly interpreted as 4 spaces. But in the original definition of tabs, it was a "variable" amount of spacing, which took you to a predictable column. These are two vastly different concepts.
3) Those who are smart enough to realize that there is confusion are really annoyed by those who are clueless and inserting real tab characters without knowing that there's an issue.
The code was first copied, correctly.
The copyright notices in the comments, etc were then replaced with AT&T ones, replacing the Berkeley ones (also replacing the earlier AT&T ones, btw.) I can vouch for this personally, having worked on the "vi" source code both at Purdue (original BSD 4.3 code) and at AT&T (System Vr4 code) -- all of the BSD copyrights, as well as the (bad) poetry, had been removed from the comments in the vi sources.
The Folks from the UCB law school took advantage of this in the counter suit, since the AT&T folks, having changed the copyright notices in the troff sources, ended up doing this this then in the printed manuals. So while AT&T was suing about vague things like including code derived from code derived from code they wrote; UC Berkeley countersued about printed, published, paper manuals, where AT&T was clearly publishing them without the UCB copyright and license info. Clear, obvious, game-set-match, paper copyright violations.
So rather than have to find and "Destroy all Copies" of SystemVr4 manuals (including those published in turn by licencees like HP, IBM, etc.) AT&T agreed to drop their initial suit and make the countersuit go away.
- "History shows again and again how nature points out the folly of men" -- Blue Oyster Cult, 'Godzilla'
Usually, the system is using the same structure when it builds the packet. That's why it matches the actual packet. In a technical sense you could put the structure members in whatever order you wanted, but then you'd need to go write code that put them into the order that's in the actual packet ... and that code would be all overhead. It's much simpler to just have the structure match the packet and build it in the right order to begin with.
You can call it creating a "derived work" if you want if it makes you feel better. It doesn't matter that you call it: It was perfectly legal and Compaq had every right to do it. Compaq never made any secret about what it was doing or the steps it took when to do it. This is a well-established legal area.
Reverse engineering is completely legal if done properly. Deal with it.
It doesn't really matter. Headers almost certainly cannot be copyrighted anyway. A header file is really no different than a phone book. It is a purely factual description of an interface. Phone books were held to not be copyrightable in Feist Publications v. Rural Telephone Service. In that case, the court ruled that although creative aspects of a collection of facts can be copyrighted (which facts to include, the order and style of the information, etc.), the facts themselves are facts and cannot be copyrighted.
An interface definition is a fact. There is only one interface definition that correctly describes a given interface. Change even one letter (not including comments) and code written against that interface will not compile without modification (unless you're doing something funky with C preprocessor macros, but even then, what the compiler eventually sees must be identical). Therefore a header is nothing more than a collection of facts. So long as the organization of the header is substantively different from the organization of the original header and the new header does not contain any non-paraphrased comments from the original, it is unlikely that copyright violation has occurred.
And Sega v. Accolade seems to support that assessment, along with several other reverse engineering cases.
Check out my sci-fi/humor trilogy at PatriotsBooks.
Scoxq.pk was trading for about $0.03 a share last week, and not it's trading for about $0.09 a share.
http://finance.yahoo.com/echarts?s=SCOXQ.PK+Interactive#chart1:symbol=scoxq.pk;range=5d;indicator=volume;charttype=line;crosshair=on;ohlcvalues=0;logscale=on;source=undefined
That's like the car Hitler's analogy would have driven.
-
- - You can't take something off the Internet! That's like trying to take pee out of a swimming pool.
First a judge declared that scox does not own the code. So scox insisted on jury trial. After a few years, scox got their second bite at the apple, but the jury also ruled against scox. Now scox is appealing the jury's decision.
Indeed. Let's review some of it.
Much of the "linux" code seems to cover libelf, a library written for the explicit purpose of API level compatibility with SVR4. It covers both Michael Riepe's implementation of the library, as well as RedHat's implementation. The shared API means that functions with identical names and signatures, as well as quite a few API defined constant values. The names for structure feilds larely derives from the elf specification, so similarities there should also be expected.
tab 422: A function that returns a member of a structure passed in by reference, where the name of the necessary structure element is apparently not part of the API. It returns -1 if passed a null pointer. The linux version has a function with the same name and same signature, but that is no surprise. It checks for a null pointer using a different idiom than SVR4.2, and the name of the returned structure member is different. The "linux" code also has an assertion call, as well as explicitly casts the member to the correct datatype. In other words, the "linux" code is as different from the SVR 4.2 code as C code permits! (As long as you only consider C code with remotely reasonable coding standards).
Tab421 is covering a function to get the next item in what is effectively a linked list. It is actually surprising to me how different the code is, despite performing such a simple function. The only lines that are the same are those returning constants defined in the header as part of the API.
Tab 420 covers a three line function, returning a header defined constant if passed a null pointer, or an element of the passed structure. The only unusual similarity is that the argument uses the same name, but the function name strongly suggests using that name as the argument name. The structure field name is similar, but not identical, and is based on the name in the ELF specification.
Tab419 covers a different implementation of the same function, this time by redhat's libelf.
Tab418 shows annother "copied" 3 liner, where the "linux" implementation is a one-liner utilizing the ternary operator. This is one time where some copying may have occured, namely it looks like the function may have been copied, sans the body, and somebody else implemented the body. The reason I suspect this, is because the redhat implementation is using old K&R style argument definitions, like the SVR4 code, despite most of the redhat code using ANSI style argument definitions. Nevertheless, even if that had been copied, it is 4 lines of code, of which two are only curly braces.
This just keeps going on and on. Basically he was checking for any similarly named files that contained any code that looked similar, and alleging that said similarity indicates copyright infringement. He has no understanding of API's and how those naturally create similarity, and how such similarity has already been determined in past cases not to be considered copyright infringement.
Stylish sheet to fix many problems in Slashdot's D3: https://gist.github.com/801524
Assuming you can believe what you read on-line I just learned something, thanks (and shows I don't know FORTRAN nearly as well as I likely should).
Anyway, I always assumed (i)cnremental and j/k neatly followed in the alphabet.
whois gawk date unzip strip find touch finger mount join nice man top fsck grep eject more yes exit umount sleep dump
Hi Godwin :)
Now tell me why we use i,j,k... so often.
I use i for iteration, and the letters after that in alphabet are one logical way to do nested iteration loops.
Except I hardly ever use single letters (sometimes x and y but that's about it), because it's a pain to grep for, and to search-replace. For non-nested loop I usually use ii, and for nested loops it's usually i1, i2, i3...
Ask anyone who was forced to maintain and support those systems even before this SCO vs Novel and SCO vs IBM started.
But what else you could expect from a product (Xenix) created by Microsoft and its later mongoose cousing SCO UNIX.
Anyway, I always assumed (i)cnremental and j/k neatly followed in the alphabet.
That's probably far more common reason than some archaic Fortran convention. Also it could just mean "integer loop variable" without any relation to Fortran, or whatever an individual programmer was thinking when using it. It's just a co-incidence that "integer", "incrementing" and "iteration" start with same letter, and it's not very unlikely co-incidence that many people used it and applied same alphabetical logic to related variables.
"TIS Committee members include representatives from Absoft, Autodesk, Borland International
Corporation, IBM Corporation, Intel Corporation, Lahey, Lotus Corporation, MetaWare
Corporation, Microtec Research, Microsoft Corporation, Novell Corporation, The Santa Cruz
Operation, and WATCOM International Corporation. PharLap Software Incorporated and
Symantec Corporation also participated in the specification definition efforts."
Note that 'The Santa Cruz Operation' in that is the original SCO, not the renamed-Caldera SCO. Note that the original committee released the first spec in 1993. Note that the spec explicitly states:
'The TIS Committee grants you a non-exclusive, worldwide, royalty-free license to use the information disclosed in this Specification
to make your software TIS-compliant; no other license, express or implied, is granted or intended hereby.'
In other words, McBride is full of crap, the spec was released with the intent of anyone being able to use it. To come back later and say 'It was never meant for enterprise Linux' is ridiculous, it was meant for anyone who wanted to comply with the standard.
For the same reason that we use m and n for matrix row and column indices; x, y, and z for coordinates; p and q for predicates; etc. Formal computer science education traditionally entails a fair bit of mathematics, and mathematicians have been using particular symbols for particular roles for eons. Intent is best communicated when people don't have to pay quite so much attention to the meaning of each and every symbol, and it turns out that these sorts of conventions work equally well for computer scientists as they do for mathematicians.
The question isn't whether they wrote any code, or whether they wrote good code; the question is whether they wrote that code.
I'm questioning the belief that they did, because they claim the infringement is from code they bought rights to (except according to the courts they didn't).
He didn't use foo, bar, baz, qux, quux, quuux, quuuux? I rarely use more than $foo, but old-school hacker types often used those. Those were explicitly taught to me in CS 101, too -- but, luckily, I never made a habit of using them. I prefer annoyinglyLongAndExtremelyVerboseVarialbeNamesEndingWithDataTypeSuchAsString.
You can call it creating a "derived work" if you want
So why does it matter whether you have read the IBM TRM or not? Derive from IBM source / derive from IBM object.
It doesn't matter that you call it: It was perfectly legal
The term you are not looking for is "irrelevant", not "legal".
Sony v. Connectix in 1999 finally confirmed that the whole "copying is determined by whether the code has been viewed" is bullshit. Connectix openly admitted to looking at object code directly and freely in order to produce an emulator. Sony failed because Sony could not prove that the protected creative aspect of Sony's work had been copied by Connectix.
IBM's mock lawsuit against Compaq (I say "mock" because it expended pretty much no resources by IBM standards, and probably existed only to placate certain investors) failed because Compaq did a good job of creating a BIOS which looked nothing like IBM's BIOS, even while behaving like IBM's BIOS and created by looking at IBM's BIOS.
Compaq never made any secret about what it was doing or the steps it took when to do it. This is a well-established legal area.
The lie here is in claiming not to have read the TRMs, and the misdirection is in giving the impression that whether it's legal depends on whether the TRMs were read. The lie to the technically inexperienced court is in claiming that you didn't essentially copy the IBM BIOS in all but machine code byte order.
Reverse engineering is completely legal if done properly. Deal with it.
Everything non-criminal is completely legal if done sufficiently sneakily and with no private party sufficiently interested in stopping you. What kind of a stupid argument is this?
God is real, unless explicitly declared as integer.
I've seen cases where me and another person are working on code independently, and when it came time to merge, we had both ended up creating the same variable names, and pretty much the same code.
I took a lot of college classes with my best friend, Aaron. We worked on a lot of projects together and evolved a similar coding style. On one particular assignment, we had to simulate a number of telephones connecting to a switchboard with a number of incoming lines answered by a given number of operators. If you've done a CompSci degree, you've probably done the same project somewhere along the way. We worked independently, although we bounced ideas off each other (which was explicitly allowed as long as we didn't actually share code): "I was thinking about doing $X. How about you?" "Well, that would work, but I think $Y is a better fit." "Oh, good point!"
When it came time to turn in our assignments, we submitted identical code. Same variable names. Same algorithms. Same formatting. Same comments. And we had never looked at each other's work, not even at a glance.
Fortunately, our teacher knew us well enough to believe our explanation, and we were both able to independently explain exactly how our identical implementations worked and why we made the design decisions that we did.
I imagine that a lot of kernel and OS programming is just like that. Given two programmers who've been working on the same common codebases and used to the same formatting, bracket placement, variable naming standards, etc., it's very easy to imagine them producing line-for-line identical implementations without even knowing that each other's work existed.
Dewey, what part of this looks like authorities should be involved?
Some closed-source code is "available" even if it's not (legally) usable in mainstream open source projects. Wasn't that the case with the early Unix variants? Then there's MS's Shared Source, and the Win2k code leak a few years ago.
Not that I'm agreeing with GP ;-)
"You can either cut their heads off, or burn 'em. They go up pretty easy..." -- _The Original Night of the Living Dead_
- "History shows again and again how nature points out the folly of men" -- Blue Oyster Cult, 'Godzilla'
I C
"The idea that this is proof that Linux violated any Unix copyrights is totally absurd."
Since we're dealing with SCO here, I think instead of "totally absurd" you meant to say "patently ridiculous".
FTFY!
Just don't forget to pay your SCO licensing fees you cock-smoking teabaggers!
Okay. Now I'm really confused. What does Sarah Palin have to do with SCO???
Teabagging is a colloquial term for a gay male sex act and has been for a long time.
I don't know the details, but one can safely assume it involves a scrotum. If you care to know more google it.
Work bio at MMWD
http://www.groklaw.net/article.php?story=20100627122353935
http://www.groklaw.net/pdf/iowa/www.iowaconsumercase.org/011607/8000/PX08593.pdf
But now, thanks to a volunteer working on doing the exhibits in the Comes v. Microsoft antitrust litigation as text, we find an email thread in Exhibit 8953 [PDF] where Microsoft employees, including the managing director of Microsoft in India at the time, mention SCO in a discussion about heading off the Linux threat in India. The emails are dated September 11, 2002. Given the date, I believe this opens up the question of Microsoft's involvement once again.
Even Dr. Sbaitso could give better responses than Sarah Palin.
As for the story, didn't some court already rule that UNIX belongs to Novell? So even if Linux were a verbatim rip off of UNIX code, what business would it be of SCO's? What are they, like the "Cherub of Justice" for Novell or something?
This is why the statement:
is my friend. :-)
I still write new Fortran 77 code on occasion, and I tend to use things like LOOOP or LOOP1, LOOP2, etc. for loop counters. Or something like COUNT. Or PAGE. Or something else meaningful.
I, J, K, etc., are good for use in DEFINE statements and such, tho. :-)
Mainframe/UNIX Bit Twiddler and long time Windows/Linux Hobbyist.
The Theorem Theorem: If If, Then Then.
"God is real - unless declared integer" - following the FORTRAN naming rule.
You do know that v 0.01 of Linux was about 10,000 lines right?
That should be about a three to six month project for a CS major.
Work bio at MMWD
Foo predates WWII by a few years, but the military certainly took it and ran. The British radar operators referred to false returns as "Foo Fighters." While i knew that, i did not know that the night fighter squadrons would refer to UFO's as foo fighters as well. (UFO in it's specific definition, not implying flying saucers.) FooBAR then is a backronym for F'd Beyond All Recognition.
Thus sayeth the wikipedia.
If brevity is the soul of wit, then how does one explain Twitter?
In grad school, I took a class from a professor who couldn't keep his is and js straight, it was pretty much a disaster in class. We listened to his explanations but wouldn't use any formulae unless we looked them up in a book first.
..far too late to be doing this...
Just don't forget to pay your SCO licensing fees you cock-smoking teabaggers!
Okay. Now I'm really confused. What does Sarah Palin have to do with SCO???
The approximate IQ of the management.
Levi Johnston dated Darl's daughter?
But LiS doesn't contain STREAMS code - STREAMS code wouldn't work directly under linux.
I now write in Java, C++, PHP, Perl, and Objective C... and my loops use i for the index variable even though I know that is bad form.
No it isn't. Everybody (by which I mean all programmers) knows that i is the standard loop iterator. It would be more confusing not to use i.
All I want is a secure system where it's easy to do anything I want. Is that too much to ask ~~ Randall Munroe
That's what IMPLICIT NONE is for.
Of course not - what do you think "one true tab" means?
Using spaces for indents is a mess - especially when you go to cut-n-paste code.
Of course it's insane. We've had 7 years of insanity - why should it suddenly stop now?
The latest speculation is that insiders suspect SCO will be in Chapter 7, and it's time to start making with the "plausible deniability" game because the creditors will be getting a closer look at SCO's internals.
There are many that do not agree with you. If for no other reason that it is hard to search for a single char and not get a bunch of bad useless hits.
But then again I still use it way too often.
See my blog http://ilovecookes.blogspot.com/ for light hearted technical information.
and his brain is in a jar ?!?
When I took typing class (back in the days of manual Underwoods with typewriter ribbons, etc) we were taught that proper tabstops were fixed every 8 spaces, margins were at 8 and 72, you started an inch from the top, and ended an inch from the bottom. Anything else got you a "do it over again."
Later on, electric typewriters like the IBM Selectric let you set and clear individual tab stops, but mostly nobody bothered except for tables. Still later, text and code editors that were WordStar-compatible maintained the "tab-stop every 8 columns" rule. It's only when people started drag-n-dropping their code that tabs got all weird. Why? Because people wanted to treat code editors like Word.
A real tab character is not n spaces, where n=enough spaces to get to the next tabstop. If people are implementing a "soft tab" as the equivalent of a keyboard macro that spaces n spaces, regardless of distance, they don't know what they're doing. It's not a tab.
A tab is a specific character in the ASCII set = #9. An ASCII 9 followed by an ASCII 8 should by definition put you in the same column you started from. That only works for real tabs, not "set tab=n spaces".
Using leading tabs also makes it easier to write tools to parse code - and code that writes code is the happiest code in the world :-)
Braces where needed, but not necessarily braces, and tabs because a tab is a tab is a tab. The code is visually much cleaner, and takes up less vertical space.
I,J,K also work pretty good as array indexes because they are the unit vectors for X,Y,Z. So physicists were mostly ok with leaving them as is.
I through N were chosen for integer variables in FORTRAN precisely because they are the first letters of integer, which made them easy to remember. Also, FORTRAN source back in the day was on 80-column punched cards, so short variable names were a necessity. It wasn't like COBOL with MINIMUMCUSTOMERBALANCE. In FORTRAN that would be MCB or some such. That said, there were no professional programmers when FORTRAN appeared. Many people writing it had a math background, so i/j matrix notation was common knowledge.
Intron: the portion of DNA which expresses nothing useful.
LiS is (or was, when the project was still alive) a full STREAMS implementation, including STREAMS head, pushable modules and multiplexers, and STREAMS drivers. So the GP is wrong. Being one of the major contributers to LiS, I should know.
And we were quite surprised to find out that Caldera started distributing LiS as part of their Linux distribution, as we had never heard from them. But they published the sources as the license demanded, so we could see what changes they had made. And it turned out that they took an old version of LiS, and fixed a number of bugs that we had already fixed. So they could have saved a lot of work if they had simply contacted the community instead of taking an old version of the code and fixing bugs that were already fixed. None of their changes made it back into the official release, as they were all bugs that were already fixed.
Caldera needed STREAMS in the Linux kernel because of their port of Netware 3 to Linux (Netware is/was based on STREAMS) and the port needed a full STREAMS implementation.
Some time later the kernel syscall numbers changed, which made the old LiS incompatible with the new Linux kernel. This was fixed in the community in a matter of days. But Caldera was about to drop their Netware port because of the problem. At that time I worked for a Novell Gold Authorised reseller, who really believed in this Netware port. So we contacted Caldera, offering them to fix their problem free of charge, and informing them that we could do this without needing access to any proprietary code. Caldera never bothered to even reply, and shortly after they dropped both their Netware port and LiS.
Being a contributer to the LiS project I have written major parts of the code, including most of the DPLI, TLI, autopush and auto-load code. And I have never seen the source for another STREAMS implementation. This is no problem, because all STREAMS interfaces are specified in detail in publicly available sources.
So just like almost all the other "evidence" of infringement shown here, their "evidence" for copyright infringement from Linux STREAMS are similarities arising from the publicly available standards saying that things must be done in a certain way.
Xenix would have, it was originally another V7 fork just like BSD as I recall, and it evolved following the SysV line -- quite parallel to BSD. The last time I used it it was pretty much SVR3, no BSD in sight.
OpenServer and UnixWare, on the other hand ... those are pure SVR4 and SVR4 owed a hell of a lot to BSD.
jim frost
jimf@frostbytes.com
Which led to the old joke...
GOD is real...unless declared integer.
Yesterday on /. I was a "thief" for blocking iAds, today I'm a "troll" for suggesting that studying object code to create a derived work is creating a derived work.
Welcome to the contradictory world of freetards: where everything's fair game until you start using their stuff.
I called you a cheap fuck and a few people called you an asshole.
You didn't steal anything though, just your run of the mill EULA violation, which I personally don't think is worth much at the end of the day.
Doesn't change the fact that you're still being cheap and an asshole. But that's your right.
You know Slashdot has a sig field right? So why don't you use it? Everyone else is smart enough.
A real tab character is not n spaces, where n=enough spaces to get to the next tabstop. If people are implementing a "soft tab" as the equivalent of a keyboard macro that spaces n spaces, regardless of distance, they don't know what they're doing. It's not a tab.
There are in fact editors that convert tabs immediately to spaces. I can think of two different conventions here, and I've seen them both. One editor converts tabs to n spaces immediately moving you to the next tab stop. The other converts tab to n spaces where n is a fixed number (configurable, defaulting to 4 or 8, I forget).
The third method, which you allude to as your preferred method is to insert ASCII 9. That's all fine, but you still have the issue of how to display it. And either one of the two options above could be chosen (personally, I think that jumping to a tab-stop makes the most sense, and when I saw the other behavior - jumping ahead a fixed number of spaces, it seemed very non-intuitive.)
I have also seen the concept where an ASCII 9 is inserted, but then if backspace is entered, it will back you up only one space. So tab-tab-tab-backspace would take you one space to the left of the 3rd tab stop. This is actually the behavior that emulates an old typewriter, and is useful for "decimal tab stops" and "right justification tab stops". So, while it seems like odd behavior when considering how the file is stored, it actually best emulates the original tab intent. (The way this is implemented is that tab-tab-tab-backspace with tab stops every 8 positions would be stored as ASCII 9, ASCII 9, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE. The last tab is converted when you press backspace to be the right number of spaces, and then one is removed.)
Life would be simpler if a committee decided on one convention, but that's not how things are. There are many editors out there, and you can't guarantee what editor will be used to open your source code. The safest answer then is to avoid tabs!
Those editors, by definition, are wrong. Pressing a tab should insert a char(8) at the current position. Anything else is, by definition, not inserting a tab.
scumbag lawyer? ... I believe they are more commonly known as "Bloodsucking Lawyers". :)
I personally expected it to go more the way of the AT&T veresus BSD case, where it turned out that AT&T had stolen tons of code from BSD, not the other way around. The Linux emulation layer in SCO UNIX seemed a particularly likely candidate. Either that turned out not to be the case or IBM simply didn't push the issue (perhaps because SCO was having so much trouble proving anything in their claims) though.
Since IBM most likely wouldn't own the copyrights on that code, they wouldn't have standing to raise the issue, and so probably didn't even care to check. AT&T vs BSD was AT&T vs U of C copyrights.
SCO's strategy always seemed to me to be a shakedown, scare companies into license agreements. Why they went after one of the deepsest pockets first is beyond me, IBM was very likely to fight given their investment, but it was clear early on that management was not very competent.
Their initial hope was to get bought out by IBM. Not a sign of great intelligence, right there. Only when that plan failed spectacularly did they shift to trying to extort Linux customers, using the ongoing existence of the IBM suit as evidence of their claims.
The enemies of Democracy are
you are quite incorrect that this is "conceptual nonsense" what the AC is trying to describe is the coding equivalent of copying just about anything, lets take a car for example. The way they had it laid out was this: There are two teams one team has a car to look at (but not the blueprints, just the end product) and they get to examine the car and figure out how everything works, the other team has to put something together that works in a similar fashion, however they have no access to the car, they only have a basic understanding of the principals that make it work. When the construction team runs into a problem, they can ask the inspection team for help, but the inspection team can only give a general answer as to how to overcome the problem without letting the construction team see the car, or writing anything down (pictures, detailed descriptions, etc). The end result is something that's an original work (it was INSPIRED by the other car, but is not derivative of it)
btw the definition of derivative is as follows:
wikipedia: http://en.wikipedia.org/wiki/Derivative_work A derivative work pertaining to copyright law, is an expressive creation that includes major, copyright-protected elements of an original, previously created first work. (which would infer direct copying of the code, or in the car analogy, casting the new parts from the parts on the car to be examined.)
and in case wikipedia is not a reliable enough source
http://www.businessdictionary.com/definition/derivative-work.html Artistic or literary work derived from one or more existing works which, to be copyrightable, must contain sufficient element of originality that makes it a new work in its own right.
ie the work has to be original, and non-trivial, both of these elements are missing from the case being argued about code, elf header's are trivial (in this day and age) and are hardly original, they are common to most all major intel (x86) OS'es in one form or another, Thus they do not qualify as "copyrightable" and even so they would have to be an exact line for line copy to be infringing. The work shown is hardly line for line, they show lines where they suggest code was copied and modified to look different, however this still precludes line for line. In the case of Compaq vs IBM there are not enough details to make the assessment, however as the AC has pointed out if either side felt it was infringing, its 100% certain that the code would have never seen the light of day either through Compaq's own internal audit process, or through a MAJOR lawsuit by IBM (which even then was a vastly wealthy and powerful company).
My point is YOU are a TROLL.
Noone writes jokes in base 13!
Yeah, cc is common for me. I use "index" in ruby and javascript, because it describes exactly what the variable is. In C, though, I will use 'cc' or 'xx'.
Slashdot: Where people pretend to be twice as smart as they really are by behaving like children.
I was always curious as to how SCO's cron acquired a specific Linux cron's exact same bug ... about a year after it appeared in Red Hat Linux. I think that was in SCO OpenServer v5.0.5 or v5.0.6. SCO somewhat quickly released a bugfix for this (I personally sent in a bug report on how the specific bug was fixed in Linux), but OS install CDs were shipped with it.
That always bugged me. Still does.
So is the Bible a derivative work of the Torah, or the Qur'an? or is the Torah a derivative work of the Bible which is a derivative work of the Qur'an, which is a derivative work of the Torah?? zomg im so confused!
Noone writes jokes in base 13!
)
found this in your backyard
I'm not trying to dissociate her from the tea party movement because I'm a lefty who believes she has "killed [and] eaten... babies [and] loved ones". Rather, I'm a republican* who wishes to avoid the tarnish her ilk bring to the party. A "vacuous" political figure isn't harmless, but is a puppet (at best). Her seemingly desirable qualities do not include the abilities to lead nor to be taken seriously.
*(only because it is the least bad choice available to me)
I won't join Slashcott. OTOH, If Beta goes live, I just won't be back until it's fixed. Sorry Dice.
If they can patent this, they can patent the electric wall plug and sue every electronics manufacturer. They can patent the alphabet for that matter. This is not even code; since you're clearly not a programmer, I have to tell you that this is more like the list of cast members in a play with a completely different script. This just shows what a joke the McBride's case was, and how little they understood their own product.
Wasn't this crap settled already?
Can't we get a C & D on these buggers who keep dredging this crap up?
That function was the part where they found the offending code. The comparison shows the similarities mentioned but outline actual code not just headers and data structures. In this case SCO takes a header file for an ELF lib which is an open format to execute binary files so it is pretty much guaranteed to be identical because if they wern't the files wouldn't be able to run ;).
A loop, by its nature, continues. If that didn't make sense, start reading this sentence again.
Of course LiS doesn't contain STREAMS code - LiS is STREAMS. its writers claim it doesn't contain AT&T code, and I believe them - but there is no technical reason LiS couldn't be a copy of the SYSV code, it's just that nobody but a fool would bother - STREAMS is rather simple and quite well documented.
Watch this Heartland Institute video
IBM's work was stolen.
Plain and simple.
No it wasn't. That guy read the disassembled code, someone else wrote a new BIOS based on the first guy's description of how it was supposed to work. They didn't directly copy any code, they didn't directly copy any algorithms. They did a clean-room reverse engineered implementation. Maybe google that for en-clue-ification. It's a perfectly legitimate technique.
The enemies of Democracy are
IBM's mock lawsuit against Compaq (I say "mock" because it expended pretty much no resources by IBM standards, and probably existed only to placate certain investors)
This "IBM didn't actually want to win the lawsuit" theory belies a hilarious ignorance of IBM in the 80s. They absolutely wanted to stop any unlicensed BIOS. They absolutely wanted to control the home PC market. And they absolutely knew what the consequences would be -- loss of market control. Which is exactly what happened.
It may surprise you, but some companies actually don't pour endless resources down lawsuits that are lost causes. Some lawyers actually inform their clients of the legal realities, not the fantasies the client wants to hear. Actually... most, in both cases.
Compaq did a good job of creating a BIOS which looked nothing like IBM's BIOS
And ergo was not a derivative work. That's the long and short of it. If you implement a piece of code based simply on a description of how it's supposed to work (which is what the AC is trying to describe to you, him playing the role of the desciber) and the result doesn't look substantially like the original work that was described, then that's not a derivative work in any sense.
The lie to the technically inexperienced court is in claiming that you didn't essentially copy the IBM BIOS in all but machine code byte order.
If you were technically experienced you'd understand what a clean-room reimplementation was and this conversation never would have begun.
The enemies of Democracy are
This "IBM didn't actually want to win the lawsuit" theory belies a hilarious ignorance of IBM in the 80s. They absolutely wanted to stop any unlicensed BIOS.
It doesn't matter how often people say this, it won't make it true. Case history even in the early '80s already confirmed that it was fairly difficult to prove that derived firmware work had been created (for reasons I explained in the '99 case). IBM, unlike you, had smart enough lawyers to know that they weren't going to be able to protect their whole PC over a few kilobytes of ROM BIOS.
The IBM PC was an almost entirely open architecture with a few kilobytes of copyrighted code. Meanwhile, the PS/2 was IBM's genuinely closed and patent-encumbered system.
If you implement a piece of code based simply on a description of how it's supposed to work and the result doesn't look substantially like the original work that was described, then that's not a derivative work in any sense.
That's ridiculous and you know it. If you look at what X's work does and how it works, and use that information to copy what it does, then you are using X's creative input in order to make a creative work of your own. Thus a derivative work has been created.
Now it may be hard to prove that a derivative work has been created, especially (i) to a technically illiterate court, more a problem then than now; (ii) when you've used your knowledge of the original work to scrub obvious signs (e.g. long sequences of identical instructions). But that's just a sign of a working legal system erring on the side of caution, not a moral victory.
(What's more, as I've described, whether you've read the original work is irrelevant. And Sony v. Connectix agrees with me.)
Imagine that, like any hip geek, you've never read the Bible. Consider my giving you a description of all the proverbs in the Book of Proverbs, drilling down to how they're expressed. You then rewrite the Proverbs in your own words so that the message of each remains. All the byte sequences are different, but you've really made very little creative input: the new work is just two stages of rewording the expressed message in the old work. A derived work has been made.
If you were technically experienced you'd understand what a clean-room reimplementation was and this conversation never would have begun.
Today, a "clean-room reinterpretation" is used fairly honestly: you can only read what you're not restricted by or from reading. IOW, you implement from published licence-unencumbered specs. 30 years ago it meant, "Pretend that a derived work hadn't been created by handwaving an imaginary wall. This wall ignores the nature of creative expression in software and takes advantage of a technically illiterate court."
You're angry because you know that so much of the geek dream lore surrounding the development of PC clones is sophomoric bullshit. Compaq copied the BIOS but made it look like they hadn't, they concocted a mixture of handwaving about code writers never seeing the code (irrelevant per 1999 case) and no-one ever seeing the TRM source (just plain irrelevant - there's nothing worse about seeing proprietary source vs object).
IBM prodded Compaq a bit but knew that it had essentially created an open system which wasn't going to be protectable as a whole just because Compaq had copied 8kB of ROM BIOS. Clones were born, IBM moved on, and the victory for straight "piracy" was rechronicled lest the nascent commercial PC software market be scared away. Perhaps had people such as yourself not been so dishonest at the time, we'd see a very different software landscape where copying is considered far more acceptable.
In an environment where there is not an enforced indentation style, people don't all use the same ones (which, as you described things, was your case), so someone will use spaces.
So if you merge your code into that codebase, it should use spaces as well, so as not to mix tabs and spaces.
The fact that you think that your code is self-contained and a bit apart from the rest is irrelevant, because someone is eventually going to edit your code.
On the contrary - since others are going to use it (and everyone who doesn't use a hard tab to indent has their own display preferences), it's preferable to use only hard tabs in code that others are going to edit. Most editors can be configured to display hard tabs as "n" spaces, without losing the hard tab in the actual file, so people who want 4-space indents get it, ditto those who want 2, or 5, or whatever - onscreen.
The worst are the people who insist on listing all their parameters, one on a line, and they all have to line up under the first - this is totally retarded when I see code with 15 lines for parameters, all indented around column 90. Fix your damn code. First, there's no excuse to be that deeply indented. Second, there's no excuse to need that many parameters. Never. Again, fix your damn code.
Second-worst are those who insist that everything has to line up nicely in a certain column and that's why it has to be exactly "n" spaces for a tab, so they force 4 spaces on people who want 2, or 8, or vice versa. Use hard tabs, let the individual coder set his screen preferences, but don't worry if your #defines don't all line up nicely - the compiler doesn't care, and if it's that important to you, make each #define into 2 lines - one for the #define foo \ with the backslash line continuation character, the second with the actual define, and as many tabs as you want to satisfy your inner child.
Third-worse are the K&R gang - even 20 years ago it was stupid, ugly, and a waste of keystrokes.
And then there's the java weiners - because their code usually has methodNamesThatAreTooLongForAnyoneToFitEverythingOnOneLineIfWeUseHardTabs, instead of fixing the language, they use 2 or 4 tabs to fit it on the available screen real estate.
Hard tabs also make it easy to write code that generates code, or manipulates generated code.
It's not a case of "get off my lawn", but overall simplicity, flexibility, and efficiency. Hard tabs win on all 3 counts.
Why are they still trying to sue the main people around Linux? It just costs them money, with nothing in return...
I am not devoid of humor.
Yup. And the other OSes are doing the same thing. Are you trying to make a point here or what?
I am not devoid of humor.
Fucked OOp Beyond All Recognition?
> Because I, J, K, L, M, or variable names beginnning with them, are integers in Fortran. Otherwise variables are floating point,
This is the fortran default. The programmer is free to declare his/her variable names and their types butin the end, loop index variables don't
always need long_self_documenting_names
My Heart Is A Flower
Since IBM most likely wouldn't own the copyrights on that code, they wouldn't have standing to raise the issue, and so probably didn't even care to check. AT&T vs BSD was AT&T vs U of C copyrights.
That's a great point, but showing migration of code in the opposite direction sure would have been damning in front of a jury even if IBM couldn't have hoped for damages. Then again it's obvious at this point there was no need....
jim frost
jimf@frostbytes.com
McBride?
What makes this guy 'expert' on this? Nothing as far as I can see, just more of the same bogus stories his brother stated repeatedly. And the courts disagree, end of story. Groklaw? Please.. We are not so dumb as we look. You on the other hand post a different appearance....
Go away, do something productive, have a nice life. Your 1/2 second of fame is up.
PK
it probably took more time and more keystrokes to type that last line, than it would have to log in.
It doesn't matter how often people say this, it won't make it true. Case history even in the early '80s already confirmed that it was fairly difficult to prove that derived firmware work had been created (for reasons I explained in the '99 case). IBM, unlike you, had smart enough lawyers to know that they weren't going to be able to protect their whole PC over a few kilobytes of ROM BIOS.
It doesn't matter how often you say IBM didn't want to stop Compaq, it only demonstrates your ignorance. You're nearly right about the rest, though, in that IBM's lawyers understood copyright law well enough that once the facts of the case were in the open, they knew that they didn't have a chance and endless appeals would be pointless.
You seem to think every company is like SCO, and will pursue a case indefinitely if they want to win regardless of facts, so if they accept a defeat, it means they didn't want to win. Which is cute and funny and stupid.
That's ridiculous and you know it. If you look at what X's work does and how it works, and use that information to copy what it does, then you are using X's creative input in order to make a creative work of your own. Thus a derivative work has been created.
And here you demonstrate your ignorance regarding what constitutes a derivative work, and then in your analogies ignorance of the specific situation. Maybe read up on the legal code and acquire a clue.
Today, a "clean-room reinterpretation" is used fairly honestly: you can only read what you're not restricted by or from reading. IOW, you implement from published licence-unencumbered specs. 30 years ago it meant, "Pretend that a derived work hadn't been created by handwaving an imaginary wall. This wall ignores the nature of creative expression in software and takes advantage of a technically illiterate court."
The wall was real, no handwaving, otherwise Compaq would have lost the case. And the same technique is used today which you'd know if you had any relevant experience and weren't using your imagination in place of knowledge -- the court exceeding you both in technical experience and knowledge of the law despite your hilarious claims otherwise. The main difference today is in that word "license-unencumbered" since back then software patents were much more rare. Had IBM held patents on pieces of the BIOS, not even a clean-room implementation would have been legally safe. But I'm sure that's not the point you were trying to make, since it's far too intelligent.
You're angry because you know that so much of the geek dream lore surrounding the development of PC clones is sophomoric bullshit.
I'm laughing my ass off. You're mad because your attempt to re-imagine reality, the public record, and established case history is failing so spectacularly.
BIOS. Clones were born, IBM moved on, and the victory for straight "piracy" was rechronicled lest the nascent commercial PC software market be scared away. Perhaps had people such as yourself not been so dishonest at the time, we'd see a very different software landscape where copying is considered far more acceptable.
Bwa ha ha! Oh yeah! If IBM and others hadn't realized there was a legally valid way to implement "secret" functionality, they totally would have been happy to have people outright copy later! Please. The connection to "straight piracy" is in your imagination only. The rest of the engineering profession knows that reverse-engineering is important to the point where they were even able to get exceptions in the DMCA for it. The "pro-piracy" crowd you are so hilariously trying to paint the accurate historical view as coming from has not such power. IEEE and ACM? That's a different story.
IBM hadn't moved on even in the 90s, btw, when I was there. They were still bitter over losing control of the PC market, though their impression of the case was the same as everyone else, at least those who know what happened. I.e. not you. But keep it up! You're cracking me up here with your "truth".
The enemies of Democracy are
Actually a claim, mostly disproven. The court pruned the list of potentially-infringing code down to a few hundred lines, but didn't issue a final ruling in the IBM case yet. The Novell case, however, established that SCO doesn't own the copyrights, and that their claims against IBM are waived.
So:
-SCO doesn't own any of the code
-Even if they did own the code, at most a few hundred lines are infringed
-Even if they owned the code and some lines of it were infringed, all claims against IBM are waived by Novell and the Court has affirmed their right to do so.
FUBAR F***ed Up Beyond All Recognition
You know Slashdot has a sig field right? So why don't you use it? Everyone else is smart enough.
Okay, what the hell I'll bite. You mean the .sig field currently holding my, ah, signature? That .sig field?
or some other .sig field follies?
Pug
An Invisible Entity of Vast Power whose existence must be taken on faith alone: Liberal Media
As AC points out, I WAS talking in my first reply about whether or not SCOG could be said to own the code, not on the fact of copying or derivation from anywhere.
I'd add another point to your list of So:
-Even if they owned the code and even if some lines of it were infringed and even if Novell's waiver doesn't hold, SCOG went on distributing *the same code* under the GPL for years after they started suing folk (IBM, Novell, Autozone, RedHat...).
I've got a licence for the Linux kernel from Caldera/SCOG already. As SCOG's lawyer said in his summing up for the jury trial in Utah, SCOSource is gone and it can't be resurrected.
http://www.groklaw.net/article.php?story=20100326184700459
You're a moron.
It is impossible to copyright ideas. You can copyright the specific expression of an idea, but not the idea itself. For example, if you write a bad romantic vampire novel, you own the copyright to that bad vampire novel, but you do not own a copyright on the concept of a bad vampire novel. Someone else can write one very similar to yours, even down to having a very similar plot, and not fall afoul of copyright law so long as they didn't copy any actual sequences of words.
Same thing applies to code. The OP only passed ideas he discovered by examining the original code to the reimplementation team, and care was taken to avoid ever copying the expression of said ideas. What he did is well known to all intelligent people who bother to study copyright law before trolling /. as being the canonical technique for "clean room" (that is, legal) reverse engineering and reimplementation. (Technically you could have the reverse engineer write the new code, but it's much easier to guarantee in practice that no copying takes place (as well as much easier to prove in court that none did) if you carefully separate those roles.)
"Derived work" doesn't mean what you think it does, either. A derived work is one where you start with the original work (say, the sequence of bytes in the original IBM BIOS), modify a few things here and there, and try to call it your own.
I think it is in its original container, a JarJar.
You create your first variable to increment something, is it odd to use the first letter of the word increment? You then create another variable to do the same thing, would it be odd that your NEXT variable would use the NEXT letter in the alphabet and so on?
I think that everything in your comment indicates that the GP is actually invalid in spirit. That post indicated a belief that code is commonly copied and pasted.
If programmers try to conform to patterns (etc.) you'll see more instances where they write similar looking code but do not copy and paste.
If programmers try to accomplish similar tasks using compact vocabularies and operators, again, they're more likely to write similar looking code without copying and pasting.
I'm not a coder. I couldn't create a kernel if my life depended on it. I couldn't code a hungry cat to catch a mouse. 1/2 or more of what I read in code is gibberish to me.
But, one thing is pretty sure. Linus Torvalds wrote Linux, and his programming background came directly from Unix. OF COURSE he is going to write the same commands he has used a thousand times in the same way. OF COURSE there are going to be lines that look very much the same, sometimes even identical.
Linus Torvalds started linux; out of the current code he authored a few percent. Linux is now massive, and this is a pretty large amount of it for one guy to have written, but his main job these days is on managing code submissions from others. This case is really unrelated to Torvalds; if submitted code was plagiarized he wouldn't have been responsible or known about it, and it's really fairly unrelated to Linux; if SCO were to have succeeded Linux wouldn't disappear, but certain companies like IBM, SGI, etc, would have needed to pay some cash and redo some code.
Torvalds is not on trial here.
Also, as a guy who had his own code plagiarized, I am very wary of special pleading to try and excuse such behavior. We need to look at the facts of the case; we can still use Linux (I do) and at the same time be completely, absolutely opposed to it being tainted with plagiarized code.
The truth is that code was reused (if not copied, exactly, in the same way you don't submit a copied essay which you've taken from a classmate) from a UNIX derivative, which is now (somewhat disputably) owned by SCO.
That is understandable (even if illegal and arguably inethical); there's a dying version of UNIX which no-one seems to be the definite owner of, why not reuse useful snippets from it for the sake of compatibility and efficiency? Well this whole mess is exactly why; when in doubt write your own goddamn code, always.
We should be just as mad at SGI and IBM for being lazy and careless as we are annoyed that a company like SCO exists only to litigate and not do anything useful.
But please do not try and excuse or downplay this behavior. Linux is not going away, and we want justice to always be done because next time it'll be some other company using code from Linux (or one of your projects).
These are not small words like "kissing" that are under dispute, this is not about reusing some very common routines that everyone uses, that's just silly. Rather it's about companies wanting to maintain compatibility with legacy versions of UNIX and doing so by referring directly to the legacy UNIX at best, and plagiarizing their code at worst.
Trying to imply that this is some nonsense that should be dismissed just because you like Linux is like playing down and ridiculing the evidence of the murder of Hans Reiser's wife because you like ReiserFS. It's even sillier in some ways because Linux isn't at stake in the case like ReiserFS was. (An extreme analogy I know, but valid).
Always support justice, always maintain strict ethics when using your code as you would expect others to for your own code. If everyone did that companies like SCO couldn't exist, and more money would go to coders and less to lawyers.
I'm afraid this isn't the strong case you're making it out to be. I can see from somebody who isn't familiar with standards how similar comments and identical function names could perhaps be considered copying. However, much of the code here is either directly taken from BSD or the headers are shared/copied on person for the sake of a standardized ELF implementation. Read more on ELF, but the gist is that IBM and a bunch of other UNIX vendors openly wanted a standard binary format to be shared across platforms so that it could be understood and linked in a conventional way. Now of course McBride is making some silly argument about how ELF wasn't IBM's to open for council, but there's a pretty le
gah, that's supposed to say "on purpose" not "on person".
(1) You're an AC and you could just be making everything up -
by FuckingNickName (1362625)
I LOLed
Ubuntu is an African word meaning 'I can't configure Debian'
Personally, I thought 'i' stood for 'index', but 'I' guess it doesn't really matter...
The CB App. What's your 20?
I'd use those variables in LISP if I had to. I always wanted to know the cdddddaddr of quuuuuux.
The CB App. What's your 20?