Oracle v Google judge drops a bombshell: He's a programmer and won't be fooled by technical bullshit

[JustExtreme]

[QUOTE=download;35991579]Judges should, in theory, be versed in what they're making a decision over[/QUOTE]

Yeah so are politicians and look what we end up with :)

[meppers]

photo of judge in question:

[IMG]http://static.fjcdn.com/pictures/Meeting_2ea313_285717.jpg[/IMG]

[Bobie]

[QUOTE=JustExtreme;35992546]Yeah so are politicians and look what we end up with :)[/QUOTE]

politicians arent versed in anything other than politics

which is why they are generally very clueless unless they need to raise an election campaign

[Van-man]

[QUOTE=JustExtreme;35992546]Yeah so are politicians and look what we end up with :)[/QUOTE]

Show me a politician who's both bad AND also actually smart.

Rest of 'em are just well versed at licking corporations asses for money.

[AceOfDivine]

Good, all tech related questions should have tech literate judges.

[ZombieDawgs]

I'm seeing everyone saying "That looks untidy" but as a non programmer I'm looking at it thinking "lol what the fuck is this"

[AceOfDivine]

[QUOTE=ZombieDawgs;35992959]I'm seeing everyone saying "That looks untidy" but as a non programmer I'm looking at it thinking "lol what the fuck is this"[/QUOTE]
Okay? It's normal to feel confused when looking at something you don't understand.

[Source]

Why can't the system have Judges that are experts in certain fields and then put them onto the certain cases, what's so wrong with wanting the system like that? it would cut the amount of patent cases in half if they actually had someone who knew in detail the technicalities of the case from personal experience and knowledge. [sp] i am not an expert on the judicial system so if this sounds daft i apologies [/sp]

[mobrockers2]

[QUOTE=inconspicious;35992152]It looks tidier that way, but I have a habit of doing it the other way.[/QUOTE]

I put the curly bracket on the same line as the header, and then a white line in between the header and the contents of the method :/

[Robber]

[QUOTE=inconspicious;35991808]That last curly brackets indentation is bothering me.[/QUOTE]
It's just C&P'ed badly. This is what the original code most likely looked like:
[cpp]
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);

}
[/cpp]

[Penguiin]

[QUOTE=Robber;35993442]It's just C&P'ed badly. This is what the original code most likely looked like:
[cpp]
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);

}
[/cpp][/QUOTE]

it's a good thing you came and fixed it

[Robber]

[QUOTE=Penguiin;35993741]it's a good thing you came and fixed it[/QUOTE]
I know, right?

[Curls]

[QUOTE=calzoneman;35991657]Here's the code:
[cpp]
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);

}
[/cpp][/QUOTE]

I'm severely coding illiterate but, from what I understand, that looks generic/basic as all fuck

Theres no complicated math in there that I see, theres really nothing I see.

Oracle much be having some serious PMS.

[thisispain]

i think everyone should start using that exact coding in their programmes.

[sir whoopsalot]

[QUOTE=J!NX;35994079]I'm severely coding illiterate but, from what I understand, that looks generic/basic as all fuck

Theres no complicated math in there that I see, theres really nothing I see.

Oracle much be having some serious PMS.[/QUOTE]

Speaking as someone with an at best amateur understanding of coding basics, it is. From what I can tell, all it literally does is check whether or not something falls within a certain set range.

[Curls]

[QUOTE=Sir Whoopsalot;35994114]Speaking as someone with an at best amateur understanding of coding basics, it is. From what I can tell, all it literally does is check whether or not something falls within a certain set range.[/QUOTE]

AKA "X # is at X, check it".

Looks like Oracle is desperate.

[Sigfrial]

[QUOTE=J!NX;35994079]I'm severely coding illiterate but, from what I understand, that looks generic/basic as all fuck

Theres no complicated math in there that I see, theres really nothing I see.

Oracle much be having some serious PMS.[/QUOTE]

If/then statements are practically the most basic of all codes.

I took a semester of programming, and this is like... day 1 shit.

[Gmod4ever]

Wow. This is just ridiculous.

I never really paid much attention to this particular case, and I never saw what the actual code was.

That code is so trivial it's not even funny. That particular function is so remedial, I honestly think it should be a core function of Java.

[b]For those who are not programming-savvy, allow me to attempt to explain what that code does, and why this lawsuit is so stupid:[/b]

