Slashdot Mirror
Declaring Code Is Not Code, Says Larry Page (arstechnica.com)
Alphabet CEO Larry Page says his company never considered getting permission from Oracle for using the latter's Java APIs in Android. Page, who appeared in a federal court, said Java APIs are open and free, which warrants them or anyone to use it without explicit permission from Oracle. From an Ars Technica report (edited for clarity): "But you did copy the code and copy the structure, sequence, and organization of the APIs?" Oracle attorney Peter Bicks asked, raising his voice. "I don't agree with 'copy code,'" Page said. "For me, declaring code is not code," Page said. "Have you paid anything to Oracle for using that intellectual property?" Bicks asked. "When Sun established Java, they established it as an open source thing," Page said. "I believe the APIs we used were pretty open. No, we didn't pay for the free and open things." [...] "Was Google seeking a license for Java?" Google lawyer Robert Van Nest asked. "Yes, and a broader deal around other things, like branding and cooperation," Page said. "After discussions with Sun broke off, did you believe Google needed a license for APIs?" Van Nest asked. "No, I did not believe that," Page said. "It was established industry practice that the API and just the headers of those things could be taken and re-implemented. [It must be done] very carefully, not to use any existing implementation of those systems. That's been done many, many times. I think we acted responsibly and carefully around these intellectual property issues."
If APIs are copyrightable, this will be a huge problem for projects like Wine (which implements Microsoft APIs), and GNU/Linux (which implements Bell labs APIs).
Larry Page states same argument Google has been using in this fight for the last two years. News at 11, back in 2013.
The more strong a type system is, the more one can know about a function only from its type. Therefore, his claim will not stand for languages with very strong type systems.
Example: in Safe Haskell, a generic function whose type is 'a -> a' will have to be the identity function.
Explanation for C++ers: In Safe Haskell, this type is the same as 'template T f(T)', but in Haskell one must specify what interface T supports in the declaration, and not ad-hoc in the implementation. Furthermore, in Safe Haskell one can't simply throw an exception from a function, and one can't do IO unless the function signature specifically says it does IO.
void Sort(Vector f) // This bit here compiles into code that executes in the processor // This line is a comment, it also does not generate code
{
}
Is not code, its the calling convention of that block of code. It is not compiled into code, it does not execute on the processor. Code executes on the processor.
But also Java itself is built on a lot of C++ conventions and apis THAT IT COPIED without license. So if anything Google should have licensed those C++ APIS. The word 'Sort' is not owned by Oracle, the word "Vector" and the API conventions for Vectors did not come from Oracle.
The lawyer is trying to join the two things in one sentence to define equality and mislead a jury.
Someone should go back and look for any examples where Sun or Oracle have copied APIs but didn't have any specific license to use the code behind those APIs.
There must be some example somewhere of Sun or Oracle doing exactly what they are now claiming Google has done...
Or indeed WABI from Sun (now Oracle) that copies the API of Windows so it can run on Sparcstations.
Or Java from Oracle that implements the Berkeley Collections library APIs.
Or Java from Oracle that copies the API conventions of C++.
They really are trying to fool a jury here.
Wow, the bs people fight over..... This right here is what's wrong with the USA.
It's time people's courts stopped ruling in terms of cowporate rights, which are arbitrary handwaving, and instead considered what benefits society most. On the one hand, Larry Ellison is everything bad about public-private partnerships. On the other, Google just did what got Microsoft in trouble with msjvm.dll, but people just didn't like Microsoft, while people like Google, even though Google has taken far more control from people than Microsoft ever gave (before it too went cloudy). On balance, then, fuck the whole collective of spunkpuffins.
Larry Page is systematically ending his sentences with a comma,
IANAL, but I could imagine a case where someone names a method with a copyrighted haiku: void old_pond_CR_a_frog_leaps_in_CR_waters_sound(). (From Wikipedia's example of a haiku translation; I don't know if their example is copyrighted, but you get the point.) In that case, I think it's not an unreasonable case that the API is copyrightable at least in part. In such a case, even code calling the API--not just an implementation of the API--would require a fair-use defense. I would hope such a fair-use defense would be possible.
So, yes, my example shows that it should be possible for an API to be copyrighted, at least in theory (whether java.lang is sufficiently poetic is a different question!). But the example also shows that unless a fair-use defense is possible, programming is really stifled.
Far worse, you will have to watch what you call your functions in unrelated programs, because it might be the same as somebody else. It's a whole new copyright type, not code (the stuff that implements algorithms and runs on a computer) but the name used to describe that code has to be unique.
It's like they'd trademarked the APIs and want to prevent people using the names.
So all that code we wrote calling Windows APIs, which references the API by name,.... all of that code belongs to Microsoft now because we used their API name to call the API.
Don't be evil.
An Ad-hoc one, but part of language nonetheless.
The ENGLISH Language has an API too. You will find much of it documented in a dictionary.
The words are the element of the language; but an API tells you how to exchange messages between two people.
Attempting to have exclusive rights to an API is like a restaurant wanting exclusive rights to phrases such as "GET WATER", or "ONE BEER PLEASE".
So patrons will be sued if they go to a competitors' restaurant and formulate requests such as that
The code does things...... the API is just a functional (non-creative) description of the correct way to interact with the code.
> which outcome is better for society? ... instead considered what benefits society most.
> It's time people's courts
Should individual unelected judges make up laws based on what they think will turn out best?
I (and the framers of the Constitution) think that the legislature and the voters should carefully consider that when they create and pass laws. Judges should then read the law and apply determine how it applies to a particular case. Occasionally, the Supreme Court and other courts have pointed out "this law doesn't work well, the legislature should change it". I think that's the best approach.
* Here I'm not talking about cases in which the legislature tried to create a law which they had no authority to create. I'm referring to laws which the legislature properly passed, within their authority, but didn't do a very good job.
If Oracle wins this case and all the appeals, where it's ruled that using open APIs is copyright infringement, then I would strongly suggest you get into corporate law.
Because the end result is that basically every software company in the world (including not just Oracle and Google but Microsoft, Apple, IBM, Intel, Samsung, etc.) will suddenly find themselves in a Mexican standoff of potentially trillions of dollars in "intellectual property" suits ready to be fired off. The only winner will be the one with the best legal department; oh, and the lawyers.
All the aforementioned companies would be wise to pen amicus curiae letters in favor of Google.
non public domain extendable system that has an API. Even if the current company says it is open one day Oracle will buy that company and sue you for licensing fees. IF API are copyrightable then keywords and statements might be. Nobody should use any programming language that is not public domain until this is settled.
Alphabet CEO Larry Page says his company never considered getting permission from Oracle for using the latter's Java APIs in Android.
Technically, he's correct. But Google did apparently try to get a license of some type from Sun Microsystems. From 2011:
Google: Sun Offered to License Java for $100 Million
Sun Microsystems offered to license its Java technology to Google for US$100 million, a Google attorney said Thursday, attempting to show that Oracle is out of touch as it seeks billions from Google for patent infringement.
...
Holtzman said Oracle has an e-mail from a Google executive to Rubin, the head of Google's Android division, which he said shows that Google recognized it needed a license for Java.
He read part of the email in court: "What we've actually been asked to do by Larry and Sergey is to investigate what technology alternatives exist to Java for Android and Chrome," the Google executive wrote, referring to founders Larry Page and Sergey Brin. "We've been over a hundred of these and think they all suck. We conclude that we need to negotiate a license for Java."
...
Before going to the bookstore, did you copy down the address? Did you copy the address structure of the number, streetname, town and state and enter it into your navigator ("computing device")?
Copyright thief! The address is theirs and you stole it without their permission. Pay pay PAY!
To make the first PC Clone. I wonder how much HP will owe to IBM?
Best Slashdot Co
As long as Page/Google keep talking about APIs & implementations none of this will matter because neither a jury or judge not 'skilled in the art' will have ANY clue. They need to 'map' these ideas to real-world things, physical things would be best, to help the Jury & Judge understand. For example they could use a steering wheel in a car. The 'API' for a steering wheel is 'what it does', specifically 'if you turn the steering wheel to the right it causes the front wheels to turn to the right and thus turn the car to the right'...the actual SHAPE of the steering wheel is its 'implementation', it can be round, square, oblong or any other shape but all steering wheels if turned to the right will cause the wheels to turn to the right...(this may not be the best example, I'm just saying they need to find some real-world example that is more easily understood by the Judge and Jury(*).
On another note, presuming there is a Jury in this phase it seems odd to me that Google has not helped shape the jury to have at least a few of them have programming experience. Perhaps in a civil trial this doesn't apply but I thought both sides got to vet the jury members and approve/disapprove up to a given number of members. At a minimum I would argue that 'jury of your peers' would suggest that there should be some of them that are certified programmers otherwise they are not 'peers' at all.
Or you could be a non faggot cuck and IGNORE the ruling.
Is the United States your god, FAGGOT?
And if they come for you, KILL them.
Why was Google trying to get a license for Java if they ultimately felt they didn't need one? That's right there in the article.
Riddle me this.
Intellectual means "of the intellect" and is thus intangible.
Property has always been used as a nomer for physical items that are clearly in possession, after all possession is 9/10th of the law.
This whole "IP" terminology is thus clearly double speak, and should be avoided. The whole legal constructs around them, be it patents, invention or copyright are only there to not disrupt existing economic structures. They are a philosophical abomination, especially in the digital age, where copying is cost-less, and distribution nearly so. This is true for books, code, movies and basically everything digital IMHO, and in this case even more so.
In this particular case of Oracle vs Google regarding Java "IP" we are talking about API Headers. To anyone with some coding background, API Headers are a description of a system. They are not patentable, as patents require implementation. (In Europe software is considered "math", and atm not patentable at al) They should not be copyrightable, for the same reason that announcing you will write a book about Fire and Ice and Dragons is a description of a book, but not the book itself. This description should not grant you the right to be the sole author of books about Fire and Ice and Dragons.
I applaud Google in this fight, and I hope they fight till they win.
Simple fact is without Java Android does not happen. This has been all stated. Google knew they could tap into a developer base that knew Java as opposed to developing their own language. Google wanted to use their own language but felt it would take too long to develop an eco system.
Ok, I'm going to take a slightly unpopular stance here and suggest that APIs probably should be copyrightable.
Ignoring all the legal issues, my rational is simple: An API spec represents the output of the intellectual effort of the architect far better than any implementation code. Designing a good API is difficult. Doing so requires finding exactly the right abstractions to allow users to use your API to perform complex operations in a simple, straightforward manner. The design process often involves several iterations of implementation to refine the API - not only implementing the functionality, but writing software that uses to to make sure it meets its goals.
The book title/chapter title argument is often used to show why APIs shouldn't be copyrighted. That's a poor analogy. Many books don't bother with chapter titles, so they're clearly not essential to the interpretation of the material. When present, they usually can't be used to quickly summarize a book. A well designed API will clearly and concisely present to you everything the underlying library can do. In fact, you should never care about the implementation of the library. If you ignored the text of a book, you wouldn't really be reading it.
If we're going to look to artistic pursuits for analogies, I'll suggest music is a better one. Melodies and lyrics are primarily what's copyrightable in music. Chord changes and musical embellishments are not. Arrangements are copyrightable when written down. Specific performances are also copyrightable (which is why samples must be cleared for use in other songs). Melodies and lyrics are akin to an API - the instantly let you identify the song/library and are the primary way most people remember it. For example, I can play "Yesterday" on a piano, guitar, speak-and-spell, and it's still a Beatles song. I still owe the Beatles royalties for using their lyrics and melody, regardless of how I arrange and perform it.
Now, if we allow APIs to be copyrighted, we gain a lot of flexibility. Most importantly, the copyright holder can release the API under a free and open license if they want. The designer can say: here's my work, feel free to do with it what you want. Or, they can lock it down and restrict what can be done with it.
For better or worse, Sun wanted the best of both worlds with Java. They implied that it was free and open, but never actually released the APIs under a specific free and open license. In the music world, the "Happy Birthday" saga is similar. The melody and lyrics were thought to be under copyright and Warner collected a few million a year from artists for performing it and using it in their works. Just like the core Java APIs, everyone knows "Happy Birthday" and most people used it casually without paying royalties (yes, I realize not everyone knows Java, but most readers of /. do). With the song, it turned out an earlier version that wasn't under copyright was found, which invalided Warner's claims. Unfortunately, that's unlikely to happen with Java.
tl;dr: APIs are the creative output of the design process, just like melodies and lyrics are in music. They probably should be copyrightable.
-Chris
Oracle knows they are dying. This is a money grab from a sinking ship. It is too bad they took over MySQL, but thankfully there is MariaDB.
FYI: http://www.cafc.uscourts.gov/sites/default/files/opinions-orders/13-1021.Opinion.5-7-2014.1.PDF
There was also another ruling or opinion that I can't seem to locate now.
Per my understanding, the jury was of the opinion that method signatures were themselves not copyrightable because there was nothing creative about it. For example int max(int, int). If a programmer were to come up with declaration of a method that identified and returned the maximum of two integers there are only a few ways to do it that make sense and IMO all of them involve just the name of the function itself, e.g. max, maximum, greater, larger, etc. On the other hand, the organization of such methods and names of packages are much more numerous. For, e.g. sin falls under math. However, the question "shall one further classify (no pun intended) under trigonometry?" can generate a lot of varied responses and arguments. Each of such instances would need to be evaluated individually. Additionally, the jury should also consider whether the defendant had any option to deviate from the plaintiff's API without causing much grief to the consumers of such API
If headers aren't copyrightable, why do headers have copyright statements in them?
Although it’s meant for a machine, I think declaring code is documentation. It’s also somewhat redundant because in theory, a compiler COULD just find the function definitions directly and infer the prototypes. This is true about Verilog, for instance. Declaring code is in the form of code, but it doesn’t represent any functionality, only the interface you use to get access to the functionality provided by the defining code.
That all being said, I hold an unpopular opinion. What Google did should be techinically legal, and it should obviously be possible to develop compatible implementations of operating systems and other software infrastructures. However, Google’s choice to usurp the Java empire totally fucked over Sun. Android started at a time when Sun was still Sun. They were making revenue from Java, and if that revenue stream had continued, the may have been able to avoid going under. Instead, Android totally ripped the rug out from under that part of Sun, and Sun had to liquidate and get sold to to the assholes at Oracle.
So while technically, within the law, Google doesn’t owe a penny to Oracle (in my opinion), what Google did was morally wrong, and there were consequences (surely anticipated by Google to some degree or other) that lead to Sun’s demise.
Yes, if Java was the one thing that broke Sun, then there were bigger problems there, but that doesn’t change the fact that Android fucked over Sun. Basically, people at Sun put an enormous amount of effort into developing a platform independent language and software infrastructure that we have all benefitted greatly, but they never got the chance to reap the rewards because Google took it all away.
What this basically tells me is that unless I’m just a pure altruist and humanitarian and ready to give away all of my hard work for no reward, then I should just not do anything, because all my hard work is just going to be (legally) ripped off by some other company. I’m a huge fan of both using and contributing to free software, but a dude’s gotta eat, and we should have a moral right to get something back from our efforts. Copyrights are FAR too lengthy, and patents are given away for the stupidest shit, but the spirit of these protections is sound in that for a limited time, you should be able to profit from your hard work. Sun’s ability to profit from Java was far too limited, because they were never able recoup the investment. If Google had played nice, then Sun would still exist, and the world would be a better place.
Oh, and don’t give me bullshit about how Google could have chosen a different language. Sure, they could have. Apple sure did, and Objective-C sucks. That doesn’t change the fact that Google’s boostrapping would have taken FAR LONGER if they’d had to start from scratch. And I’m of the opinion that although I hate GC’d languages in general, and they suck battery like there’s no tomorrow, Android apps would be a hell of a lot crashier in general if they’d chosen a language with manual memory management. If Google had made other choices, Java would have remained longer under the control of Sun, and Android would have taken far longer to get off the ground. It’s possible that if Google had taken that route, their software stack would be more mature now and not tied down by the drawbacks that Java has with regard to energy usage.
Lawyers, can't live with them, and too many of them are in too good of shape to hit with our cars
You can own a house. You can't own the directions to get there.
For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
...I miss Groklaw so much. =(
For legal purposes, it seems that there is an extra consideration for C-like programming languages: One can put basically anything into header files, including huge blocks of code. Even the GNU Lesser General Public License makes a distinction in its licensing terms of object files produced using header files that contain macros or static functions more than 10 lines long.
Dunno that I agree with Page's stance at all.
His argument seems to hinge on declarations not being part of the code, and are somehow automatic consequences of the implementation or at best trivial afterthoughts. It seems to me that APIs are actually the toughest part to get right and it takes experience and skill to design a logical, flexible and useful API, Hardly zero value stuff.
I kind of hope the court gets it "right" this time and declares APIs completely and totally protected. Then, when everything comes tumbling around our ears, it'll be obvious that everything Congress has ever written in regard to intellectual property is vague and essentially meaningless.
Doesn't anyone know how to explain this properly? An interface explains how you connect things together. It is a standard, meant to facilitate interaction between components from diverse parties. This particular interface facilitates interaction between java application programs on the one hand, and a java implementation on the other. (and that's why we call it an "Application Program Interface")
Everybody agrees that the java implementation is itself covered by copyright. The interface, however, is not, a fact established, I believe, explicitly by law, and by decades of historical precedent.
An interface is also clearly not the same as 'code'. An interface, all by itself, does not do anything - it cannot be compiled into an executable or a library. It is merely a set of agreements that the (copyrighted) implementation, and the application program, conform to, stated in such a way as to be readable and verifyable by a computer.
Off your meds, coward?
They said they wanted to use the official source code and implementation. They wanted an Apache license for that which Sun refused.
They wanted the TCKs, branding and everything that goes with the licensing.
Google argues that all the design work that people put into figuring out the best APIs for their software systems cannot be protected by copyright. That all that design activity is basically worthless and not worthy of legal protection. I really have no clue how this became the predominant belief amongst software people. Convenience? Stealing someone else's API design is easier than figuring one out yourself, I guess.
Look at the design of the C++ language and its standard library. Think about the huge amounts of effort that Bjarne Stroustrup (and others) put into making the language and all of its API pieces fit together in the best way in their view. Now, imagine that Bjarne's team instead did all that design work only for their own company's use and never intended it for general consumption or use outside their company.
The arguments put forward by Google, and many others, are that if all those complicated, interconnected APIs somehow leaked out onto the internet (e.g. - a disgruntled employee surreptitiously posted them somewhere without permission), then everyone else would be legally free to copy them verbatim and reimplement the backing code without a single bit of permission nor consideration going back to Bjarne nor his company. They are "just" APIs that aren't copyrightable and almost surely not subject to patent protection. Google's approach values all that API design work as entirely worthless and not intellectual property in the least.
That's ridiculous. API design is a HUGE part of software design and development. I'd argue that it is often more important and valuable than any particular backing implementation of the API.
Ok, now imagine a bit different C++ scenario. Stroustrup really likes his C++ language and wants to publish about it, including his specific API design. Does the mere fact that he voluntarily revealed his API to the public (without any license but with a copyright claim), now allow everyone to run off and copy it verbatim again without permission nor consideration back to him? Again, that does seem to be Google's argument and it seems bonkers to me.
Arguing, as the EFF does, that open and free APIs are a good thing that facilitate competition, wide adoption, superior implementations, etc. is one thing. But arguing that all APIs are inherently open and cannot be protected as intellectual property -- that anyone can legally come along and copy verbatim the huge, complicated class hierarchy and interfaces that you designed for your software without your permission nor consideration back to you -- is an entirely different proposition. Authors should absolutely retain intellectual property rights to their specific APIs. They can license them or put them in the public domain as they see fit or not.
Now, the obvious criticism of my stance is that what is to prevent someone from putting and enforcing a copyright on something absurdly simple like C's strlen() function or something similar? Would we have the equivalent of patent trolls trying to extract money from anyone who codes? My answer to that is it would be up to the US Copyright Office and the courts to determine what is fair-use and what is simply too trivial to copyright. For example, a book author's copyright does not give them the right to go and sue anyone who happens to use a sentence that appears in their book, but it does allow them to sue people who reproduce significant sections of their book that go beyond fair-use. The same sort of logic would apply here too.
Software companies will all close shop in the U.S. and move their operations to countries where APIs are legally declared not copyrightable. ... The U.S. will be relegated to a software backwater, as most of the software made and sold in the rest of the world cannot legally be distributed in the U.S.
Something similar to this happened with encryption. The US regulated it as a weapon and banned / limited / added red tape to the export of strong encryption software. US companies also couldn't import strong encryption software, include it in their products, and resell them elsewhere. The software had to be installed outside the US by non-US companies.
The result was that commercial development and deployment of strong encryption software pretty much stopped in the US and picked up outside its boundaries for several years, and various workarounds were developed (such as "encryption with a hole" so a strong encryption module could be installed later).
This continued up to about the turn of the centur, when laws, policies, and court decisions loosened things up enough that US companies could play again.
Bantam Dominique roosters crow a four-note song. Once you've heard it as "Happy BIRTHday" you can't NOT hear it that way
Raymond Chen of Microsoft has often equated an API to a contract. An API has an implementor and a user, just as there are several parties to a contract. Each party expects the other to do certain things (use the API in a certain way) and in return promises other things (to do what the API is specified to do). If one party does not act in accordance with the contract, chaos ensues.
I'm trying to figure out why we assign dumb niggers to juries and elect dumb niggers as judges. Can someone please explain this?
It works like this: Come up with a baseless claim against another company. Take the amount the court could award us, A, multiply by the probability that we can convince the court to rule in our favor, B. A times B equals X. If X is more than our lawyer fees, then we sue.
You forgot: "What counter-claims could they come up against us and how much, C, could they sue for? How likely, D, is the court to decide to award that? Is AxB - CxD still greater than the lawyer fees?"
And then there's: "How big is their patent pool? How big is ours? Do they have any patents that would be really useful for something we want to do? Do we have patents that they might like to use (that won't result in them competing us into oblivion)? Are they open to settlements of the form: 'We'll cross-license our patents, they guy with the smaller pile gives the guy with the larger pile some money, and then we BOTH go back to work - including our lawyers, who use the combined pile to spike our mutual competition (or suck them into a similar deal).'".
Bantam Dominique roosters crow a four-note song. Once you've heard it as "Happy BIRTHday" you can't NOT hear it that way
By "centur" you mean half-man half-horse, right (https://www.google.com/search?q=centur&biw=1289&bih=822&tbm=isch&tbo=u&source=univ&sa=X&ved=0ahUKEwjzlrbu3unMAhUDRVIKHVkKCLgQ7AkIKg&dpr=0.9)? Or is it just "century" / 100 years?
Set to make plenty of money... Clearly not, if it was worth a complete reimplementation to avoid license fees. I think this is a case where you set up a $100,00 toll road and get mad when people pave their own roads to bypass it.
That's fair. It only copies the design mistakes of C++. The good parts they mostly managed to avoid.
This is not about APIs being copyrighted. This is about intentionally, knowingly breaking the license terms / tou for commercial gain.
To explore the terms in question, refer to verbatim Sun v Microsoft case from a few years ago.
centaur is the creature you speak of. "centur" does not exist, at least according to https://en.m.wiktionary.org/wiki/centur
You have good arguments wrt Sun.
The thing bout ReactOS, though, is that the project has (indirect) supported from the Russian government and some of its politicians; so in this case, if Microsoft can (could) throw a wrench into ReactOS deveopment on the basis of copyright alone, then that's fine by me.
Sun's problems were many. In retrospect, one its issues was, that its product portfolio was not particularly diverse, as it lacked a presence in the consumer market.
Imagine, then, if at one time, Sun could have made its own laptops/netbooks (!), and purchased Palm and Danger Inc... Palm phones for businesspeople / advanced users, Sidekicks for younger people. Both able to run Java apps everywhere, and Palm phones able to open and edit OpenOffice.org files. It would have been a trifecta, at least in the U.S.
Elsewhere in the world, Nokia had that segment until Elop, his stupid burning platorm memo, and Windows Phone-only strategy.
tlhIngan here and F.Ultra well describe some of the potential externalities that the case might bring. In this case, I would rather declare a mistrial just to preseve the fact, that headers can be GPL'd, without Google having to pay Oracle large sums of money.
On one hand, GPL headers should continue to be GPL'd, so that software under the GPL license could not be lifted by some hack software company to make their own. This is where I partially support the Oracle stance.
On the other hand, if Oracle wins, then there's the question about who -- if not Google / Open Handset Alliance -- owns Android 4.4 and below, which are affected by copyright infringement claims (given that Dalvik is in these). It would be a potential nightmare for Oracle, if they instead were made liable to keep lawsuit-affected Android installations secure.
By "centur" you mean half-man half-horse, right
Only if he did something in my keyboard to make the Y key intermittent.
Bantam Dominique roosters crow a four-note song. Once you've heard it as "Happy BIRTHday" you can't NOT hear it that way
Oracle is a database company that makes lots of money by selling software with a standard SQL interface.
I wonder if Oracle copied/used/reconstructed an API to make this flagship product?
If so, this would be much worse than Java.
Sun wanted folks to use Java because this made Java more valuable to Sun.
I'm not sure the case is the same for IBM and SQL.
Nothing launched Israel's IT businesses like the US's anti-competitive regulations. We'd never have Allot (and dozens of others) if the US hadn't run off tech, and those that work on it.
Learn to love Alaska
In actual fact there is no such thing as a right to "intellectual property". The very idea is relativly new, less than a thousand years old. Before that there was no such idea.
The copyright and patent laws came about as a "fix" for ideas and tech being lost when people died. As in: Disclose your trade secrets and we will protect you from loosing your business. So, many ideas were documented and shared and tech took a really big surge in development that is still going on.
We have the laws because they work and make everyone better, but that does not mean it is an inherent right. Actually ideas are like breath, once you breath out it is gone and you have no more claim to it.