Hacker News new | comments | show | ask | jobs | submit login
The 9 lines of code that Google allegedly stole from Oracle (majadhondt.wordpress.com)
358 points by nkurz on May 18, 2016 | hide | past | web | favorite | 196 comments



Looks like something I've written a hundred times. It's a common pattern, you could "steal" this just through organically writing a program.

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.


The article misses the forest for the trees. This lawsuit isn't about rangeCheck, it's about the structure/sequence/organization of the Java APIs. Whether you think SSO should be copyrightable or not, you can't argue it's trivial. Copying the SSO allowed Google to greatly reduce the barrier to entry for Android by leveraging the enormous Java ecosystem.[1]

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.


> Copying the SSO allowed Google to greatly reduce the barrier to entry for Android by leveraging the enormous Java ecosystem.

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.


Playing devil's advocate - perhaps Oracle sees the ecosystem as being a "derived work" of their Java IP. This would be a dangerous view for software.


It's only a matter of time before the hunter - in this case Oracle - becomes the hunted. You would think they know better. But this isn't about code and law, is it? It's a testosterone fueled pissing match. Don't cha think?


At this point though Java is largely GPLv2 with the Classpath exception.

This case increases the risk of using platforms, libraries, and services in general.


> 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.

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.


For EEE to work the Extend needs to be proprietary so that the third E can take place with regard to competing products. The GCC exists under an open license so it can't be used that way.

It's not a phrase for winning by doing a better job.


I don't recall reading that in the infamous Microsoft memo. Extending and extinguishing can and most certainly has taken place, whether a monetary incentive exists or not.

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.


I think what you are doing is re-defining the strategy and saying it isn't bad. But the way MS used it was wrong. They didn't just create open tools that everyone wanted to use so they won out. They intentionally tried to join into an effort, purely to try to move it in a direction where they could shut others out using their market dominance and then kill off competitors. It's not just winning through fair competition and that's the problem I have with your statement. MS violated the law and behaved in an unethical manner rather than competing on the merits of their products.


Your case is reinforced by clang's recent rise as a worthy alternative to gcc.


Yes, and especially by the very large investment (of Apple time and resources) they've put into their ongoing effort to reach one-for-one compatibility with GCC's non-standard extensions. It's unlikely Clang would be growing in popularity nearly so fast had they exclusively rolled their own APIs for language extensions, or especially if they stuck strictly to the standards.


> Extending and extinguishing can and most certainly has taken place, whether a monetary incentive exists or not.

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.


This question or questions very close to it must have come up in the endless litigation surrounding things like IBM BIOS/x86 ISA/Apple ][ ROMs/PS1 emulators, right?

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?


Copyright doesn't say anything about "APIs." It protects any "work fixed in a tangible medium." In the BIOS cases, you just had to connect certain code to known interrupt vectors. The code itself was totally clean-room implemented, and an interrupt vector table that exists transiently in memory isn't "fixed" and "tangible." But a Java API is much more than that. You have tangible permanent source code files containing classes that have specific names and members that have specific names. Copying a Java API involves copying these things. Moreover, here it was clear that Google did have access to the JDK code while developing the Android JVM.

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.


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.

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?


The fixedness requirement is really fundamental. It defines the scope of copyright. That's why a live music performance is not copyrightable, even though it's creative.

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.


Another key point (in my view) is that these APIs are textual whereas BIOS / protocols / binary interfaces are purely functional. Copyright is meant to cover "forms of expression". Text can have "expressive" creativity, but binary interfaces can have only functional creativity, which is expressly the realm of patents.

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.


Sega v. Accolade was over the actual string "SEGA".


IIRC, it was some bytes of object code they copied to be interoperable, so that string could just as well have been an array of random numbers as far as being the key to interoperability was concerned.


Sega v Accolade '92 - copying a trademark is allowable when it becomes a functional requirement for interoperation.

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.


No, you don't have to copy the source code to replicate an API. Method and class names are just aliases for memory addresses, which like a phone book, would not be copyrightable.


You don't, but Google did. And unlike the flat interrupt map of a BIOS, there is non-trivial structure and organization to the set of aliases comprising a Java API.


Not really, the words are descriptive.

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.


Copyright doesn't say anything about "APIs."

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...


Didn't Intel & AMD sign a licensing agreement allowing AMD to implement the x86 ISA? That would explain one of your examples.

Very good question though.


The former Intel & AMD agreements were about patents, as far as I'm aware. (The latest actually expired a year or two ago. Still, neither will sue the other because it's mutually assured destruction.)


