dow.ngra.de » meme

How to sneak easter eggs past the pointy haired boss

Toomas Römer — Wed, 15 Apr 2009 10:22:14 +0000

I’m part of a small team that is developing a cool Java product. We’ve been afloat for more than a year and we’re doing better every month. We’ve grown quite a bit during this time. There used to be only one developer, then I joined the team and now we already have 4 devs.

Until now we’ve got away with most of the jokes we’ve pulled but we have matured over the period and we’re not the same young naive happy hackers anymore (right!). We still do like to throw a joke in every now and then.

We released a XML configuration file schema with our last product release and we had to pick a schema location for that. Remembering the Mozilla Ghostbusters reference we also had to reference something. And so we did.

But last week we got an email from our pointy haired boss. He had made a memo with 5 points about the documentation we have. The last point read: Why is there an alderaan in the namespace? It should be our product name!

I guess this marks a landmark in our small team, we’re not small anymore and we’ll have to figure out a way to keep the pointy haired occupied with something (Google Analytics usually does the trick). Luckily for us, we could still play the founder card, but later we may not be so lucky. What jokes have you managed to sneak by your boss and how did you hide them?

PS. We did not have to change our schema but it came quite close.

Caricature: JavaRebel winning the JOLT Productivity Award

Jevgeni Kabanov — Tue, 17 Mar 2009 15:26:54 +0000

Thanks to Risto for making it. I’m the dude on the left :) Oh, and download JavaRebel!

JavaRebel wins JOLT productivity award

Jevgeni Kabanov — Thu, 12 Mar 2009 02:35:22 +0000

JavaRebel wins JOLT productivity award — awesome!

The Ultimate Java Puzzler

Jevgeni Kabanov — Mon, 16 Feb 2009 15:01:08 +0000

Why is this particular one the ultimate? Two reasons:

It’s at the very core of the Java language, not some obscure piece of API.
It melted my brain when I hit it.

UPDATE 2: If you want to test yourself before reading the post take this test. Results are not saved (it’s a paid feature apparently and I just don’t care enough), but you can post them in the comments.

Let’s start by setting up the puzzler environment. We’ll have three classes in two packages. Classes C1 and C2 will be in package p1:

PLAIN TEXT

JAVA:

package p1;
public class C1 {
public int m() {return 1;}
}
public class C2 extends C1 {
public int m() {return 2;}
}

Class C3 will be in a separate package p2:

PLAIN TEXT

JAVA:

package p2;
public class C3 extends p1.C2 {
public int m() {return 3;}
}

We will also have the test class p1.Main with the following main method:

PLAIN TEXT

JAVA:

public static void main(String[] args) {
C1 c = new p2.C3();
System.out.println(c.m());
}

Note that we’re calling the method of C1 on an instance of C3. The output for this example is “3″ as you’d expect. Now let’s change the m() visibility in all three classes to default:

PLAIN TEXT

JAVA:

public class C1 {
/*default*/ int m() {return 1;}
}
public class C2 extends C1 {
/*default*/ int m() {return 2;}
}
public class C3 extends p1.C2 {
/*default*/ int m() {return 3;}
}

The output will now be “2″!

Why is that? The Main class that invokes the method does not see the m() method in the C3 class, it being in a separate package. As far as it cares the chain ends with C2. But as C2 is in the same package it overrides the m() method in C1. This does not seem too intuitive, but that’s the way it is.

Now let’s try something different, let’s change the modifier of C3.m() back to public. What will that do?

PLAIN TEXT

JAVA:

public class C1 {
/*default*/ int m() {return 1;}
}
public class C2 extends C1 {
/*default*/ int m() {return 2;}
}
public class C3 extends p1.C2 {
public int m() {return 3;}
}

Now Main can clearly see the C3.m() method. But amazingly enough output is still “2″!

Apparently C3.m() is not considered to override C2.m() at all. One way to think about it is overriding methods should have access to the super methods (via super.m()). However in this case C3.m() wouldn’t have access to its super method, as it it not visible to it, being in another package. Therefore C3 is considered to be in a completely different invocation chain from C1 and C2. Were we to call C3.m() directly from Main the output would actually be “3″.

Now let’s look at one last example. Protected is an interesting visibility. It behaves like default for members in the same package and like public for subclasses. What will happen if we change all of the visibilities to protected?

PLAIN TEXT

JAVA:

public class C1 {
protected int m() {return 1;}
}
public class C2 extends C1 {
protected int m() {return 2;}
}
public class C3 extends p1.C2 {
protected int m() {return 3;}
}

My reasoning goes like this: as Main is not a subclass of any classes protected should behave as default in this case and output should be “2″. However that is not the case. The crucial thing is that C3.m() has access to super.m() and thus the actual output will be “3″.

Personally, when I first encountered this accessibility issue I got thoroughly confused and couldn’t get it until I did all of this examples through. The intuition I got from this is that if and only if you can access super.m() the subclass is a part of the invocation chain.

