My Thoughts on Oracle v Google | Hacker News Reader

My Thoughts on Oracle v Google

blog.headius.com

606 pointsdochtman82 comments

This brought myself into a grand realization.

I've always anticipated that the right thing for myself would be to pass any opportunity to contribute to any patent applications should I ever "invent" anything potentially "worth" patenting. I have seen that patents greatly harm the software ecosystem and I don't think I would ever want to take part in any of that.

However, now that I think about it I will never even consider. I'll just say "No" right out of the way, and walk away from the opportunity as quickly as I can.

I announce that, as of today if my current, at any time, employer happened to be patent-unfriendly, only file defensive patents, never litigate anyone, and perhaps win some patent trolls because of their accumulated defensive intellectual "property" I will still say "No" to getting myself involved in any patent application. Even if I was offered a bonus for that. Or a job.

This whole Sun vs. Oracle thing made me realize that software patents are categorically undesirable.

Patents are like guns. Maybe so because I'm a pacifist. Now: sure, you can buy a cabinet full of rifles, shotguns and pistols to defend your house on the prairie should the evil gansters arrive. However, if they do and succeed in taking over your house, then they have the guns. This is exactly what has happened here. And with companies desperate for money, it's probably easier than robbing a house.

Thus, there's no such thing as a defensive patent: patents are all offensive, even if most of them (software patents) are bogus. While a good-spirited company or person might choose to not exercise the monopoly granted by patent law, it only postpones the inevitable unless the patent expires before that.

Similarly, there are no defensive guns. All guns are designed to wound or kill people. All patents are designed to take away other hackers' freedom to make the world better. I'll reconsider my stance when I see the first useful software patent and when all the useless ones are revoked.

While I think the gun analogy was a little superfluous - perhaps because we clearly look at the gun situation differently - I completely agree with you otherwise. Software patents, even if "unused", are a threat lingering above your head like a guillotine. Even if the person in charge of that guillotine promises you they'll never let it drop, you'll probably not put your head under there for fear of what could happen.

Sun guarded the guillotine. Oracle "bought them out", and now they have the guillotine. Google put its head under the guillotine. Now we get to see how sharp it is, and whether Google brought body armor.

And you questioned his analogy?!

(Not questioning the point, just suggesting that we all go back to metaphor school this afternoon for a little brush up).

I'm wondering how - if you created something that is potentially patentable - would you "protect" it? Not protect in the sense of "ensure a revenue stream" but protect in the sense of "ensure it's available royalty-free for any future users"?

From what I understand, Licenses (MIT/Apache/GNU) are different than Patents, so it seems that just licensing it wouldn't work. Can you receive a patent and then immediately put said patented idea into the public domain?

I think it's sufficient to publish it as soon as you can. It then becomes prior art that can't (theoretically) be patented later.

Truly an epic post. Halfway through it, I had to come back and upvote it before returning to the article.

Stephen Colebourne's "Oracle, Google and the politics of money" is also a great shed of light on this topic: http://www.jroller.com/scolebourne/entry/power_corrupts_abso...

I kinda agree with Stephen on the damage Oracle does to open source and the added uncertainty for collaborators on the open parts of java. I think Charles underemphasized this aspect.

I finished half my #noprocrast time limit reading it :)

http://www.xkcd.org/743/

Remember when NTP sued RIM and won over $400 million? Their patent for sending email over RF seemed pretty silly at the time too. So, while this is a good article on the whole, it may be a bit naive to assume that Oracle can't win the case on a few simple patents. This case appears to be the only reason they bought Sun, and I suspect they're smart enough not to place a $6 billion bet without some very smart lawyers feeling like they've got a good shot at winning.

Regarding NTP vs. RIM: seems like the NTP patent was, in fact, invalid as will be determined by an ongoing patent office reexamination:

http://spectrum.ieee.org/at-work/innovation/rim-v-ntp-yet-ag...

Thanks for the link. I wasn't aware the patent was still in question. I don't think it invalidates my point, though. RIM was criticized for waiting too long before settling the case, and thus paying 10x what NTP originally asked for. Waiting for the patent office to invalidate the patent takes long enough that it has plenty of its own risks.

Well, one encouraging thing in Headius' post is the indications that Google has been preparing for this for a while (and we know they have deep pockets).

OpenJDK itself took years to gain acceptance from OSS purists