I was thinking of NEC v Intel although that one is pretty murky too, to the nonspecialist - NEC already had certain licenses, etc.


The same guy wrote the code in both places. Therefore he did come up with it "organically".


Yes. But he came up with at / for Oracle. And then nicked it for Google / Android. The former was original. The latter a knock off. I believe that's the crux of the rub, eh.


We live in a ridiculous world when you can "nick" your own code when it's open source.


If we're arguing for a clean room implementation, then it absolutely matters if he copied his old code.


This may be a description of what Oracle is trying to claim, but it has no bearing on the reality of the situation. The OpenJDK code was copied in order to contribute to OpenJDK. It's utterly shocking that Oracle would misrepresent this as theft rather than a gift from Google.


> Copying the SSO allowed Google to greatly reduce the barrier to entry for Android by leveraging the enormous Java ecosystem.[1]

Google used Apache Harmony implementation of Java.

Why Oracle never sued Apache Foundation?


Sun did refuse to give the Apache Foundation access to the necessary test suites to certify the Harmony implementation.


Well, I'm sure that part of it is that Oracle committed to Harmony.


If anybody considering being contributing to 'open source' weighs that in an easy credit is just for others, at least me will reconsider.


But if the issue at hand is whether they copied the interface, how does copying the implementation speak to that? That is, if the creative, copyright-able part is how the interface is structured, why would it matter how intensely they looked at the behind-the-scenes implementation? What role would "state of mind" play there?

Is it related to whatever dynamic requires companies to "clean room reimplement" something?


You do a clean-room implementation to preserve the ability to say "even though these lines of code are similar, they couldn't have been copied because we locked these engineers in a room while they were writing this implementation." But it's also part of the story: "we're good guys; we did all the work ourselves from scratch instead of trying to leverage all the work our competitor already did."

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.


The dynamic that requires companies to clean room, typically comes from some license that comes with the original product.

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.


What does SSO stand for in this context?


Structure, sequence and organization.


Oracle is the biggest patent troll.


Judge Alsup made the exact same point in the original trial: "I have done, and still do, a significant amount of programming in other languages. I've written blocks of code like rangeCheck a hundred times before. I could do it, you could do it. The idea that someone would copy that when they could do it themselves just as fast, it was an accident. There's no way you could say that was speeding them along to the marketplace. You're one of the best lawyers in America, how could you even make that kind of argument?"

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


Is it really common that you'd have a judge in a case end up with that kind of "subject matter expertise"? I guess I can't completely fault Boies for arguing the case in the manner you see in that exchange, but I was pretty floored that the judge could just see right through it.


He learned Java solely for the purpose of being able to understand the case more clearly. (Wikipedia) and has implied that he knows other langauges as well. He has a B.S. in math so its not too surprising.

Adorably, the Judge's full name is William Haskell Alsup.


"Your honor, we believe John Fogerty is infringing on our sound when he plays guitar like himself."

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.


Nice Fogerty reference! (He's citing this case: https://en.wikipedia.org/wiki/Fogerty_v._Fantasy,_Inc.)


Well, there are 6 different orders in which you could insert the 3 if statements, but I'm not sure that's a material difference :-)


Yes and no, if the first conditional is moved then the behavior of the function would be different. You could for example specify a fromIndex of -1 and a toIndex of -2. That would result in an ArrayIndexOutOfBoundsException instead of an IllegalArgumentException. Arguably, it doesn't matter but if it's different than it wouldn't necessarily be compatible with other calling code.

Of course that still leaves two other arrangements of the remaining code.


This line also stood out to me:

> [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!


I've worked in many large Java enterprises and nobody knew about the bytecode. They knew it was there but not what it consisted of how it was structured. It's no different to many C/C++/Go etc developers not understanding what ASM gets generated.


I guess that makes sense actually, I think I only even ran into an issue where bytecode was actually relevant because I'm just a hobbyist programmer. So I like to explore things that have only marginal utility and don't have anyone else to help out with specialist stuff. I can imagine how a professional developer wouldn't ever want or need to deal with bytecode.


I was taught JVM bytecode as part of a required class for my CS degree. We had to write a rudimentary interpreter for a subset of it.

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.


Situations like this intrigue me, where the ethical thing to do is not the moral thing. Morally, it's reprehensible that a man as smart and distinguished as Boies could make an argument like that with a straight face, but, ethically, he's doing exactly what he should do as an attorney for his client. And he can can use that ability for good as well as evil, as evidenced in his work for the Justice Department in the Microsoft anti-trust trial. It's perverse and gross, and he makes more money in a year doing that than I'll make in my lifetime.


Why is that the ethical thing to do? It seems like the ethical thing to do is to go to your client and say, look, I hear this judge writes code, and even if not I hear the other side has expert witnesses. We're not going to be able to win on rangeCheck. Let's pursue the "structure, sequence, and organization" angle, it'll be more worth the money you're paying me.

(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.)


The current state of the lawsuit isn't over the novelty of function, it's about the copyright of it. Also, very important to their argument is that this wasn't some random developer at Google who added it into Android, it was the guy who had added that function to OpenJDK.

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.


Exactly why no engineers will be allowed on the jury.


Not just lawyers, but entire companies want to be paid for stuff like this. See Microsoft, for instance:

> 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-foresee...

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.


To be fair, that's not an enormously crazy thing to say. If I read George R.R. Martin's work and then write the exact same story, going through sentence by sentence and changing each material word just enough to say it wasn't "copied" (e.g., "Tyrion shot the arrow through his father's heart" becomes "Tyrone fired the bolt, piercing his patriarch's breast"), I'm surely guilty of copyright infringement.

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.


Would it be a more fair analogy to say that you read George's work, copied the chapter names and wrote your own story underneath those?


Could you use a less significant line as your example?


I bet some even have code like that stored in their snippets library.


https://github.com/search?utf8=%E2%9C%93&q=rangeCheck+fromIn...

Indeed, quite a lot, but I dont think that was the point.


This is like saying the Vietnam War was just a bunch of of officers trying to get promoted. It happens to be a lot true, but its hardly complete.


I think it would be neat if anyone who sees this would link to a github repo of their own that shows an organically created version of these nine lines. I believe that for a patent you have to demonstrate novelty. I have no idea how copyrights work. It seems that novelty is not so important in the case.


Copyright requires some creativity ( http://caselaw.findlaw.com/us-supreme-court/499/340.html ):

"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."


You think someone checked in every line as they wrote it? I'm sure the repo update for that function is just "implemented the following API functions: ...." + a bunch of lines.

Dirt simple 9 line functions don't "organically grow" over time, they're just pounded out and the programmer moves on.


Bugs count. Anything that shows you didn't cut and paste it.

Bonus points for conceptual issues that demonstrate a natural convergence to the same solution as understanding of the domain increases.


But since we, engineers, aren't asked much... ¯\_(ツ)_/¯


Given the guy who wrote this wrote both the first and supposedly infringing code, I have a bit of an analogy here from personal experience from another field.

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.


Dear goodness. And there are tens if not hundreds of people involved in trying to prove/disprove this case and they're all getting some hefty money. What a waste of human intellect and time.


I wonder if it's possible to measure energy spent in court cases? One of the things that amazed me about spam was how many resources we spend just transmitting it across the internet, it's kind of tragic when you think about the waste, but also kinda awesome that everything still works, despite relatively poor resource allocation.

The Economics of Spam: http://pubs.aeaweb.org/doi/pdfplus/10.1257/jep.26.3.87


You'd have to define what you mean a lot more carefully. Certainly any sort of network transmission costs would be dominated by, say, climate control in the court room.


I think the parent commenter was just using spam as an example of an activity that uses a disproportionate amount of energy compared to it's value.

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)


How many SV angels can balance on a pinhead?


Depends on whether the pinhead is of the steel or investor variety.


When you have to draw the borders between two giant companies, you are going to spend significant resources drawing those borders, but the total time spent may be a very tiny amount of effort compared to what the companies are worth, or the long-term costs of just letting the borders be undefined.


> They're all getting some hefty money. What a waste of human intellect and time.

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.


This article is from 2012 and is very outdated. The "famous 9 lines" are not being contested anymore. Google lost that case. The current trial is about whether Google's copyright infringement constituted "fair use".


I was also surprised to see this here. It needs a (2012) tag in the title at the very least, as this is not what is being litigated right now.


"tag" is apparently not the correct word. I was downvoted for using the same term to point out the same thing for another article recently. No idea what the "correct" word should be though.


Maybe you weren't downvoted over the terminology. Putting the year in titles isn't required if it's an evergreen article (i.e., not news, not timely).


Interesting, thanks that's something I hadn't considered.


One thing I've been thinking about as I've read through the trial:

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?


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-ru...

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.


Which goes to how important these lines are. Google claims to have done a 'clean room' implementation. That is, someone with access to the source, writes down the API. Someone else writes based on the API that was inferred.

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.


The only defense I can see here is that the programmer who "copied" the code was the one who wrote it for Sun in the first place. He wasn't working from the API spec thrown over the wall, he was doing it from memory.

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.


How much liability should google have given that one of their trusted employees broke the trust? The speed of software development depends on trust. If companies start to scrutinize every commit, then development would come to a screeching halt.


It taints the whole project. Its a serious flaw, if you've watch silicon valley, the whole bit about him doing a slight thing on a company laptop, and now that company would own the whole project. Its that.


I mean, that's basically what code reviews are, and they don't bring anything to a screeching halt.

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?


Slightly tangential: You have your history slightly off.

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.


No disrespect intended towards the GNU project. I'm aware that they precede Linux and am grateful for all the work they've done. I was specifically recalling having read Linus' original announcement[0]:

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_...


Bash is also a GNU tool. It was written from scratch in the GNU project as a replacement for /bin/sh, the original Unix Bourne Shell.


IANAL but I believe imitation to ensure interoperability is covered by fair use clauses.


Clean room implementations are more than fair use, aren't they? IIRC it's how most IBM PC clones got their BIOSes.


The difference here is that Google was not trying to ensure interoperability with anything, they just wanted to mimic Java to attract developers.

Is that true? Can't you use several Java packages (at least in source form), IDEs, etc. with Android?


Sorry, i removed that bit from my comment because I thought it was a bit too biased, and tbh I wasn't paying too much attention to Android when it started, so I might be wrong and everything.

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.


My understanding is Android already used Java when Google acquired it.


Yeah, but the switch to Dalvik (which is where the trouble starts) was done under Google.

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.


Yes. A good though old (1992) example is Sega vs Accolade.


Sega v Accolade, the expression whose copying was deemed "fair use" was actually object code copied en route to discovering the programming interface for the Sega. The interface itself was deemed by the court to be "functional requirements for compatibility with the Genesis console – aspects of Sega’s programs that are not protected by copyright", and which Accolade had a right to access.


Ssssshhh! Oracle is listening. Don't give them any ideas, or they may go after Gnu/Linux next.


Wow, this is legal bullshiting beyond comprehension. It is the equivalent of one engineer copycating the way another engineer moves his arm when fastening a screw. To give anything beyond 5 minutes attention to this in a court is an insult to society.


Yes, there's a concept in law called "de minimis", short for "de minimis non curat lex": "The law does not care about trivial things". Google argued that rangeCheck was "de minimis".

http://www.groklaw.net/articlebasic.php?story=20120802030811...

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.


"Has Oracle proven that Google's conceded use of the following was infringing, the only issue being whether such use was de mimis"


It's akin to copywriting the pattern of wood and bricks used to build your house.


I likened it to my architect spouse as copyrighting buildings for having flat walls with door and window sized openings. A win for Oracle would have every construction related company designing doors and windows in proprietary shapes.


More relevant information: "What are the 37 Java API packages possibly encumbered by the May 2014 Oracle v Google decision?"

http://stackoverflow.com/questions/23583968/what-are-the-37-...

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.sql


I thought it "not obvious to a practitioner of the craft" was a requirement for a patent no? Give 10 programmers the task to write "rangeCheck()" and you'll end up with very similar looking code.


Although this case relates to copyright, I feel it worthwhile to note that in patent-lawyer-land, what you say does not work so much.

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.


So basically an alternative universe is where these claims are decided?

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.


Yes, totally. Patent drafting and patent litigation in this field has almost nothing to do with reality.


This is regarding copyright. But you are correct, if patents were in dispute this (alone) would fail.

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.


Yet, who decides? A pro-IP court powered 'industry' in East Texas that keep entire towns afloat? It seems counter to their financial wellbeing to be critical of IP claims because then we'd all assume a loss in most cases and this stuff would never go to court (mediation would probably solve most issues).

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...


This concerns copyright, not patents.


Especially if you give them the detailed requirements for 100% compatibility. There is only one way to write that method such that the same exceptions are thrown with the same error messages for the same input.

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.


That part is a copyright claim, not patent claim.


am I the only one that when looking at the implementation sees that there is a major flaw in the code?

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.


Also the code isn't syntactically correct:

    (int arrayLen, int fromIndex, int toIndex {
Missing parenthesis after toIndex. Something is fishy here.


Maybe it's transcription error. Probably a paralegal somewhere copied it from the original source to a different document and doesn't have the programmer's eye for noticing minor differences in what would basically be line-noise to them.


Someone copied it by hand, most likely.


Ranges are usually specified with the lower bound being inclusive and the upper bound exclusive. In this case [fromIndex, toIndex)

So if the range goes to the end of the arrary, then you would expect toIndex == arrayLen and the check is correct.


Is that consistent with the first condition in the function? This function accepts fromIndex == arrayLen if toIndex == arrayLen. Of course, there may be a precondition that rules it out, or it might be an acceptable postcondition.


Under the scheme described, fromIndex == toIndex would be a stretch of 0 array elements, so it wouldn't really matter whether fromIndex and toIndex pointed into the array at all.


Doh! - thanks.


Are upper bounds not generally exclusive in Java? I've been writing almost exclusively C++ for the past few years so I can't remember, but in C++ APIs are almost always set up so that you can pass the length of the container (or, equivalently but much more commonly, the end() iterator, which points just past the last element) as the upper bound of a range.


Without looking back at the article, I am willing to bet that Josh Bloch did not make that mistake.


agree, should be if (toIndex >= arrayLen)


If an index of of the closed interval 0...arrayLen-1, then no.

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.


Incredible. The amount of money being set to the fire for the sake of something that even a student knows is utter crap.


Considering this case is probably not influencing the US dollar inflation rate, nothing is being set on fire -- it's just being moved from Google's + Oracle's pockets to Google's + Oracle's _lawyers'_ pockets :)


Well, people-time is certainly being wasted.


So really, this is like a current flow, with dollar bills. lol


Sort of off topic, anyone know who's this Tim Peters who created the TimSort? Python docs and Wikipedia[1] has virtually no bio for him even though he's very well known Python contributor and his code becomes a legacy in this billion dollar lawsuit, among other things(like Zen of Python[2]).

[1]: https://en.wikipedia.org/wiki/Timsort

[2]: https://www.python.org/dev/peps/pep-0020/


The worst part is that the programmer only "stole" these lines as he was contributing an improvement back to the OpenJDK and wanted his stuff to be compatible. Which adds one more level of absurdity.


Yeah, a bunch of jurors will be ruined financially while being forced to watch billionaires fight over how to best split up their empire. Sortition is how you spell slavery in the 21st century.


As a software engineer, I get sad when I read news like this.


It's not news because the article is old. 2012


This code is ugly anyway:

    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);
    }
