Time X: Awareness of a sore lack of understanding about topic.

Time X+1: Read the wikipedia article and top few Google search results about the topic. Convince myself that I kinda-sorta understand what it all means.

Time X+2: Promise myself to read up more thoroughly on the topic. After a hurried stack overflow or Google search of how to learn multi-threading, try to bookmark various excellent resources on multi-threading like C# threading, the little book of semaphores or the Java concurrency book. Fail on realizing that all of them are already filed under ‘toread’ in delicious / pinboard.

Time X+3: Berate myself for wasting time.

Time X+4: With 33% probability, read the first chapter of one of the materials above. With exponentially decreasing probability, read the next chapter(s), never getting past the third. In any case, promise myself that when the C++ concurrency book is finally out, I will buy and read it.

Time X+(5…N-2): Real life interrupt.

Time X+(N-1): (Read inspiring but confusing blog post about how company X increased performance by multithreading) OR (come across a tough interview question on multithreading) OR (have a discussion with the significant other about spin locks) OR (…)

Time X+N: Time = Time – N

As you can probably guess, I’m in the penultimate step of that cycle. In an effort to take a little break from it without committing the time needed for reading a book, I’ve decided to write a bit about my understanding of spin locks, hoping it at least helps make N larger.

We need locks to guard against concurrent access to a resource or a value. If an ATM reads a value M for your someone’s bank balance while an account transfer request reads the same value, because if that happens, both the ATM and transfer code would let M dollars be withdrawn, resulting in 2*M dollars where there were only M before. That’s a bug. Except if you’re the Federal Reserve, but that’s another story.

Implicit in the need for locks is the fact that the code we’re running is multi-threaded. That doesn’t imply parallel processing — even on a single-core CPU, multiple threads are being switched in to and out of fast enough to give the illusion of parallel processing. The switching is done either by the kernel, or a thread library, in accordance with some scheduling algorithm.

So when thread X is running some code and requests a resource that is locked by some other thread Y, thread X then has to wait for thread Y to release the lock. Waiting can take two different forms, depending on the locking mechanism. If the resource to be acquired has a spin-lock, thread X must continuously poll a boolean guard variable or flag (e.g. is_locked) until it can acquire the lock, a process known as busy-waiting. Conceptually, this is like the following:

while (true) {
 if (!is_locked) {
   is_locked = true; // acquire lock
   break;
  }
}

is_locked = false; // release lock


In reality the code above won’t work, since the check and subsequent lock acquisition isn’t atomic. Proper busy-waiting usually involves an atomic test-and-set operation which has to be supported in hardware. The upshot, however, is that the thread doesn’t really stop, it keeps looping until the resource in question gets released.

The other option is for thread X to sleep on encountering a locked resource and for the kernel or thread library to resume (wake-up) the thread once the resource is available. This is how most multi-threading primitives like mutexes or condition variables operate. Unlike spin-locks, in this case, the thread is not scheduled to run until there is a change in the status of the resource which it was requesting.

Which one is better depends primarily on how long the expected wait time is. On the face of it, spin-locking seems more expensive as the thread keeps running (and therefore consuming CPU cycles) even while waiting; whereas a thread encountering a mutex-locked resource goes into the background until it can do useful work, freeing up the CPU to work on other tasks. There are costs associated with the latter, though; the cost of putting the thread on the suspend queue and bringing it back, and the cost of the kernel keeping track of the resource state in order to wake up the suspended thread. If your thread expects to have an extremely short waiting time, then, a spin-lock may be more efficient.

I don’t have a very good idea of the numbers involved, but a good lower bound for a thread state change is the time it takes to do a context-switch, which is on the order of a few hundred CPU cycles; a really short period of time, about the same as RAM latency. A disk seek, by comparison, has a latency measured in millions of cycles (see this excellent article for more info). The bottom line — you shouldn’t be using spin-locks unless you’re writing very low level code and know exactly what you’re doing; but in that case you don’t need me to be telling you these things!

Lets say you want to write your own, simple fixed-size vector class for integers. The specification is simple — construct the vector with one argument, the size of the vector. Construction creates a vector of the given size, all initialized to zero. Support accessors via indexing.

Here’s the first try (which I write on the whiteboard for the candidate):

#include "stdio.h"
#define OUT_OF_RANGE 1

class Vec {
  public:
    Vec(int sz) : sz_(sz) {
      data_ = new int[sz_];
      for (int i=0; i != sz_; ++i) { data_[i] = 0; }
    }

    ~Vec() { delete data_; }

    int size() { return sz_; }

