Minnesota Republican Watch » Blog Archive » Norm Coleman’s Staff Attempts To Remove Facts From Coleman Biography In Encyclopedia

This is a consistant problem with Wikipedia. As a fun experiment, I would suggest going in and changing some insigificant value — adding a middle initial to a name, changing a date by day, changing a count by a subtle amount — and see how long it takes for it to get changed back. I would suggest doing this from a library or some other public terminal, though, because it will log your IP address.

Coleman’s staff has taken a slightly different tact towards Wikipedia — they’re changing Coleman’s biography to try to cover up his huge left-to-right pendulum swing and distance himself from Bush and Rove. Now — mark my words — the entry is going to have a bunch of edits which expose that pandering even more explicitly. And the war will erupt.

This kind of thing is already happening with the USS Liberty post (main post, more hotly contested “incident” post). The clearly identifiable American ship “USS Liberty” was attacked by Israeli forces after documenting their war crimes (including crimes committed by Ariel Sharon) and the ship was nearly sunk. The lifeboats that were launched from it were attacked, and antipersonnel chemicals were used on the deck. This, however, is not a popular story among Zionist groups, because it looks like an out-and-out attack on a United States vessel from Israeli forces in order to cover their own butt. So the result is that there’s a lot of controversy about it, with Zionist groups trying to downplay the travesty and researchers increasingly trying to get the story out. I highly suggest Bamford’s Body of Secrets for a well-researched account of the Liberty fiasco and the ensuing suppression and contention.

Back to the main point, though. You can see a war of edits going on at the history of the USS Liberty Incident page, with consistant fighting and tiny edits to make the incident read in a way that is better to that one person — and then the change back. Read the comments and take a look, and it’s clear to see that the history isn’t going through any kind of Hegelian evolution (as Wikipedia’s founders argue it will), but that it is simply being driven to extremes by people on either side and then dragged back to the other extreme by people who respond.

The fact of the matter is that Wikipedia has liberal leanings on the grounds that more of the people editting it are liberal. Making changes to it for political motivations are going to be strongly frowned upon, and are simply going to start a war of edits that you can’t win. This was a stupid move on Coleman’s part.

Edit: I love this entry in Coleman’s page’s edit history.

# (cur) (last) 12:38, 31 January 2006 NiftyDude m (→Recent Developments - added link to Coleman’s staff editing Wikipedia entry)

Edit2: Check out this response.

Hey, BHurt-AW, this might be worth a DailyKos post — I’d be curious to see what they’ve got to say over there about this maneuver.

Popularity: 2% [?]

Experts Claim Official 9/11 Story is a Hoax - Yahoo! News

Hrm. I recognize none of these “distinguished experts” listed. Then again, I’m not in the field. Anyone have a clue if there’s anything to trust about this kind of stuff? It’s being generated in my backyard over here at the U of MN.

Maybe those conspiracy theories aren’t complete nonsense.

Popularity: 2% [?]

Like most traumatic realizations, I’ve been having trouble getting the fundamental equals/compareTo brokeness of Java out of my head.

I decided to take a look at the Commons-Lang library to see how they deal with it. They’ve got a class called EqualsBuilder which is supposed to take care of this stuff for you. So I was wondering how it did that.

It gives you two options:

1. Reflection
2. Manual

The manual process has all the problems that I’ve talked about here and here, so we’re going to punt on that.

For the manual process, if that was the way it was decided to go, my deisgn would be a bit different. First and foremost, the isEquals private member variable should really be a constant.

I would go a step further and make there be only two instances of an EqualsBuilder: the one where it’s not false yet, and the one where it’s been determined to be false. These two could be implemented as private inner classes implementing the common abstract base class, so the one where it’s been determined to be false literally does no work and the one where it’s not false yet contains all the tricky thinking code. That’d save some branching and a lot of object burn. Of course, that’s arranging the deck chairs on the Titanic, so let’s not spend any more time there.

The reflection option has much more promise. It (in its most precise form) accepts the following information:

1. Two objects to compare
2. Whether or not to test transients
3. Class to test up to