Missing a closing paren in the function prototype, among other things.

    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);
         }
    }
There you go Google, Oracle, et al. I release this snippet under MIT / WTFPL / CC0. You're welcome.


I'd use whatever Java's printf equivalent is for the IllegalArgumentException too. Sting concatenation like that is an eyesore.


Good point. Updated.


Careful, they might sue you.



That was good haha. Gotta wonder how many were made up.


When the content of a trial are 9 lines of code then of course the topic are not really the 9 lines of code. It's just a way to gain something else. Everybody involved probably knows that.

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.


(2012)


You're right. Please, someone update the headline.


That has to be a joke. By pursuing this Oracle just makes themselves look like idiots to anyone who actually has an technical knowledge.

So, they're idiots.


Oracle has long looked like idiots to people with technical knowledge.

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.


> "They're getting their ass handed to them by Azure, AWS, and Google Cloud for this very reason."

I'd add PostgreSQL to that list, they're clearly concerned about the risk it poses to their core business:

http://www.postgresql.org/message-id/CANNMO++6tPiwBv2OKcy-Hh...


"I May Not Be Totally Perfect But Parts of Me Are Excellent" - I think this is a useful article to read when considering the 9 lines of code, because copyright law tends to treat novels, pop songs, and software code as the same: http://fairuse.stanford.edu/2003/09/09/copyright_protection_...