    int& operator[](int i) {
      if (i < sz_) return data_[i];
      else throw OUT_OF_RANGE;
    }

    int sz_;
    int* data_;
};

int main() {
  Vec v(10);
  int i;
  for (i = 0; i != 10; ++i) v[i] = i+1;

  // this prints "1 2 3 4 5 6 7 8 9 10"
  for (i = 0; i != 10; ++i) printf("%d ", v[i]);
}

The question is this. The code, with a basic test, compiles and works as you might expect. Is there anything wrong with this code?

If your candidate stares at this and says “looks OK to me”, it’s probably time to end the interview and send them home. The correct answer, of course, is “many, many things.”

No encapsulation. The members sz_ and data_ should be declared private, otherwise clients could corrupt the data, intentionally or otherwise.

The destructor won’t delete the allocated array. It should say delete [] data_;. If they don’t know this, they have no idea of C++’s memory model.

It’s a mistake to use an integral size, since integers can be negative. In the given code, if you give a negative integer parameter to the constructor, new will throw an exception, or even if it doesn’t the for loop will be infinite. If you call an accessor with a negative index (v[-2]), it’ll access illegal memory. The size parameter should ideally be std::size_t, or at least unsigned.

The compiler will auto-generate crash-inducing code for copy construction and assignment, since these haven’t been defined. For example, the auto-generated assignment operator will look like this:

Vec& operator= (const Vec& rhs) {
  this.sz_ = rhs.sz_;
  this.data_ = rhs.data_;
  return *this;
}

Note that this copies the pointer to the array and not the array. The simple act of adding Vec v2(10); v2 = v1; at the end of the main function above will cause delete to be called twice on the same pointer, when v1 and v2 are destructed, leading to potential disaster. The candidate should be able to code both functions correctly.

You can’t use a const Vec object or reference for read-only operations, which basically cripples the class. If you want to pass a Vec to a function that only reads it, func(Vec v) results in an expensive copy operation, and func(Vec& v) or func(Vec* v) doesn’t guarantee that the vector won’t be mutated. Whats needed is to mark the size() function as const and add a const accessor:

const int& operator[](std::size_t i) const {
  /* same code as non-const */
}

An implicit constructor could lead to uncaught bugs at compile time. For example, a function with the signature myFunc(Vec v) could be called as myFunc(5) with an implicit Vec object being constructed as the argument. In almost all cases, this is unintentional and erroneous, and the constructor should be marked with the explicit keyword.

What I like about this question is that the quality of the candidate’s answers tell you a lot. Some candidates will surprise you and go beyond the basic issues listed above. If a candidate gets through these quickly, that’s a very good sign and you can go on to further improving the design, using templates, dynamic re-allocations etc.

As time has passed, I see an increasing need to reduce distractions while writing. At one point, I would happily compose a post in the Blogger or WordPress native web interface. For the past year or two, however, I’ve noticed that I could only write in a plain text editing tool with no interface clutter, like good old Notepad.

Recently, I started using Writeroom (or its equivalent, Darkroom on Windows) for writing. A full-screen text-only editor suddenly made a lot of sense. I was even more excited when I found out about textarea, a really clean writeroom-like interface on the web. It’s a basic HTML/js file that I thought was the perfect interface for writing. Unfortunately, it was client-side only.

Thankfully, I had a week of unemployment between jobs, so I wrote a web app that adds a back-end to the textarea interface. It’s at http://write-only.appspot.com and I’m using it to write this very post. It’s open to anyone: you’ll need a google account to sign in, since I used Google’s App Engine for making it.

It’s striking how much easier web programming has become. The last time I did any of this stuff was during my graduate school days, and then I was just interested in getting some user input over the web to use as parameters for a long computation on the back-end. I could’ve nominated my design for the worst web user-interface design ever award!

P.S. This is a purely personal project and doesn’t have the endorsement of my employers in any way, shape or form.

if ( A or B ) // A and B are some valid conditions
{
if ( A ) return x; // x is some valid return value
if ( B ) return y; // y is some valid return value
throw error; // should never reach here, right?
}

There should be absolutely no reason I’d get the error. Yet, I was. And once I got the error, I praised myself for having kept an “open mind” and actually anticipating that the impossible could happen. I enchanted myself with the discovery I was about to make which allowed this execution flow and rewarded myself with a subway cookie.

A while later, after banging my head around trying the complex conditions A and B by hand, I realized that it was impossible for this impossible thing to happen – as any first year undergrad could tell you. I’m doing a PhD and have to keep an open mind and let my brains leak out. That’s my excuse.

