I’ve been through a lot since 2005. I invented a technology that launched a company. That business thrived and withstood a global recession. The unsustainable practices of Silicon Valley’s VC-funded culture eventually crushed that company and my innovations were lost forever (or so I thought). Making peace with the situation wasn’t easy, but I did and moved on to other projects.
One day out of the blue, my original technology and trademarks returned to me as suddenly as they had disappeared. Today I’m working on rebuilding the company, only now with over a decade of hard-earned business experience.
You may be wondering why on earth anyone would want to keep building these particular products after going through so much. After all, there are much easier ways to make a living.
The truth is, it’s not about the money. Don’t get me wrong, having cash is preferable to not having it, but it’s just a tool.
The accounting department at Bell Laboratories would have to call Dennis Ritchie, imploring him to cash his paychecks. The people that created Unix weren’t doing it for the money.
People like us work so hard because we love the craft of software. It’s a beautiful, gratifying art. It’s our calling.
I was fortunate enough to discover my calling at just the right time to learn a particular school of thought. The computing culture at the time prided itself in creating better computing products than what was being churned out by corporate committees. Our software had heart. We could do this because machines were still simple enough to fully understand everything from the software to the architecture and implementation.
See, the people who taught me software knew something that the corporate machine didn’t: when you love something, you put in the hours to do it right. You study harder, think longer, and work harder to produce something meaningful and lasting.
It’s what I did when I invented stateful packet inspection for the PIX, the trick that makes firewalls work even today. Network Address Translation (NAT) was the same, and now it allows the internet to grow far beyond its original design. All these years later, load balancing, the reverse of NAT, was built with the same philosophy in mind and enables users to access a wide array of servers for scale-out web services.
Software created by people who love the craft is better for the user, and has a longer impact because it’s lean. Buried deep inside every complicated tangle of code is a small system trying to get out. Passionate programmers find the process of digging that system out thrilling. That means our code is 1/10th the size of other code. Sometimes 1/100th the number of lines.
Why should a user care about the size of a program? Lean code is faster, has fewer bugs, and is more secure all while being affordable.
Simple minded code runs slow, but if you improve it ever so slightly, measuring the changes, and keep growing it in small increments, you’ll find efficient performance. It’s when you start slapping on new features with little thought that the code becomes bloated. This is especially true when there are too many people on a development team. After a certain point, the code is too complicated to understand and the temptation to add new lines instead of fixing the old ones becomes too great.
Lean code has fewer bugs because every line of code has some coefficient of bug, usually much less than one. Add enough lines, and there will be a bug. Add a lot of lines and there will be a lot of bugs. Getting the same job done in fewer lines mean fewer bugs.
Lean code is also more secure code, something I learned in spades while creating the PIX Firewall. When code is small enough, understanding it inside and out isn’t an issue. This means you can inspect it, test it, and easily make sure you’ve executed every code path through the system. Only then can you be confident of its security. (Plus, many security problems come from bugs. See above.)
Lean software is affordable software because everyone knows that the hardware is just the bottle; it’s the software that is the wine. Small, efficient code doesn’t need the help of expensive hardware, which cuts costs dramatically.
At Coraid, we make network appliances that we enjoy using and give the kind of support we would want to receive. We do it in a unique way thanks to lean software. Our appliances have better performance, fewer bugs, and are more secure. Coraid hardware is sold basically at cost, and when a client subscribes to Coraid software, they’re usually paying less than what they pay for a Windows or VMware subscription.
These values aren’t unique to me. I learned them from Niklaus Wirth, Dennis Ritchie, Ken Thompson, Brian Kernighan, and others. They’re being passed on to other Coraiders who will continue to innovate and build neat stuff long after I’m gone.
That’s what we do. That’s what makes us tick. It’s all for the love of software. Thanks for being a part of it all.