The first thing you need to understand is that programming is entirely logic-based - if X then Y. That's how programming works. The second thing you need to understand is that programming is very heavy on variable manipulation. Think algebra: 5 + X = 7; what is X? In this case, X is 2. Now if you take that X and add 3 to that X, you get X = X + 3. Substitution in the X in the right-hand side, you get X = 2 + 3 = 5. So now X is 5. The logical "if X then Y" and this concept of manipulating variables are the cornerstones of programming.

Now, in virtually all programming languages, Java included, there is a catch: you can't just use variables willy-nilly. You first have to tell the computer that you will be using a variable, what the name of that variable is, what kind of variable is, and sometimes an initial value for that variable. The reason for this is in how computers operate - the computer has to set some memory / RAM aside for that variable, and keep it for ONLY that variable, so nothing else uses it.

This works just fine for many cases. For example, if you want to have a function that, when called, adds three to a variable named "MyVariable," then you could simply have a function do "MyVariable = MyVariable + 3" or "MyVariable += 3" (these are the same; the right-most version is a shortcut method most programming languages allow).

However, what if you don't know how many variables you are going to have? Let's say you have a program so people can look at different models of cars to buy. Now, imagine that a new car is made available, and it needs to be added to the program. When that program was made, this car wasn't even conceived, so there is no variable sitting for that car's mileage, price, and all that stuff you want to know when buying cars. So, what do you?

One solution is to sit down and rewrite the entire program, with variables for that car put in. But that's not very practical. The other solution is a variable that allows you to put things into it, and take things out of it, at will: such a variable is called a "table" or an "array."

However, like variables, in most programming languages, you can't just use arrays willy-nilly; you have to tell the computer that you are making an array, the name of that array, and what type of stuff you're going to store in that array. In addition to that, though, you also have to tell the computer that maximum size of that array*.

Much like variables, this is because the computer has to put memory / RAM aside for that array, so nothing else uses that memory and causes problems. This is because an array is really just a bunch of variables put in one place. Let me show this, by way of example.

[b]Method 1: Variables.[/b]

int Var1 = 5;
int Var2 = 7;
int Var3 = 9;
int Var4 = 2;
Int Var5 = 0;

[b]Method 2: Array.[/b]

 int[5] Vars = {5,7,9,2,0}

These two function do exactly the same thing: in both cases, you have five variables, with the values of 5, 7, 9, 2, and 0. The only difference is the first method defines each variable by itself, and the second one puts them all inside a single variable. In both cases, you have 5 of them, and so you have to tell the computer to make room for 5 variables.

[b]NOW[/b], with that in mind, some restrictions are placed on arrays in most languages.

Firstly, because you have to tell the computer how big an array is (how many variables it holds), you will run into issues if you try to make the array bigger than you told the computer it is - the computer gets confused, and it kicks up a tantrum by erroring at you, because it doesn't know what to do.

Directly related, if you try and access a variable from an array that isn't there, the computer gets confused and kicks up a tantrum because it doesn't know what to do. Imagine that you're visiting a friend, and he tells you to pick up the box of tissues off the coffee table, but there's nothing on the coffee table. You try to tell him that there's no tissue box, but he INSISTS that you grab the tissue box off the coffee table. No matter how many times you try to tell him there is no box of tissues, he keeps telling you to pick it up - you quickly get frustrated with him, because there is no tissue box.

The same thing happens with the computer, when you tell it to grab something in an array that isn't there. And, like when you try to make the array bigger than you told the computer it is, it gets angry and errors.

It is also just a fact that arrays start indexing at 0, and for each variable, goes up by 1. So the first variable is index 0, the second index 1, the third index 2, and so on. This means that if an array is of size 5, then it's last index is 4 (because you go 0, 1, 2, 3, 4; that's 5.) Ergo, if you tell it to grab something from index 5, which doesn't exist, it gets frustrated and errors at you - just like your friend telling you to grab the tissue box that doesn't exist.

The same issue occurs if you tell and grab something from, say, index -1. Because the array starts at 0, there is no -1, so you're trying to grab something that's not there: the computer gets mad and errors at you.

[b]WITH ALL THAT IN MIND, LET'S NOW LOOK AT WHAT THIS CODE DOES.[/b]

If I were to translate that code into plain English, it would come out as such:

"Given how big an array should be, a starting index, and an ending index, if the starting index is bigger than the ending index, throw an error saying that our starting number is bigger than our ending number. If the starting number is less than zero, throw an error saying our starting number is less than zero. And if the ending number is bigger than how big our array should be, throw an error saying that the ending number is bigger than how big the array should be."

That is literally all that code does.

* There are exceptions, using dynamic memory. However, I'm not going to get into that. Sticking with the basics here.

[sir whoopsalot]

[QUOTE=J!NX;35994177]AKA "X # is at X, check it".

Looks like Oracle is desperate.[/QUOTE]

Maybe more of a 'is this still in a physically possible space? If not, BEEEEEP! ERROR!'.

[Virtanen]

[img]http://cdn.abovethelaw.com/uploads/2012/04/WilliamAlsup1.jpg[/img]

He looks kind of like Michael Caine imo

[Frost 31]

[QUOTE=Source;35993155]Why can't the system have Judges that are experts in certain fields and then put them onto the certain cases, what's so wrong with wanting the system like that? it would cut the amount of patent cases in half if they actually had someone who knew in detail the technicalities of the case from personal experience and knowledge. [sp] i am not an expert on the judicial system so if this sounds daft i apologies [/sp][/QUOTE]

In theory this is supposed to happen, but in practice it almost never does. At the state level and below (county, city), the States are pretty much left to themselves to decide if they want to use a system like this, which is more complex and tends to be more time consuming than attaching any judge to a case. Most state judicial systems aren't going to spend the time to make sure they have at least one judge that knows programming, another that knows some kind of engineering, another that knows about roads, or cars, etc. Most state judiciaries are not going to spend the time finding and either appointing or electing judges with relevant credentials. In this case it is easier to use a blanket approach of assigning judges.

At the federal level... well, that's a bit of train wreck, comparatively speaking. I'm not saying that federal judges are not good judges, simply that the system for hearing cases does not work like you suggest.

Honestly, the fact this judge happens to be a programmer is likely coincidence more than anything else. Lucky coincidence for Google, but coincidence none the less.

[Grempington]

I'm a starting programmer and even for me that is one of the most basic functions I've ever seen.

It literally is the most generic bit of code anyone could see in any fucking program - all it does it basically check if the index range given is within an array's boundaries I mean that's..

It has never been more obvious that a company is trying oh so hard to take advantage of the court's lack of knowledge in programming, and that doesn't seem to be working for them.

[Van-man]

Well this just further cements Oracle position as one of the big dicks in the IT industry.

[Eltro102]

im going to sue Oracle AND Google for stealing the letter A which I have patented

[AceOfDivine]

[QUOTE=Eltro102;35995449]im going to sue Oracle AND Google for stealing the letter A which I have patented[/QUOTE]I'm going to sue you because I've patented trying too hard.

[asteroidrules]

[QUOTE=calzoneman;35991657]Here's the code:
[cpp]
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);

}
[/cpp][/QUOTE]

THAT is their claim? THAT!? They have literally less than no grounds for this lawsuit.

[smurfy]

[QUOTE=Eltro102;35995449]im going to sue Oracle AND Google for stealing the letter A which I have patented[/QUOTE]

Google doesn't have an A in it :eng101:

[GhettoGeek]

[QUOTE=Gmod4ever;35994206]Wow. This is just ridiculous.

I never really paid much attention to this particular case, and I never saw what the actual code was.

That code is so trivial it's not even funny. That particular function is so remedial, I honestly think it should be a core function of Java.

[b]For those who are not programming-savvy, allow me to attempt to explain what that code does, and why this lawsuit is so stupid:[/b]

The first thing you need to understand is that programming is entirely logic-based - if X then Y. That's how programming works. The second thing you need to understand is that programming is very heavy on variable manipulation. Think algebra: 5 + X = 7; what is X? In this case, X is 2. Now if you take that X and add 3 to that X, you get X = X + 3. Substitution in the X in the right-hand side, you get X = 2 + 3 = 5. So now X is 5. The logical "if X then Y" and this concept of manipulating variables are the cornerstones of programming.

Now, in virtually all programming languages, Java included, there is a catch: you can't just use variables willy-nilly. You first have to tell the computer that you will be using a variable, what the name of that variable is, what kind of variable is, and sometimes an initial value for that variable. The reason for this is in how computers operate - the computer has to set some memory / RAM aside for that variable, and keep it for ONLY that variable, so nothing else uses it.

