Abstract
As demand for specific, complex and resilient software increases, a demand less appreciated is the increased need of proper, future proof software architecture often required by this software. Architecture is among the most important and fundamental parts of any software application. It is the base, and determines the future of software, and should be thoroughly researched as one of the first steps in the development process of any software. Good architecture is based on well-understood principles and induces benefits to the development of software such as improved code quality and maintainability.
This article discusses:
- the importance of software architecture;
- the scope of software architecture;
- common pitfalls and best practices in software architectures.
Keywords: software architecture, software design, software engineering, future proof, compatibility, portability, modularity, best practices.
Introduction
“If builders built houses the way programmers built programs, the first woodpecker to come along would destroy civilization” (Weinberg, G., 2010, p. 9). Comparing the timespan building architects have been around for with the timespan software architects have been around for it is to be expected that the general knowledge of software architecture is not as refined.
Just as buildings, software cannot be maintained without a thoroughly defined architecture and a team that understands this architecture. Programmers may be spending the majority of their time refactoring code, finding bug- and error sources and grasping unclear code structures. At the hand of improved structure an increase of working efficiency may be found or further decrease could be avoided.
This article will expand into some of the characteristics of future proof software architecture and explores why unstructured projects often fail.
Related works section
The field of software engineering and architecture are broad and recent disciplines, and new engineering principles are still emerging rapidly (Mall, 2018). Because of this, researchers have varying backgrounds and experiences. Mall (2018) explains that besides research innovations, a programmer’s own experience results in good development techniques.
Opinions about the effectiveness of software architecture vary as well. Bohnet, J., (2010) critiques complex software structure, stating that it is often costly because developers need to spend a large amount of time grasping the system’s structure and behavior. In contrast however, Kouroshfar et al. (2015) states that bad architecture leads to increased complexity and possibly decreased software quality. This is further backed with another point made by McConnell (2004), stating that it is nearly impossible to change code to match conventions after it has been written without them.
Analysis
With the rapid improvement of computer hardware of the past few decades computers can execute more complex software and requires more complex software engineering solutions. Conflicting goals during the engineering process are solved by picking one of many proposed solutions based on trade-offs such as cost, maintainability and usability. These required solutions should originate from well-understood principles, rather than intuition (Mall, 2018). An idea of the scope of software architecture given by Sommerville (2004), is that an architecture should consider any non-functional system requirements. Among these requirements are maintainability, compatibility, portability, and scalability, which are more significant to ‘future proofing’ software.
Personal experiences show a night-and-day difference between a software project with a defined architecture versus multiple projects that started with no plan and structured code “as needed”. It seemed that the more code written without defined structure, the messier and harder to understand the project got. Mall (2018) mentions that this style of programming is referred to as “exploratory”, or “build and fix” and is often what inexperienced programmers do. The good example on the other hand was a plugin architecture defined by interfaces of everything that was required. This structure applied principles such as dependency inversion and interface segregation.
Now let us investigate what principles can help the architecture meet the requirements stated earlier. Separation of concern is one of many principles that contributes to maintainability. It allows allocation of functionalities and responsibilities to designated elements of the system. The less scattered the concerns, the less likely bugs are to be introduced (Kouroshfar et al., 2015). Compatibility, portability and also maintainability, are mostly achieved through the dependency inversion principle (Martin, 2017). Compatibility however also depends on the compiler. As such, some architecture specifications determine or even fully generate the compiler (Farfeleder et al., 2006). Lastly, scalability, which is achieved through segregation of mutability. Segregation of mutability is not an officially documented principle, but describes that variables or data are only changed within controlled spaces. No immutable process will ever interfere with another immutable process, allowing for unlimited scalability of the process. Since Moore’s law is not likely to persist forever, the significance of scalability will increase with time and needs (Martin, 2017).
Conclusion
Software architecture of good quality is achieved by utilizing well-understood principles such as separation of concerns and the SOLID principles. When the architecture conforms to the correct non-functional requirements, such as, maintainability, compatibility, portability and scalability, its resilience to ‘the future’ is likely to increase. Furthermore, the benefits of sensible architecture include less defects, increased quality of code and understandability of its structure. This subsequentially leads to more time-efficient coding.
Recommendations
In this article many details were left undiscussed, and many principles were not explored. It is recommended to seek more knowledge about popular software design principles such as the SOLID principles. As a practical application of scalability, the functional programming paradigm could be investigated. Besides this, more research could be done on architectural requirements other than the ones discussed, and their significance to the future of the software.
Bibliography
Weinberg, G. (2010). Mastering Software Quality Assurance: Best Practices, Tools and Technique for Software Developers. p. ix.
Mall, R. (2018). Fundamentals of Software Engineering. (5th ed.). PHI Learning Pvt. Ltd. https://books.google.nl/books?hl=nl&lr=&id=-JNuDwAAQBAJ&oi=fnd
Sommerville, I. (2004). Software Engineering. (7th ed.). Pearson Education. https://books.google.nl/books/about/Software_Engineering.html?id=PqsWaBkFh1wC
Kouroshfar, E., Mirakhorli, M., Bagheri, H., Xiao, L., Malek, S., Cai, Y., Computer Science Department, George Mason University, USA,. Software Engineering Department, Rochester Institute of Technology, USA,. & Computer Science Department, Drexel University, USA. (2015). A Study on the Role of Software Architecture in the Evolution and Quality of Software. Working Conference on Mining Software Repositories (12), 1–12. https://doi.org/10.1109/MSR.2015.30
Martin, R. C., (2017). Clean Architecture: A Craftman’s Guide to Software Structure and Design. Prentice Hall.
Farfeleder, S., Krall, A., Steiner, E., & Brandner, F. (2006). Effective Compiler Generation by Architecture Description. Proceedings of the 2006 ACM SIGPLAN/SIGBED conference on Language, compilers, and tool support for embedded systems, LCTES(’06), 145–152. https://doi.org/10.1145/1134650.1134671
McConnell, S. (2004). Code complete Redmond, Wash. : Microsoft Press.
