This blog has moved to Medium

Subscribe via email

Archive for August 2009

Requiring a minimum CPU benchmark in TeamCity

I wrote before on how to setup TeamCity to require an environment variable on agents.
It appears you can also specify the minimum CPU benchmark for an agent. The CPU benchmark is the number that appears in the Agents tab, and it represents “how powerful the CPU is”.

You can add a requirement for a system property “system.teamcity.agent.cpuBenchmark” to be high enough, in order to avoid builds running on weaker computers.

Java is less magical than C#

I have been programming in C# for several years now, and recently made the switch to Java (at least for now). I noticed that Java, as a language, is “less magical” than C#.

What do I mean by that is that in C# things are usually done for you, behind the scenes, magically, while Java is much more explicit in the toolset it provides. For example, take thread-local storage. The concept is identical in both langauges – there is often a need for a copy of a member variable that’s unique to the current thread, so it can be used without any locks or fear of concurrency problems.

The implementation in C# is based on attributes. You basically take a static field, annotate it with [ThreadStatic], and that’s it:

private static ThreadUnsafeClass foo = null;
private ThreadUnsafeClass Foo
    if (foo != null)
      foo = new ThreadUnsafeClass(...);
    // no other thread will have access to this copy of foo
    // note - foo is still static, so it will be shared between instances of this class.
    return foo;

How does it work? Magic. Sure, one can find the implementation if he digs deep enough, but the first time I encountered it I just had to try it to make sure it actually works, because it seemed too mysterious.

Let’s take a look at Java’s equivalent, ThreadLocal. This is how it works (amusingly enough, from a documentation bug report):

public class SerialNum {
     // The next serial number to be assigned
     private static int nextSerialNum = 0;
     private static ThreadLocal<Integer> serialNum = new ThreadLocal<Integer>() {
         protected synchronized Integer initialValue() {
             return new Integer(nextSerialNum++);
     public static int get() {
         return serialNum.get();

No magic is involved here – get() gets the value from a map, stored on the calling Thread object (source code here, but the real beauty is that’s it’s available from inside your IDE without any special effort to install it).

Let’s look at another example – closures.

In C#, you can write this useful piece of code:

var list = new List<int>();
// find an element larger than 10
list.Find(x => x > 10);

You can also make this mistake:

var printers = new List<Action>();
foreach (var item in list)
  printers.Add(() => Console.WriteLine(item));
Parallel.Foreach(printers, p => p())

An innocent reader might think this prints all the items in list, but actually this only prints the last items list.Count times. This is how closures work. This happens because the item referred to in the closure is not a new copy of item, it’s actually the same item that’s being modified by the loop. A workaround is to add a new temporary variable like this:

foreach (var item in list)
  int tempItem = item;
  printers.add(() => Console.WriteLine(tempItem));

And in Java? Instead of closures, one uses anonymous classes. In fact, this is how they are implemented under the hood in C#. Here the same example, in Java:

for (Integer item : list)
  final int tempItem = item;
  printers.add(new Action(){
    public void doAction()
      // can't reference item here because it's not final.
      // this would have been a compilation error
      // system.out.println(item);

Notice it’s impossible to make the mistake and capture the loop variable instead of a copy of it, because Java requires it to be final. So … less powerful perhaps than C#, but more predictable. As a side note, Resharper catches the ill-advised capturing of local variables and warns about it.

I myself rather prefer the magic of C#, because it does save a lot of the trouble. Lambdas, properties, auto-typing variables… all these are so convenient it’s addictive. But I have to give Java a bit of credit, as the explicit way of doing stuff sometimes teaches you things that you just wouldn’t have learn cruising away in C# land.

Israeli Developers Community Conference 2009

Check out the idcc, register (free), vote on the topics, and attend.



Actually, registration costs 100 NIS.

When your OpenID provider crashes

Today, I installed Windows 7 RTM. Trying to login to StackOverflow, I found that Verisign’s login portal crashed.

This locked me out of all my OpenID enabled websites (effectively, the StackOverflow trilogy). Luckily, my OpenID is really my blog’s URL, just delegated to Verisign. After spending a good fifteen minutes just finding where to disable the delegation, I finally found and disabled it, regaining the ability to log on.

Never use synchronized methods or lock on this

Especially when extending a 3rd party base class.

This is a known best practice, but when I read about it I natrually assumed I was smarter than the author of the best practice. The reason not to use synchronized methods (or lock(this)) is that other code might lock on your object too, thus causing nasty deadlocks.

I figured this wouldn’t happen because ‘who would just lock on my object, there’s no chance of that’. Well, this is obviously not safe, but especially so when extending a 3rd-party base class. In my case, I was extending log4j’s AppenderSkeleton, and found out the hard way that log4j obtains locks on the appenders.

The solution:

  1. Use a private lock object (duh), seperating your intended lock semantics from whatever evil outside code will use
  2. Stop assuming that I know best and ‘it will never happen’