This works just fine for many cases. For example, if you want to have a function that, when called, adds three to a variable named "MyVariable," then you could simply have a function do "MyVariable = MyVariable + 3" or "MyVariable += 3" (these are the same; the right-most version is a shortcut method most programming languages allow).

However, what if you don't know how many variables you are going to have? Let's say you have a program so people can look at different models of cars to buy. Now, imagine that a new car is made available, and it needs to be added to the program. When that program was made, this car wasn't even conceived, so there is no variable sitting for that car's mileage, price, and all that stuff you want to know when buying cars. So, what do you?

One solution is to sit down and rewrite the entire program, with variables for that car put in. But that's not very practical. The other solution is a variable that allows you to put things into it, and take things out of it, at will: such a variable is called a "table" or an "array."

However, like variables, in most programming languages, you can't just use arrays willy-nilly; you have to tell the computer that you are making an array, the name of that array, and what type of stuff you're going to store in that array. In addition to that, though, you also have to tell the computer that maximum size of that array*.

Much like variables, this is because the computer has to put memory / RAM aside for that array, so nothing else uses that memory and causes problems. This is because an array is really just a bunch of variables put in one place. Let me show this, by way of example.

[b]Method 1: Variables.[/b]

int Var1 = 5;
int Var2 = 7;
int Var3 = 9;
int Var4 = 2;
Int Var5 = 0;

[b]Method 2: Array.[/b]

 int[5] Vars = {5,7,9,2,0}

These two function do exactly the same thing: in both cases, you have five variables, with the values of 5, 7, 9, 2, and 0. The only difference is the first method defines each variable by itself, and the second one puts them all inside a single variable. In both cases, you have 5 of them, and so you have to tell the computer to make room for 5 variables.

[b]NOW[/b], with that in mind, some restrictions are placed on arrays in most languages.

Firstly, because you have to tell the computer how big an array is (how many variables it holds), you will run into issues if you try to make the array bigger than you told the computer it is - the computer gets confused, and it kicks up a tantrum by erroring at you, because it doesn't know what to do.

Directly related, if you try and access a variable from an array that isn't there, the computer gets confused and kicks up a tantrum because it doesn't know what to do. Imagine that you're visiting a friend, and he tells you to pick up the box of tissues off the coffee table, but there's nothing on the coffee table. You try to tell him that there's no tissue box, but he INSISTS that you grab the tissue box off the coffee table. No matter how many times you try to tell him there is no box of tissues, he keeps telling you to pick it up - you quickly get frustrated with him, because there is no tissue box.

The same thing happens with the computer, when you tell it to grab something in an array that isn't there. And, like when you try to make the array bigger than you told the computer it is, it gets angry and errors.

It is also just a fact that arrays start indexing at 0, and for each variable, goes up by 1. So the first variable is index 0, the second index 1, the third index 2, and so on. This means that if an array is of size 5, then it's last index is 4 (because you go 0, 1, 2, 3, 4; that's 5.) Ergo, if you tell it to grab something from index 5, which doesn't exist, it gets frustrated and errors at you - just like your friend telling you to grab the tissue box that doesn't exist.

The same issue occurs if you tell and grab something from, say, index -1. Because the array starts at 0, there is no -1, so you're trying to grab something that's not there: the computer gets mad and errors at you.

[b]WITH ALL THAT IN MIND, LET'S NOW LOOK AT WHAT THIS CODE DOES.[/b]

If I were to translate that code into plain English, it would come out as such:

"Given how big an array should be, a starting index, and an ending index, if the starting index is bigger than the ending index, throw an error saying that our starting number is bigger than our ending number. If the starting number is less than zero, throw an error saying our starting number is less than zero. And if the ending number is bigger than how big our array should be, throw an error saying that the ending number is bigger than how big the array should be."

That is literally all that code does.

* There are exceptions, using dynamic memory. However, I'm not going to get into that. Sticking with the basics here.[/QUOTE]

what

[assassin_Raptor]

[QUOTE=Sir Whoopsalot;35991895]Oh dear, the curly bracket indentation is ACTUALLY distracting me![/QUOTE]

You would hate to code then, that curly bracket ends the function/method.

[POLOPOZOZO]

Aw yeah laying down the law motherfuckerrrrrr