tantalor9 years ago
(2012)
The Economics of Spam: http://pubs.aeaweb.org/doi/pdfplus/10.1257/jep.26.3.87
The court room climate control costs would likely be dominated by energy expended for every involved individuals' commutes, which would likely be dominated by the opportunity cost of all of those individuals doing something more productive (if you want to go that far)
Unfortunately, the purpose of human intellect and time has become to get more money, so what they're doing is by definition not a waste, but the only possible outcome.
private static void rangeCheck(int arrayLen, int fromIndex, int toIndex {
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex+")");
if (fromIndex < 0)
throw new ArrayIndexOutOfBoundsException(fromIndex);
if (toIndex > arrayLen)
throw new ArrayIndexOutOfBoundsException(toIndex);
}OT: Really convenient use of emacs for formatting quotes. Copy the text into a text-mode buffer, put two spaces at the start, M-q and the whole thing is wrapped and each line prefixed with two spaces.
Utterly absurd...
Keep in mind, components of an invention that's patented can be quite obvious. How a standard gearbox in a car works is well-known, but pair it up with some novel input and output or some novel use, and it's a patentable construct.
I had the pleasure to spend some time working with some very (very!) smart patent lawyers on a couple of cases.
Apart from feeling like I was in an episode of Boston Legal merged with The Good Wife, I was able to gain some understanding of the rules of the game. In that game things like "but it's patently obvious" gets you zero points. Any argument you advance that's based on obviousness will lead to eye rolling and deep sighs. Such arguments are extremely hard to win, it turns out. In our legal system, proving invalidity is difficult.
By contrast, things like : a comma in the wrong place in claim drafting; case moved to a different jurisdiction; tricks with filing dates; prior art (the thing I was helping with) and other noninfringement theories are greeted with enthusiasm.
I did a patent a few years ago, and that's how it felt. The patent lawyer would call me to get my version and when the application was done, it would look like it came from another plane of existence.
Phrasing like "cause a calculating machine to..." were repeated a lot. Totally unreadable, probably only makes sense if you're a lawyer.
And symptomatic of a broken system, in my view.
Because of how the federal system operates, its difficult for the defendant to force a change of venue here. These pro-IP jurisdictions give companies like Oracle the wins they want and all the fees and fines and lawyer hourlies add up. Its a win-win for everything but justice.
http://arstechnica.com/tech-policy/2013/01/east-texas-courts-are-back-on-top-for-patent-lawsuits/
You can rearrange the last two if blocks and have complete interoperability, but the messages will be different. Moving that first if block, though, will change the behavior of the method by a large degree.
if(toIndex > arrayLen) does not handle the case in which toIndex == arrayLen, which should still throw an ArrayIndexOutOfBoundsException if we are dealing with 0-based indexes.
Please correct me if I am wrong.
(int arrayLen, int fromIndex, int toIndex {
So if the range goes to the end of the arrary, then you would expect toIndex == arrayLen and the check is correct.
If the array index is of the closed interval 1 ... arrayLen, then yes.
Shame on the second case; that war was fought decades ago and it lost. FORTRAN indexing is Bad.
Ok, maybe that venerable codebases doesn't have exception handling like Java but you can prove to have the same logic maybe 10 or 20 years before that code was written.
http://www.groklaw.net/articlebasic.php?story=20120802030811156
This article is from 2012. The trial currently happening was remanded from an appeals court, which overruled Judge Alsup in determining that the "structure, sequence, and organization" of the Java APIs (not the code itself) was copyrightable, which is much less de minimis I don't believe rangeCheck itself is still at issue.
It's my understanding (I am a wee lad compared to the grizzled vets here, so bear with me) that most of our common *nix tools were written during the UNIX days and were technically proprietary (awk, grep, cut, etc). When Linux came around, these tools were "ported" to become GNU tools and completely rewritten on the backend, while still keeping the same name so that existing UNIX developers would feel at-home using the same tools on Linux,BSD, etc.
The key point here is that they intentionally kept the same command names, for familiarity's sake.
Given that, could one make the analogy that a command name would be similar to an "API" and should also have been illegal by Oracle's logic?
EDIT:
I first said "no" but to be honest Oracle has tried to claim ownership of the API and the implementations. And apparently Oracle has won some of these points https://gigaom.com/2014/05/09/tech-world-stunned-as-court-rules-oracle-can-own-apis-google-loses-copyright-appeal/
However the is exactly what Google is trying to do by doing "clean room" implementations of an existing API. New code but the same calling API and return values with completely new code. This whole article is one case where they did not rewrite the function but instead copied the existing one.
If there was literal copying going on, even in one small case, that breaks down the entire clean room. How can you claim you strictly kept a wall up, if code was just copied? It would have been bad enough if the engineers writing down the API were the engineers developing it.
I'm curious though, if you have access to the source, and you have engineers who are "tainted", could those engineers not put together a tool that scans commits automatically for anything in the original source and outputs a warning to those tainted engineers that they can go to the clean room engineers about?
But then that also breaks the whole clean room premise. If was a former Sun employee he should have never been allowed to work directly on the code in the first place.
Is that true? Can't you use several Java packages (at least in source form), IDEs, etc. with Android?
This said, IIUC, the point is that they did not build Android specifically to achieve interoperability with, say, Eclipse; they built Android in Java for whatever reason (including attracting developers), and when they realised they couldn't use the JVM because of commercial issues, they swapped it with Dalvik (which may or may not be a complete clean-room JVM reimplementation).
So it's not exactly in the same bucket as "we built this because existing tooling expected it this way"; it's more like "we built something, then had to rewrite the bits underneath because we realised we couldn't use them", a different scenario.
If they had just thrashed out an agreement with Sun (which would have been much much cheaper than dealing with Oracle will ever be...), they could have continued using the official mobile-oriented JVM, likely influencing its development as well; but first they dragged their feet and then they thought they'd just rewrite the whole thing so they could claim originality and independence, and here we are.
Before Linux was even conceived, the GNU project was started, but its aim was not writing Unix tools, but to write an entire Unix replacement – Unix kernel, Unix tools, all of it. The GNU tools were initially written not for use in existing proprietary Unixes, but for use in the (then thought to be) soon upcoming GNU system. However, since the GNU tools were superior to the aging and buggy Unix implementations, the GNU tools were widely ported and became very popular, and the patches for running the tools on contemporary Unix systems were accepted upstream. Then, the name “GNU” came to be associated with these tools, and not with the actual project to replace Unix; the fact that the GNU kernel never really materialized did not help. Only then did Linux (the kernel) burst onto the scene, and it happily noticed that there were all these tools available to be easily ported (and they were all adapted to be easily portable), and the concept of a “Linux system” was coined, meaning a Unix-like system with additional Unix-like tools gathered from around the Internet. Too bad that these were all actually the GNU tools, made by the GNU project for GNU, a replacement for Unix. A Unix-like system with the GNU tools, using Linux as the kernel, then fulfilled the object of the GNU project. This is why GNU people are slightly irked when this system is called a “Linux system” – it’s not about the size of the kernel vs. the GNU tools, it’s that the goal of the GNU project was always a full Unix system, and the Linux kernel was the final component, the appearance of which allowed the project to be realized.
I've currently ported bash(1.08) and gcc(1.40), and things seem to work. This implies that I'll get something practical within a few months, and I'd like to know what features most people would want. Any suggestions are welcome, but I won't promise I'll implement them :-)
And took that to mean that the key rewrites were being done by Linus himself, and possibly other volunteers working on getting the "userland" apps ported. I suppose on cursory examination, it should be obvious that the mention of 'gcc' implies that the GNU compiler had already been written.
[0] https://en.wikipedia.org/wiki/History_of_Linux#The_creation_of_Linux
I personally am very happy if powerhouses fight each other with lawsuits instead of giving me a sword and asking me to die for them. In that regard I feel humanity has come quite far over the last centuries.
So, they're idiots.
Their entire business has been selling software to C level executives who will never come into contact with the product, let alone use it.
This isn't about merit, or technology. This is about a company's legal team doing whatever they can to utilize acquired patents to create a revenue stream.
Companies the size of Oracle simply aren't structured for innovation, and have a culture which actively undermines it. They're getting their ass handed to them by Azure, AWS, and Google Cloud for this very reason. When a company starts making money off of professional services to help customers implement and utilize their software, they simply aren't going to be incentivized to make that software good. Shitty software and vendor lock-in combine to produce guaranteed revenue streams, which sustain the company just enough for them to be comfortable while they cruise towards irrelevance.
I'd add PostgreSQL to that list, they're clearly concerned about the risk it poses to their core business:
}
private static void rangeCheck(int arrayLen, int fromIndex, int toIndex {
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex+")");
if (fromIndex < 0)
throw new ArrayIndexOutOfBoundsException(fromIndex);
if (toIndex > arrayLen)
throw new ArrayIndexOutOfBoundsException(toIndex);
}
private static void rangeCheck(int arrayLen, int fromIndex, int toIndex)
{
if (fromIndex > toIndex) {
throw new IllegalArgumentException(
String.format("fromIndex(%d) > toIndex(%d)", fromIndex, toIndex)
);
}
if (fromIndex < 0) {
throw new ArrayIndexOutOfBoundsException(fromIndex);
}
if (toIndex > arrayLen) {
throw new ArrayIndexOutOfBoundsException(toIndex);
}
}
It doesn't properly work if an array is zero-based nor it works if it's 1-based. It neither properly work if toIndex is meant to be included in the range or excluded from it.
This is backwards, developers do what management allows. If management cares to know what goes in the software, they will know. There are ways to know. Whether business people want to pay for that is a different matter. Of course they don't, for this precise reason- so they can throw up their hands and say, "those darn developers!"
This trial should now be entirely focused about wether Google "stole" the API SSO under a fair use exception and shall be relieved.
The preceding phases of this case already determined that: -thoses a nines lines are not significant -Google used API SSO without consent of Sun/Oracle and without any license -API SSO of Java are indeed copyrightable (this was ruled in appeal and confirmed by the Supreme Court)
This retrial is only happening because judge Aslup did a half baked first trial and the appeal court returned him the case after invalidating his bad ruling about non-copyrightability of API.
For thoses who seek deep insights about this case, take a look at Florian Mueller's blog: http://www.fosspatents.com
He pretty accurately predict the reversal of the first ruling against the opinion of many mainstream analysts. And he frequently publish link to public court documents so you can make up you mind by yourself.
EDIT: If you downvote please argument, otherwise it's very suspicious. I'm totally open to discussion but I can't fight against a hidden lobbyst activity that systmatically downvote diverging views.
EDIT2: I edited the first sentence to be more explicative. I've seen I got some upvote, but silent bashing seems to continue. Again, please argument!
I don't get why the name of this blogger unleash so much passions while he actually always publish documents and link to actual rulings. Yes he clearly don't write as elegantly as some, and yes he's by now pretty opinionated but why such much hate?
From the #1 answer (it is worth clicking the link and reading the full answer):
java.awt.font
java.beans
java.io
java.lang
java.lang.annotation
java.lang.ref
java.lang.reflect
java.net
java.nio
java.nio.channels
java.nio.channels.spi
java.nio.charset
java.nio.charset.spi
java.security
java.security.acl
java.security.cert
java.security.interfaces
java.security.spec
java.sql
java.text
java.util
java.util.jar
java.util.logging
java.util.prefs
java.util.regex
java.util.zip
javax.crypto
javax.crypto.interfaces
javax.crypto.spec
javax.net
javax.net.ssl
javax.security.auth
javax.security.auth.callback
javax.security.auth.login
javax.security.auth.x500
javax.security.cert
javax.sqlI've heard people say that Google actually copied the API structure (which is copyright-able) but I've also heard that this lawsuit was actually about Google using a wrong (or missing license). And I've heard that Google also manipulated the developer community by only propagating "we only copied 7 lines of code" and big evil oracle sues us.
From what I know Google used Java's API structure but did not include a license. They could have paid oracle for a license to use it conmercially or they could have used the GPL from OpenSDK and be bound to its restrictions. What they did instead was not to include a license at all, because try did not want to pay oracle but also did not want to be bound by the GPL (which might complicate things with phone manufacturers that change the code).
Could anyone tell me what the fuck this lawsuit is actually about?
For a while I worked in translating, and I translated a couple of books for the same author. One of the later books quoted about a page from the first one I had translated a couple of years earlier. I just translated it again because it was faster than finding the passage in my other translation (first point). Afterwards, I went back out of curiosity and checked the two translations against each other. I was quite surprised to see that in one full page of translation, after years of further experience, there was only one or two prepositions that were meaninglessly changed (point two).
Some things are just so obvious that the same guy doing the same thing years apart will produce the same results, especially if he is an expert in his craft. Unless there is some way to prove otherwise, this point of the case should be definitively dropped.
Shouldn't i be between 0 and 9?
> Google owes Oracle between $1.4 billion and $6 billion in damages if liable
The more I hear about this case, the more I realize it's just a bunch of lawyers trying to pad their bank accounts. No sane engineer would claim this is infringement.
Indeed, quite a lot, but I dont think that was the point.
David Boies (counsel for Oracle): "I want to come back to rangeCheck."
Alsup: "rangeCheck! All it does is make sure the numbers you're inputting are within a range, and gives them some sort of exceptional treatment. That witness, when he said a high school student could do it—"
Boies: "I'm not an expert on Java—this is my second case on Java, but I'm not an expert, and I probably couldn't program that in six months."
http://www.groklaw.net/article.php?story=20120515120106322
Any other way to write that method, short of changing the exception text and variable names would be silly. The truly astonishing thing is that enough people could be fooled to think otherwise.
Of course that still leaves two other arrangements of the remaining code.
Adorably, the Judge's full name is William Haskell Alsup.
> [Oracle]: even Java programmers don't learn about Java bytecode.
Uh, what? I'd hardly call myself a dedicated Java programmer and I've learned about Java bytecode. I had to, and wanted to. I'd guess most professional Java programmers would consider it a point of pride to do the same!
While it might not be required to dig deep into the bytecode, the fact that Java comes completely with a suite of tools for dealing with bytecode suggests Sun did expect developers to understand and work with the JVM bytecode at some level.
(And in fact they did not get a meaningful win on rangeCheck, and the case is back before Judge Alsup with his view of structure-sequence-and-organization overturned.)
> Microsoft focuses on Oracle's argument that copyright supports "non-literal" elements of software. In other words, Google can be found a copyist—even if there's no actual copying of code. The "structure, sequence, and organization" (or SSO) of software "can, in some instances, be protected by the copyright in the work." Copyright violations can be found in a software case "even when the defendant did not copy the underlying developers' code," Microsoft insists, because the defendant has copied "some other, non-literal element of the software."
http://arstechnica.com/tech-policy/2013/02/microsoft-foresees-chaos-if-google-v-oracle-result-stands/
So it's not just literal "copying" (accidental or not) that must be punished/paid for, but companies or developers should be forced to pay for making "similar" APIs as well.
I don't think SSO should qualify for this sort of protection, for a number of reasons (it has significant functional constraints on how its expressed, it's a tiny fraction of an overall creative work of software, etc.). But it's not obviously nuts to claim it should either.
While I also disagree with the lawsuit, if you are coming at it from the mindset that code you have a copyright to was used elsewhere, Oracle has a compelling case. Certainly not a $9 billion case, and not one that takes up 6 years of time to decide, but that's not for me to decide.
The relevance of rangeCheck isn't that it's some crucial functionality that Google couldn't have written themselves. The relevance of rangeCheck--and Google's admission that it literally copied the code instead of developing it "organically"--is proving that Google was looking at JDK code while developing the Android JVM.
Oracle would never sue on rangeCheck by itself because the damages would be trivial. They're hammering on the literal copying of rangeCheck because of what it says about Google's state of mind.
[1] The fundamental legal question is actually pretty interesting and has implications beyond this case. Remember Microsoft's policy of "embrace, extend, extinguish" in the 1990s? If SSO is protectable, then "embrace, extend, extinguish" tactics may cross the line from simply distasteful to actionable unfair competition.
This ecosystem doesn't belong to Oracle. It comprises of thousands of companies and individuals, who actually welcome that their existing investment into Java code can be reused on additional platform.
If Oracle's argument is accepted, it becomes a gatekeeper to the platform who decides, where and for what purpose you can run your own code or not. It greatly increases the risk of using the Java platform.
This case increases the risk of using platforms, libraries, and services in general.
Google used Apache Harmony implementation of Java.
Why Oracle never sued Apache Foundation?
What makes this case different? That APIs aren't protectable has been bandied about as gospel truth in the nerdosphere for decades. Was that assumption just wrong all along or is there something about this case that seems to make it subject to re-litigation?
Very good question though.
I appreciate that this feels like an arbitrary distinction from the programmer's point of view. The way to think about it, I think, is this: what creativity is required to design the API? Designing a class with particular methods and appropriate names requires at least minimal creativity. Putting the disk I/O routines at INT 13h instead of INT 12h doesn't; it's arbitrary.
To be creative,
Sunshine.Unicorn13(spaceshipIsFunnyPants);
would be how you'd set permissions on a directory. Do you see why? No, of course not - if it was at all obvious it wouldn't be creative.
This is still very much an open question and right now not true. Core to this case (and a ruling Oracle has won) is the copyright of the Java API itself.
https://www.eff.org/deeplinks/2015/06/bad-news-supreme-court-refuses-review-oracle-v-google-api-copyright-decision
I think that's the crux of it or at least, of my confusion because I don't see the fundamental distinction in creativity (or really, fixedness of media although that seems like an easily avoided technicality). A BIOS API is still an API in purpose and intent. It has structure, design choices (parameters and returns, what calls to and not to provide), a specification, etc. Is the legally significant difference really that methods in classes have names and interrupts don't?
A BIOS API has purpose and intent and structure and design choices, but all that is implicit in the code. You can write up a specification describing those conventions, and that is copyrightable. But you can clone the BIOS without copying a single word from the specification.
Of course, the only reason code is copyright-protected is because it's text, and text can have expressivity and code can be creative. But that does not mean code has creative expression. Most code does not express anything, not in the way other artworks do -- most code exists only to solve specific problems and hence is functional. Sure we can use whatever names we want for the methods and variables but you'll notice they all tend to be very descriptive of what they do. Not much creativity in the text of the code itself (at least for "good" code). All the creativity in software is in the technical ideas, approaches, algorithms and abstractions we use to solve those problems, but unfortunately only patents protect that, if at all.
The real problem here is the use of copyright to protect code. It's a legal hack, enacted because there was nothing better around to use. And to make the hack uglier, binaries enjoy copyright protection because they are "derivative works" from copyright-eligible program code. We need something more appropriate, lying between patents and copyright to protect software.
Also, creativity is irrelevant here - it's a collection of fact. 'Hermione' may have taken creativity to come up with but it's a fact that Harry Potter stars a character of that name. As long as the names are the signatures, the names can't be protected.
As for arbitrary, whatever. That's your line in the sand. But it's wrong. As in, outcomes based on that reasoning are less functional. If it ends up being upheld it's yet another case of our legal system weakening us, not strengthening us.
Is it related to whatever dynamic requires companies to "clean room reimplement" something?
Which is part of the whole rationale of unfair competition law. It hits a moral button when someone takes advantage of someone else's work to make themselves a bunch of money. The more intentional and purposeful that copying is, the more wrong it seems.
I license you a black box with 3 switches on it and 3 lights. The license dictates you may not look inside. The clean room implementation is, I right down what the effect of each switch has upon the lights. I then give that specification to an engineer who's never seen the box. They build a copy of the box, based on the spec.
Let's step back a bit. There's a software product in use today that embraced an open standard, extended it and in doing so "extinguished" other implementations in a way that has much greater implications for software development (especially in the present tense) than anything Microsoft ever did.
What product am I thinking of? The GNU C Compiler, of course! And the GNU tools in general (which have thoroughly "EEE'd"[0] competing POSIXes), while we're at it.[1]
If "SSO" or "EEE" are "actionable unfair competition," then whoever is the current owner of the Bell Labs IP has every right, and every monetary incentive, to get the whole GNU/Linux ecosystem shut down.
[0] "EEE" isn't bad! You could just as easily call it "beating the competition by making a product with better features."
[1] Assuming you agree with me that compiler lock-in and operating system lock-in have greater implications for software development than for example web browser lock-in.
It's not a phrase for winning by doing a better job.
Over the past 20 years GCC and GNU/Linux have gone from negligible to overwhelming market share in the fields of C compilers and POSIX-on-the-server, thanks in large part to the massive software ecosystem that has developed which can only be compiled using GCC and its non-standard language extensions, and/or can only run on GNU/Linux and its non-standard extensions to POSIX.
Once enormously-popular competing implementations, Borland C, Solaris, etc, have been "extinguished." Surviving and new implementations treat GCC and GNU/Linux as the reference standards more than anything the ISO puts out.
Again, I'm not saying that's a bad thing; just the opposite. Inferior products (which can and do include the published standards themselves) were beaten out by superior ones.
Um, sure, but EEE is important because it was a strategy and one that was executed repeatedly by Microsoft. On the other hand, just because some products have been "extinguished" (debatable) does not mean that was the strategy employed by GNU, nor does applying EEE here seem to serve any predictive function.
Dirt simple 9 line functions don't "organically grow" over time, they're just pounded out and the programmer moves on.
Bonus points for conceptual issues that demonstrate a natural convergence to the same solution as understanding of the domain increases.
"Original, as the term is used in copyright, means only that the work was independently created by the author (as opposed to copied from other works), and that it possesses at least some minimal degree of creativity. ... To be sure, the requisite level of creativity is extremely low; even a slight amount will suffice. The vast majority of works make the grade quite easily, as they possess some creative spark, 'no matter how crude, humble or obvious' it might be. ... Originality does not signify novelty; a work may be original even though it closely resembles other works, so long as the similarity is fortuitous, not the result of copying."