This is total FUD. (EDIT ND: because thoses lines of code are already out of every discussions to be held in the current retrial, they are already ruled out the only remaining question is fair use)

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?


[flagged]


Accusing other users of astroturfing is not allowed on HN. If you think you see genuine abuse, you're welcome to email us (hn@ycombinator.com) so we can investigate. But slinging such accusations to score points in an argument isn't allowed. Usually people do this merely because they don't like someone else's view, and that's not a legitimate move to pull in a discussion here, no matter how wrong someone else is.


My apologies


Says the guy paid by Google. Tell me, when Alsup issued his "name your shills" order, was yours amongst those Google released? I certainly see you (or at least your handle) commenting on various Google-related threads here and on Ars.


I didn't want to citation here but here is what he wrote about your point. Again, if you have proof he is a liar share it no problem, but please don't blindly accept and repeat mainstream opinion without seeking information by yourself first. http://www.fosspatents.com/2016/05/the-biggest-problem-for-o...

Quoting Mueller

Please bear with me while I'm repeating the following: I haven't done any work for Oracle in quite a while, I have no reason to assume today that I'll ever do any again (I'll release two game apps this year and that's my professional future), and I have taken consistent positions ever since the case started. This lawsuit was filed not long after I had been fighting against Oracle's acquisition of Sun Microsystems on the antitrust front. Despite having embroiled in a bitter fight with Oracle, I realized early on that Oracle had a point here (though I usually like Google a lot, especially Android). I still hold those views even though working with Oracle on standard-essential patent matters is a thing of the past for me.