Recent events seem to indicate the "purists" had a point...

it's important to point out that OpenJDK actually is safe. The Java specification has a patent grant clause for compliant implementations, which obviously includes OpenJDK. We can also hope that Sun did their due diligence during the development of Hotspot and during the open-sourcing of OpenJDK to ensure other patents not covered by the grant would not affect it (but of course we can't be sure).

Outside of that, it's no more at risk of patent attacks then any other piece of open-source software.

> The Java specification has a patent grant clause for compliant implementations, which obviously includes OpenJDK

OpenJDK is safe because AFAIK the GPLv2 license also has a patent grant.

But if you want to take Apache Harmony and trim it down so it fits on a mobile device or on a pen ... the very essence of open-source ... then you're fucked.

If you want to take some idea from OpenJDK and use it in Jikes; a cross-pollination of ideas (not copyright infringement) which is again ... the very essence of open-source ... then you're fucked again.

Java is not an open-platform. It never was.

Taking some patented "idea" from a GPL'd piece of code and re-implementing it in your own separately licensed code is not something that the GPL gives you the right to do.

Your definition of open-platform requires that the code not be covered by any patents. Anyway, the best thing that can come out of all of this is more deep-pocketed players angry with the software patent system.

But my point isn't about what the GPL gives you the right to do.

I don't see the Linux kernel devs getting sued or suing the *BSD kernel devs, although they share ideas all the time.

Also, people scale/modify the Linux/BSD kernel to fit their needs all the time. The Java patent grant only applies if you're not building a subset/superset of Java or if you're extending OpenJDK. But these aren't enough ... some people do not want GPL.

That's what I mean by "the spirit of open-source" ... it's a collaboration effort from which everyone benefits.

And as of this recent announcement, OpenJDK is open-source only by license ... if that wasn't clear already.

Hmm,

A purist might mention that one would like more than bare safety from a platform. If you start using OpenJDK for, say, desktop applications, you wind-up restricted from switching JVMs, adapting a Java JVM for mobile applications and so-forth. IE, you "have less freedom".

Personally, Open Source is my platform ... gcc, python, ruby, perl are my languages ... now with exciting new developments like Rubinius, Pypy, LLVM and Parrot.

Java always had a certain appeal to it, and I've given this platform 2 years of my life ... but the corporate stench just won't go away.

And here it is again, the owner of Java ... instead of redirecting resources to Java 7 which is a crippled release already, they are starting lawsuits.

"But I think the real damage will be in how the developer community perceives Java, rather than in any lasting impact on the platform itself."

A change (for the worse) how the dev community perceives a platform is (or will lead to) a significant impact on the platform?

Or is he saying usage in big corps (where devs don't decide the platform, mangers do) won't be affected?

Minor nitpicks aside, decent essay!

I think he's saying it's not actually going to kill Android or any other Java-based platform (like some people fear), but it might make some people a little more skittish about embracing the platform and it might drive OSS development to a platform whose rightsholder doesn't go around suing people for trying to create their own version.

I think it's likely a strategic cross-licensing play, which is to say that Oracle have found they read on one or more patents held by Google and are knocking on the front door with a sledgehammer.

From what little legal knowledge I have, I think you don't go looking at your own patents that way, because then you are knowingly infringing, which means you would pay more damages.

It's simpler: they just want to shake Google down for some cash.

Do you mean go looking at other's patents that way, because then you're are wilfully infringing? You're pretty right, but in my experience the flow is more like:

a) "Invent" X.

b) Can we patent it?

c) Opps. We read on someone's patent.

d) Risk assessment: Will any one notice?; EV(X) > cost of future lawsuit?; EV(X) > cost of (cross)licensing? etc. etc

e) Either make X or forget X

f) (Optionally, but for bonus MegaCorp points.) Try to patent X regardless.

Edit: I guess there's a reason the only things I've ever seen in writing from a patent lawyer is a) an invoice, and b) a patent application.

I saw one interesting idea proposed on another blog: What if Oracle wants a license to BigTable in return for letting the Java patents out?

Then Google lets the court decide instead.

Imagine someone sues you for spilling coffee on them. They are willing to settle if you cut your hand off. You disagree, go to court, and the court awards the plaintiff twenty bucks. Same thing happens in the corporate world, too.

