Johnathan had never purchased custom software in 20 years of business. But after months of searching for an off-the-shelf solution, he had given up. He was anxious to get things going and wondered how the process worked. He had decided to go with No-Glitch Software to do the work and their top programmer, Richard, would arrive in no time for their first meeting.
When Richard arrived, he was shown around the office and manufacturing floor to get a feel for how things worked, then they went to Johnathan’s office to talk about the process.
“Well”, Richard said, “creating customer software is a lot like construction of a building. We have to do some planning. This is similar to the blueprints and site planning. During this phase we’ll sketch out all the screens and reports and create a prototype. When that’s done, we’ll start the work, which is like that actual construction process. We’ll create everything then install it so you can do some testing. That’s when we enter the bug fix stage and finally, after that, you’ll be up and running. The whole thing should take about six months.”
The analysis process ended up taking longer than expected. Once the prototype was delivered and approved, No-Glitch Software was already a month behind schedule. Johnathan was surprised when the prototype code was thrown away and Richard started coding all over again. But the coding process seemed to be going well, at lease he assumed it was based on the bills he kept getting from No-Glitch.
Then, about a month before the test version was to be delivered, Johnathan learned that interface to the key piece of machinery had changed and that would require a change to his new program. He called Richard and he did not seem happy.
“That will require some major changes because the interface is a key part of the application and it is used in all over in the application. I estimate it will take an additional month.”
Does this all sound familiar to you? Have you ever compared software development to building construction? I have, but I don’t do it anymore.
There are a lot of things wrong with the above story. Let’s see if we can figure out what’s going on.
Software Development - What is the problem?
For many years, I have heard software development compared to building a house or a building. A plan needs to be put into place, a good foundation, and solid walls that can support the roof. It will take months of work just to get a good plan ready before the real work begins.
The comparison even goes further. Software development even uses many of the same terms as construction. Both have architects, architecture, engineers, plans, contractors, scaffolding, design, etc. That’s not to say these words are bad. It’s the comparison between construction and software development that’s bad.
You see, construction has fixed rules and regulations. The plans are set in stone and are difficult to change. The problem is, construction is, with few exceptions, run using the Waterfall methodology. And this is bad for software as Waterfall does not allow change. It does not allow enhancements. Maintenance is difficult and best practices are difficult to follow.
When you use Waterfall project management in software it leads to code bloat, rotting code, rewrites, spaghetti code, bugs, dissatisfied customers, dissatisfied managers, schedule overruns, cost overruns, and technical debt. (I’ll discuss technical debt in more detail in a future column.) The bottom line is using Waterfall processes is like going over Niagara Falls in a barrel. Few people that did it, lived to tell about it.
Other problems with our story exist. First, the interface to the machinery was not isolated to a single area of the application. Time was also wasted on a prototype.
So, what are we to do? As a start, let’s change our definition. Stop comparing software development to construction and start comparing it to gardening.
Software development - A new definition
I first came on this idea about a few years ago while re-reading the book Pragmatic Programmer. When talking about refactoring, the authors said
Rather than construction, software is more like gardening – it is more organic than concrete.
As I started thinking about this and realized they were right. Software is organic. But the authors also didn’t carry this concept far enough. Gardening can be applied to many other areas of development, not just refactoring. I then started speaking about Software Gardening at conferences and code camps. The topic was hit. Many attendees came up to me afterwards and said the comparison was right. Some even said it was the best presentation of the conference.
Then earlier this year, I started reading the book Object Oriented Software Guided by Tests. In the forward, Kent Beck writes
What if software wasn’t “made”, like we make a paper airplane – finish folding it and fly it away? What if, instead, we treated software more like a valuable, productive plant, to be nurtured, pruned, harvested, fertilized, and watered? Traditional farmers know how to keep plants productive for decades or even centuries. How would software development be different if we treated our programs the same way?
After reading this, I was positive that I was onto something. After all, here is one of the great minds in software saying the same thing I have been saying for over three years. But I needed to spread the word to a larger audience. And thus, here I am, writing a regular column for the .Net Curry Magazine
Software is organic
So what does it mean that software is organic? Think about a plant. It grows and changes in unpredictable ways. It may change with the seasons. It may bear fruit or shade or beauty. But we also have to care for it properly. Think about what Kent Beck said in the above quote. We need to nurture, prune, harvest, fertilize, and water our software. We also need to remove the weeds, keep the insects away, give it light, the proper soil, plant the right seeds, and use the right tools. By treating software as something organic, we expect change. We learn how to care for it so that when that change comes, we’re ready for it.
You are probably familiar with the software development dilemma. If not think of a triangle. One side is labeled time. Another is money. The third is either features or quality. The old saying is that you can have two of the three, so pick them. I propose that if you treat software as a Garden, you can have all three.
Software Gardening is about all this and more. I’m excited to be writing this new column and have it come to you every couple of months. Along the way I will talk about soil, light, water, pruning, weeding, tools, and more. Apply the concepts you will learn here. If you do, your software will be lush, green, and vibrant.
The other parts of this series are as follows:
Software Gardening: Project Management (Using the Right Soil)
Software Gardening: Software Craftsmanship (Watering Your Garden)
Software Gardening: Light and Sunshine
Software Gardening - Storing Seeds (Software Branching Practices)
Software Gardening: Insecticide – Getting Started with Unit Testing using an ASP.NET MVC application
Software Gardening: Harvesting (Continuous Delivery Techniques)
Software Gardening - Agile is not for the faint of heart
Code Refactoring (Software Gardening - Pruning)
Object Oriented Programming (Software Gardening - Seeds)
Single Responsibility Principle (Software Gardening: Seeds)
Open-Closed Principle (Software Gardening: Seeds)
SOLID: Liskov Substitution Principle (Software Gardening)
SOLID: Interface Segregation Principle
Dependency Injection - SOLID Principles
Coding Guidelines - Important for Developers
Reduce Bad Code with Code Reviews
Revisiting SOLID principles
This article has been editorially reviewed by Suprotim Agarwal.
C# and .NET have been around for a very long time, but their constant growth means there’s always more to learn.
We at DotNetCurry are very excited to announce The Absolutely Awesome Book on C# and .NET. This is a 500 pages concise technical eBook available in PDF, ePub (iPad), and Mobi (Kindle).
Organized around concepts, this Book aims to provide a concise, yet solid foundation in C# and .NET, covering C# 6.0, C# 7.0 and .NET Core, with chapters on the latest .NET Core 3.0, .NET Standard and C# 8.0 (final release) too. Use these concepts to deepen your existing knowledge of C# and .NET, to have a solid grasp of the latest in C# and .NET OR to crack your next .NET Interview.
Click here to Explore the Table of Contents or Download Sample Chapters!