When Marc Andreessen wrote "Software is eating the world", what he actually meant was that technology is transforming industries through software that "finally works and can be widely delivered at a global scale". However, the side effect of this is that we are seeing more and more systems fail due to software errors, and in more complicated ways. For example, in 2014 thousands of callers couldn't reach 911 operators because the software that was supposed to generate unique identifiers reached a predefined threshold. No one really knew what would happen when this threshold was reached nor was the system designed to warn about this. The FCC concluded this as a 'preventable coding error', which to some extent puts the blame directly on the developers.
A project manager would argue that there should be several levels of testing and quality control that should have detected this problem much before it was encountered in the field. Not really!! Lets go back to era before the advent of micro-processors. Most systems at this time were electro-physical, which meant it had a limited number of configurations, and it was possible to enumerate and test all possible combinations. But with software, unless there is a formal proof of correctness it is very unlikely we can guarantee bug free code with any amounts of testing.
In spite of this, we continue to successfully create complex software products. From my personal experience, I think this success can be attributed to "taking ownership". In simple terms, all this means is developers should not assume that some kind of process will detect their mistakes. Although this sounds intuitive, unfortunately this is not how most commercial software products and services are developed nowadays. Not all companies can build their own software they require and as a result, they are typically 'outsourced'. In this model, a group of developers spend anything between a few months to a year collecting the requirements, designing and writing code. This piece of software is usually verified and certified by a testing team, which in some cases could be the clients themselves. The problem with this approach is that the primary goal is to get the software out and certified, which may not encourage developers to think about longer term implications.
In contrast, in companies where software products are built and shipped directly to customers, developers are expected to have a greater sense of ownership. When I started working for Novell, I met developers who had worked on the same product for over a decade. While I found it hard to believe, these developers took care of the code they wrote and maintained as if it was their child. This created a culture of zero tolerance for bugs and near instantaneous turn around for customer issues. So even if bugs due to coding errors do occur, developers have more accountability.
A project manager would argue that there should be several levels of testing and quality control that should have detected this problem much before it was encountered in the field. Not really!! Lets go back to era before the advent of micro-processors. Most systems at this time were electro-physical, which meant it had a limited number of configurations, and it was possible to enumerate and test all possible combinations. But with software, unless there is a formal proof of correctness it is very unlikely we can guarantee bug free code with any amounts of testing.
In spite of this, we continue to successfully create complex software products. From my personal experience, I think this success can be attributed to "taking ownership". In simple terms, all this means is developers should not assume that some kind of process will detect their mistakes. Although this sounds intuitive, unfortunately this is not how most commercial software products and services are developed nowadays. Not all companies can build their own software they require and as a result, they are typically 'outsourced'. In this model, a group of developers spend anything between a few months to a year collecting the requirements, designing and writing code. This piece of software is usually verified and certified by a testing team, which in some cases could be the clients themselves. The problem with this approach is that the primary goal is to get the software out and certified, which may not encourage developers to think about longer term implications.
In contrast, in companies where software products are built and shipped directly to customers, developers are expected to have a greater sense of ownership. When I started working for Novell, I met developers who had worked on the same product for over a decade. While I found it hard to believe, these developers took care of the code they wrote and maintained as if it was their child. This created a culture of zero tolerance for bugs and near instantaneous turn around for customer issues. So even if bugs due to coding errors do occur, developers have more accountability.
However, it is very unlikely to expect every company to hire engineers to build it's own software, nor can we expect the outsourcing model to change any time soon. But the more I hear of software failures as a result of coding errors, I cannot stop thinking back at my experience with these two types development paradigms.
Coming back to the title of this post. We never neglect our kids just because they are doing well. We strive to keep them healthy and sound. Well, this is what a sense of ownership brings to your code too.
Coming back to the title of this post. We never neglect our kids just because they are doing well. We strive to keep them healthy and sound. Well, this is what a sense of ownership brings to your code too.