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.

Comments

Wow, nice bias

[rabtech]

I like how the submitter conveniently left out Paul's blog entry on the subject:

http://www.panopticoncentral.net/archive/2004/11 /2 0/2321.aspx

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.

And that's not all...

[Michalson]

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

Re:Oh please!

[janoc]

Well all LISP variants have at least four comparison predicates (and LISP predates Visual Basic by ages):

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 :(

Re:Oh please!

[WillerZ]

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.

Re: Oh please!

[Black Parrot]

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

Re:Oh please!

[gstoddart]

a isNot b
is equivalent to:
&a != &b

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!

Prior art

[hey!]

OK, as others point out, *ptr != *ptr2 tests if what the ptrs point to is equal (e.g. if they both point to the value 3). Now arguably, ptr1 != ptr2 is not the same concept either, because we are testing whether two addresses have the same value. But suppose I have a C program with two structs.

// don't try this if you want to work for me...
struct foo {
int x;
int y;
}

struct foobar {
int x;
int y;
int z;
} // ... later on we see

struct foobar fb;
struct foobar *fbptr;
struct foo *fptr;

fb.x=1;
fb.y=2;
fb.z=3;

fbptr = &fb;
// this is a bad idea, you'd better know your machibe representation
// if you don't want a core dump, but you CAN do it.
fb = & ((foo) fb);

if (fbptr != fb)
println("this should not be seen.");
else
println("the pointers are equal.");

However, I think there is a closer parallel.

Consider the following java snippet:

String s1 = "this is a string";
String s2 = "This is a string";

if (s1 != s2) {
System.out.println("s1 is NOT s2");
} else {
System.out.println("s1 IS s2");
}

if (!s1.equals(s2)) {
System.out.println("s1 DOESN'T equal s2");
} else {
System.out.println("s1 EQUALS s2");
}

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 ;lkasd lk dfllelaksdf lkasjdf lkasdjf lkajsdf lkkas df asdlfkj ealksdf . asaKJ SADF SADKFJ kj kajsdfh kjashdf kjas dfk aksdjf llk jasdlkjhs adflkjh asdf lkjhsad flkjadhsf lkjh j aldksjfh lsadkjfh lkj laksdjfh lkajsdfh lkasjdfh lakjsdf laksjdfh laskjdf laskjdfh lsadkjfh iuewriuy c,m.xzb wuoery oj lkjasdf ,