What happened was pretty simple. Master Yoda would put it this way: “Putting way too many error messages leads to lost time. Lost time leads to hurrying up your code. Hurrying up your code leads to copying and pasting aforementioned error messages. That leads to confusion about which error message you’re seeing. Confusion leads to suffering. Mmmm?” I sure found that out, after trying for an hour to debug code that was completely and obviously correct.

After this episode, which was actually the least of my worries (ever heard of segmentation faults?), I was wondering why it felt like I’d gone around in a circle a hundred or so times. And that’s when the universe, in a cruel stroke of brilliance, responded through subversion:

$ svn commit
Committed revision 314.

Just one of those days.

Anyhow, one thing was lacking – I wanted a blog-like (time-based) view when I opened my tiddlywiki file, for easy parsing of previous posts (usually, the previous day’s work). A kind soul had written a plugin for it (here) – but it unfortunately it doesn’t work with the current version. So I decided to see how rusty my Javascript was (very rusty, as it turns out), and after an hour or so of hair pulling, I finally fixed it to get what I believe is a working plugin. Grab it from here.

[Update 09-Jan-2008] Emmanuel has been kind enough to add restricted tag support, so you can, for example, only apply the blog-like behavior to entries that have a certain tag. Thanks!

Given this piece of C++ code:

  // definitions (a and b are primitive types)
  a = b+1;
  if (a == b+1) cout<<"True";
  else cout<<"False";

Under what conditions would the code print "False"?

The answer, when I finally get it, is obvious, but I manage to forget it every time and repeatedly fall into this trap.

I was playing around with Scheme today (for the uninitiated and/or the young, that is a programming language). I was pretty uninitiated too, which is why I had never bothered to try out Scheme before… but this is the closest to playing God that I have come. Here’s why.

Weird but cool syntax: Almost everything in scheme feels like it must have been created around the beginning of time. Scheme is to C++ what Sanskrit is to Hindi. For instance, here’s how you add two numbers in Scheme:

(+ 2 3)
5

This seems simple enough to follow at first – but then you realize everything in Scheme follows this rule – and so if you want to write an absolute value function, this is how you do it:

(define (abs x) (if (< x 0) (- x) x))

It all goes downhill from there.

Warp the world: The scheme book I was reading unwisely told me that anything and everything in Scheme was changeable. I did not read a sentence further and went ahead and wrote this out:

(define (+ a b) (* a b))
Setting compiled read-only variable+ can yield to incoherent state
+

This basically tells the interpreter that I want addition to mean multiplication. Despite the warning that I was entering a demented world, I was overjoyed that this appeared to work. And, sure enough:

(+ 5 10)
50

Bending the fabric of reality: Upward to enlightenment, I realized that + was just a name, and could really point to anything. We often hear these days that "everything is an object". But really, in Scheme, "everything is what you want it to be". And so, after turning my world upside-down, I turned it inside out.

(define + 2)
Setting compiled read-only variable+ can yield to incoherent state
+

Which says I want + to be a variable with value 2. For an ideal God, of course, the world would just carry out orders without cursing, but hey, I was just playing God! And was indeed bending the world to my will. And so I can now enter this, which looks positively alien, but is perfectly logical and returns a nice round figure:

(* + (- + +) (/ (* + +) +))
0

By this time, of course, subjects of the now-warped-and-bent-beyond-recognition world were, as you can imagine, feeling like Neanderthal man presented with the supernova of the Crab Nebula (or bash users presented with the Windows command line), and I thought it was about time to un-warp the world again. Even without restarting the interpreter, this is quite easily done:

(define (+ a b) (- a (- b)))

...and there was light :D (though of course the original + procedure can take any number of arguments, I'll figure that out someday)

If you're feeling down, I heartily recommend an episode of playing God to get you feeling on top of the world.

One issue I faced that I have four mail accounts in Thunderbird and I don’t care about three of them, but by default the above hack gives a notification for all messages. Thankfully, the back end controlling the notification is a good old bash shell script. After a little hacking, all was well.

To digress a bit, I would like to propose the following theorem.

You will always need to code a shell script right after you’ve forgotten the syntax of the if and for statements.

Proof: Emprical story of my life since I wrote my first shell script.

Thankfully, there is a corollary:

Every possible shell script in bash has already been written (and indexed by Google).

Proof: See above.

Back to Thunderbird. Thunderbird has had Junk mail filtering for a while now, and occasionally it will interpret some messages as “Junk” and give you a button to indicate that it’s “Not Junk”. Today, I saw this:

Interesting to note that there’s a difference between “scam” and “junk” mail detection. Even more interesting to know that Thunderbird doesn’t particularly care much about NUS Business School!