An opinionated, independent view is not "propaganda" by any stretch of the imagination. This blog got copyrightability right when Judge Alsup got it wrong, and three higher judges than Judge Alsup totally agreed with me (and the top U.S. court didn't elect to hear the case in order to disagree). The truth is on my side, not his. And when all is said and done, people will see that this blog also got "fair use" right to a greater extent than he did/does.


> This blog got copyrightability right when Judge Alsup got it wrong

That remains to be seen. The blog got copyrightability the same way the Federal Circuit decided that the Ninth Circuit would have ruled [0], and the Supreme Court declined to review that interlocutory appeal. But the final judgement is bound to also be appealed, and its much more likely that the Supreme Court will take the case after final judgement -- at which point we'll know who got copyrightability right [1], since either Google will be appealing a judgement against it on Fair Use where copyrightability will be a necessary issue to resolve or Oracle will be appealing on Fair Use and Google will be cross-appealing on copyrightability.

An appeal being interlocutory is a factor agains the Supreme Court taking it, and quite likely a significant factor in why the Supreme Court didn't hear Oracle v. Google.

For Mueller to claim he got copyrightability "right" because the Federal Circuit agreed with him is premature.

[0] on issues that aren't the ones that force an issue into the Federal Circuit (particularly patent), the Federal Circuit is supposed to apply the law of the Circuit which otherwise would have heard the case.

[1] at least, to the limit of "right" within the US legal system.


"I haven't done any work for Oracle in quite a while,"

AFAIK, he now gets paid by someone oracle pays (and strongly supports oracle), and before that he was getting paid by someone who strongly supports oracle and so didn't need oracle's money. So this is technically accurate but still not what most people would consider being honest.

"This lawsuit was filed not long after I had been fighting against Oracle's acquisition of Sun Microsystems on the antitrust front."

This i know to be practically false from personal knowledge, having been involved in the review.

I'm sure, like the previous statement, there is some crazy view in which it is technically correct but not, again, what most people would consider being honest.


Clearly he consistently sided with Orcale thought all this case. And I think it's totally ok to consider that he's not independent and very subjective.

But by following he's blog since a few years I often found very interesting insights about the trial. And i think it's important sometimes to be open to counterpoints.

While he can be very irritating when he touts out loud that he was right against every other analyst... We should conceded that he was remarkably good at predicting the outcome of the appeal.

And while i don't agree on him on every points I'm pretty sure that the ruling about copyrightability of API is a very good one and might one day prove beneficial to the FOSS community.

People often tends to mix up concept like Free/OpenSource Software and don't really get why licensing published code (even under WTFPL) is very important to keep projects rolling. I give to Mueller that he's probably better than many to understand complexity's of theses matters.

On the other side the linked article of this thread is a giant misinformation as it use the most dumb and old argument Oracle used in this trial even thought it already have been ruled out years ago.

EDIT: On a side note, I personally use PostgreSQL daily and wont recommend OracleDB to anyone as of nowadays.


"hile he can be very irritating when he touts out loud that he was right against every other analyst... We should conceded that he was remarkably good at predicting the outcome of the appeal."

I'm not sure what analysts you are talking about. Since the appeal was to the federal circuit, pretty much everyone i'm aware of thought google would lose hard.

"And while i don't agree on him on every points I'm pretty sure that the ruling about copyrightability of API is a very good one and might one day prove beneficial to the FOSS community. "

We are going to really strongly disagree on that.

"I give to Mueller that he's probably better than many to understand complexity's of theses matters."

I also see no evidence this is correct either. He pretty much has no insight into the way people work in any real basis, only what he thinks he can sell to people.

He has literally no real software experience, he was a writer :)