UPDATE: Apparently even though the whole thing is obvious to anyone, the intuition I came up with was wrong. A mysterious commenter know only as “C” has provided the following example:

PLAIN TEXT

JAVA:

public class C1 {
/*default*/ int m() {return 1;}
}
public class C2 extends C1 {
/*default*/ int m() {return 2;}
}
public class C3 extends p1.C2 {
/*default*/ int m() {return 3;}
}
public class C4 extends p2.C3 {
/*default*/ int m() {return 4;}
}

Note that C4 is in the package p1. If we now change the Main code as follows:

PLAIN TEXT

JAVA:

public static void main(String[] args) {
C1 c = new C4();
System.out.println(c.m());
}

Then it will output “4″. However super.m() is not accessible from C4 and putting @Override on the C4.m() method will stop the code from compiling. At the same time if we change the main method to:

PLAIN TEXT

JAVA:

public static void main(String[] args) {
p2.C3 c = new C4();
System.out.println(c.m());
}

The output will be “3″. This means that C4.m() overrides C2.m() and C1.m(), but not C3.m(). This also makes the issue even more confusing, and the amended intuition is that a method in a subclass overrides a method in a superclass if and only if the method in the superclass is accessible from the subclass. Here superclass can be any ancestor, not necessarily the direct parent and the relation has to be transitive.

For the kicker try reading all of this out from the JVM specification that selects the method to be invoked:

Let C be the class of objectref. The actual method to be invoked is selected by the following lookup procedure:

If C contains a declaration for an instance method with the same name and descriptor as the resolved method, and the resolved method is accessible from C, then this is the method to be invoked, and the lookup procedure terminates.

Otherwise, if C has a superclass, this same lookup procedure is performed recursively using the direct superclass of C; the method to be invoked is the result of the recursive invocation of this lookup procedure.

Otherwise, an AbstractMethodError is raised.

SpringSource is not the devil?

Jevgeni Kabanov — Tue, 07 Oct 2008 21:07:30 +0000

SpringSource is not the devil? — apparently the community outcry was strong enough to revoke the most outrageous part of the new policy: now the latest stable branch will have maintenance releases even after the three month stoppoint. The funny part is that now the “three months” don’t have any value whatsoever, as the space between Spring branch releases is at least half a year. I get that SpringSource needs to shake the money out of the enterprise, but if JBoss somehow managed to do that without resorting to the outright extortion, so should they.

Google Chrome, Fixed

Jevgeni Kabanov — Tue, 07 Oct 2008 10:43:03 +0000

The latest Dev Channel version with the “–new-http” switch fixes all the problems I had with Google Chrome for me. Kudos to the team!

SpringSource will charge for updates to Spring, what comes next?

Jevgeni Kabanov — Sun, 21 Sep 2008 08:56:15 +0000

Under the new policy all bugfixes after three months will be available only in subscribed releases (the patches will still be available in the open source trunk, but you’ll have to compile them yourself).

This is a very expected move from Spring after the VC investment. Their previous business model was largely based on high class consulting and training. Obviously this just doesn’t scale. Now they are searching for new ways to sell licenses and subscription.

One of them is the new Spring Application Platform (renamed from the Spring Application Server). As far as I checked it it’s a relatively thin layer over OSGi, which doesn’t stop them from charging money for it. To be fair OSGi did need something like this to be useful to the larger community and if the tools will also be up to scratch it may be a useful project.

The new policy is just a part of that move. There is of course no reason why someone couldn’t just set up a public repository with the compiled releases unencumbered with Spring trademarking, but it will take some work. This is exactly what happened to the RedHat Linux wrt YellowDog Linux. This leaves me wondering if the “spring” in the package names is considered trademarked, because otherwise it would be impossible to produce untrademarked binary compatible releases, which kinda defeats the whole purpose of the open source.

What is the next move we can expect from SpringSource? They are also already offering companies to certify themselves for a hefty price to be “Spring Certified Solutions”. They also certify developers and may start to certify whole shops for “Spring-Enabled Process” or somesuch (if they’re not doing it yet). What we may yet come to see is

Making access to the Spring forums and FAQ paid
Making full documentation available only for a fee
Making full examples available only for a fee
Making Spring IDE commercial
Making downloads available only to registered users with aggressive upsale.
Making a Spring job board available only to certified developers and enterprises. (I was always surprised that this haven’t been done much in the industry)
And so on. Take any practice from Oracle/IBM/Sun and make it more aggressive, since SpringSource needs to be making money yesterday.

One very important question that came to me is if there’s any contributors to the Spring framework outside the SpringSource? Unless they have signed a copyright surrender agreement the whole commercial release is a license change without the agreement of a copyright holder. Given that the Spring guys seem to like to abuse the community understanding of open source without given much though to laws, it would be nice to see them bitten in the ass with it.

