The business rules which form the basis of the unique product offerings of corporates are typically embedded in bespoke systems. Gartner, in their 2013 IT Cost Optimization (ITCO) webinar , states that the biggest ITCO opportunity is found in reducing the per function point application development costs. To this end corporates may look towards writing their own frameworks in order to achieve ITCO targets. Although building a framework may be a viable option, it is certainly not a guarantee for success.
Benefits to be Reaped from a Framework
Let us first look at the benefits companies hope to reap from creating their own frameworks:
- Developer productivity – Reuse is an often cited benefit of frameworks  . Instead of different business units creating their own but slightly different business capabilities, business units can leverage off the common business capabilities provided by the framework.
- Shorter time-to-market – With readily available common business capabilities, the assumption is that business units can focus on only developing the delta of differentiating business capabilities unique to their particular business unit. The ability to focus on the differentiating business capabilities of the business unit; enables business units to push new products into the market much faster. This in turn results in prompt return on investment (ROI).
- Reduced maintenance costs – Since common business capabilities are only implemented in one place, it is developed and tested once. When the business rules change, changes to the relevant business capabilities can be made in one place.
Complexities of Designing a Framework
If there are so many benefits to having a framework, why are all corporates not creating one? Frameworks are orders of magnitude more complex to design due to the higher level of reuse, the need for constant evolution and backward compatibility  .
- High level of reuse – In software development reuse is often considered a virtue    . When stable and robust artefacts are reused, this is certainly true. However, reuse can become a vice when the artefact in question is in frequent flux and/or brittle.
- Constant evolution – Requirements are seldom stable. As requirements change, the framework will have to evolve gracefully.
- Backward compatibility – If clients are forced to make major changes to their existing code every time a new version of the framework is released, developer productivity is hampered rather than accelerated. Backward compatibility is not merely achieved by keeping API signatures consistent: It also wreaks havoc in instances where the underlying behaviour of the framework changes between versions.
Impact of Getting it Wrong
Multiple incompatible variants of a framework are a sure sign of a framework failing. Please note: I am not talking of legitimate versions here which forms part of a roadmap. Rather, I am talking of accidental variants of the framework that come into existence due to attempts at addressing flaws in framework. These variants may come about for a number of reasons.
- Use cases of the framework may not be clear resulting in teams inadvertently using the framework incorrectly. That is the framework is accidentally used in a non-backward compatible way.
- Brittleness of the framework may force teams to independently hack the framework into a vaguely working state resulting in multiple incompatible variants of the framework.
- The framework may not have been designed with backward compatibility in mind. The effect is that the effort to upgrade to a later version of the framework becoming an obstacle in itself.
Needless to say when multiple variants of a framework exist, it destroys all intended benefits:
- Maintenance costs will increase due to the inherent complexities associated with frameworks. With each variant of the framework evolving independently, maintenance costs are increased further.
- Developer productivity will be decreased due to increased complexity which will cause an increase in analysis time. These additional efforts will increase the time-to-market which hurts ROI.
Guidelines for Making a Framework work for Bespoke Software
Does this mean frameworks are a bad idea for bespoke software? Certainly not! Here are some guidelines for making a framework work for bespoke software development:
- Design stepwise – Do not attempt to provide the solution to all problems in one go. Particular good advice from both  and  is that a new feature should rather be delayed or not added at all when adding it will cause the integrity of the framework to deteriorate
- Build slowly – You are going to make mistakes, especially if you have a team with limited experience in building frameworks. Remember, once you have added features into the framework, removing them can be extremely difficult to almost impossible. Building the framework slowly gives the team the opportunity to learn without making too many commitments to their users that they cannot honor in the long run.
- Manage business expectation – An appropriate framework has the ability to reduce time-to-market substantially once it has reached a critical mass of functionality. A key point is that while it is in the process of being built, it slows down time-to-market significantly due to the inherent complexities in building a framework. Business expectation has to be managed accordingly.
Frameworks certainly have the ability to decrease the per function point application development costs, but the cost of naively embarking on a framework journey should not be under estimated.
|||K. Potter, “2013 IT Cost Optimization: Strategy, Best Practices and Risks,” 5 December 2012. [Online]. Available: http://my.gartner.com/portal/server.pt?open=512&objID=202&mode=2&PageID=5553&ref=webinar-rss&resId=2232818&srcId=1-2973089105&prm=tpc-itco. [Accessed 15 Febuary 2013].|
|||M. Fayad and D. C. Schmidt, “Object-Oriented Application Frameworks,” vol. 40, no. 10, 1997.|
|||D. C. Schmidt, “Applying Design Patterns and Frameworks to Develop Object-Oriented Communication Software,” in Handbook of Programming Volume I, MacMillan Computer Publishing, 1997.|
|||J. Tulach, Practical API Design: Confessions of a Java Framework Architect, Apress, 2008.|
|||K. Cwalina and B. Abrams, Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries, Addison-Wesley, 2009.|
|||M. Fowler, K. Beck, J. Brant, W. Opdyke and D. Roberts, Refactoring: Improving the Design of Existing Code, Addison Wesley, 1999.|
|||S. McConnell, Code Complete: A Practical Handbook of Software Construction, Microsoft Press, 2004.|
|||R. C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship, Prentice Hall, 2009.|
|||K. Beck, Implementation Patterns, Addison-Wesley, 2008.|
|||J. W. Ross, P. Weill and D. C. Robertson, Enterprise Architecture as Strategy: Creating a Foundation for Business Execution, Harvard Business School Press, 2006.|
|||M. Kanat-Alexander, Code Simplicity, O’Reilly®, 2012.|