Thursday, December 01, 2016

The Most Famous Programmers of All Time

Legendary programmers who contributed hugely to and had a lasting influence on the software development profession, as well as an extraordinary personal background:

  • Ada Lovelace, for the first algorithm on a Turing machine (Bernoulli numbers), which included conditional branches, loops and subroutines, and for recognizing such a machine is capable of more than solving numerical problems.
  • Donald Knuth, for a work of beauty on TAOCP and TeX.
  • Dennis Ritchie and Ken Thompson, for Unix and C, laying the groundwork for today's server operating systems.
  • Bill Gates, for his contribution to the microcomputer software revolution, combining technical brilliance (Altair Basic) with business instinct (dealing with IBM) at a very young age.
  • John Carmack, for revolutionizing game programming several times.
  • Linus Torvalds, for bestowing Linux and git upon the world.

Read about their story in my slide deck below:

Sunday, August 21, 2016

Make Better Software Magazine

Free Fog Creek PDF on software engineering, hiring developers and technical leadership: Make Better Software Magazine.

Tuesday, August 02, 2016

Servant Leadership

I’ve always thought that the hardest and most valuable thing in work is to get a group of smart people to work together toward a common goal.
Great article on Servant Leadership by Rich Armstrong.

Tuesday, February 02, 2016

Sunday, January 17, 2016

The Developer Axe

1997 was the time of Java 1.1, which was still hyped for applets. Another buzz was VRML runnning in browsers. Back then I was working on a 3D chat project. I had learned the Java basics at university and at work, and cranked out a chat server / applet combination that would talk via TCP sockets using a homegrown serialization protocol. Lacking an async socket API I used one server thread per client connection that would read messages and broadcast them to other clients. I was aware of the concurrency issues to be considered, so I sync'ed accordingly on serverside data structures.

My local tests worked fine, and I uploaded my little chat system to a server, where it started attracting a decent amount of users over the next months. After a while I noticed they started complaining. Under a certain network load they had issues not being able to send/receive messages at times, until the whole server might stop responding. I remember being disappointed - I had been happy with the project's initial outcome, but the users were not. My developer axe had not been sharp enough.

Some System.out-debugging showed that the broadcast mechanism stopped and blocked connection threads when sending messages over slow or stuck connections. Which basically meant if one receiver turned out to be slow, it could block senders as well. Socket timeouts did not change anything (it would have been a duct tape fix anyway) - sending on some connections would simply block. I had a conceptual problem. For the meantime I added a cron job that would restart the server each day. Not nice.

I concluded I needed to decouple receiving and sending, and to introduce serverside sending threads as well. I planned for queues between receiving and sending threads (so even more connection threads, not very scalable, but all I could do at that point - "luckily" the number of concurrent users never exceeded 100). This would prevent one screwed connection to affect any other connections.

But how to implement that, when all the Java 1.1 collection classes had to offer were Vector and Hashtable (no BlockingQueue), and I couldn't find any Semaphore class either?

It took me a while to dig out how Object.wait() and Object.notify() could be applied here. No programming course had covered it, and the JavaDoc on that was slightly mystical too (remember, Google was still a small startup back then). I finally came up with this solution:

public class SenderThread extends Thread {

 private Object lock;
 private MyLinkedList pendingEvents;
 private Connection conn;
 private boolean stopped;

 public SenderThread(Connection _conn) {
  conn = _conn;
  lock = new Object()
  pendingEvents = new MyLinkedList();
  stopped = false;

 public void run() {
  while (!stopped) {
   synchronized(lock) {
    if (pendingEvents.isEmpty()) {
     try {
     catch (InterruptedException e) {
   if (!stopped && !pendingEvents.isEmpty()) {
    Object obj = (Object)pendingEvents.popFront();

 public void send(Object obj) {
  synchronized(lock) {

 public void terminate() {
  stopped = true;
  synchronized(lock) {

That worked, and the chat server was running like this until some years ago, when the Java plugin studdenly required applets to be signed, and certain browsers stopped supporting Java altogether. The binaries and the source can still be downloaded here and here (one funny detail, it originally wouldn't compile on later Java compilers, because I had used variables named "enum", which was not a reserved keyword back in Java 1.1).

The chat in its heyday on Windows XP (500,000 users signed up overall)

Private side-projects like this are a great playing ground. And they are important for developers. Such projects allow to experiment, make mistakes and learn from them at low risk. Not everything is in the textbook or taught in classroom, and at work one often is constrained to a certain technical area.

I am conducting a lot of developer interviews today, and notice the difference in skillset between those who just do what is required at work or school (and not more), and those who are curious beyond the tasks at hand, and code in their spare time as well.

When developers link to their development blogs, stackoverflow profiles or github pages from the CV, I can get a glimpse at those endeavours. By choosing what to work on within private projects they sharpen their developer axe, and are well prepared for tomorrow's challenges.

Similar articles: