Introduction to Software Architecture
Student’s Name
Institution Affiliation
Introduction to Software Architecture
Historical Narrative
Software development dates back to the 19th century during a period when Augusta Ada King wrote about a computer program and worked on an analytical engine that later came to move the industry overwhelmingly and served as the basis for modern-day calculators. This work by Countess Lovelace was in support of Charles Babbage’s invention of the computer. In later years, the imaginations of aspects that facilitated development in computing architecture and software took the industry by force. Although the development of the software has advanced in contemporary times, computing architecture cannot exist without the capability of systems that happened during the 19th century (Ceruzzi, Aspray, & Misa, 2003). However, the development of experiences in software capability and computing power has evolved and developed in what appears as a symbiotic relationship. This cycle shows that growth in the demand for the capability of software increases the need for powerful computing power in that increased growth in power facilitates heightened software capability, which aids the development of a virtuous cycle. In the same manner, an increase in software capability leads to a higher demand for heightened computing power.
Growth in computing technologies has developed from different areas of scientific research in universities into large businesses. The adoption of computers in business began in the 1960s, during which most of the software was used to produce reports and process transactions. During this period, the architecture of software was developed through the use of the waterfall model, which resulted in software that suited the purposes for which it was developed. The resultant software was modular in design, an aspect that made it relatively easy to maintain and use. The software during this time was also arranged around a client-server architecture that included a server with the ability to serve many clients. It was also simple in that a client could make the requests to the server, which would respond as expected (Ceruzzi, Aspray, & Misa, 2003). This meant that one server was responsible for undertaking different aspects of the software system, including error detection, collection of data, data retrieval, validation of inputs, and presentation of results such that the client did not have to do any work. This client-server model does not require the client any computation work in addition to facilitating the input of data from the user.
Since the 19th century, software technology has developed exponentially such that contemporary architecture has become obsolete. However, some aspects remain relevant, including the virtuous cycle that exists between software capability and computing power. The current technology also observes that software should be well organized in accordance with appropriate architecture. Client-server architecture is also relevant, although it is not the only architecture available. Technology has grown from mainframe computers that require huge maintenance and significant investment and were known to consume a large amount of space with a great need for specialized staff (Moshix, 2018). The mainframe computers developed to minicomputers, which later propagated the development of desktop computers that led to the famous laptops. Progression of each of the technological features resulted in the reduction of machine weight and increased portability, which is mostly characterized by smartphones that led to the birth of tablet computers. Advancement in technology through the years led to cost reduction and miniaturization, which resulted in cheaper, lighter computers with higher computing power. The virtuous cycle was carried through the years with increased portability and power of computing.
Technology continues to advance as people continue to adopt computing into their lives. Communication has changed from SMS to communication through iMessage and Whatsapp, among other options to choose from. The transition in messaging is an indication of increased demand for software capability. The software has also grown in complexity and programming languages. In the coming years, there are expectations to experience increased growth and advancement in complexity and ease of use.
Software Architectures
Architecture entails the interplay between different layers in that each of the layers cannot function individually or comprise an item or building separately. Software architecture entails bringing together different layers and appreciating the role and contribution of each layer to the building. Software architectures include client-server, monolithic, micro-services architecture, layering and stack, and service-oriented architecture.
Monolithic Architecture
As the name suggests, monolithic architecture refers to a large, strong, imposing, and indivisible architecture that combines various functions that would be separated into different components. This architecture entails different modules and classes that are packed together tightly such that software gets deployed as one single file. A monolithic application, such as the fragrance westore application has three layers in each underlying application, which include the presentation layer, application layer, and data layer. The presentation layer is the front-end layer that comes up with the interface that interacts with the software while the application layer embodies different software calls in the business logic.
This architecture is best suited for a small application or that that are suited for single developers. Monolithic architecture is preferred due to the simplicity of development, management, and deployment. The architecture is known for simplicity in development in that the layers in the application are coupled tightly. Since the architecture is compiled in one software, it is easy to deploy and distribute it. There is also the simplicity of management in that the layers in the architecture are accessible through software calls. This architecture is also simple to test, easy to understand, and it is easily scalable.
However, the monolithic architecture has a language lock-in that the programming language should be used in subsequent versions of the software. The size of the software’s codebase can also become large, making it challenging to undertake future maintenance. The size of the codebase also makes it difficult to digest and to distribute the development. In addition, the size of software makes it difficult to optimize resources due to its size, thus making it complex and slow to load the computer.
Client-Server and Peer-to-Peer Architectures
This architecture is built on the basis that there exists a series of services that are often delivered by servers to the client who made the request. The client in question can include a computer program with the need to make a request for various services. A service, on the other hand, refers to a computer program that provides clients with functionality and often serves other types of computer programs. This scenario shows that one server can serve different clients who can request services from different servers. In this architecture, the servers and the clients run computer programs, and there are varying types of servers, including database server, web server, or file server that is always listening to different requests to respond with an appropriate message. There are many servers installed in one computer in that servers are considered as computer programs rather than a physical computer. This architecture often separates different components into a server and client such that it becomes defined as a centralized model in that functionality is often concentrated into different servers that hold and serve the requests of the clients. A variant of the client-server architecture is the peer-to-peer model where different computers interact such that one makes the request, and the other furnishes the client with the requested service. This model is different from the client-server model in that this peer model lacks the separation between the functionality of the server and the client.
Layering and Stack Architectures
This architecture refers to a stack or layering architecture, which includes the open systems interconnection (OSI) model and the Internet Protocol(IP) or the Transport Control Protocol (TCP). Both of these systems often facilitate the efficient movement of data in diverse networks, although one must be more dominant or important than the other (Lau, 2004). The OSI model comprises different interacting layers, including applications that are used by network applications such as email clients and web browsers. The presentation layer is an interacting layer that receives data from varying application layers in the form of numbers and characters converting the data and compressing it. Other interacting layers include presentation, session, transport, data link, and network.
The overall agility is low in that this architecture makes it difficult to undertake changes since it is cumbersome and time-consuming. This is because of the monolithic aspect of implementations and the coupling of components that makes it difficult to makes changes (Khoury, 2018). This architecture has low ease of deployment and a high degree of testability in that some of the components belong to particular layers while others are stubbed or mocked. The performance is low as a result of the inefficiencies involved in going through the different layers in order to fulfill the request from the client. Although it has a low rating, layering architecture has a high ease of development in that the pattern is famous, and it is easy to implement through the separation of applications and skillsets by different layers – database, business, and presentation. A shopping cart web application is an example of a multi-layered architecture that is common in most e-commerce sites. This application is used in such sites in that it allows users to add the identified items to the cart, make payments, and make necessary changes to the number of items in the cart.
Service-Oriented Architecture (SOA)
This architecture is a type of software design whereby the services are availed by software components over a network to other software components. This architecture has a serving component and a requesting aspect that makes it similar to client-server architecture (Anandamurugan & Priyaa, 2014). This architecture is often established with the component’s interface and mode of communication between different components. The components in these systems are self-contained such that it avoids revealing inner workings. Communication between the components occurs when the calling component identifies the interface of the other serving component. Anandamurugan and Priyaa (2014) explain that unless one knows and identifies the components of the SOA, one cannot call the member function. After they are known, the serving and calling components require communication, which is often done through the eXtensible Mark-up Language (XML). This architecture is most applicable in marketplaces, where the services and components offered are published and cataloged (Anandamurugan & Priyaa, 2014). There are three parts to this architecture, including service registry, service requester, and service provider. This architecture is widely implemented in web services such as the Simple Object Access protocol.
Software as a Service (SaaS)
SaaS is a business model is an advanced version of the traditional style of software that requires installation in that this software does not need to be installed on the user’s machine (Carvalho et al., 2014). Examples of SaaS include Gmail, Google Docs, LinkedIn, and Facebook.
Microservices Architecture
This architecture is a variation on SOA in that it structures software such as a collection of different services, which can be considered as loosely coupled services with the advantage of the ease of testing, reuse, enabling the deploying of services, and promoting parallel development. This architecture is also characterized by lightweight services with ease of implementation in any programming language. However, this software has the drawback of a language lock that is known to pervade the monolithic software. This architecture is advantageous in that it is open to agile development in terms of deployment and continuous releases (Selvaraju, 2018). However, this architecture is also criticized for a high degree of complexity, latency costs, and information barriers. It is applied widely in that the link that exists between agile software development and microservices architecture is mutually supportive. This is the reason why large-scale services, including eBay, Twitter, Amazon, Netflix, and Paypal have evolved from the use of monolithic architecture to microservices architecture.
Conclusion
The development of the software started in the 19th century by Countess Lovelace, who worked on the analytical engine and formed a basis for modern-day calculators. Software architecture had developed from the use of the waterfall model during the 1960s when resultant software were modular in design, an aspect that increases use and maintenance. Although traditional software has become obsolete, various aspects are still relevant, including the virtuous cycle between software capability and computing power. Technology continues to advance as people continue to adopt computing into their lives owing to advanced software architecture, including software as a service (SaaS), layering and stack, monolithic architecture, monoservice architecture, and client-server architecture. In the future, the landscape of developers is likely to change across diverse perspectives, including technological, business, social, and business perspectives. From a social perspective, rich content, navigation paradigm, and user-related content will drive the trends. The business perspective will see improvement in micro-transactions and advanced monetization business models. A technological perspective will give birth to lightweight technologies, including SSE (Streaming SIMD Extensions), Ajax, POX (Plain Old XML), and RSS, which will continue to change the industry in surprising ways.
References
Anandamurugan, S & Priyaa, T (2014). Service Oriented Architecture, Nova Science Publications, Hauppauge, NY, available at: http://search.ebscohost.com.ezproxy.laureate.net.au/login.aspx?direct=true&db=nlebk&AN=1134313&site=ehost-liveCarvalho, M, Bellotti, F, Berta, R, De Gloria, A, Gazzarata, G, Hu, J & Kickmeier, M (2014). A case study on Service-Oriented Architecture for Serious Games Entertainment Computing, 6(1), pp.1-10, [online] https://www.researchgate.net/publication/268816327_A_case_study_on_Service-Oriented_Architecture_for_Serious_Games, accessed 17 June 2019.
Ceruzzi, PE, Aspray, W & Misa, TJ (2003) A History of Modern Computing, ‘Chapter 3: The Early History of Software, 1952-1964’, MIT Press, available at: https://lesa.on.worldcat.org/oclc/53883074KarBytes CS (2011). Intro to Computer Architecture, [online] https://www.youtube.com/watch?v=HEjPop-aK_w, last updated 3 January 2011, accessed 16 June 2019.
Khoury, J (2018). Waterfall Model Definition & Example [online] https://www.youtube.com/watch?v=Y_A0E1ToC_I, last updated 14 March 2018, accessed 12 May 2019.
Lau, K-K (2004). Component-based Software Development: Case Studies, World Scientific, New Jersey, USA, available at: http://search.ebscohost.com.ezproxy.laureate.net.au/login.aspx?direct=true&db=e000xww&AN=127449&site=ehost-live.
Moshix (2018). Mainframes, How They Work and What They Do – M80’, [online] https://www.youtube.com/watch?v=eGlC3WXL8FQ, last updated 11 August, 2018, accessed 12 May 2019.
Selvaraju, S 2018 ‘TCP/IP Model’, [online] https://www.lynda.com/IT-Infrastructure-tutorials/TCPIP-model/740413/753484-4.html?org=think.edu.au, last updated 19 June 2018, accessed 17 June 2019.