Honestly, Oracle's patents should be easy to find prior art for. Nothing in computer science is new, even if a patent examiner or some dude working 9-5 at Sun say they are.

RIM probably thought there was prior art too.

Wondering what you mean by "license to BigTable".

BigTable is using GFS, so it will not be much use to Oracle without GFS. Also, since Google nicely described some of the major ideas behind BigTable in a paper, there are few Open-Source implementations of it. I expect that like many database systems - getting a license is easier than building and maintaining a stable system :)

BigTable seems overhyped to me. When you read the details on the very scarce reported facts (remember, there's no source anywhere to be seen) things either don't add up or don't look that revolutionary. For example their super-secret compression technologies (Zippy in particular.) Also Jeff Dean's talk last year seems to completely miss work on integer compression in the previous 4 years.

Claims on slides and videos don't cut it for me anymore (I used to be borderline fanboy of Google's tech reports, like so many others.) Stonebraker has a great paper analyzing Google's claims with respect to databases (and it doesn't look so revolutionary.) That's why I'd be surprised if Oracle buys Google's hype just like that.

I've been hearing this one quite a bit as well. It could just come out in the form of a non-monetary settlement, a cross-licensing deal for $0.

That Oracle chose to go "knocking on the front door with a sledgehammer" implies they want something fairly big.

Could be patents, yes.

Could be a yacht-load of cash.

Could also be software source code, or data center or fiber access, or search data, could be the search technologies and implementation, could be a partnering agreement. Or some combination of these.

Google knows what they want. Or will soon.

Whether additional information leaks out from either camp?

That's also a tactic that is used when they want the other party to comply without going to court. You make it look overwhelming...

Very good. The patents described really are laughable. An implementation of "fork"? Really?

Patent lawyers who filed that patent would probably laugh at you for talking about kitchen utensils in respect to such an awesome patent idea ;-)

On the subject of kitchen utensils...

One of my favorite patents is for the OXO angled measuring cup[1]. It seems obvious now in hindsight, but was truly unique when it appeared on the market. The uniqueness comes from seeing the volume from both the top and the side otherwise the patent would probably not have been granted.

[1] http://www.freepatentsonline.com/6263732.html

I remember seeing those in the store and thinking -- why didn't anyone think of this before !?

I am not a Java developer, but how is this situation is too much different from the Java/J++/C# issues that were had between Sun and Microsoft? It is a different type lawsuit, and (arguably scary) patents are involved, but it seems to be similarly motivated.

Sun originally developed Java to be a standardized, cross-platform development tool.

The original intent (as I see it, anyway) was to get some market share away from Microsoft/Intel by providing a tool that would allow a program written and compiled once on one platform to run on any platform. (The actuality is that you have to make small changes, but for the most part, this works).

So Microsoft started working on J++, and did/were doing the same thing that they did in the web browser space. They built non-standard extensions that would not be compatible from one platform to the next. Exactly the opposite of what a vendor providing an OS/Hardware combination wants, when the entire idea of the language is to make the OS/hardware a reasonable option.

Dalvik doesn't support certain parts of either SE or ME. I would have to believe that this is the reason Google is unwilling to license; they would then have to comply with one of the (bloated/inefficient) standards. (This isn't because Google doesn't have the cash to pay up).

From Oracle/Sun's perspective, this could easily be seen as a long term threat to the platform. If you have runtime compatibility issues, the ship is sunk. You have reliability issues, as with early C++ implementations (can't use 1/2 of the features); Or you have compatibility issues, as with the current state of Common Lisp implementations (many rock-solid implementations, but things are subtly different from one to the next. Aside: subtly different is the worst type). So from that perspective, that they do not want the JVM fragmented, I sympathize with Oracle.

From the perspective of the patents as described in this article, as a computer scientist and programmer, that these things can be patented is shocking. What worries me, is that I will unknowingly build something which has already been patented.

In particular, the hybrid compilation technique does not seem to be very much different from the methods involved in having a lisp (for example) with both an interpreter and a compiler. It is an interesting technique, and very clever, but how can a compilation technique be patented? Specifically this early in the history of computing. What if someone had patented using assembly instead of machine code, or intermediate representations of code? What if McCarthy had patented the AST? Or if the various ways of implementing regular expressions had been patented? It seems morally objectionable.

I honestly, truly hope that Oracle loses this patent suit.

I probably should have made this clearer, since others have asked the same question.

