Slashdot Mirror
Microsoft's 'IsNot' Patent Continued...
An anonymous reader writes " According to the patent application--filed in mid-November by Paul Vick, lead architect for Visual Basic .Net at Microsoft; Amanda Silver, a program manager on the Visual Basic team; and an individual in Bellevue, Wash., named Costica Barsan--the IsNot operator is described as a single operator that allows a comparison of two variables to determine if the two point to the same location in memory." This article continues the tale started last november, and here is an eWeek story on the same subject.
No, they want to patent: if (ptr1 != ptr2) ...
Athletic Scholarships to universities make as much sense as academic scholarships to sports teams.
I like how the submitter conveniently left out Paul's blog entry on the subject:
1 /2 0/2321.aspx
http://www.panopticoncentral.net/archive/2004/1
He says, among other things that software patents are a "bad idea" and that he did not "feel particularly proud of my involvement in the patent process in this case".
So there you have it, from the horse's mouth.
Natural != (nontoxic || beneficial)
> I remember our programming instructor in sixth grade teaching us about this logic operator is BASIC.
Actually, it's not the same operator.
They're talking about creating an operator that can say if two objects are the EXACT same object or not.
In C++ terms this is the equivalent of doing *ptr != *ptr (!=) vs. ptr != ptr (IsNot).
As you all know, int a = 1 and int b = 1 does mean that &a != &b whereas it does not mean that a != b.
So, basically they're trying to patent a new keyword with new functionality in all BASIC-related languages, effectively locking all companies that provide BASIC-interpreters out because they can't provide this functionality.
"IsNot" is different from "Not equal to"
Actually, depends on your point of view. If I have a pointer A to an object, and a pointer B to an object, then IsNot is simply doing A != B or in VB terms, A B, if we treat A and B as pointers.
Since in object oriented stuff, A and B are references, then equals (and != and ) is an overloaded operator that would, if implemented, return True if the contents of the two referenced objects were equal.
But you can still do IsNot with a != operator - you just have to be careful what you're testing the equality of.
You would think this would apply to Java and Modulo-3 as well... but I don't know them very well. If it existed in those languages, it would be prior art. But so would the fact that someone could write this little routine in their VB app:
Function IsNot(A As Object, B As Object) As Boolean
IsNot = Not A Is B
End Function
In the last month alone the software patent bastards also gained patents on:
Network drives and folder mapping
The Photo Album Software that came with your digital camera
The clickable progressbar found in all video and music playing software
The "recent" menu
From Lisp primer:
= (= x y) is true if and only x and y are numerically equal.
equal As a rule of thumb, (equal x y) is true if their printed representations are the same (i.e. if they look the same when printed). Strictly, x and y are equal if and only if they are structurally isomorphic, but for present purposes, the rule of thumb is sufficient.
eq (eq x y) is true if and only if they are the same object (in most cases, this means the same object in memory).
eql (eql x y) is true if and only if they are either eq or they are numbers of the same type and value.
So what Microsoft is trying to patent is known in LISP as (not (eq a b)) for a long time already :(
Depends on your language. In a language like Java, all object variables are references, so saying Object1 != Object2 is asking if both variable point to the same object. The same is true in Objective-C, where all object variables are pointers. In these languages, you need to invoke a method defined in the object itself to compare objects by value.
I am TheRaven on Soylent News
The IsNot operator described in the patent also differentiates between objects with the same address in different memory spaces. They mentioned running a cluster-aware program which could manage objects on multiple machines simultaneously.
So, it's equivalent to:
((&a != &b) && (a.host != b.host))
Which is yet more complex but still not worth patenting a simplification on.
I guess today is a passable day to die.
> But it is the same as "Not equal to" applied to the address of the variable [...] So, it's still a pretty trivial concept...
There's also single-operator prior art in the Scheme neq? operator.
(I don't know whether it's standard, but it is provided by some interpreters.)
Sheesh, evil *and* a jerk. -- Jade
The letter 'T' is already trademarked by the Deutsche Telekom. Sorry, MS.
The Tao of math: The numbers you can count are not the real numbers.
IsNot compares the addresses of the variables, not the value. The equivalent in C is &a != &b instead of just a != b.
It's just like the equivalent in Python: a is not b (or not a is b, I don't really understand the need for a separate operator). Only difference is that it's one word instead of two. And different capitalization (but isn't Basic case insensitive?)
This sig under construction. Please check back later.
Well, in C, if a and b are strings, structures, or arrays, then the variable name is the same as the address.
Therefore a != b when you're testing if the 'two variables point to the same location in memory' is covered by friggin' PDP-11 architechture. It's basically a comparison of two integers and a BNZ (branch non-zero) instruction.
They can make all the claims they want about how they've done all sorts of innovative stuff to make the link novel, it's still comparing a pointer reference in a programming language as far as I can seem.
What's next, start patenting the AND, NOT, OR family of operations? I hope not!
Lost at C:>. Found at C.
However, I think there is a closer parallel.
Consider the following java snippet:
Of course, underneath it is probably implemented with pointers, but the semantics of the != operator on reference types is defined to be object identity non-equality.
This prints out the following:
s1 is NOT s2
s1 EQUALS s2
The comparison operators in Java, when applied to reference variable types (which is everything other than built in primitive3 types) tell you whether the objects have the same identity (==) or different (!=).
Imagine, for example, instead of a conventional virtual memory architecture, we have an architecture where we have different kinds of memory with different speeds mapped to different address ranges; say that adresses under 1 million are fast memory and addresses 1 million or over are slow memory. This is not impossible to imagine for some kind of embedded device. Suppose, in addition, the runtime system understands this and caches copies of frequently used addresses in the below 1 million range to enhance performance.
In that case suppose we have the java expression:
if (objRef1 != objRef2)
In this case, a correct java implementation on this hypotethetical platform could not use a simple address comparision. If the addresses were unequal, it would have to do a further check to see if one of them were a cached version of the other.
Y'know, a news for nerds site really ought to make it possible to post code examples without resorting to stupid tricks like this: 2qy982uoiu 3o2iu4o23iuoi23u4 23o4uo23iu ou34oi 23oi4u o2i3u4o i234 lkasdfls llflawl fasdf ssdlllle asdf foo sdalkfl adlk;jlaskdf lsadf . as;ldkf
Post may contain irony: discontinue use if experiencing mood swings, nausea or elevated blood pressure.
T is already trademarked by the german Telekom, another industry giant who trademarks anything under the sun (including the colour pink and the word "hotspot" - I kid you not).
Assorted stuff I do sometimes: Lemuria.org
Pointers are such a basic but misunderstood concept. Here is some C basics.
int *p0,*p1;
Treat the value that is held by the variable p0 as an address somewhere in memory.
if(*p0 == '\0') foo();
Check to see if the variable p0 holds the value NULL.
if(p0 == '\0') foo();
if(*p0 != *p1) Retrieves the values of p0 and p1. Treats them as the address of the values to be compared.
if(p0 != p1) Compares the values that p0 and p1 actually hold.
"...if the two point to the same location in memory..."
It looks like MS is trying to patent if(p0 != p1)
Actually, the grandparent post was right...
...
...
...
a and b are references, which are pointers in the C sense:
So the C code would be:
int *a, *b;
if (a != b) {
}
The extension to C++ usage is obvious to a skilled practioner.
And the (new, patent pending or granted?) Microsoft BASIC approach is:
if a isNot b then
The equivalence is EXACT between != and isNot. I am a skilled at programming, and I find it obvious.
Microsoft will NEVER defend this patent. 'Cause they will lose.
PS. Object equality vs. Value equality is carefully delineated in "Smalltalk, The Language and Its Implementation" (just the reference I had at hand, there are HUNDREDS of other discussions -- usually for stuff a bit more interesting though).
Ratboy.
Just another "Cubible(sic) Joe" 2 17 3061
Unless the government specifically passes legislation allowing you to sue the government, then you can't sue the government. It's a legal concept called sovereign immunity and is derived from the ancient concept of "the divine right of kings."
Ha, ha! Nobody ever says Italy.
"this is just a shortcut (well, actually &&!= are 4 letters and isNot are 4 letters, but you know what I mean...),"
:-)
isNot != 4 letters
-nB
whois gawk date unzip strip find touch finger mount join nice man top fsck grep eject more yes exit umount sleep dump
"VC++ is sufficiently broken"
I hate to say it, but that's no longer the case. For a couple of years now MS has had the most standards (ISO/ANSI) compliant compiler. In fact I think Microsoft even hired one of the main STL guys to help on this front...
Need I go on? You can see some more here:
Enter The 'Stupid Patent Tricks' Contest
Disclaimer: This opinion was created without the use of any facts
Here are two links:
http://www.heise.de/newsticker/meldung/19650
http://www.golem.de/0307/26462.html
Both in german, however, because the lawsuits were in Germany and probably not big news in english speaking countries.
C - the footgun of programming languages
!= on pointers checks the memory location.
java has some sort of function to check the memory location too.
We've secretly replaced Slashdot with new Folgers Crystals - let's see if it notices.
See here for a whole discussion from December 2001 and here for a suggestion for an IsNot operator dated January 2001. The patent application was filed in May 2003. Anyway this application is just funny and I hope it'll be granted just to watch the effect.
Click here for more info on the topic.
Ha, ha! Nobody ever says Italy.
Common Lisp has a number of equality operators (eq, eql, equal, equalp, =) which are subtly different. CL differentiates among objects that are equal in type and value, equal in value regardless of type, are identical, or some combination of these.