Source code is a liability
Any software development company operates three major components: an intellectual capital, software, and source code. The intellectual capital is a strategic asset that company builds over time. This includes people, patent, white papers, etc. Intellectual capital requires investment but not much of maintenance.
Software is the collection of applications and systems that company hosts or distributes. It provides business value to clients and drives cache flow. Running software is an asset, but it entails operating expenses like license fees, hardware amortization, data center maintenance, monitoring, backup, production support etc.
The source code, however, is not an asset. It is a liability that drives most of company’s operating expenses. These expenses include documenting, education, knowledge transfer, debugging, refactoring, integration, testing, etc. Unlike software, source code expenses have tendency to grow over time as the code became more complex, cluttered and patched.
|Intellectual capital||Applications||Source Code|
|Type||Long-term asset||Tactical asset||Liability|
|Drives cache flow||--||YES||--|
|Operating expenses||--||Fixed per time||Grow over time|
|Lifetime||5 – 10 years||2 – 4 years||3 – 18 months|
Table 1: Three components of software development organization
When you develop a new program it is a clean start. You do not have baggage to carry. You do not have to spend time to get familiar with existing code, regression testing and merging design for new features with existing design.
Modifying application software requires more effort. With each release source code became more complex and interdependent. It is getting worse as different developers leave and enter the process. This is why software development processes and methodologies are so important. Their goal is not only to make sure that all requirements are satisfied, but also to make software maintainable – easier to modify it later.
The following table illustrates end-to-end cost of an abstract system release from design through development:
|Activities||New System||Existing Ad-Hoc||Existing Optimized (1)|
|Understand existing architecture and design||--||80||24|
|Validate gaps between deployed systems and design documentation||--||24||--|
|Document new architecture and design||40||24||16|
|Documenting detailed design for new features||40||40||40|
|Understanding existing code||--||80||40|
|Coding new features||80||80||64|
|Component testing and debugging||32||40||40|
|Integration with new code||--||40||16|
|Code review (and updating documentation)||24||40||16|
|Understanding existing configuration and deployment||--||40||16|
|Documenting application configuration||8||16||4|
|Integration testing and debugging||16||80||32|
|Testing new features in QA||40||40||40|
|Regression testing in QA||--||120||40|
|Fixing bugs found in QA||40||120||40|
|Fixing bugs found in Performance||40||180||24|
Table 2: Platform development cost structure
(1) The optimized development assumes both development processes and system design are optimized for cost control.
The numbers above are provided for illustration purposes only. The cost of real project may vary, however you cannot avoid expenses associated with maintenance and support of legacy source code.
A new system does not have legacy source code to maintain. This is why a pilot or the first release of a new application is usually cheaper than subsequent releases. As the source code piles up, became more complex, cluttered and patched, the team has to spend more and more time to maintain it. Sooner or later it reaches the point when the team forced to abandon the old code and to start new development from scratch:
This problem must be addressed by optimizing both the development processes and application design. A software development organization has to follow proven systems engineering practice and to optimize development life-cycle. This allows reducing time spent or repetitive and unnecessary activities; resources reusing and simplifies knowledge transfer.
However, the process optimization will only take you this far. In order to keep the development cost under control the system architecture and application design must follow certain standards:
- Encapsulation – design application as a composition of reusable modules (components) with stable interfaces that can be designed and tested independently from each other.
- Business Rules – implement system parameters and business rules either as configuration files or a database. Reuse and share algorithms and patterns across multiple clients and requirements.
- Process Automation – automate both run-time (transactions and workflow) and back-end processes (ETL, backup, build, deployment, etc.). Automate testing when possible.
- Error handling – each component must implement independent parameters validation. Do not use exception to communicate planned scenarios, implement automatic error monitoring and notification.
An ideal result of combination of processes and design optimization will allow to “box” operating expenses and to significantly prolong software life time. This chart illustrates how an ideal state:
As you can see from this illustration, as long as code maintenance cost does not grow over time, the team will have time left for recursive improvements and development for new features.