This suit is unlike the Sun v Microsoft suit in that Microsoft was building a licensed Java implementation, which they actually advertised as being a compliant Java implementation...and then they started making incompatible modifications to it. Not simply to the VM or by adding their own libraries off to the side, but by actually modifying some of the java.* core classes. This is obviously way out of bounds when claiming you're a specification-compliant Java, and as a result Sun went ape all over their asses.

FWIW, even though Android doesn't claim to be "Java", they've kept the core classes they ship API-compatible (and no supersetting) with Java 1.5's.

One difference between J++ and Dalvik is that Dalvik is free software. Another is that the JDK is supposedly under the GPL at this point; this is probably the first time a GPL licensor has sued a free-software compatible reimplementation of their GPL code for patent infringement. It's a new level of "shocking" in this area, although it may not really rise to the level of the SCO case.

Being free in the copyright sense does not affect your patent status as far I understand (unless there is a specific patent grant in the license)

Even without an explicit grant, distributing a product includes an implied license to use related patents. So even under an open source license with no specific patent clause, a company would have a hard time releasing something open source, then suing users for patent violations for using that same something. (They might still be able to sue for violating those same patents in other ways.)

Very good read. I'm not considering myself as a Java developer (even if I wrote some java) neither an Android one and this really helped me to have context and more background about this lawsuit. Thanks !

I suspect if the case was as open and closed and without merit as many are thinking, Oracle wouldn't have bought it.

Google aren't some tiny outfit who are going to fold at the first threat. They have very deep pockets and plenty of lawyers and there is no reason to think that they'd give in easily.

Oracle will know this and therefore we can reasonably assume that they have bought this case with the willingness to fight it (and spend the significant amounts of time and money involved in doing so).

Certainly if the suspicion is that they spent $7.4bn buying Sun primarily so they could bring this case it seems even more unlikely - you don't cough up that sort of money unless you think your case is really pretty strong.