Live: Alternative and Emerging Languages Panel at JavaZone

Jevgeni Kabanov — Thu, 18 Sep 2008 15:58:00 +0000

Lineup:

Guillaume Laforge for Groovy (I can never spell his name, so I’ll just call him “Big G”)
Bill Venners for Scala
Gilad Bracha for Newspeak
Ola Bini for JRuby
Charles Oliver Nutter for JRuby
Scott Davis against Groovy

Moderator: Robert C. Martin (Uncle Bob).

Everyone introduces themselves. Bill is to blame for the “emerging” v/s “dynamic” languages. Ola fools around with AI stuff, hello robot overlords!

Bob: “I’m sick and tired of new languages, why C++ wasn’t good enough? Same with Java?” Python isn’t really represented on the panel, although it’s not really emerging either.

Charles: “must embrace the multiple tools”. Big G: “haven’t you been frustrated with Java?”. Scott is annoyed by static typing, I’m annoyed by Scott :) Duck-billed platypuses comes into play, generic consulting bullshit ensues.

Ola: “Lisp developers laugh at Java”, forget to mention that they laugh at Ruby as well. Haskell guys will laugh at anyone. Bill just wanted something better, reminds that type inference makes Scalla waaay better than all that dynamic nonsense. All languages do trade-offs, Bill likes types. Charles: “Like C++ — keep using it. If something works better for you, use that. Embrace multiple tools!”.

Bob: “Why did you sacrifice the static typing? Do you have a runtime exception fetish?”.

Big G: “You don’t get too many runtime errors in Groovy.” He’s just way too good for that. Ola: “Scala has cool type inference, but way too complicated.” Says you get other benefits in dynamic languages, but doesn’t names them. Scott brings driving analogies, which don’t mean anything, blablabla.

Gilad: “Lies by academics — types are useful for catching errors. But those errors are trivial. Types are great for documentation, structuring and performance.” Charles: “Types are about not trusting the people who write the code”. Fair enough, but I don’t trust myself, not to mention others. Bill: “I’m getting nervous in a big system. Types protect against certain type of errors”. Kinda weak.

Bob: “Your languages are hideously slow. Explain!”

Scott: “Speed is overrated”. And this is when the CPUs have plateaued and we just get more concurrency that noone uses. Brings Java as example of slowness, but the CPUs caught up with Java, Groovy won’t be so lucky. Big G: “Thin DSL layer in Groovy on top of a Java library made a world of difference, still Java performance underneath.” Gilad: “Google V8 might be a target for many dynamic languages soon, ’cause it’s been developed for dynamic languages”.

Kirk: “Productivity is king, but performance is important, if you produce bytecode why are you slower than Java?”

Gilad: “JIT is locked behind the type system. This makes dynamic languages reimplement basic stuff”. Charles: “Harder to know where does a method invocation end up, INVOKEDYNAMIC to the rescue. Numerical types are a real issue, unboxing them is really hard, SmallTalk did that.” Sounds reasonable. Scott speaks again. I had to switch from Google Chrome to Firefox in between, because spellchecking there sucks :(

Charles: “DocumentBuilderFactory is ridiculous, static typing overhead sucks. It cannot be just one languages, it’s not enough…” Bill: “Not static type fault — structural types, implicit conversions.”

Me: “What about contracts?”

Ola: “Dynamic languages do have the same contracts. ” Fails to explain what are they, though. Bill: “draw() has no meaning in dynamic languages, but it doesn’t necessarily produce more bugs”. Gilad: “Typechecker should be just a tool that warns you, while using types for documentation”. Someone from the crowd: “I program in 26 languages and that’s why your argument sucks [meaning me]“. Scott speaks.

Someone: “The problem isn’t in language, but in the people who use it, is it?” Reaaally long explanation that boils down to nothing specific. Oh, “What about refactoring?” OMG, please stop talking now!

Big G: “Refactoring works on Groovy with IntelliJ IDEA”.

Someone: “Multiple languages are like teenage sex, when will multiple languages become mainstream?” Time’s up!

Google Chrome — Fast, but Unstable

Jevgeni Kabanov — Tue, 02 Sep 2008 22:12:39 +0000

I gave Google Chrome a quick spin. At least two problems came out:

Digest-based authentication isn’t handle correctly, the sent request does not include the query causing 400 Bad Request
Google Analytics will randomly crash the Flash plugin freezing the whole browser (with all the talk of isolated processes…)

On the immediate positive side it fixed my main pet peeve with Mozilla Prism — the inability to change font size, so I replaced the Prism shortcuts with Chrome applications. It is also really, really fast.

All in all it’s fast and cool, but needs lots more polish before massive adoption.

Hug a developer today

Jevgeni Kabanov — Fri, 29 Aug 2008 20:53:04 +0000

Found from tOMPSON’s blog.