I’m not entirely sure about the value of the class to test up to, because the scenarios where that’s anything other than “Object” seem to be making some really strong assumptions about the internal behavior of the code. Similarly, I’d be prone to always have transients tests turned off, but I’m pretty morally opposed to transients as a general statement.

Once the two objects are passed in, it calls one the “left” object and one the “right” object. Then here are the steps it takes:

   
1. If the two sides are the same object, return true.

   

2. If either side is null, return false. (Personally, I’d consider null to be equal to null.)

   

3. Determine the class to use to test as follows.
         
            
   1. If the left object is an instance of the right object’s class, but the right object is not an instance of the left object’s class, then use the right object’s class. This is the scenario where the right hand object is an instance of a child class of the left hand object’s class.

            

   2. If the right object is an instance of the left object’s class, but the left object is not an instance of the right object’s class, then use the left object’s class. This is the scenario where the left hand object is an instance of a child class of the right hand object’s class.

            

   3. If neither object’s class is an instance of the other, then return false. This is the case where two classes are different — although they may share a common ancestor.

            

   4. Else, arbitrarily use the left object’s class, since they are equal.

         

      

4. Now, for the class to test and all of its super classes, determine all the fields of that class through reflection and test them.

This is better, but there are still some concerns.

First, there are a lot of technical difficulties inherent in reflection. Private classes are notoriously picky, and the handling of them in the various reflection-based methods are pretty inconsistant. To fix this, the Commons-Lang code sets the accessability of the fields to true, which is a start, but the maintenance on all of this is kind of ugly. There is also significant overhead to reflection, which you’re now hitting on every time you try to walk a list, insert into a tree, etc., etc. — some caching might be able to help this, as long as the number of different classes you’re encountering within a window stays reasonably small.

There’s another couple of issues which I would probably go so far as to call “bugs”.

First, variables belonging to inner classes aren’t checked. Inner classes which implement interfaces and contain data are exceedingly common — the most common examples are the Map.Entry and Iterator interfaces. I also have many times when I will have an inner class which provides the “doIt”-ness of the class, while the class itself does clean-up and maintenance on that “doIt”-ness. Similarly, anonymous inner classes that inline an object reference or value (see “closures”) could generate false positives, because the “value equality” and “functional equality” of those classes are drastically different.

Second, two classes that are sibling classes but value-equivalent cannot have their equality properly determined through this method — in fact, they’ll always be false. If two classes both implement a base abstract class, and are to be considered equal in some cases, then we’re in trouble. Think about the Number class and its various descendents — in this case, a Float with a value of 1 and an Integer with the value of 1 would be identified as not being equal. This case is so weird and identifying when it’s supposed to be equal and when it’s not is so hard that I would generally punt back to the user to have to address this case. I’m not sure how the user isn’t going to handle it, but I don’t fault the Commons-Lang developers for leaving this bug in play.

That said, it’s easier to use the reflection mode in the EqualsBuilder class than to try to actually generate a sensical work-around for the equals() problem. It’s not a perfect solution, but it’s a reasonable hack that sacrifices performance for correctness…at least, correctness in more cases.

Popularity: 4% [?]

Sen. Kennedy and Sen. Kerry are trying to do a last-minute push to fillibuster Alito. What are they trying to accomplish?

C’mon, people: it’s too little, too late. All this is going to do is to validate the weakness of the Democratic party and their role as secondary to any real decision-making in Washington. That’s if they’re lucky. If they’re unlucky, this pointless push is going to destroy the Congressional tradition of the fillibuster — the so-called “Nuclear Option”.

Of course, I don’t think the Democrats can hold themselves together to even start a fillibuster, much less hold one hard enough for the Nuclear Option to be invoked.

Popularity: 2% [?]

Due to my fond affection and angst over their loss, I have cunningly located and now will proceed to host the first three installments of the Foamy’s Rant series.

Foamy’s Rant Index
Foamy’s Rant 1
Foamy’s Rant 2
Foamy’s Rant 3

I haven’t gotten Mr. Ill Will Press himself to actually respond to my emails offering to host these officially, so I’m going ahead and hosting them unofficially. We’ll see if that gets his attention. :D

Popularity: 2% [?]