(Incidentally I think the suggestion that this is the primary reason they bought Sun doesn't really add up - it's far too big a gamble and the damages award would have to be vast, way beyond the Microsoft / Sun damages to justify it. Oracle are a proper company with proper products, generally speaking they're not patent trolls and have better things to do with the money than take this sort of punt.)

I'm not saying that they will win it, just that the frequent claims from technologists that their case is without merit fail to explain why a bunch of smart people (because whatever you think of them over this the evidence is that the people running Oracle are not stupid, they are not SCO) with a lot of very smart, very well paid lawyers, were willing to take such a punt when their case is evidently so weak.

This one: "System And Method For Dynamic Preloading Of Classes Through Memory Space Cloning Of A Master Runtime System Process (7,426,720)"

Sounds fairly similar to one of the tricks that ETLinux used:

http://www.linuxfordevices.com/c/a/Linux-For-Devices-Article...

Prior art is not as easy to use as a defense as people usually think. On that topic, I found the talk by Andew Tridgell quite interesting:

" You need to learn to read patents. And that doesn’t mean just the abstract. In fact, many people in the free software community, a lot of discussions on sites like Slashdot, people stop at the title. And they think that based on the title they can say "Ah, that was done by the FooHits Corporation in 1925, therefore it’s not a problem". Right? And it doesn’t work like that. You can’t stop at the title, you can’t just stop at the abstract. "

http://news.swpat.org/2010/03/transcript-tridgell-patents/

Circa 2000 I and another developer at my company implemented two systems which are very good examples of prior art for this patent. Both of those systems are still in use today, and I consider the mechanism to be a standard design pattern for robust SOA components. Reading the claims, the only ones that don't match what we did are the claims that say the system is implemented in Java; ours are C++ and Perl. That should be sufficient to invalidate the patent though, at least in a reasonable world.

It's possible to invalidate only certain claims of a patent with prior art. In theory you would think that if there's lots of prior art of people doing XYZ, then someone doing XYZ in Java because their project uses Java would be obvious and therefore not patentable. In practice the Federal Circuit has taken an absurdly narrow view of "obvious".

I guess that might also answer something I've been wondering since this began (well actually before, but this case has brought it back up in my mind). If you take some people skilled in the relevant art, and just describe a problem to them and tell them that someone did solve it but not how it was solved, you lock them away to do a clean room implementation of something that solves that problem, and then their solution happens to be the same as in some patent... then isn't that a bit of evidence that the solution in the patent isn't non-obvious?

Exactly. In fact not only could you say it isn't non-obvious, you might go as far as to say it is obvious.

Was the code published?

Not externally, but there's plenty of documentation and version control history internally, and many witnesses who can attest to the accuracy of those records. That may or may not be sufficient evidence of prior art.

For the Perl implementation, the basis of the design came from the book "Network Programming with Perl" by Lincoln Stein. I'm pretty sure he covered the basic "accept a connection and fork" pattern, and in the Perl world the big benefit of the pattern is the pre-loading and compiling of modules/classes that the forked process is going to need. So that book probably contains sufficient published prior-art.

It is a bog-standard technique in the mod_perl world.

For instance chapter 10 of Practical mod_perl is titled, Improving Performance with Shared Memory and Proper Forking. Guess what that was about? This was published in dead tree format in May 2003, before the December 2003 filing date for this patent. And it appeared in online documentation before that.

Charles' main take-away point, at the end of the article, is that for 99% of Java developers this law suit should have no effect at all, except that it might stifle the future of the Java platform. So, maybe we just have JDK 6 forever.

Since I find myself switching between Java/Clojure, Common Lisp, Ruby, and Scheme (and would like to be better at Haskell), I am not losing any sleep over this law suit. If Java stagnates, I'll just slowly migrate to new languages.

Even if Oracle and Google settle in some peaceful way (best outcome out of the likely ones), it is very likely Oracle will continue this avenue of profit. Perhaps IBM is next, given the long time hostilities among both. Or the Android-based handset manufacturers and sellers. There's a lot of shakedown money to be made for Oracle. And it is probably even lawful in spite of it being labeled as morally wrong. Good luck.

IBM is safe, since they've played by the rules and since they have an even bigger patent bat than Oracle does. There may be tensions, but probably nothing we'll ever see from the outside.

I think other OSS Java implementations are safe too, because: a. they don't harm Oracle's business in any substantial way (nobody's using them), and b. there's no profit in going after them.

If you start to look at everything Oracle does through the lens of "profit above all else" the clouds become a little less cloudy.

Safe now, but for how long? What about upcoming versions? What about relicensing? What if they are breaking some fine print? It's not that easy.

As the article says, IBM's JVM is an officially licensed (and sanctioned) implementation, meaning they had Sun's / have Oracle's permission. So what could they be sued over?

I'm a complete outsider of the subject, but with complex licensing and trivial software patents there's often something overlooked, some clause. One of the comments there mentions incompatibilities in classlibs.

Well, buying a license that doesn't actually fully cover what you are buying would tend to not make sense.

Oracle going after IBM and its huge patent portfolio has about the same chances as a gerbil attacking a tiger. Theoretically possible, but not a good idea.

Eminently true. Even with the acquisition of Sun's portfolio, Oracle is still dwarfed by Big Blue several times over.

Suffice it to say, IBM has had the most patents granted of any American company for the past 17 consecutive years as of early 2010: http://www.networkworld.com/news/2010/011210-patents-2009.ht...

Certainly an unknown quantity must be quite specious, but the sheer cost of fighting the number of patents they could counter-attack with would probably bankrupt Oracle, not to mention however many turned out to have merit.

"a gerbil attacking a tiger"

Very apt description of the SCO vs. IBM law suit, with the predictable result.

You are reflecting on hindsight. Also, SCO didn't happen to own Unix. That was why they lost, IBM's size didn't affect the outcome as much as the particular details. Oracle owns rightfully Java and all its related patents.

AFAIK, Oracle can pull a low blow like not licensing Java to IBM next time or perhaps more subtle putting ridiculous clauses for new standardized versions. They can even do so with popular support by switching to Affero GPLv3, for example. IBM would never run something like that license due to the patent-related characteristics of it.

I wouldn't underestimate Oracle.

It isn't the corporate size that is the issue, it is the size of the patent portfolio that IBM has. I would not doubt IBM's response to any of your scenarios is to find 10 or so patents key to Oracle's database software and file a patent infringement case.

I don't think we are underestimating Oracle, we are just given IBM their due.

  >>> "a gerbil attacking a tiger"
  > It isn't the corporate size that is the issue

Argh.

And note I originally gave IBM as an example of just ONE possible target after Google. So you selectively challenge one point and then even on that point dismiss the other issues (like the "low blow" argument where Oracle doesn't even have to sue the target, be it IBM or some other deep pocketed corporation.)

I admit to a bit of confusion on your response. I was pointing out in the "low blow" scenario that Oracle is much more vulnerable than IBM to a contest of patents. Oracle might not be suing in your scenarios, but that wouldn't stop a suit by IBM.

The crux of this whole thing is that Google isn't using the GPLed version, wasn't paying a license fee to Sun, and isn't to Oracle. Oracle believes Google should and (probably after failed talks) is filing a lawsuit. IBM and Blackberry payed to license like other companies. So, Oracle really has no reason to sue anyone but Google.

I think the patent "Interpreting Functions Utilizing A Hybrid Of Virtual And Native Machine Instructions (6,910,205)" is a important arsenal, dalvik or alternate implementation would need to grow to this level some point in the future.

cutting access to a growth path can hold back development of the android platform

It sounds to me like it would be easy to circumvent, just like JRockit does (as describe in the article): instead of mixing interpretation and JIT compilation, have different levels of JIT compilation: cheap and unoptimized vs. slow and highly optimized.

Could someone explain what the heck "One of the big contentious items is the addition in Java 5 of parametric polymorphism as a compile-time trick without also adding VM-level support for reifying per-type specializations as .NET can do." means for a language implementation layman?

"parametric polymorphism" is fancy way to say "I'm declaring a type that is composed of other types".

The canonical example is a set.

In C# (that's what I'm familiar with) we have IEnumerable<T>. It represents enumerating over some homogeneous set of type T.

so when you write "var myList = new List<int>() { 1, 2, 3 };" the type that gets written down in the bytecode is List<int> (which implements IEnumerable<int>).

So the statement "typeof(myList) == typeof(List<int>)" returns true. The type you specified at compile time doesn't loose information at runtime. (For instance you can also do typeof(IEnumerable<>).MakeGenericType(new[] { typeof(int) }), which gets the Generic Type Definition and then you can fill that in at runtime).

The Generics implementation in Java 5 however was all a compiler trick. All the benefits only existed in the AST of the compiler, they never got down to the runtime. So it was easy to check that you couldn't add a int to a strongly typed list of strings, but only in source. (I think, I'm not as well read as javac / JVM internals)

Hopefully that helps.

So it was easy to check that you couldn't add a int to a strongly typed list of strings, but only in source. (I think, I'm not as well read as javac / JVM internals)

You're right. Here's Jim Waldo's explanation from Java: The Good Parts:

"the inability to change the VM or bytecodes [due to requirements of backwards compatibility] meant that parameterized types could occur only in the source code. The type system of the runtime hasn’t changed, and doesn’t include generics or parameterized types. What we see in our code as a Set<Player> is seen in the bytecodes as simply a Set of objects."

I think read part of that as well, I just don't do Java dev day in, day out is all :-)

But this got me thinking about compiler tricks in general, and how they can be a good thing.

For instance in C# the keywords foreach, and using are just compiler tricks, as well as the notion of closures.

At the VM level, List<String> is still a list of Objects that need to be cast to String whenever you access an item in the list.

More interestingly, in Java List<int> is a list of objects, boxed ints, but in C# List<int> is a list of int32s, with no boxing or unboxing.

Something hit me:

BSD history is repeating itself...

That was rather markedly different, since it was a copyright suit, not a patent suit. AT&T never claimed that they had patents that forbade using BSD; they simply claimed that BSD could not possibly have been written without violating AT&T's Unix copyrights.

In this case, as far as I'm aware, Oracle is not claiming that Google misappropriated any Java source code, but rather that they violated numerous patents that cover JVM-like technologies. This would be akin to AT&T saying that Linux was illegal because it violated patents it held on Unix.

Huh? Someone changed the title. Is that customary around here?

That was an epically long post. It was good.

It reminds me of the apt quotation (I can't get an authoritative source on it in 30 seconds of searching), "If I had more time, I would have written a shorter letter."

Blaise Pascal: I have made this letter longer than usual because I lack the time to make it shorter.

(There are several variants on WikiQuotes,)

Yeah, it's the first time I've seen Charles rival Yegge's verbosiveness. Good points!

If there was a word for 'text bukkake' it would likely summarize this post.

Reply on news.ycombinator.com