Uhm. That code wouldn't even compile...


First though I had. I wonder who's responsible for the typo -- the journalist, Google, or Oracle?


> Every company tries to control its developers’ actions, but does management really know what goes into the software?

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!"


Actual code aside, I would think this should strike fear in the hearts and minds of any dev who wishes to change jobs and doesn't change industries / product type. I would think that push come to shove employers will opt for less direct experience, else they'll fear "a temporary measure" they didn't ask for. That is, suddenly, experience might not be as valuable as it used to be.


I'm pretty sure I've seen

  }
before...


Thankfully the patent system didn't exist when the number system was developed. Otherwise one would need to pay a royalty for counting.


In the university I graduated, the professor definitely will mark plagiarism and give an F, unless a strict rule of sourcing followed. Most openjdk source has the first line a usual header. Maybe I am a late student of JDK. or may be there the court may prevail an exception. Finally you have to consider yourself what do we mean to contribute to open source?


>if i is between 0 and 11 before retrieving the ith element of a 10-element list.

Shouldn't i be between 0 and 9?


Reminds me of all those court cases of 'stolen' logos, using a small and fixed set of geometric primitives, the probability of coincidences is just high that way. Of course, some people believe all art is immitation and nothing ever gets created from first principles.



Code aside. This should strike fear in the hearts and minds of any dev who wishes to change jobs and doesn't change industries / product type. I would think that push come to shove employers will opt for less direct experience.


Does anyone have an idea what is really going on?

I'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?


Am I reading this correctly that it's actually buggy?

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.


The resonance with left-pad and the questions of "how exactly to we share super simple code" evolves through so many different prisms. From legal to organizational to not invented here to...


Is it just me or does this code seem to have an off-by-one error (i.e. throwing on toIndex > arrayLen and not toIndex >= arrayLen, given that the lower bound check implies zero-based arrays)?


Interesting that these 9 lines were apparently re-typed by hand, or possibly even from memory.... or so I suppose based on the missing close-paren on the first line...


There is a lot of vested interest in this case and I do not know the author of this article. Are we sure the claim is down to the implementation of this function?


A void function that does nothing but throw exceptions. Scala engineers everywhere cringe at the thought of converting this kind of code to native Scala.


Who cares? We are talking about Java, were is perfectly fine to do "*check()" methods that signals errors through exceptions.


Thanks for wasting course time on non-sense like this. Things like this squatting our legal system and yields absolutely nothing.


  > Google owes Oracle between $1.4 billion and $6 billion in damages if liable
In what damages, exactly?


Perhaps, someone should make a software that checks code to see if it is infringing any copyright. :)


I would leave my last comment, doing 'cheap things' is/are habitual.


I bet you can get a similar code from BSD, EMACS, Ingres, or any venerable open source codebase and use it as prior art against that patent claim.

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.


One billion dollars per line.


This case is not about RangeCheck, is about the 37 Java classed declaration


Is this what the whole case rests on, or is it just one of many details?


Naively, that's $200 million to $800 million per line of code.


wow, each line costs nearly one billion dollars


tldr -

  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);
  }


This like saying we found a brush stroke in your painting that you copied from Picasso, look at the details of this one stroke you copied it's the same!!!

Utterly absurd...


You may want to start lines with (at least) 4 spaces for HN to preserve original formatting.


2 spaces are all that's needed.

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.


Pretty sure that the only reason they copied that code was that they didn't know how to do it themselves.




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: