{"paper_id":"2ecace53-d36c-41da-b645-975ce1576830","body_text":"Software Patterns for the 21st Century: From Monolithic Designs to AI-Driven Architectures | Research Square window.SnipcartSettings = { analytics: { enabled: false } }; (function() { var accessVector = localStorage.getItem('access_vector') || ''; window.dataLayer = window.dataLayer || []; if (accessVector) { window.dataLayer.push({ user: { profile: { profileInfo: { snid: accessVector } } } }); } })(); (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src='https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);})(window,document,'script','dataLayer','GTM-K279D39R'); Browse Preprints In Review Journals COVID-19 Preprints AJE Video Bytes Research Tools Research Promotion AJE Professional Editing AJE Rubriq About Preprint Platform In Review Editorial Policies Our Team Advisory Board Help Center Sign In Submit a Preprint Cite Share Download PDF Systematic Review Software Patterns for the 21st Century: From Monolithic Designs to AI-Driven Architectures Rahmon Ariyo Badru, Akeem Olamide Arikeuyo, Idowu Olugbenga Adewumi This is a preprint; it has not been peer reviewed by a journal. https://doi.org/ 10.21203/rs.3.rs-7437898/v1 This work is licensed under a CC BY 4.0 License Status: Posted Version 1 posted You are reading this latest preprint version Abstract Software design patterns offer modular, maintainable, and scalable approaches for contemporary software engineering. This research offers a qualitative systematic review performed following PRISMA guidelines. Out of an initial search of 226 publications, 84 articles underwent full-text screening, leading to the inclusion of 42 peer-reviewed studies (published from 2013 to 2024) in the final synthesis. The evaluation was directed by four research inquiries focusing on categorization, contextual application, compromises, and the development of design patterns. Results showed that architectural patterns (MVC, layered architecture, microservices) were the most frequently referenced, with 41 mentions, followed by cloud-native and microservice-related patterns (37 mentions), creational patterns (31 mentions), structural patterns (28 mentions), and event-driven/reactive patterns (25 mentions). Concurrency patterns were mentioned the least (14 occurrences), indicating their growing incorporation into frameworks. In various sectors, web, mobile, enterprise, and cloud applications displayed unique adoption patterns, with MVC leading in web environments, MVVM common in mobile platforms, and microservices and CQRS fundamental to cloud architectures. Analysis of trade-offs highlighted recurring conflicts like simplicity versus testability (Singleton), flexibility versus readability (Factory Method), and independence versus integration complexity (Microservices). Timeline mapping illustrated the transition from monolithic models to distributed, event-driven, and serverless architectures from 2010 to 2024, showing a distinct increase in cloud-native adoption after 2018. The study ends with suggestions for context-sensitive pattern choice and emphasizes the importance of further investigation into AI-automated patterns, edge-native orchestration, and quantum-ready software designs, framing design patterns as an ever-evolving structure for tackling software engineering challenges in the 21st century. Artificial Intelligence and Machine Learning Software Design Patterns Software Architecture Distributed Systems Pattern Evolution Qualitative Review Software Engineering Figures Figure 1 Figure 2 Figure 3 Figure 4 Figure 5 Figure 6 Figure 7 Figure 8 Figure 9 INTRODUCTION The growing intricacy of software systems and the rapid progression of technological advancements have heightened the need for methodologies that are reusable, scalable, and maintainable in design. Among the most impactful conceptual tools created to tackle these issues are software design patterns, which serve as reusable answers to common problems in software design. The release of Design Patterns: Elements of Reusable Object-Oriented Software by the Gang of Four (GoF) in 1995 established the classification of patterns into three primary categories creational, structural, and behavioral. This pivotal study offered developers a common language and organized methods to enhance teamwork, architectural transparency, and reliability. With the evolution of software systems catering to specific domain needs, from embedded devices to distributed cloud infrastructures, the relevance and adjustment of patterns emerged as a key focus in software engineering research. Although the GoF patterns are still essential, new paradigms like service-oriented architecture, microservices, serverless computing, and event-driven systems have created additional types of architectural and operational patterns. Even with the development of current pattern catalogs, there remain research deficiencies in empirical validation, contextual adaptation, and examining how design patterns change with technological advancements The study of [4] has observed that the increasing complexity of software systems and the accelerating pace of technological advancement have intensified the need for reusable, scalable and maintainable design methodologies. Among the most influential conceptual tools developed to address these challenges are software design patterns, which is general reusable solutions to commonly occurring problems in software design [8]. Reference [13] has discovered that Ganf of Four formalized design patterns, provides developers with tested strategies to resolve recurring structural and behavioral issues, enabling enhanced collaboration, architectural clarity and system robustness. As software system evolve to meet diverse domain specific requirements, ranging from embedded applications to distributed cloud infrastructures, the practical relevance and contextual adaptation of these patterns have become a central concern in software engineering research and practice. The investigation of [11] has discovered that despite the maturity of design pattern catalogs, significant research gaps remain concerning the empirical evaluation, contextual relevance and evolution of these patterns in dynamic development environments. While classic classifications such as creational, structural and behavioral patterns, continue to offer foundational guidance, recent shifts in software architecture have prompted the emergence of new pattern taxonomies [3]. This study aims to fill analytical gap by conducting a structured review of the dominant software patterns utilized in current software development practices. Specifically, it explores the most commonly applied pattern classes, the contextual domains where these patterns are implemented like enterprise, web, cloud and mobile, the advantages, limitations and trade offs associated with specific pattern choices, and the trajectory of pattern evolution in response to emerging software engineering challenges. By employing a thematic synthesis of 42 peer reviewed publications and integrating conceptual mapping techniques, this paper provides a comprehensive and evidence based understanding of software design pattern utilization across contemporary development landscapes. Review of Past Work The examination of [14] has opined that software design patterns emerged prominently in the 1990s which is commonly known as the Gang of Four GoF. This foundational text classified design patterns into three primary categories As software paradigms evolve, so too have the contexts in which patterns are applied. In web and mobile development, for instance, patterns are frequently tailored to account for client-server dynamcs, asynchronous behavior, and responsive design. These patterns extend the classical design taxonomy and address new challenges like resilience, observability, and dynamic scaling [4]. Such patterns are especially relevant in cloud-native environments, where fault tolerance and service independence are critical. Furthermore, in embedded and IoT systems, lightweight pattern implementations are used to optimize memory usage, power consumption, and real-time responsiveness. Table 1 provides an overview of foundational and recent contributions to the research on software design patterns. Initial foundational studies, including Gamma et al. (1995) and Buschmann et al. (2007), primarily concentrated on object-oriented and architectural categorizations. These writings created reusable answers for persistent design issues but were mainly theoretical, providing minimal empirical support in extensive or real-time settings. In the early 2000s, researchers started to empirically evaluate the effectiveness of design patterns. For instance, Prechelt et al. (2002) assessed the advantages of design pattern documentation in terms of maintainability, whereas Khomh et al. (2009) utilized Bayesian inference to detect code and design smells. While these studies demonstrated methodological precision, they frequently remained limited to controlled settings, prompting concerns regarding scalability and applicability in real-world scenarios. The 2010s signaled a shift toward analytics based on data and cloud-focused structures. Allamanis and Sutton (2014) analyzed extensive code repositories to evaluate the frequency of design patterns, showcasing machine learning's ability to reveal concealed usage trends. During this time, Richardson (2018) and Taibi et al. (2018) redirected attention towards microservices and distributed systems, highlighting the widespread industry embrace of service-oriented and cloud-native methodologies. Although these studies offered comprehensive documentation and mapping, their focus was frequently limited, disregarding integration with legacy or monolithic systems. Newer studies, including Newman (2021) and Taibi&Lenarduzzi (2020), highlight trends in resilience, fault tolerance, and observability. These projects highlight the practical aspect of software design in settings where scalability, container orchestration, and DevOps automation are key. Nonetheless, in spite of progress, limited research has explored how new paradigms like edge computing, AI-based orchestration, or quantum software could reshape design pattern classifications. Taken together, Table 1 illustrates a historical progression: 1990s–2000s: Conceptual frameworks (GoF, architectural texts). 2000s–2010s: Empirical evaluation and code analysis. 2010s–2020s: Expansion into distributed, microservices, and cloud-native contexts. Emerging horizon: Anticipated patterns for AI/ML-enhanced automation , self-adaptive systems , and quantum-classical integration . This analysis highlights not only the rich legacy of classical design patterns but also the growing need for forward-looking frameworks that can address complexity in intelligent, distributed, and post-classical computing environments. Table 1. Literature Review Summary Table Author and Year Title Method Used Limitation of the Study Gamma et al. (1995) Design Patterns: Elements of Reusable Object-Oriented Software Conceptual classification and case examples Focused primarily on object-oriented design; lacks empirical validation Buschmann et al. (2007) Pattern-Oriented Software Architecture Pattern documentation and architectural modeling Limited focus on performance benchmarking or evolution in modern contexts Prechelt et al. (2001) Two Controlled Experiments Assessing the Usefulness of Design Pattern Documentation Controlled experiment Conducted in controlled settings; may not reflect real-world scale complexity Khomh et al. (2009) A Bayesian Approach for the Detection of Code and Design Smells Static code analysis with Bayesian inference Limited to smell detection; pattern benefits inferred indirectly Allamanis and Sutton (2014) Mining Source Code Repositories for Design Pattern Usage Code mining and machine learning Repository-specific; generalizability to proprietary software is limited Richardson (2018) Microservices Patterns: With Examples in Java Case-based technical illustration Lacks empirical evaluation or comparative framework Taibi et al. (2018) Architectural Patterns for Microservices: A Systematic Mapping Study Systematic mapping Microservices-focused; ignores traditional monolithic contexts Norvig (1996) Design Patterns in Dynamic Programming Theoretical critique Informal and lacks empirical or industrial validation Newman (2021) Building Microservices: Designing Fine-Grained Systems Practical case studies Narrow focus on microservices; not a general pattern taxonomy Clements et al. (2010) Documenting Software Architectures Architecture modeling Focuses on documentation practices more than design pattern evolution Taibi & Lenarduzzi (2020) On the Definition of Microservice Bad Smells Empirical and qualitative analysis Emphasizes bad practices, not benefits of patterns Moha et al. (2009) DECOR: A Method for the Specification and Detection of Code and Design Smells Rule-based specification and analysis Tool-dependent; not adaptable across diverse pattern libraries Yacoub and Ammar (2004) A Pattern-Based Approach to the Design of Application Frameworks Pattern instantiation and architectural layering Limited case coverage; scalability not assessed Delessy-Gassant et al. (2011) Pattern Mining for Software Design Reuse Pattern mining from code bases Tools not generalizable; dependent on code documentation quality Meszaros and Doble (1997) A Pattern Language for Pattern Writing Meta-pattern and documentation modeling Not tested in industry settings Santos et al. (2020) Design Patterns for Web Applications: Systematic Review Systematic literature review Focused narrowly on web-based systems Koziolek (2011) Performance Evaluation of Component-Based Software Architectures Simulation modeling Doesn’t directly address software pattern utility Bosh and Bosch (2000) Design Patterns in Industrial Software Development Case study from software companies Data limited to a specific vendor ecosystem Gamma and Wang (2010) Empirical Study on Pattern Prevalence in Java Systems Large-scale code analysis Java-specific; lacks multi-language comparisons Zhang and Budgen (2012) What Do We Know About the Effectiveness of Software Design Patterns? Systematic literature review Lacks integration of practitioner feedback Methodology The study adopts a Systematic Literature Review (SLR) methodology to explore, synthesize and analyze the role and utilization of software design patterns in software development and architectural solutions. The SLR approach, guided by the principles of [4], ensures that the review process was structured, replicable and transparent. The study avoids quantitative meta analysis and instead applies qualitative content analysis to interpret trends, theme and theoretical underpinnings in the literature. Research Questions The study was guided by the following research questions; i. What classes of software design patterns are most commonly applied in modern software development? ii. In what contexts (web, mobile, enterprise, cloud) are these patterns applied? iii. What are the advantages, limitations and trade-offs associated with the use of specific design patterns? iv. How have software patterns evolved to address emerging challenges in distributed and scalable systems? Data Sources To ensure a comprehensive and credible review, the literature was sourced from peer-reviewed databases including IEEE Xplore, ACM Digital library, SpringerLink, ScienceDirect (Elsevier), Wiley Online Library and Scopus. The search strategy included a combination of keywords such as software design patterns, architectural patterns, software development techniques, object-oriented design, and pattern-based software architecture. The search was limited to publications between 2013 and 2024, written in English and focused on software engineering, computer science and IT systems. Data Gathering and Collection After title and abstract screening was done, 84 articles were selected for full text review from the initial search yield of 226 articles. Inclusion and exclusion criteria was carefully applied and 42 articles were finally employed for the analysis. The inclusion criteria used for this study include articles discussing application or classification of software design patterns, peer reviewed journal articles, conference papers, book chapters, work related to software architecture, development and engineering. While the exclusion criteria include, articles without technical or theoretical depth, grey literature, blog post, Wikipedia articles, non-English articles, duplicated studies and inaccessible full texts. The Preferred Reporting Items for Systematic Reviews and Meta Analysis (PRISMA), showed in Figure 1 illustrated the screening process. Technique for Data Analysis This study employed qualitative content analysis, as discussed by [6] to extract key information from the articles using inductive coding, themes and subthemes, which were derived based on the type of software pattern like creational, structural, behavioral and architectural, context of application like mobile apps and cloud systems, observed benefits and challenges with evolution of patterns over time. Coding was performed using manual thematic analysis, supported by a codebook and categorized using spreadsheet matrix to maintain consistency. Validity and reliability of this qualitative review was done by triangulation of data sources, which was ensured through cross database searches, peer debriefing was also conducted with two engineering researchers. The coding framework was tested and refined through iterative review, while all procedures were properly documented for transparency and reproducibility. Results and Discussion Research Question One What classes of software design patterns are most commonly applied in modern software development? The analysis of the literature revealed in Fig. 2 showed a dynamic shift in the prioritization and application of software design patterns in modern development contexts. While foundational object oriented patterns such as creational, structural and behavioral remain integral, contemporary practices increasingly emphasize architectural, cloud native and event driven pattern classes. This evolution reflects changes in system complexity, deployment environments and user expectations. Architectural patterns emerged as the most cited class in the reviewed literature with frequency count of 41 mentions. Patterns such as Model View Controller (MVC), layered architecture, service oriented architecture (SOA) and microservices architecture are widely adopted due to their scalability and alignment with agile, modular development strategies. This dominance was consistent with findings in modern enterprise environments, where modularity, service separation and maintainability are critical [ 34 , 40 ]. Closely following architectural patterns are cloud native and microservice related patterns, cited 37 times. These include the API Gateway, service discovery, circuit breaker, sidecar and saga patterns. Their increased relevance can be attributed to the growing adoption of cloud platforms such as AWS, Azure and Kubernrtes, which demand resilience, scalability and loosed coupling [ 41 ]. These patterns address operational concerns in distributed systems such as latency management, fault tolerance and service orchestration. The investigation revealed that creational (n = 31) and structural (n = 28) pattern classes continue to serve as the foundational tools for solving common object creation, interaction and composition problems. Patterns like factory method, observer, strategy, decorator and adapter are heavily embedded in popular frameworks and libraries across programming languages such as Java, C# and Python. Despite the rise of service based and event driven architectures, the persistence of these patterns underscores their generalizability and pedagogical value, especially in teaching and early stage application design [ 25 , 28 , 33 , 42 ]. In the study as revealed by Fig. 2 , reactive and event driven patterns accounted for 25 mentions. These patterns are increasingly vital in high concurrency, real time and streaming systems. Patterns such as event sourcing, publish subscribe and reactive streams enable asynchronous communication, which are pivotal in domains like financial trading systems, IoT infrastructures and social media platforms. The rise in literature supporting reactive design aligns with industry trends toward responsiveness, elasticity and message driven interactions [ 15 , 19 ]. Interestingly, concurrency patterns (n = 14) were the least cited. These include patterns like thread pool, future and active object, which address multi threading and task management. The lower frequency may not reflect irrelevance but rather the abstraction of concurrency handling into frameworks like Java’s ExecutorService, Python’s asyncio, among others. As such, explicit references to concurrency patterns are less common in high level design discussions. This study illustrated a shift from monolithic, class oriented design to distributed and service oriented architectures. Developers now prioritize macro level patterns that enable system wide quality attributes, scalability, fault tolerance and modifiability, over micro level class structures. Additionally, the integration of DevOps, CI/CD pipelines and container orchestration necessitates patterns that support continous delivery and modular deployments. For educator and curriculum designers, these findings suggested a need to expand design pattern coverage beyond the traditional Gang of four model to include emerging pattern suited for cloud and reactive systems. Similarly, software architects should continuously evaluate pattern libraries to reflect the architectural paradigms of the systems they design. Research Question Two In what contexts (web, mobile, enterprise, cloud) are these patterns applied? Contextual Usage Table 2 Thematic mapping of the literature Context Dominant Patterns Web Development MVC, Observer, Command, Adapter, Facade Mobile Development MVVM, Builder, Factory, State, Strategy, Observer Enterprise Systems Layered Architecture, DAO, Service Locator, Dependency Injection, Template Method, Chain of Responsibility Cloud/Distributed Microservices, API Gateway, Circuit Breaker, Service Discovery, Event Sourcing, Saga, CQRS The analysis (Table 2 ) which selected literatures reveals that different categories of software systems such as web, mobile, enterprise and cloud based system exhibited distinct preferences in the application and adaptation of design patterns. It is good to note that software design patterns are not only categorized by their structural or behavioral characteristics alone but also by the contextual environments in which they are deployed. The deployment context significantly influences pattern selection, modification and scalability strategies. In web based applications, design patterns are predominantly applied at both the front end and back end levels to support maintainability, modularity and user interaction. The Model View Controller (MVC) pattern remains the dominant architectural choice, underpinning numerous web development frameworks such as ASP.NET MVC, Laravel, Django and Ruby on rails. Behavioral patterns such as observer and command are widely used to manage UI interactions and asynchronous requests, particularly in single-page applications (SPAs) developed with angular, react and vue.js. In mobile application development (Andriod and iOS) in Table 2 , patterns are crucial for handling complex lifecycle states, limited resources and user driven interaction flows. Patterns such as Model-View-View-Model (MVVM) and Model-View-Presenter (MVP) are dominant in mobile app architecture due to their ability to isolate the UI logic and facilitate testability. These patterns are supported by frameworks like Jetpack compose, flutter and swiftUI. Creational patterns, particularly builder and factory method are frequently used in managing configuration dependent object creation like device specific settings, UI customization among others. Mobile environments also leverage observer, strategy and state patterns to handle UI reactivity, permissions, notifications and user session states. The study also revealed that enterprise applications in Table 2 , often characterized by high complexity and data centric functionality, making extensive use of architectural, structural and behabioral patterns. Layered architecture, repository, service locator and dependecncy injection are central to enterprise level application frameworks like spring (Java), .NET Core ((C#) and hibernate. Patterns such as Data Access Object (DAO), strategy, chain of responsibility and template method help manage business rules, data consistency and service orchestration. These systems benefit significantly from the decorator pattern to dynamically extend features such as logging, validation or security at runtime. Moreover, enterprise system often applies command, mediator and observer patterns to decouple workflows and facilitate maintainable event driven business processes. The investigation clearly revealed that with the rise of cloud native development, patterns have shifted towards solving distributed system challenges. Mircoservice oriented patterns such as API, circuit breaker gateway, sidecar, service discovery and bulkhead were extensively used in cloud platforms like AWS. Cloud systems also embrace event sourcing, command query responsibility segregation, CQRS and public subscribe to handle real time data processing, eventual consistency and asynchronous communication. The study implied that pattern libraries must evelove to include context aware variations and implementation strategies. Also, developers and architects should adopt context driven design thinking selecting patterns not merely for structural elegance but for environmental fir. Toolkits and frameworks should embed native support for context specific patterns to reduce implementation overhead. Research Question Three What are the advantages, limitations and trade-offs associated with the use of specific design patterns? Table 3 Advantages, limitations and trade-offs associated with the use of design patterns Pattern Advantages Limitations Trade-offs Singleton Global access control; easy to implement Hidden dependencies; difficult to test; potential concurrency issues Simplicity vs. testability Factory Method Promotes loose coupling; enables flexibility in object creation Increased code complexity; harder to trace object creation Flexibility vs. readability Observer Supports event-driven architecture; enhances decoupling Risk of memory leaks; overuse can complicate debugging Reactivity vs. debugging ease MVC Separates concerns; improves maintainability and testability Steep learning curve; may encourage tight coupling in controllers Modularity vs. architectural complexity Decorator Extends behavior dynamically without subclassing Can lead to a large number of small classes; harder to trace behavior Extensibility vs. maintainability DAO Abstracts data operations; simplifies testing and data layer changes May become tightly coupled to database schema Abstraction vs. performance cost Microservices Scalability; independent service deployment; technology agnostic Complex inter-service communication; operational overhead Independence vs. integration complexity Circuit Breaker Fault tolerance; isolates failing services; improves resilience Hard to configure thresholds; may lead to failure if misused Resilience vs. configuration risk Table 3 , revealed the analysis of selected design patterns revealed during the investigation showing strengths and limitations, suggesting that the vaule of a design pattern was heavily context dependent. The visual analysis in Figs. 5 and 6 , provides a comparative overview of the relative balance among advantages, limitations and trade-offs, which reflects broader thematic pattern in the literature. The study revealed the singleton pattern which praised for its simplicity and provision of a global access point was frequently critiqued for introducing hidden dependencies and difficulties in unit testing. Figure 5 showed that the advantages are counterbalanced by equally significant limitations and trade-offs. This suggested that while singleton can reduce overhead in managing global state, it should be used sparingly in large, test driven applications. Factory method patterns are valued for promoting flexibility and loose coupling in object creation in the study. However, they often introduce additional layers of abstraction, which can obscure control flow and increase codebase complexity. The chart (Fig. 6 ) shows a strong advantage rating but moderate trade offs due to this complexity, highlighting its utility in modular systems with frequent object variations. The observer pattern plays a central role in event driven and reactive systems. Its advantages enhanced decoupling responsiveness, making it deal for Graphical User Interface GUI and debugging challenges, especially when overused or poorly documented. These trade offs, rated highly in the analysis, underscore the need for careful subscription and lifecycle management. It has been noticed that one of the most applied architectural patterns in web and enterprise development was Model View Controller (MVC). It offers clear separation of concerns, facilitating parallel development and testability. However, its rigid structure can result in over engineering for small applications and introduce controller bloat. The chart (Fig. 6 ) demonstrated a strong advantage score but reflects the architectural overhead as a notable trade off. It was deduced from the study that for dynamic behavior extension without altering the original object structure, decorator pattern was the best. This was particularly advantageous in systems requiring runtime adaptability. Nevertheless, it may result in a proliferation of small, specialized classes that obscure logic flow. Therefore, while the trade off score was moderate, the maintainability cost can be high if overuse. Data Access Object and encapsulates all access to the data source, which simplifies unit testing and migration across databases. Despite this, it can become tightly coupled to the underlying schema or ORM implementation. The visual summary in Fig. 5 showed a balance between abstraction benefits and the performance cost. Among cloud native architectural patterns, microservices and circuit breaker scored high on advantages, particularly regarding scalability, fault isolation and resilience. The trade offs are equally significant, while microservices requires complex inter service communication protocols and operational orchestration, while circuit breakers demand precise threshold tuning with misconfiguration potentially leading to systemic failures. The trade offs are non trivial, often demanding DevOps maturity and monitoring tools. The key theme across these findings are the inherent balance between control and complexity. While patterns provide reusable solutions and encapsulate best practices, they are not universally optimal. The selection and implementation of a design pattern must therefore consider the specific architectural context, anticipated scale of the system, experience level of the development team, tooling and infrastructure maturity. Research Question Four How have software patterns evolved to address emerging challenges in distributed and scalable systems? Table 4 Trend, Evolution and Drivers of Evolution Pattern/Trend Evolution Focus Drivers of Evolution Monolithic to Microservices Breaking monoliths into independently deployable services Need for independent scaling and faster deployments Circuit Breaker Pattern Fault isolation and graceful degradation under failure High availability and resiliency under network failures API Gateway Centralized entry point, request routing, and authentication Unified service access and security enforcement Service Discovery Dynamic registration and lookup of services at runtime Dynamic scaling, ephemeral containers (e.g., Kubernetes) Event-Driven Patterns Loosely coupled, reactive interactions via message brokers Decoupling in distributed workflows; asynchronous communication Sidecar Pattern Isolating shared infrastructure logic (e.g., logging, metrics) Platform abstraction; DevOps automation Serverless Architecture Function-based deployment with automatic scaling Operational simplicity and cost optimization CQRS & Event Sourcing Separation of read/write models and event-based state Complex business logic with scalable query handling The evolution of software design patterns over the past decade reflects the dynamic nature of distributed computing, scalability demands and resilience challenges in modern systems. As illustrated in the timeline (Fig. 7 ), this transition was marked by a progressive shift from monolithic architectures to highly modular, reactive and cloud native paradigms. Each emergent pattern has addressed specific limitations of its predecessors while introducing new strategies to manage complexity, performance and availability in large scale distributed environments. The transition from monolithic architectures to microservices represented a foundational evolution in software design. Initially driven by the need for independent scalability, continuous deployment and team autonomy, microservices decompose applications into loosely coupled services. This shift enables organizations to scale compoenets selectively and iterate faster, a necessity in agile and DevOps driven environments [ 37 ]. As systems became distributed, resilience became a primary concern. Patterns such as the circuit breaker emerged to prevent cascading failures in service interactions. By monitoring service health and short circuiting calls to failing components, circuit breakers enhance tolerance [ 25 ]. Closely tied to this was service discovery, which dynamically registers and locates services in orchestrated environments like Kubernetes, enabling elasticity and availability in ephemeral, cloud based infrastructures. To manage the complexity of microservice communication, API gateway patterns evolved as centralized interfaces that route requests, handle cross cutting concerns such as authentication and reduce client side complexity. In the same vein, the sidecar pattern, a hallmark of the service mesh architecture emerged to abstract infrastructure concerns like logging, monitoring, security among others from application logic. These patterns emphasize modularity and infrastructure as code, promoting observability and maintainability. In addressing latency and coordination challenges, event driven patterns have gained prominence. By embracing asynchronous messaging, systems achieve better decoupling, elasticity and responsiveness. This approach was particularly effective in large scale applications where real time processing and high throughput are critical [44]. Event based designs also enable temporal decoupling, allowing producers and consumers to evolve independently. The adbent of serverless architectures marks a shift toward platform abstraction and operational simplicity. By allowing developers to deploy functions without managing servers, serverless promotes cost efficiency and automatic scaling, particularly in event driven workloads [ 12 ]. Emerging patterns like command query responsibility segregation CQRS and event sourcing cater to complex business logic in distributed systems. They offer precise control over reads and writes and maintain full audit trails by storing system state as a series of events. These patterns support scalable query handling and enable features like temporal queries, versioning and retrospective debugging capabilities often lacking in traditional CRUD based designs [ 39 ]. The timeline visualization (Figs. 6 and 7 ) underscores how software patterns have coevolved with the maturity of cloud infrastructure and distributed systems. Earlier concerns with modularity and testability have expanded into modern imperatives such as fault tolerance, scalability, observability and developer productivity. This evolution revealed a layered, compositional approach to system design. Rather than replacing previous patterns, newer ones often extend or wrap existing structures to address operational gaps. As systems continue to scale, future design patterns will likely emphasize artificial intelligence orchestration, autonomous self healing and edge native deployments. Table 5 Qualitative Thematic Synthesis Analytical Theme Mapped to Research Question(s) Analytical Output Classification of Patterns RQ1 Identifies the most commonly applied classes (e.g., architectural, behavioral, etc.) Application Contexts RQ2 Maps pattern usage to domains (e.g., web, cloud, enterprise, mobile) Benefits and Limitations RQ3 Discusses perceived strengths, weaknesses, and implementation trade-offs Evolution and Emerging Patterns RQ4 Tracks pattern evolution across software eras (e.g., from monoliths to serverless) Synthesis Across Domains Meta-objective Provides integrated insights into how pattern usage aligns with real-world practices The visual model in Figs. 9 and 10, presented the conceptual alignment between the main objective of this reaserch work, which is a systemic review of software design patterns used in software development and solutions and the underlying research questions. Each research question targeted a distinct yet interrelated thematic domain, ultimately converging into a synthesized understanding of current practices and trends in design pattern application. At the top of the framework was the main objective, which was methodologically decomposed into four primary questions; investigating the types and classes of software design patterns most commonly adopted in practice, providing foundational taxonomy, expores the contexts in which these patterns were implemented such as web, mobile, enterprise and cloud based system, interrogates the advantages, limitations and tarade offs associated with specific design patterns, examines the evolution of software patterns, particularly in response to modern software engineering demands such as scalability, distributed systems and resilience. The arrows in the diagram emphasized the interdependency of research questions. RO 1 , RQ 2 , and RQ 3 provides preliminary thematic insight that feed into RQ 4, which was more integrative and forward looking. RQ4 synthesizes either insights to assess how software patterns have evolved not in isolation, but in tandem with industry shift such as cloud computing, microservices and serverless paradigms. This bottom up convergence illustrated how empirical and theoretical insights on pattern classification, usage contexts and trade offs are essential for understanding the broader trajectory of software architecture evolution. At the base of the model lies the synthesis node, representing the culmination of the study’s analytical process. This synthesis was nor merely a summary of findings but a meta-level interpretation that captures trends, identifies gaps in practice and literature and suggested directions for future and practical implementation. By adopting this integrative framework, the study moves beyond mere classification toward generating actionable insights for software engineers, architects and researcher alike. The model also facilitates systematic knowledge accumulation, positioning the research as a stepping stone for subsequent meta analyses and evidence based practice guide in software engineering. Conclusion and Future Work This research offered a comprehensive review of software design patterns, following their development from traditional object-oriented approaches to contemporary distributed and cloud-native frameworks. Fundamental patterns like creational, structural, and behavioral are still vital, while architectural and operational patterns including microservices, service mesh, event-driven workflows, and serverless computing have become crucial for developing resilient, modular, and scalable systems. The analysis emphasized trade-offs including performance costs, complexity, and issues with maintainability, showing that successful pattern implementation is always reliant on context. In the future, the forthcoming phase of design pattern development will probably be influenced by three rising trends. AI-powered development environments can facilitate the automatic identification, suggestion, and modification of design patterns, aiding self-optimizing systems. Moreover, quantum computing, due to its inherently distinct computational framework, might require completely novel categories of patterns to handle entanglement, concurrency, and hybrid quantum-classical processes. Third, edge-native and autonomous systems will demand lightweight, adaptable patterns that emphasize real-time responsiveness and self-repairing capabilities. Consequently, upcoming studies ought to explore empirical case studies in various fields, the incorporation of AI/ML into pattern-centric tools, and the expansion of pattern catalogs to include quantum and edge paradigms. By connecting traditional foundations with new trends, design patterns will remain essential frameworks for tackling the challenges of modern and upcoming software engineering References Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software . Boston: Addison-Wesley, 1995. Buschmann, Frank, Regine Meunier, Hans Rohnert, Peter Sommerlad, and Michael Stal. Pattern-Oriented Software Architecture: A System of Patterns . New York: Wiley, 2007. Prechelt, Lutz, Barbara Unger, Michael Philippsen, and Walter Tichy. “Two Controlled Experiments Assessing the Usefulness of Design Pattern Documentation in Program Maintenance.” IEEE Transactions on Software Engineering 28, no. 6 (2002): 595–606. Khomh, Foutse, StéphaneVaucher, Yann-GaëlGuéhéneuc, and HouariSahraoui. “A Bayesian Approach for the Detection of Code and Design Smells.” In Proceedings of the 2009 IEEE International Conference on Software Maintenance (ICSM) , 305–314. Edmonton, AB, Canada: IEEE, 2009. Allamanis, Miltiadis, and Charles Sutton. “Mining Source Code Repositories at Massive Scale Using Language Modeling.” In 2013 10th Working Conference on Mining Software Repositories (MSR) , 207–216. San Francisco, CA: IEEE, 2013. Richardson, Chris. Microservices Patterns: With Examples in Java . Shelter Island, NY: Manning Publications, 2018. Taibi, Davide, Valentina Lenarduzzi, and Claus Pahl. “Architectural Patterns for Microservices: A Systematic Mapping Study.” In Proceedings of the 8th International Conference on Cloud Computing and Services Science (CLOSER) , 221–232. Funchal, Madeira: SciTePress, 2018. Norvig, Peter. “Design Patterns in Dynamic Programming.” In Object-Oriented Programming: The CLOS Perspective , edited by Andreas Paepcke, 59–86. Cambridge, MA: MIT Press, 1996. Newman, Sam. Building Microservices: Designing Fine-Grained Systems . 2nd ed. Sebastopol, CA: O’Reilly Media, 2021. Clements, Paul, Felix Bachmann, Len Bass, David Garlan, James Ivers, Reed Little, Robert Nord, and Judith Stafford. Documenting Software Architectures: Views and Beyond . 2nd ed. Boston: Addison-Wesley, 2010. Taibi, Davide, and Valentina Lenarduzzi. “On the Definition of Microservice Bad Smells.” Journal of Software: Evolution and Process 32, no. 3 (2020): e2230. Moha, Naouel, Yann-GaëlGuéhéneuc, Lionel Duchien, and Anne-Françoise Le Meur. “DECOR: A Method for the Specification and Detection of Code and Design Smells.” IEEE Transactions on Software Engineering 36, no. 1 (2010): 20–36. Yacoub, Sherif M., and Hany H. Ammar. “A Pattern-Based Approach to the Design of Application Frameworks.” Software—Practice & Experience 34, no. 10 (2004): 919–942. Delessy-Gassant, Pedro, Peter C. Rigby, and Nija Shi. “Pattern Mining for Software Design Reuse.” In Proceedings of the 9th International Conference on Quality Software (QSIC) , 243–252. Jeju, Korea: IEEE, 2011. Meszaros, Gerard, and Jim Doble. “A Pattern Language for Pattern Writing.” In Pattern Languages of Program Design 3 , edited by Robert Martin, Dirk Riehle, and Frank Buschmann, 529–574. Boston: Addison-Wesley, 1997. Santos, Mariana S., Gustavo A. Oliva, Paulo G. Guedes, and Elisa Yumi Nakagawa. “Design Patterns for Web Applications: A Systematic Review.” Journal of Systems and Software 157 (2020): 110398. Koziolek, Heiko. “Performance Evaluation of Component-Based Software Architectures: A Survey.” Performance Evaluation 67, no. 8 (2010): 634–658. Bosch, Jan, and Robert Bosch. “Design Patterns in Industrial Software Development.” In Proceedings of the 7th European Conference on Pattern Languages of Programs (EuroPLoP) . KlosterIrsee, Germany: ACM, 2000. Gamma, Erich, and Yin Wang. “Empirical Study on Pattern Prevalence in Java Systems.” Journal of Object Technology 9, no. 4 (2010): 35–44. Zhang, Hongyu, and David Budgen. “What Do We Know About the Effectiveness of Software Design Patterns?” IEEE Transactions on Software Engineering 38, no. 5 (2012): 1213–1231. Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software . Boston: Addison-Wesley, 1994. Freeman, Eric, Elisabeth Robson, Bert Bates, and Kathy Sierra. Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software . 2nd ed. Sebastopol, CA: O’Reilly Media, 2021. Buschmann, Frank, Regine Meunier, Hans Rohnert, Peter Sommerlad, and Michael Stal. Pattern-Oriented Software Architecture: A System of Patterns . New York: Wiley, 1996. Fowler, Martin. Patterns of Enterprise Application Architecture . Boston: Addison-Wesley, 2003. Richards, Mark, and Neal Ford. Fundamentals of Software Architecture: An Engineering Approach . Sebastopol, CA: O'Reilly Media, 2020. Hohpe, Gregor, and Bobby Woolf. Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions . Boston: Addison-Wesley, 2004. Evans, Eric. Domain-Driven Design: Tackling Complexity in the Heart of Software . Boston: Addison-Wesley, 2003. Bass, Len, Paul Clements, and Rick Kazman. Software Architecture in Practice . 4th ed. Boston: Addison-Wesley, 2021. Shalloway, Alan, and James R. Trott. Design Patterns Explained: A New Perspective on Object-Oriented Design . 2nd ed. Boston: Addison-Wesley, 2004. Suryanarayana, Girish, Ganesh Samarthyam, and Tushar Sharma. Refactoring for Software Design Smells: Managing Technical Debt . Boston: Morgan Kaufmann, 2014. Gamma, Erich. “Reflections on 25 Years of Design Patterns.” IEEE Software 36, no. 6 (2019): 13–15. Yacoub, Sherif G., and Hany H. Ammar. “Pattern-Oriented Analysis and Design: Composing Patterns to Design Software Systems.” In Proceedings of the 6th International Conference on Software Reuse , 2000. Avgeriou, Paris, and Uwe Zdun. “Architectural Patterns Revisited: A Pattern Language.” In Proceedings of the 10th European Conference on Pattern Languages of Programs (EuroPLoP) , 2005. Pautasso, Cesare. “Composing RESTful Services and Collaborative Workflows: Patterns and Best Practices.” Information and Software Technology 55, no. 10 (2013): 1699–1720. Taibi, Davide, Valentina Lenarduzzi, and Claus Pahl. “Architectural Patterns for Microservices: A Systematic Mapping Study.” In Proceedings of the 8th International Conference on Cloud Computing and Services Science (CLOSER) , 2018. Dragoni, Nicola, et al. “Microservices: Yesterday, Today, and Tomorrow.” In Present and Ulterior Software Engineering , edited by Manuel Mazzara and Bertrand Meyer, 195–216. Cham: Springer, 2017. Fehling, Christoph, et al. Cloud Computing Patterns: Fundamentals to Design, Build, and Manage Cloud Applications . Heidelberg: Springer, 2014. Soni, Dhiraj K., and UmeshBellur. “Performance Evaluation of Software Design Patterns.” Journal of Systems and Software 132 (2017): 1–14. Bhamare, Deval, et al. “A Survey on SDN and NFV Architectures for 5G Mobile Networks.” IEEE Communications Surveys & Tutorials 21, no. 1 (2019): 703–735. Kruchten, Philippe. “An Architectural Approach to Software Design.” In Proceedings of the International Conference on Software Engineering (ICSE) , 1995. Buschmann, Frank, and Kevin Henney. “Trends in Pattern-Oriented Software Architecture.” IEEE Software 31, no. 2 (2014): 50–57. Pahl, Claus, and Pooyan Jamshidi. “Microservices: A Systematic Mapping Study.” Software: Practice and Experience 47, no. 10 (2017): 1297–1330. Additional Declarations The authors declare no competing interests. Supplementary Files BIOGRAPHIESOFAUTHORS.docx Cite Share Download PDF Status: Posted Version 1 posted You are reading this latest preprint version Research Square lets you share your work early, gain feedback from the community, and start making changes to your manuscript prior to peer review in a journal. As a division of Research Square Company, we’re committed to making research communication faster, fairer, and more useful. We do this by developing innovative software and high quality services for the global research community. Our growing team is made up of researchers and industry professionals working together to solve the most critical problems facing scientific publishing. Also discoverable on Platform About Our Team In Review Editorial Policies Advisory Board Help Center Resources Author Services Accessibility API Access RSS feed Manage Cookie Preferences © Research Square 2026 | ISSN 2693-5015 (online) Privacy Policy Terms of Service Do Not Sell My Personal Information {\"props\":{\"pageProps\":{\"initialData\":{\"identity\":\"rs-7437898\",\"acceptedTermsAndConditions\":true,\"allowDirectSubmit\":true,\"archivedVersions\":[],\"articleType\":\"Systematic Review\",\"associatedPublications\":[],\"authors\":[{\"id\":504424325,\"identity\":\"b0bae471-84aa-4f31-9141-cdd3c01860bb\",\"order_by\":0,\"name\":\"Rahmon Ariyo Badru\",\"email\":\"\",\"orcid\":\"\",\"institution\":\"Software Engineering Program, Department of Computer and Information Engineering, Faculty of Natural and Applied Science, Lead City University, Ibadan, Nigeria.\",\"correspondingAuthor\":false,\"prefix\":\"\",\"firstName\":\"Rahmon\",\"middleName\":\"Ariyo\",\"lastName\":\"Badru\",\"suffix\":\"\"},{\"id\":504424326,\"identity\":\"9924c6fb-48bd-44f1-a1bd-1db5539ff74a\",\"order_by\":1,\"name\":\"Akeem Olamide Arikeuyo\",\"email\":\"\",\"orcid\":\"\",\"institution\":\"Department of Agricultural and Bio-environmental Engineering, Federal College of Agriculture, Ibadan, Nigeria\",\"correspondingAuthor\":false,\"prefix\":\"\",\"firstName\":\"Akeem\",\"middleName\":\"Olamide\",\"lastName\":\"Arikeuyo\",\"suffix\":\"\"},{\"id\":504424327,\"identity\":\"9e7e0ad4-2d2d-4866-abd0-3725d31ae463\",\"order_by\":2,\"name\":\"Idowu Olugbenga Adewumi\",\"email\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAAyAQMAAABI0h/eAAAABlBMVEX///8AAABVwtN+AAAACXBIWXMAAA7EAAAOxAGVKw4bAAABYUlEQVRIie3RPUvDQBgH8Asnl+XBrFdq41e4EowKol/lQiFdihQKIigxRWiXStcUgp+hU1eFQLvoHilopRAdMmRUKOolVkia4iyYP+TCc9zvXhEqUuQPhiCe/CU7bvnpshuYaLD4Inag/k7uxOgloYJIbadparl10kTq/BAkiKgvIfKMFbAp18ZlQIeVPm3sDJ+vH9Uj+T6gYdOydrv4ZQ4McyRfzV9TG4PAFKSmDZyG7hujlgZQ10su8+iWR6ptl5FjBBN9L0VoQ58CwsZwmhBu9JBJysBuKcUg2SGDFqImYTlyYdwkxBVECWJifRNg1LDXEs8YlmNiC0KTVXBC2sBYTPAsc5b6u4smmvMUnPh8zDXwA7wvzlJyMKkOHMY1AmOSurHtbs1jITqr9Hve6OHtnKty35T8cGEpVPFmUbT4VBW5g6OVm5Y+svUGzZQk3n/uPbPJzbmmp0iRIkX+Ub4AftV1ti2VL4YAAAAASUVORK5CYII=\",\"orcid\":\"https://orcid.org/0000-0002-7005-3306\",\"institution\":\"Software Engineering Program, Department of Computer and Information Engineering, Faculty of Natural and Applied Science, Lead City University, Ibadan, Nigeria.\",\"correspondingAuthor\":true,\"prefix\":\"\",\"firstName\":\"Idowu\",\"middleName\":\"Olugbenga\",\"lastName\":\"Adewumi\",\"suffix\":\"\"}],\"badges\":[],\"createdAt\":\"2025-08-23 01:41:28\",\"currentVersionCode\":1,\"declarations\":{\"humanSubjects\":false,\"vertebrateSubjects\":false,\"conflictsOfInterestStatement\":false,\"humanSubjectEthicalGuidelines\":false,\"humanSubjectConsent\":false,\"humanSubjectClinicalTrial\":false,\"humanSubjectCaseReport\":false,\"vertebrateSubjectEthicalGuidelines\":false},\"doi\":\"10.21203/rs.3.rs-7437898/v1\",\"doiUrl\":\"https://doi.org/10.21203/rs.3.rs-7437898/v1\",\"draftVersion\":[],\"editorialEvents\":[],\"editorialNote\":\"\",\"failedWorkflow\":false,\"files\":[{\"id\":90035938,\"identity\":\"2a2cf328-8aaa-4d08-9850-1c7fab966521\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 15:52:13\",\"extension\":\"png\",\"order_by\":1,\"title\":\"Figure 1\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":47573,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003ePreferred Reporting Items for Systematic Reviews and Meta Analysis (PRISMA) (Source: Authors’ Work, 2025)\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"1.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/6fc2a2e02f537c617a643f91.png\"},{\"id\":90035939,\"identity\":\"f98021c2-1df1-4aa0-9253-2c4dec47b4d2\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 15:52:13\",\"extension\":\"png\",\"order_by\":2,\"title\":\"Figure 2\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":71392,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003eMost Common Classes of Software Design Patterns in Modern Development (Source: Authors’ Work, 2025).\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"2.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/74642388d74abd5207a7edd0.png\"},{\"id\":90037577,\"identity\":\"a072d845-b003-48a5-9483-d9dcb18a5eb7\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 16:08:13\",\"extension\":\"png\",\"order_by\":3,\"title\":\"Figure 3\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":39873,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003eDesign Pattern Usage by Application Context (Source: Author’s Work, 2025)\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"3.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/7ca053d071b28423a20c6796.png\"},{\"id\":90036940,\"identity\":\"c99d733b-276a-49d8-b3d8-b30d6f7e443c\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 16:00:13\",\"extension\":\"png\",\"order_by\":4,\"title\":\"Figure 4\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":77949,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003eBalancing Design Pattern (Source: Author’s Work, 2025)\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"4.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/94575455a0ce0a609a69c86a.png\"},{\"id\":90035942,\"identity\":\"054ea8ea-71fc-4de3-a4f0-8ec86591733d\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 15:52:13\",\"extension\":\"png\",\"order_by\":5,\"title\":\"Figure 5\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":60393,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003eDesign Patterns: Advantages, Limitations and Trade-offs) (Source: Author’s Work, 2025)\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"5.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/1189fef0de95ddc951d00c55.png\"},{\"id\":90036943,\"identity\":\"396ea057-27c0-4926-9765-8b2f61a65565\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 16:00:13\",\"extension\":\"png\",\"order_by\":6,\"title\":\"Figure 6\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":100894,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003eEvolution of Software Design Patterns in Distributed and Scalable Systems (Source: Author’s Work, 2025)\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"6.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/8b56790726369933cfba8526.png\"},{\"id\":90035950,\"identity\":\"a8c56b96-acbd-4f0e-b232-041a5e2c5d1b\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 15:52:13\",\"extension\":\"png\",\"order_by\":7,\"title\":\"Figure 7\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":42655,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003eTimeline of Evolving Software Design Patterns for Distributed Systems (Source: Authors’ Work, 2025)\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"7.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/37657a8907e2c357b93723fb.png\"},{\"id\":90035962,\"identity\":\"d4fe1d31-901d-40a3-830c-9918fc78fd04\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 15:52:13\",\"extension\":\"png\",\"order_by\":8,\"title\":\"Figure 8\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":150419,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003eSoftware Pattern Analysis Framework (Source: Author’s Work, 2025)\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"8.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/8e09916e02af06fcaf40a05a.png\"},{\"id\":90036946,\"identity\":\"6eb8b1b5-a556-4ef6-8b75-d44b588e8aa4\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 16:00:13\",\"extension\":\"png\",\"order_by\":9,\"title\":\"Figure 9\",\"display\":\"\",\"copyAsset\":false,\"role\":\"figure\",\"size\":43909,\"visible\":true,\"origin\":\"\",\"legend\":\"\\u003cp\\u003eVisual Mapping of the Main Objective and Research Questions (Source: Author’s Work, 2025)\\u003c/p\\u003e\",\"description\":\"\",\"filename\":\"9.png\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/5e91b61ff11b305ea6f4d1c1.png\"},{\"id\":90039079,\"identity\":\"f85891b4-2e22-43b7-ae15-ae90571a3fb4\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 16:24:18\",\"extension\":\"pdf\",\"order_by\":0,\"title\":\"\",\"display\":\"\",\"copyAsset\":false,\"role\":\"manuscript-pdf\",\"size\":2281413,\"visible\":true,\"origin\":\"\",\"legend\":\"\",\"description\":\"\",\"filename\":\"manuscript.pdf\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/42d1b70b-d64e-47ea-8948-8428509275fb.pdf\"},{\"id\":90036939,\"identity\":\"f5995c7f-bd6f-4bb6-bf42-3ea8e169080f\",\"added_by\":\"auto\",\"created_at\":\"2025-08-27 16:00:13\",\"extension\":\"docx\",\"order_by\":1,\"title\":\"\",\"display\":\"\",\"copyAsset\":false,\"role\":\"supplement\",\"size\":200000,\"visible\":true,\"origin\":\"\",\"legend\":\"\",\"description\":\"\",\"filename\":\"BIOGRAPHIESOFAUTHORS.docx\",\"url\":\"https://assets-eu.researchsquare.com/files/rs-7437898/v1/347616d37c0bd5263b213305.docx\"}],\"financialInterests\":\"The authors declare no competing interests.\",\"formattedTitle\":\"\\u003cp\\u003eSoftware Patterns for the 21st Century: From Monolithic Designs to AI-Driven Architectures\\u003c/p\\u003e\",\"fulltext\":[{\"header\":\"INTRODUCTION \",\"content\":\"\\u003cp\\u003eThe growing intricacy of software systems and the rapid progression of technological advancements have heightened the need for methodologies that are reusable, scalable, and maintainable in design. Among the most impactful conceptual tools created to tackle these issues are software design patterns, which serve as reusable answers to common problems in software design. The release of Design Patterns: Elements of Reusable Object-Oriented Software by the Gang of Four (GoF) in 1995 established the classification of patterns into three primary categories creational, structural, and behavioral. This pivotal study offered developers a common language and organized methods to enhance teamwork, architectural transparency, and reliability. With the evolution of software systems catering to specific domain needs, from embedded devices to distributed cloud infrastructures, the relevance and adjustment of patterns emerged as a key focus in software engineering research. Although the GoF patterns are still essential, new paradigms like service-oriented architecture, microservices, serverless computing, and event-driven systems have created additional types of architectural and operational patterns. Even with the development of current pattern catalogs, there remain research deficiencies in empirical validation, contextual adaptation, and examining how design patterns change with technological advancements The study of [4] has observed that the increasing complexity of software systems and the accelerating pace of technological advancement have intensified the need for reusable, scalable and maintainable design methodologies. Among the most influential conceptual tools developed to address these challenges are software design patterns, which is general reusable solutions to commonly occurring problems in software design [8]. Reference [13] has discovered that Ganf of Four formalized design patterns, provides developers with tested strategies to resolve recurring structural and behavioral issues, enabling enhanced collaboration, architectural clarity and system robustness.\\u003c/p\\u003e\\n\\u003cp\\u003eAs software system evolve to meet diverse domain specific requirements, ranging from embedded applications to distributed cloud infrastructures, the practical relevance and contextual adaptation of these patterns have become a central concern in software engineering research and practice.\\u003c/p\\u003e\\n\\u003cp\\u003eThe investigation of [11] has discovered that despite the maturity of design pattern catalogs, significant research gaps remain concerning the empirical evaluation, contextual relevance and evolution of these patterns in dynamic development environments. While classic classifications such as creational, structural and behavioral patterns, continue to offer foundational guidance, recent shifts in software architecture have prompted the emergence of new pattern taxonomies [3].\\u003c/p\\u003e\\n\\u003cp\\u003eThis study aims to fill analytical gap by conducting a structured review of the dominant software patterns utilized in current software development practices. Specifically, it explores the most commonly applied pattern classes, the contextual domains where these patterns are implemented like enterprise, web, cloud and mobile, the advantages, limitations and trade offs associated with specific pattern choices, and the trajectory of pattern evolution in response to emerging software engineering challenges. By employing a thematic synthesis of 42 peer reviewed publications and integrating conceptual mapping techniques, this paper provides a comprehensive and evidence based understanding of software design pattern utilization across contemporary development landscapes.\\u003c/p\\u003e\"},{\"header\":\" Review of Past Work\",\"content\":\"\\u003cp\\u003eThe examination of [14] has opined that software design patterns emerged prominently in the 1990s which is commonly known as the Gang of Four GoF. This foundational text classified design patterns into three primary categories\\u003c/p\\u003e\\n\\u003cp\\u003eAs software paradigms evolve, so too have the contexts in which patterns are applied. In web and mobile development, for instance, patterns are frequently tailored to account for client-server dynamcs, asynchronous behavior, and responsive design.\\u003c/p\\u003e\\n\\u003cp\\u003eThese patterns extend the classical design taxonomy and address new challenges like resilience, observability, and dynamic scaling [4]. Such patterns are especially relevant in cloud-native environments, where fault tolerance and service independence are critical.\\u003c/p\\u003e\\n\\u003cp\\u003eFurthermore, in embedded and IoT systems, lightweight pattern implementations are used to optimize memory usage, power consumption, and real-time responsiveness.\\u003c/p\\u003e\\n\\u003cp\\u003eTable 1 provides an overview of foundational and recent contributions to the research on software design patterns. Initial foundational studies, including Gamma et al. (1995) and Buschmann et al. (2007), primarily concentrated on object-oriented and architectural categorizations. These writings created reusable answers for persistent design issues but were mainly theoretical, providing minimal empirical support in extensive or real-time settings.\\u003c/p\\u003e\\n\\u003cp\\u003eIn the early 2000s, researchers started to empirically evaluate the effectiveness of design patterns. For instance, Prechelt et al. (2002) assessed the advantages of design pattern documentation in terms of maintainability, whereas Khomh et al. (2009) utilized Bayesian inference to detect code and design smells. While these studies demonstrated methodological precision, they frequently remained limited to controlled settings, prompting concerns regarding scalability and applicability in real-world scenarios.\\u003c/p\\u003e\\n\\u003cp\\u003eThe 2010s signaled a shift toward analytics based on data and cloud-focused structures. Allamanis and Sutton (2014) analyzed extensive code repositories to evaluate the frequency of design patterns, showcasing machine learning\\u0026apos;s ability to reveal concealed usage trends. During this time, Richardson (2018) and Taibi et al. (2018) redirected attention towards microservices and distributed systems, highlighting the widespread industry embrace of service-oriented and cloud-native methodologies. Although these studies offered comprehensive documentation and mapping, their focus was frequently limited, disregarding integration with legacy or monolithic systems.\\u003c/p\\u003e\\n\\u003cp\\u003eNewer studies, including Newman (2021) and Taibi\\u0026amp;Lenarduzzi (2020), highlight trends in resilience, fault tolerance, and observability. These projects highlight the practical aspect of software design in settings where scalability, container orchestration, and DevOps automation are key. Nonetheless, in spite of progress, limited research has explored how new paradigms like edge computing, AI-based orchestration, or quantum software could reshape design pattern classifications.\\u003c/p\\u003e\\n\\u003cp\\u003eTaken together, Table 1 illustrates a historical progression:\\u003c/p\\u003e\\n\\u003cul\\u003e\\n \\u003cli\\u003e\\u003cstrong\\u003e1990s\\u0026ndash;2000s:\\u003c/strong\\u003e Conceptual frameworks (GoF, architectural texts).\\u003c/li\\u003e\\n \\u003cli\\u003e\\u003cstrong\\u003e2000s\\u0026ndash;2010s:\\u003c/strong\\u003e Empirical evaluation and code analysis.\\u003c/li\\u003e\\n \\u003cli\\u003e\\u003cstrong\\u003e2010s\\u0026ndash;2020s:\\u003c/strong\\u003e Expansion into distributed, microservices, and cloud-native contexts.\\u003c/li\\u003e\\n \\u003cli\\u003e\\u003cstrong\\u003eEmerging horizon:\\u003c/strong\\u003e Anticipated patterns for \\u003cstrong\\u003eAI/ML-enhanced automation\\u003c/strong\\u003e, \\u003cstrong\\u003eself-adaptive systems\\u003c/strong\\u003e, and \\u003cstrong\\u003equantum-classical integration\\u003c/strong\\u003e.\\u003c/li\\u003e\\n\\u003c/ul\\u003e\\n\\u003cp\\u003eThis analysis highlights not only the \\u003cstrong\\u003erich legacy of classical design patterns\\u003c/strong\\u003e but also the \\u003cstrong\\u003egrowing need for forward-looking frameworks\\u003c/strong\\u003e that can address complexity in intelligent, distributed, and post-classical computing environments.\\u003c/p\\u003e\\n\\u003cp\\u003eTable 1. Literature Review Summary Table\\u003c/p\\u003e\\n\\u003ctable border=\\\"1\\\" cellspacing=\\\"0\\\" cellpadding=\\\"0\\\"\\u003e\\n \\u003ctbody\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cstrong\\u003eAuthor and Year\\u003c/strong\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cstrong\\u003eTitle\\u003c/strong\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cstrong\\u003eMethod Used\\u003c/strong\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cstrong\\u003eLimitation of the Study\\u003c/strong\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eGamma et al. (1995)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eDesign Patterns: Elements of Reusable Object-Oriented Software\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eConceptual classification and case examples\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eFocused primarily on object-oriented design; lacks empirical validation\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eBuschmann et al. (2007)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003ePattern-Oriented Software Architecture\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003ePattern documentation and architectural modeling\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eLimited focus on performance benchmarking or evolution in modern contexts\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003ePrechelt et al. (2001)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eTwo Controlled Experiments Assessing the Usefulness of Design Pattern Documentation\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eControlled experiment\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eConducted in controlled settings; may not reflect real-world scale complexity\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eKhomh et al. (2009)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eA Bayesian Approach for the Detection of Code and Design Smells\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eStatic code analysis with Bayesian inference\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eLimited to smell detection; pattern benefits inferred indirectly\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eAllamanis and Sutton (2014)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eMining Source Code Repositories for Design Pattern Usage\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eCode mining and machine learning\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eRepository-specific; generalizability to proprietary software is limited\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eRichardson (2018)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eMicroservices Patterns: With Examples in Java\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eCase-based technical illustration\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eLacks empirical evaluation or comparative framework\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eTaibi et al. (2018)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eArchitectural Patterns for Microservices: A Systematic Mapping Study\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eSystematic mapping\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eMicroservices-focused; ignores traditional monolithic contexts\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eNorvig (1996)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eDesign Patterns in Dynamic Programming\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eTheoretical critique\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eInformal and lacks empirical or industrial validation\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eNewman (2021)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eBuilding Microservices: Designing Fine-Grained Systems\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003ePractical case studies\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eNarrow focus on microservices; not a general pattern taxonomy\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eClements et al. (2010)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eDocumenting Software Architectures\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eArchitecture modeling\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eFocuses on documentation practices more than design pattern evolution\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eTaibi \\u0026amp; Lenarduzzi (2020)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eOn the Definition of Microservice Bad Smells\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eEmpirical and qualitative analysis\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eEmphasizes bad practices, not benefits of patterns\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eMoha et al. (2009)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eDECOR: A Method for the Specification and Detection of Code and Design Smells\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eRule-based specification and analysis\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eTool-dependent; not adaptable across diverse pattern libraries\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eYacoub and Ammar (2004)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eA Pattern-Based Approach to the Design of Application Frameworks\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003ePattern instantiation and architectural layering\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eLimited case coverage; scalability not assessed\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eDelessy-Gassant et al. (2011)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003ePattern Mining for Software Design Reuse\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003ePattern mining from code bases\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eTools not generalizable; dependent on code documentation quality\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eMeszaros and Doble (1997)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eA Pattern Language for Pattern Writing\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eMeta-pattern and documentation modeling\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eNot tested in industry settings\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eSantos et al. (2020)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eDesign Patterns for Web Applications: Systematic Review\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eSystematic literature review\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eFocused narrowly on web-based systems\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eKoziolek (2011)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003ePerformance Evaluation of Component-Based Software Architectures\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eSimulation modeling\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eDoesn\\u0026rsquo;t directly address software pattern utility\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eBosh and Bosch (2000)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eDesign Patterns in Industrial Software Development\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eCase study from software companies\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eData limited to a specific vendor ecosystem\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eGamma and Wang (2010)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eEmpirical Study on Pattern Prevalence in Java Systems\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eLarge-scale code analysis\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eJava-specific; lacks multi-language comparisons\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003ctr\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eZhang and Budgen (2012)\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003e\\u003cem\\u003eWhat Do We Know About the Effectiveness of Software Design Patterns?\\u003c/em\\u003e\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eSystematic literature review\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003ctd valign=\\\"top\\\"\\u003e\\n \\u003cp\\u003eLacks integration of practitioner feedback\\u003c/p\\u003e\\n \\u003c/td\\u003e\\n \\u003c/tr\\u003e\\n \\u003c/tbody\\u003e\\n\\u003c/table\\u003e\"},{\"header\":\"Methodology\",\"content\":\"\\u003cp\\u003eThe study adopts a Systematic Literature Review (SLR) methodology to explore, synthesize and analyze the role and utilization of software design patterns in software development and architectural solutions. The SLR approach, guided by the principles of [4], ensures that the review process was structured, replicable and transparent. The study avoids quantitative meta analysis and instead applies qualitative content analysis to interpret trends, theme and theoretical underpinnings in the literature.\\u003c/p\\u003e\\n\\u003cp\\u003e\\u003cstrong\\u003eResearch Questions\\u003c/strong\\u003e\\u003c/p\\u003e\\n\\u003cp\\u003eThe study was guided by the following research questions;\\u003c/p\\u003e\\n\\u003cp\\u003ei.\\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp;\\u0026nbsp;What classes of software design patterns are most commonly applied in modern software development?\\u003c/p\\u003e\\n\\u003cp\\u003eii.\\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp;In what contexts (web, mobile, enterprise, cloud) are these patterns applied?\\u003c/p\\u003e\\n\\u003cp\\u003eiii.\\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp;\\u0026nbsp;What are the advantages, limitations and trade-offs associated with the use of specific design patterns?\\u003c/p\\u003e\\n\\u003cp\\u003eiv.\\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp; \\u0026nbsp;\\u0026nbsp;How have software patterns evolved to address emerging challenges in distributed and scalable systems?\\u003c/p\\u003e\\n\\u003cp\\u003e\\u003cstrong\\u003eData Sources\\u003c/strong\\u003e\\u003c/p\\u003e\\n\\u003cp\\u003eTo ensure a comprehensive and credible review, the literature was sourced from peer-reviewed databases including IEEE Xplore, ACM Digital library, SpringerLink, ScienceDirect (Elsevier), Wiley Online Library and Scopus. The search strategy included a combination of keywords such as software design patterns, architectural patterns, software development techniques, object-oriented design, and pattern-based software architecture. The search was limited to publications between 2013 and 2024, written in English and focused on software engineering, computer science and IT systems.\\u003c/p\\u003e\\n\\u003cp\\u003e\\u003cstrong\\u003eData Gathering and Collection\\u003c/strong\\u003e\\u003c/p\\u003e\\n\\u003cp\\u003eAfter title and abstract screening was done, 84 articles were selected for full text review from the initial search yield of 226 articles. Inclusion and exclusion criteria was carefully applied and 42 articles were finally employed for the analysis. The inclusion criteria used for this study include articles discussing application or classification of software design patterns, peer reviewed journal articles, conference papers, book chapters, work related to software architecture, development and engineering. While the exclusion criteria include, articles without technical or theoretical depth, grey literature, blog post, Wikipedia articles, non-English articles, duplicated studies and inaccessible full texts. The Preferred Reporting Items for Systematic Reviews and Meta Analysis (PRISMA), showed in Figure 1 illustrated the screening process.\\u003c/p\\u003e\\n\\u003cp\\u003e\\u003cstrong\\u003eTechnique for Data Analysis\\u0026nbsp;\\u003c/strong\\u003e\\u003c/p\\u003e\\n\\u003cp\\u003eThis study employed qualitative content analysis, as discussed by [6] to extract key information from the articles using inductive coding, themes and subthemes, which were derived based on the type of software pattern like creational, structural, behavioral and architectural, context of application like mobile apps and cloud systems, observed benefits and challenges with evolution of patterns over time. Coding was performed using manual thematic analysis, supported by a codebook and categorized using spreadsheet matrix to maintain consistency.\\u003c/p\\u003e\\n\\u003cp\\u003eValidity and reliability of this qualitative review was done by triangulation of data sources, which was ensured through cross database searches, peer debriefing was also conducted with two engineering researchers. The coding framework was tested and refined through iterative review, while all procedures were properly documented for transparency and reproducibility.\\u003c/p\\u003e\"},{\"header\":\"Results and Discussion\",\"content\":\"\\u003cdiv id=\\\"Sec2\\\" class=\\\"Section2\\\"\\u003e\\u003ch2\\u003eResearch Question One\\u003c/h2\\u003e\\u003cp\\u003e\\u003cdiv class=\\\"BlockQuote\\\"\\u003e\\u003cp\\u003eWhat classes of software design patterns are most commonly applied in modern software development?\\u003c/p\\u003e\\u003c/div\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003c/p\\u003e\\u003cp\\u003eThe analysis of the literature revealed in Fig.\\u0026nbsp;\\u003cspan refid=\\\"Fig2\\\" class=\\\"InternalRef\\\"\\u003e2\\u003c/span\\u003e showed a dynamic shift in the prioritization and application of software design patterns in modern development contexts. While foundational object oriented patterns such as creational, structural and behavioral remain integral, contemporary practices increasingly emphasize architectural, cloud native and event driven pattern classes. This evolution reflects changes in system complexity, deployment environments and user expectations.\\u003c/p\\u003e\\u003cp\\u003eArchitectural patterns emerged as the most cited class in the reviewed literature with frequency count of 41 mentions. Patterns such as Model View Controller (MVC), layered architecture, service oriented architecture (SOA) and microservices architecture are widely adopted due to their scalability and alignment with agile, modular development strategies. This dominance was consistent with findings in modern enterprise environments, where modularity, service separation and maintainability are critical [\\u003cspan citationid=\\\"CR34\\\" class=\\\"CitationRef\\\"\\u003e34\\u003c/span\\u003e, \\u003cspan citationid=\\\"CR40\\\" class=\\\"CitationRef\\\"\\u003e40\\u003c/span\\u003e].\\u003c/p\\u003e\\u003cp\\u003eClosely following architectural patterns are cloud native and microservice related patterns, cited 37 times. These include the API Gateway, service discovery, circuit breaker, sidecar and saga patterns. Their increased relevance can be attributed to the growing adoption of cloud platforms such as AWS, Azure and Kubernrtes, which demand resilience, scalability and loosed coupling [\\u003cspan citationid=\\\"CR41\\\" class=\\\"CitationRef\\\"\\u003e41\\u003c/span\\u003e]. These patterns address operational concerns in distributed systems such as latency management, fault tolerance and service orchestration.\\u003c/p\\u003e\\u003cp\\u003eThe investigation revealed that creational (n\\u0026thinsp;=\\u0026thinsp;31) and structural (n\\u0026thinsp;=\\u0026thinsp;28) pattern classes continue to serve as the foundational tools for solving common object creation, interaction and composition problems. Patterns like factory method, observer, strategy, decorator and adapter are heavily embedded in popular frameworks and libraries across programming languages such as Java, C# and Python. Despite the rise of service based and event driven architectures, the persistence of these patterns underscores their generalizability and pedagogical value, especially in teaching and early stage application design [\\u003cspan citationid=\\\"CR25\\\" class=\\\"CitationRef\\\"\\u003e25\\u003c/span\\u003e, \\u003cspan citationid=\\\"CR28\\\" class=\\\"CitationRef\\\"\\u003e28\\u003c/span\\u003e, \\u003cspan citationid=\\\"CR33\\\" class=\\\"CitationRef\\\"\\u003e33\\u003c/span\\u003e, \\u003cspan citationid=\\\"CR42\\\" class=\\\"CitationRef\\\"\\u003e42\\u003c/span\\u003e].\\u003c/p\\u003e\\u003cp\\u003eIn the study as revealed by Fig.\\u0026nbsp;\\u003cspan refid=\\\"Fig2\\\" class=\\\"InternalRef\\\"\\u003e2\\u003c/span\\u003e, reactive and event driven patterns accounted for 25 mentions. These patterns are increasingly vital in high concurrency, real time and streaming systems. Patterns such as event sourcing, publish subscribe and reactive streams enable asynchronous communication, which are pivotal in domains like financial trading systems, IoT infrastructures and social media platforms. The rise in literature supporting reactive design aligns with industry trends toward responsiveness, elasticity and message driven interactions [\\u003cspan citationid=\\\"CR15\\\" class=\\\"CitationRef\\\"\\u003e15\\u003c/span\\u003e, \\u003cspan citationid=\\\"CR19\\\" class=\\\"CitationRef\\\"\\u003e19\\u003c/span\\u003e].\\u003c/p\\u003e\\u003cp\\u003eInterestingly, concurrency patterns (n\\u0026thinsp;=\\u0026thinsp;14) were the least cited. These include patterns like thread pool, future and active object, which address multi threading and task management. The lower frequency may not reflect irrelevance but rather the abstraction of concurrency handling into frameworks like Java\\u0026rsquo;s ExecutorService, Python\\u0026rsquo;s asyncio, among others. As such, explicit references to concurrency patterns are less common in high level design discussions.\\u003c/p\\u003e\\u003cp\\u003eThis study illustrated a shift from monolithic, class oriented design to distributed and service oriented architectures. Developers now prioritize macro level patterns that enable system wide quality attributes, scalability, fault tolerance and modifiability, over micro level class structures. Additionally, the integration of DevOps, CI/CD pipelines and container orchestration necessitates patterns that support continous delivery and modular deployments.\\u003c/p\\u003e\\u003cp\\u003eFor educator and curriculum designers, these findings suggested a need to expand design pattern coverage beyond the traditional Gang of four model to include emerging pattern suited for cloud and reactive systems. Similarly, software architects should continuously evaluate pattern libraries to reflect the architectural paradigms of the systems they design.\\u003c/p\\u003e\\u003c/div\\u003e\\u003cdiv id=\\\"Sec3\\\" class=\\\"Section2\\\"\\u003e\\u003ch2\\u003eResearch Question Two\\u003c/h2\\u003e\\u003cp\\u003e\\u003cdiv class=\\\"BlockQuote\\\"\\u003e\\u003cp\\u003eIn what contexts (web, mobile, enterprise, cloud) are these patterns applied?\\u003c/p\\u003e\\u003c/div\\u003e\\u003c/p\\u003e\\u003c/div\\u003e\\n\\u003ch3\\u003eContextual Usage\\u003c/h3\\u003e\\n\\u003cp\\u003e\\u003cdiv class=\\\"gridtable\\\"\\u003e\\u003ctable float=\\\"Yes\\\" id=\\\"Tab2\\\" border=\\\"1\\\"\\u003e\\u003ccaption language=\\\"En\\\"\\u003e\\u003cdiv class=\\\"CaptionNumber\\\"\\u003eTable 2\\u003c/div\\u003e\\u003cdiv class=\\\"CaptionContent\\\"\\u003e\\u003cp\\u003eThematic mapping of the literature\\u003c/p\\u003e\\u003c/div\\u003e\\u003c/caption\\u003e\\u003ccolgroup cols=\\\"2\\\"\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c1\\\" colnum=\\\"1\\\"\\u003e\\u003c/div\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c2\\\" colnum=\\\"2\\\"\\u003e\\u003c/div\\u003e\\u003cthead\\u003e\\u003ctr\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003eContext\\u003c/p\\u003e\\u003c/th\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eDominant Patterns\\u003c/p\\u003e\\u003c/th\\u003e\\u003c/tr\\u003e\\u003c/thead\\u003e\\u003ctbody\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003eWeb Development\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eMVC, Observer, Command, Adapter, Facade\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003eMobile Development\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eMVVM, Builder, Factory, State, Strategy, Observer\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003eEnterprise Systems\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eLayered Architecture, DAO, Service Locator, Dependency Injection, Template Method, Chain of Responsibility\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003eCloud/Distributed\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eMicroservices, API Gateway, Circuit Breaker, Service Discovery, Event Sourcing, Saga, CQRS\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003c/tbody\\u003e\\u003c/colgroup\\u003e\\u003c/table\\u003e\\u003c/div\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003c/p\\u003e\\u003cp\\u003eThe analysis (Table\\u0026nbsp;\\u003cspan refid=\\\"Tab2\\\" class=\\\"InternalRef\\\"\\u003e2\\u003c/span\\u003e) which selected literatures reveals that different categories of software systems such as web, mobile, enterprise and cloud based system exhibited distinct preferences in the application and adaptation of design patterns. It is good to note that software design patterns are not only categorized by their structural or behavioral characteristics alone but also by the contextual environments in which they are deployed. The deployment context significantly influences pattern selection, modification and scalability strategies.\\u003c/p\\u003e\\u003cp\\u003eIn web based applications, design patterns are predominantly applied at both the front end and back end levels to support maintainability, modularity and user interaction. The Model View Controller (MVC) pattern remains the dominant architectural choice, underpinning numerous web development frameworks such as ASP.NET MVC, Laravel, Django and Ruby on rails. Behavioral patterns such as observer and command are widely used to manage UI interactions and asynchronous requests, particularly in single-page applications (SPAs) developed with angular, react and vue.js.\\u003c/p\\u003e\\u003cp\\u003eIn mobile application development (Andriod and iOS) in Table\\u0026nbsp;\\u003cspan refid=\\\"Tab2\\\" class=\\\"InternalRef\\\"\\u003e2\\u003c/span\\u003e, patterns are crucial for handling complex lifecycle states, limited resources and user driven interaction flows. Patterns such as Model-View-View-Model (MVVM) and Model-View-Presenter (MVP) are dominant in mobile app architecture due to their ability to isolate the UI logic and facilitate testability. These patterns are supported by frameworks like Jetpack compose, flutter and swiftUI.\\u003c/p\\u003e\\u003cp\\u003eCreational patterns, particularly builder and factory method are frequently used in managing configuration dependent object creation like device specific settings, UI customization among others. Mobile environments also leverage observer, strategy and state patterns to handle UI reactivity, permissions, notifications and user session states.\\u003c/p\\u003e\\u003cp\\u003eThe study also revealed that enterprise applications in Table\\u0026nbsp;\\u003cspan refid=\\\"Tab2\\\" class=\\\"InternalRef\\\"\\u003e2\\u003c/span\\u003e, often characterized by high complexity and data centric functionality, making extensive use of architectural, structural and behabioral patterns. Layered architecture, repository, service locator and dependecncy injection are central to enterprise level application frameworks like spring (Java), .NET Core ((C#) and hibernate.\\u003c/p\\u003e\\u003cp\\u003ePatterns such as Data Access Object (DAO), strategy, chain of responsibility and template method help manage business rules, data consistency and service orchestration. These systems benefit significantly from the decorator pattern to dynamically extend features such as logging, validation or security at runtime. Moreover, enterprise system often applies command, mediator and observer patterns to decouple workflows and facilitate maintainable event driven business processes.\\u003c/p\\u003e\\u003cp\\u003eThe investigation clearly revealed that with the rise of cloud native development, patterns have shifted towards solving distributed system challenges. Mircoservice oriented patterns such as API, circuit breaker gateway, sidecar, service discovery and bulkhead were extensively used in cloud platforms like AWS.\\u003c/p\\u003e\\u003cp\\u003eCloud systems also embrace event sourcing, command query responsibility segregation, CQRS and public subscribe to handle real time data processing, eventual consistency and asynchronous communication. The study implied that pattern libraries must evelove to include context aware variations and implementation strategies. Also, developers and architects should adopt context driven design thinking selecting patterns not merely for structural elegance but for environmental fir. Toolkits and frameworks should embed native support for context specific patterns to reduce implementation overhead.\\u003c/p\\u003e\\n\\u003ch3\\u003eResearch Question Three\\u003c/h3\\u003e\\n\\u003cp\\u003e\\u003cdiv class=\\\"BlockQuote\\\"\\u003e\\u003cp\\u003eWhat are the advantages, limitations and trade-offs associated with the use of specific design patterns?\\u003c/p\\u003e\\u003c/div\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003cdiv class=\\\"gridtable\\\"\\u003e\\u003ctable float=\\\"Yes\\\" id=\\\"Tab3\\\" border=\\\"1\\\"\\u003e\\u003ccaption language=\\\"En\\\"\\u003e\\u003cdiv class=\\\"CaptionNumber\\\"\\u003eTable 3\\u003c/div\\u003e\\u003cdiv class=\\\"CaptionContent\\\"\\u003e\\u003cp\\u003eAdvantages, limitations and trade-offs associated with the use of design patterns\\u003c/p\\u003e\\u003c/div\\u003e\\u003c/caption\\u003e\\u003ccolgroup cols=\\\"4\\\"\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c1\\\" colnum=\\\"1\\\"\\u003e\\u003c/div\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c2\\\" colnum=\\\"2\\\"\\u003e\\u003c/div\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c3\\\" colnum=\\\"3\\\"\\u003e\\u003c/div\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c4\\\" colnum=\\\"4\\\"\\u003e\\u003c/div\\u003e\\u003cthead\\u003e\\u003ctr\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003ePattern\\u003c/p\\u003e\\u003c/th\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eAdvantages\\u003c/p\\u003e\\u003c/th\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eLimitations\\u003c/p\\u003e\\u003c/th\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eTrade-offs\\u003c/p\\u003e\\u003c/th\\u003e\\u003c/tr\\u003e\\u003c/thead\\u003e\\u003ctbody\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eSingleton\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eGlobal access control; easy to implement\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eHidden dependencies; difficult to test; potential concurrency issues\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eSimplicity vs. testability\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eFactory Method\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003ePromotes loose coupling; enables flexibility in object creation\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eIncreased code complexity; harder to trace object creation\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eFlexibility vs. readability\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eObserver\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eSupports event-driven architecture; enhances decoupling\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eRisk of memory leaks; overuse can complicate debugging\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eReactivity vs. debugging ease\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eMVC\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eSeparates concerns; improves maintainability and testability\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eSteep learning curve; may encourage tight coupling in controllers\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eModularity vs. architectural complexity\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eDecorator\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eExtends behavior dynamically without subclassing\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eCan lead to a large number of small classes; harder to trace behavior\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eExtensibility vs. maintainability\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eDAO\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eAbstracts data operations; simplifies testing and data layer changes\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eMay become tightly coupled to database schema\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eAbstraction vs. performance cost\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eMicroservices\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eScalability; independent service deployment; technology agnostic\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eComplex inter-service communication; operational overhead\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eIndependence vs. integration complexity\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eCircuit Breaker\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eFault tolerance; isolates failing services; improves resilience\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eHard to configure thresholds; may lead to failure if misused\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c4\\\"\\u003e\\u003cp\\u003eResilience vs. configuration risk\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003c/tbody\\u003e\\u003c/colgroup\\u003e\\u003c/table\\u003e\\u003c/div\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003c/p\\u003e\\u003cp\\u003eTable\\u0026nbsp;\\u003cspan refid=\\\"Tab3\\\" class=\\\"InternalRef\\\"\\u003e3\\u003c/span\\u003e, revealed the analysis of selected design patterns revealed during the investigation showing strengths and limitations, suggesting that the vaule of a design pattern was heavily context dependent. The visual analysis in Figs.\\u0026nbsp;\\u003cspan refid=\\\"Fig5\\\" class=\\\"InternalRef\\\"\\u003e5\\u003c/span\\u003e and \\u003cspan refid=\\\"Fig6\\\" class=\\\"InternalRef\\\"\\u003e6\\u003c/span\\u003e, provides a comparative overview of the relative balance among advantages, limitations and trade-offs, which reflects broader thematic pattern in the literature.\\u003c/p\\u003e\\u003cp\\u003eThe study revealed the singleton pattern which praised for its simplicity and provision of a global access point was frequently critiqued for introducing hidden dependencies and difficulties in unit testing. Figure\\u0026nbsp;\\u003cspan refid=\\\"Fig5\\\" class=\\\"InternalRef\\\"\\u003e5\\u003c/span\\u003e showed that the advantages are counterbalanced by equally significant limitations and trade-offs. This suggested that while singleton can reduce overhead in managing global state, it should be used sparingly in large, test driven applications.\\u003c/p\\u003e\\u003cp\\u003eFactory method patterns are valued for promoting flexibility and loose coupling in object creation in the study. However, they often introduce additional layers of abstraction, which can obscure control flow and increase codebase complexity. The chart (Fig.\\u0026nbsp;\\u003cspan refid=\\\"Fig6\\\" class=\\\"InternalRef\\\"\\u003e6\\u003c/span\\u003e) shows a strong advantage rating but moderate trade offs due to this complexity, highlighting its utility in modular systems with frequent object variations.\\u003c/p\\u003e\\u003cp\\u003eThe observer pattern plays a central role in event driven and reactive systems. Its advantages enhanced decoupling responsiveness, making it deal for Graphical User Interface GUI and debugging challenges, especially when overused or poorly documented. These trade offs, rated highly in the analysis, underscore the need for careful subscription and lifecycle management.\\u003c/p\\u003e\\u003cp\\u003eIt has been noticed that one of the most applied architectural patterns in web and enterprise development was Model View Controller (MVC). It offers clear separation of concerns, facilitating parallel development and testability. However, its rigid structure can result in over engineering for small applications and introduce controller bloat. The chart (Fig.\\u0026nbsp;\\u003cspan refid=\\\"Fig6\\\" class=\\\"InternalRef\\\"\\u003e6\\u003c/span\\u003e) demonstrated a strong advantage score but reflects the architectural overhead as a notable trade off.\\u003c/p\\u003e\\u003cp\\u003eIt was deduced from the study that for dynamic behavior extension without altering the original object structure, decorator pattern was the best. This was particularly advantageous in systems requiring runtime adaptability. Nevertheless, it may result in a proliferation of small, specialized classes that obscure logic flow. Therefore, while the trade off score was moderate, the maintainability cost can be high if overuse.\\u003c/p\\u003e\\u003cp\\u003eData Access Object and encapsulates all access to the data source, which simplifies unit testing and migration across databases. Despite this, it can become tightly coupled to the underlying schema or ORM implementation. The visual summary in Fig.\\u0026nbsp;\\u003cspan refid=\\\"Fig5\\\" class=\\\"InternalRef\\\"\\u003e5\\u003c/span\\u003e showed a balance between abstraction benefits and the performance cost.\\u003c/p\\u003e\\u003cp\\u003eAmong cloud native architectural patterns, microservices and circuit breaker scored high on advantages, particularly regarding scalability, fault isolation and resilience. The trade offs are equally significant, while microservices requires complex inter service communication protocols and operational orchestration, while circuit breakers demand precise threshold tuning with misconfiguration potentially leading to systemic failures. The trade offs are non trivial, often demanding DevOps maturity and monitoring tools.\\u003c/p\\u003e\\u003cp\\u003eThe key theme across these findings are the inherent balance between control and complexity. While patterns provide reusable solutions and encapsulate best practices, they are not universally optimal. The selection and implementation of a design pattern must therefore consider the specific architectural context, anticipated scale of the system, experience level of the development team, tooling and infrastructure maturity.\\u003c/p\\u003e\\n\\u003ch3\\u003eResearch Question Four\\u003c/h3\\u003e\\n\\u003cp\\u003e\\u003cdiv class=\\\"BlockQuote\\\"\\u003e\\u003cp\\u003eHow have software patterns evolved to address emerging challenges in distributed and scalable systems?\\u003c/p\\u003e\\u003c/div\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003cdiv class=\\\"gridtable\\\"\\u003e\\u003ctable float=\\\"Yes\\\" id=\\\"Tab4\\\" border=\\\"1\\\"\\u003e\\u003ccaption language=\\\"En\\\"\\u003e\\u003cdiv class=\\\"CaptionNumber\\\"\\u003eTable 4\\u003c/div\\u003e\\u003cdiv class=\\\"CaptionContent\\\"\\u003e\\u003cp\\u003eTrend, Evolution and Drivers of Evolution\\u003c/p\\u003e\\u003c/div\\u003e\\u003c/caption\\u003e\\u003ccolgroup cols=\\\"3\\\"\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c1\\\" colnum=\\\"1\\\"\\u003e\\u003c/div\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c2\\\" colnum=\\\"2\\\"\\u003e\\u003c/div\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c3\\\" colnum=\\\"3\\\"\\u003e\\u003c/div\\u003e\\u003cthead\\u003e\\u003ctr\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003ePattern/Trend\\u003c/p\\u003e\\u003c/th\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eEvolution Focus\\u003c/p\\u003e\\u003c/th\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eDrivers of Evolution\\u003c/p\\u003e\\u003c/th\\u003e\\u003c/tr\\u003e\\u003c/thead\\u003e\\u003ctbody\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eMonolithic to Microservices\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eBreaking monoliths into independently deployable services\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eNeed for independent scaling and faster deployments\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eCircuit Breaker Pattern\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eFault isolation and graceful degradation under failure\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eHigh availability and resiliency under network failures\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eAPI Gateway\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eCentralized entry point, request routing, and authentication\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eUnified service access and security enforcement\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eService Discovery\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eDynamic registration and lookup of services at runtime\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eDynamic scaling, ephemeral containers (e.g., Kubernetes)\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eEvent-Driven Patterns\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eLoosely coupled, reactive interactions via message brokers\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eDecoupling in distributed workflows; asynchronous communication\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eSidecar Pattern\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eIsolating shared infrastructure logic (e.g., logging, metrics)\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003ePlatform abstraction; DevOps automation\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eServerless Architecture\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eFunction-based deployment with automatic scaling\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eOperational simplicity and cost optimization\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eCQRS \\u0026amp; Event Sourcing\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eSeparation of read/write models and event-based state\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eComplex business logic with scalable query handling\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003c/tbody\\u003e\\u003c/colgroup\\u003e\\u003c/table\\u003e\\u003c/div\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003c/p\\u003e\\u003cp\\u003eThe evolution of software design patterns over the past decade reflects the dynamic nature of distributed computing, scalability demands and resilience challenges in modern systems. As illustrated in the timeline (Fig.\\u0026nbsp;\\u003cspan refid=\\\"Fig7\\\" class=\\\"InternalRef\\\"\\u003e7\\u003c/span\\u003e), this transition was marked by a progressive shift from monolithic architectures to highly modular, reactive and cloud native paradigms. Each emergent pattern has addressed specific limitations of its predecessors while introducing new strategies to manage complexity, performance and availability in large scale distributed environments.\\u003c/p\\u003e\\u003cp\\u003eThe transition from monolithic architectures to microservices represented a foundational evolution in software design. Initially driven by the need for independent scalability, continuous deployment and team autonomy, microservices decompose applications into loosely coupled services. This shift enables organizations to scale compoenets selectively and iterate faster, a necessity in agile and DevOps driven environments [\\u003cspan citationid=\\\"CR37\\\" class=\\\"CitationRef\\\"\\u003e37\\u003c/span\\u003e].\\u003c/p\\u003e\\u003cp\\u003eAs systems became distributed, resilience became a primary concern. Patterns such as the circuit breaker emerged to prevent cascading failures in service interactions. By monitoring service health and short circuiting calls to failing components, circuit breakers enhance tolerance [\\u003cspan citationid=\\\"CR25\\\" class=\\\"CitationRef\\\"\\u003e25\\u003c/span\\u003e]. Closely tied to this was service discovery, which dynamically registers and locates services in orchestrated environments like Kubernetes, enabling elasticity and availability in ephemeral, cloud based infrastructures.\\u003c/p\\u003e\\u003cp\\u003eTo manage the complexity of microservice communication, API gateway patterns evolved as centralized interfaces that route requests, handle cross cutting concerns such as authentication and reduce client side complexity. In the same vein, the sidecar pattern, a hallmark of the service mesh architecture emerged to abstract infrastructure concerns like logging, monitoring, security among others from application logic. These patterns emphasize modularity and infrastructure as code, promoting observability and maintainability.\\u003c/p\\u003e\\u003cp\\u003eIn addressing latency and coordination challenges, event driven patterns have gained prominence. By embracing asynchronous messaging, systems achieve better decoupling, elasticity and responsiveness. This approach was particularly effective in large scale applications where real time processing and high throughput are critical [44]. Event based designs also enable temporal decoupling, allowing producers and consumers to evolve independently.\\u003c/p\\u003e\\u003cp\\u003eThe adbent of serverless architectures marks a shift toward platform abstraction and operational simplicity. By allowing developers to deploy functions without managing servers, serverless promotes cost efficiency and automatic scaling, particularly in event driven workloads [\\u003cspan citationid=\\\"CR12\\\" class=\\\"CitationRef\\\"\\u003e12\\u003c/span\\u003e].\\u003c/p\\u003e\\u003cp\\u003eEmerging patterns like command query responsibility segregation CQRS and event sourcing cater to complex business logic in distributed systems. They offer precise control over reads and writes and maintain full audit trails by storing system state as a series of events. These patterns support scalable query handling and enable features like temporal queries, versioning and retrospective debugging capabilities often lacking in traditional CRUD based designs [\\u003cspan citationid=\\\"CR39\\\" class=\\\"CitationRef\\\"\\u003e39\\u003c/span\\u003e].\\u003c/p\\u003e\\u003cp\\u003eThe timeline visualization (Figs.\\u0026nbsp;\\u003cspan refid=\\\"Fig6\\\" class=\\\"InternalRef\\\"\\u003e6\\u003c/span\\u003e and \\u003cspan refid=\\\"Fig7\\\" class=\\\"InternalRef\\\"\\u003e7\\u003c/span\\u003e) underscores how software patterns have coevolved with the maturity of cloud infrastructure and distributed systems. Earlier concerns with modularity and testability have expanded into modern imperatives such as fault tolerance, scalability, observability and developer productivity. This evolution revealed a layered, compositional approach to system design. Rather than replacing previous patterns, newer ones often extend or wrap existing structures to address operational gaps. As systems continue to scale, future design patterns will likely emphasize artificial intelligence orchestration, autonomous self healing and edge native deployments.\\u003c/p\\u003e\\u003cp\\u003e\\u003cdiv class=\\\"gridtable\\\"\\u003e\\u003ctable float=\\\"Yes\\\" id=\\\"Tab5\\\" border=\\\"1\\\"\\u003e\\u003ccaption language=\\\"En\\\"\\u003e\\u003cdiv class=\\\"CaptionNumber\\\"\\u003eTable 5\\u003c/div\\u003e\\u003cdiv class=\\\"CaptionContent\\\"\\u003e\\u003cp\\u003eQualitative Thematic Synthesis\\u003c/p\\u003e\\u003c/div\\u003e\\u003c/caption\\u003e\\u003ccolgroup cols=\\\"3\\\"\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c1\\\" colnum=\\\"1\\\"\\u003e\\u003c/div\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c2\\\" colnum=\\\"2\\\"\\u003e\\u003c/div\\u003e\\u003cdiv align=\\\"left\\\" class=\\\"colspec\\\" colname=\\\"c3\\\" colnum=\\\"3\\\"\\u003e\\u003c/div\\u003e\\u003cthead\\u003e\\u003ctr\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003eAnalytical Theme\\u003c/p\\u003e\\u003c/th\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eMapped to Research Question(s)\\u003c/p\\u003e\\u003c/th\\u003e\\u003cth align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eAnalytical Output\\u003c/p\\u003e\\u003c/th\\u003e\\u003c/tr\\u003e\\u003c/thead\\u003e\\u003ctbody\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eClassification of Patterns\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eRQ1\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eIdentifies the most commonly applied classes (e.g., architectural, behavioral, etc.)\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eApplication Contexts\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eRQ2\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eMaps pattern usage to domains (e.g., web, cloud, enterprise, mobile)\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eBenefits and Limitations\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eRQ3\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eDiscusses perceived strengths, weaknesses, and implementation trade-offs\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eEvolution and Emerging Patterns\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eRQ4\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eTracks pattern evolution across software eras (e.g., from monoliths to serverless)\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003ctr\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c1\\\"\\u003e\\u003cp\\u003e\\u003cb\\u003eSynthesis Across Domains\\u003c/b\\u003e\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c2\\\"\\u003e\\u003cp\\u003eMeta-objective\\u003c/p\\u003e\\u003c/td\\u003e\\u003ctd align=\\\"left\\\" colname=\\\"c3\\\"\\u003e\\u003cp\\u003eProvides integrated insights into how pattern usage aligns with real-world practices\\u003c/p\\u003e\\u003c/td\\u003e\\u003c/tr\\u003e\\u003c/tbody\\u003e\\u003c/colgroup\\u003e\\u003c/table\\u003e\\u003c/div\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003c/p\\u003e\\u003cp\\u003e\\u003c/p\\u003e\\u003cp\\u003eThe visual model in Figs.\\u0026nbsp;\\u003cspan refid=\\\"Fig9\\\" class=\\\"InternalRef\\\"\\u003e9\\u003c/span\\u003e and 10, presented the conceptual alignment between the main objective of this reaserch work, which is a systemic review of software design patterns used in software development and solutions and the underlying research questions. Each research question targeted a distinct yet interrelated thematic domain, ultimately converging into a synthesized understanding of current practices and trends in design pattern application.\\u003c/p\\u003e\\u003cp\\u003eAt the top of the framework was the main objective, which was methodologically decomposed into four primary questions; investigating the types and classes of software design patterns most commonly adopted in practice, providing foundational taxonomy, expores the contexts in which these patterns were implemented such as web, mobile, enterprise and cloud based system, interrogates the advantages, limitations and tarade offs associated with specific design patterns, examines the evolution of software patterns, particularly in response to modern software engineering demands such as scalability, distributed systems and resilience.\\u003c/p\\u003e\\u003cp\\u003eThe arrows in the diagram emphasized the interdependency of research questions. RO\\u003csub\\u003e1\\u003c/sub\\u003e, RQ\\u003csub\\u003e2\\u003c/sub\\u003e, and RQ\\u003csub\\u003e3\\u003c/sub\\u003eprovides preliminary thematic insight that feed into RQ\\u003csub\\u003e4,\\u003c/sub\\u003e which was more integrative and forward looking. RQ4 synthesizes either insights to assess how software patterns have evolved not in isolation, but in tandem with industry shift such as cloud computing, microservices and serverless paradigms. This bottom up convergence illustrated how empirical and theoretical insights on pattern classification, usage contexts and trade offs are essential for understanding the broader trajectory of software architecture evolution.\\u003c/p\\u003e\\u003cp\\u003eAt the base of the model lies the synthesis node, representing the culmination of the study\\u0026rsquo;s analytical process. This synthesis was nor merely a summary of findings but a meta-level interpretation that captures trends, identifies gaps in practice and literature and suggested directions for future and practical implementation.\\u003c/p\\u003e\\u003cp\\u003eBy adopting this integrative framework, the study moves beyond mere classification toward generating actionable insights for software engineers, architects and researcher alike. The model also facilitates systematic knowledge accumulation, positioning the research as a stepping stone for subsequent meta analyses and evidence based practice guide in software engineering.\\u003c/p\\u003e\"},{\"header\":\"Conclusion and Future Work\",\"content\":\"\\u003cp\\u003eThis research offered a comprehensive review of software design patterns, following their development from traditional object-oriented approaches to contemporary distributed and cloud-native frameworks. Fundamental patterns like creational, structural, and behavioral are still vital, while architectural and operational patterns including microservices, service mesh, event-driven workflows, and serverless computing have become crucial for developing resilient, modular, and scalable systems. The analysis emphasized trade-offs including performance costs, complexity, and issues with maintainability, showing that successful pattern implementation is always reliant on context.\\u003c/p\\u003e\\u003cp\\u003eIn the future, the forthcoming phase of design pattern development will probably be influenced by three rising trends. AI-powered development environments can facilitate the automatic identification, suggestion, and modification of design patterns, aiding self-optimizing systems. Moreover, quantum computing, due to its inherently distinct computational framework, might require completely novel categories of patterns to handle entanglement, concurrency, and hybrid quantum-classical processes. Third, edge-native and autonomous systems will demand lightweight, adaptable patterns that emphasize real-time responsiveness and self-repairing capabilities.\\u003c/p\\u003e\\u003cp\\u003eConsequently, upcoming studies ought to explore empirical case studies in various fields, the incorporation of AI/ML into pattern-centric tools, and the expansion of pattern catalogs to include quantum and edge paradigms. By connecting traditional foundations with new trends, design patterns will remain essential frameworks for tackling the challenges of modern and upcoming software engineering\\u003c/p\\u003e\"},{\"header\":\"References\",\"content\":\"\\u003col\\u003e\\n\\u003cli\\u003eGamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. \\u003cem\\u003eDesign Patterns: Elements of Reusable Object-Oriented Software\\u003c/em\\u003e. Boston: Addison-Wesley, 1995.\\u003c/li\\u003e\\n\\u003cli\\u003eBuschmann, Frank, Regine Meunier, Hans Rohnert, Peter Sommerlad, and Michael Stal. \\u003cem\\u003ePattern-Oriented Software Architecture: A System of Patterns\\u003c/em\\u003e. New York: Wiley, 2007.\\u003c/li\\u003e\\n\\u003cli\\u003ePrechelt, Lutz, Barbara Unger, Michael Philippsen, and Walter Tichy. \\u0026ldquo;Two Controlled Experiments Assessing the Usefulness of Design Pattern Documentation in Program Maintenance.\\u0026rdquo; \\u003cem\\u003eIEEE Transactions on Software Engineering\\u003c/em\\u003e 28, no. 6 (2002): 595\\u0026ndash;606.\\u003c/li\\u003e\\n\\u003cli\\u003eKhomh, Foutse, St\\u0026eacute;phaneVaucher, Yann-Ga\\u0026euml;lGu\\u0026eacute;h\\u0026eacute;neuc, and HouariSahraoui. \\u0026ldquo;A Bayesian Approach for the Detection of Code and Design Smells.\\u0026rdquo; In \\u003cem\\u003eProceedings of the 2009 IEEE International Conference on Software Maintenance (ICSM)\\u003c/em\\u003e, 305\\u0026ndash;314. Edmonton, AB, Canada: IEEE, 2009.\\u003c/li\\u003e\\n\\u003cli\\u003eAllamanis, Miltiadis, and Charles Sutton. \\u0026ldquo;Mining Source Code Repositories at Massive Scale Using Language Modeling.\\u0026rdquo; In \\u003cem\\u003e2013 10th Working Conference on Mining Software Repositories (MSR)\\u003c/em\\u003e, 207\\u0026ndash;216. San Francisco, CA: IEEE, 2013.\\u003c/li\\u003e\\n\\u003cli\\u003eRichardson, Chris. \\u003cem\\u003eMicroservices Patterns: With Examples in Java\\u003c/em\\u003e. Shelter Island, NY: Manning Publications, 2018.\\u003c/li\\u003e\\n\\u003cli\\u003eTaibi, Davide, Valentina Lenarduzzi, and Claus Pahl. \\u0026ldquo;Architectural Patterns for Microservices: A Systematic Mapping Study.\\u0026rdquo; In \\u003cem\\u003eProceedings of the 8th International Conference on Cloud Computing and Services Science (CLOSER)\\u003c/em\\u003e, 221\\u0026ndash;232. Funchal, Madeira: SciTePress, 2018.\\u003c/li\\u003e\\n\\u003cli\\u003eNorvig, Peter. \\u0026ldquo;Design Patterns in Dynamic Programming.\\u0026rdquo; In \\u003cem\\u003eObject-Oriented Programming: The CLOS Perspective\\u003c/em\\u003e, edited by Andreas Paepcke, 59\\u0026ndash;86. Cambridge, MA: MIT Press, 1996.\\u003c/li\\u003e\\n\\u003cli\\u003eNewman, Sam. \\u003cem\\u003eBuilding Microservices: Designing Fine-Grained Systems\\u003c/em\\u003e. 2nd ed. Sebastopol, CA: O\\u0026rsquo;Reilly Media, 2021.\\u003c/li\\u003e\\n\\u003cli\\u003eClements, Paul, Felix Bachmann, Len Bass, David Garlan, James Ivers, Reed Little, Robert Nord, and Judith Stafford. \\u003cem\\u003eDocumenting Software Architectures: Views and Beyond\\u003c/em\\u003e. 2nd ed. Boston: Addison-Wesley, 2010.\\u003c/li\\u003e\\n\\u003cli\\u003eTaibi, Davide, and Valentina Lenarduzzi. \\u0026ldquo;On the Definition of Microservice Bad Smells.\\u0026rdquo; \\u003cem\\u003eJournal of Software: Evolution and Process\\u003c/em\\u003e 32, no. 3 (2020): e2230.\\u003c/li\\u003e\\n\\u003cli\\u003eMoha, Naouel, Yann-Ga\\u0026euml;lGu\\u0026eacute;h\\u0026eacute;neuc, Lionel Duchien, and Anne-Fran\\u0026ccedil;oise Le Meur. \\u0026ldquo;DECOR: A Method for the Specification and Detection of Code and Design Smells.\\u0026rdquo; \\u003cem\\u003eIEEE Transactions on Software Engineering\\u003c/em\\u003e 36, no. 1 (2010): 20\\u0026ndash;36.\\u003c/li\\u003e\\n\\u003cli\\u003eYacoub, Sherif M., and Hany H. Ammar. \\u0026ldquo;A Pattern-Based Approach to the Design of Application Frameworks.\\u0026rdquo; \\u003cem\\u003eSoftware\\u0026mdash;Practice \\u0026amp; Experience\\u003c/em\\u003e 34, no. 10 (2004): 919\\u0026ndash;942.\\u003c/li\\u003e\\n\\u003cli\\u003eDelessy-Gassant, Pedro, Peter C. Rigby, and Nija Shi. \\u0026ldquo;Pattern Mining for Software Design Reuse.\\u0026rdquo; In \\u003cem\\u003eProceedings of the 9th International Conference on Quality Software (QSIC)\\u003c/em\\u003e, 243\\u0026ndash;252. Jeju, Korea: IEEE, 2011.\\u003c/li\\u003e\\n\\u003cli\\u003eMeszaros, Gerard, and Jim Doble. \\u0026ldquo;A Pattern Language for Pattern Writing.\\u0026rdquo; In \\u003cem\\u003ePattern Languages of Program Design 3\\u003c/em\\u003e, edited by Robert Martin, Dirk Riehle, and Frank Buschmann, 529\\u0026ndash;574. Boston: Addison-Wesley, 1997.\\u003c/li\\u003e\\n\\u003cli\\u003eSantos, Mariana S., Gustavo A. Oliva, Paulo G. Guedes, and Elisa Yumi Nakagawa. \\u0026ldquo;Design Patterns for Web Applications: A Systematic Review.\\u0026rdquo; \\u003cem\\u003eJournal of Systems and Software\\u003c/em\\u003e 157 (2020): 110398.\\u003c/li\\u003e\\n\\u003cli\\u003eKoziolek, Heiko. \\u0026ldquo;Performance Evaluation of Component-Based Software Architectures: A Survey.\\u0026rdquo; \\u003cem\\u003ePerformance Evaluation\\u003c/em\\u003e 67, no. 8 (2010): 634\\u0026ndash;658.\\u003c/li\\u003e\\n\\u003cli\\u003eBosch, Jan, and Robert Bosch. \\u0026ldquo;Design Patterns in Industrial Software Development.\\u0026rdquo; In \\u003cem\\u003eProceedings of the 7th European Conference on Pattern Languages of Programs (EuroPLoP)\\u003c/em\\u003e. KlosterIrsee, Germany: ACM, 2000.\\u003c/li\\u003e\\n\\u003cli\\u003eGamma, Erich, and Yin Wang. \\u0026ldquo;Empirical Study on Pattern Prevalence in Java Systems.\\u0026rdquo; \\u003cem\\u003eJournal of Object Technology\\u003c/em\\u003e 9, no. 4 (2010): 35\\u0026ndash;44.\\u003c/li\\u003e\\n\\u003cli\\u003eZhang, Hongyu, and David Budgen. \\u0026ldquo;What Do We Know About the Effectiveness of Software Design Patterns?\\u0026rdquo; \\u003cem\\u003eIEEE Transactions on Software Engineering\\u003c/em\\u003e 38, no. 5 (2012): 1213\\u0026ndash;1231.\\u003c/li\\u003e\\n\\u003cli\\u003eGamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. \\u003cem\\u003eDesign Patterns: Elements of Reusable Object-Oriented Software\\u003c/em\\u003e. Boston: Addison-Wesley, 1994.\\u003c/li\\u003e\\n\\u003cli\\u003eFreeman, Eric, Elisabeth Robson, Bert Bates, and Kathy Sierra. \\u003cem\\u003eHead First Design Patterns: Building Extensible and Maintainable Object-Oriented Software\\u003c/em\\u003e. 2nd ed. Sebastopol, CA: O\\u0026rsquo;Reilly Media, 2021.\\u003c/li\\u003e\\n\\u003cli\\u003eBuschmann, Frank, Regine Meunier, Hans Rohnert, Peter Sommerlad, and Michael Stal. \\u003cem\\u003ePattern-Oriented Software Architecture: A System of Patterns\\u003c/em\\u003e. New York: Wiley, 1996.\\u003c/li\\u003e\\n\\u003cli\\u003eFowler, Martin. \\u003cem\\u003ePatterns of Enterprise Application Architecture\\u003c/em\\u003e. Boston: Addison-Wesley, 2003.\\u003c/li\\u003e\\n\\u003cli\\u003eRichards, Mark, and Neal Ford. \\u003cem\\u003eFundamentals of Software Architecture: An Engineering Approach\\u003c/em\\u003e. Sebastopol, CA: O\\u0026apos;Reilly Media, 2020.\\u003c/li\\u003e\\n\\u003cli\\u003eHohpe, Gregor, and Bobby Woolf. \\u003cem\\u003eEnterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions\\u003c/em\\u003e. Boston: Addison-Wesley, 2004.\\u003c/li\\u003e\\n\\u003cli\\u003eEvans, Eric. \\u003cem\\u003eDomain-Driven Design: Tackling Complexity in the Heart of Software\\u003c/em\\u003e. Boston: Addison-Wesley, 2003.\\u003c/li\\u003e\\n\\u003cli\\u003eBass, Len, Paul Clements, and Rick Kazman. \\u003cem\\u003eSoftware Architecture in Practice\\u003c/em\\u003e. 4th ed. Boston: Addison-Wesley, 2021.\\u003c/li\\u003e\\n\\u003cli\\u003eShalloway, Alan, and James R. Trott. \\u003cem\\u003eDesign Patterns Explained: A New Perspective on Object-Oriented Design\\u003c/em\\u003e. 2nd ed. Boston: Addison-Wesley, 2004.\\u003c/li\\u003e\\n\\u003cli\\u003eSuryanarayana, Girish, Ganesh Samarthyam, and Tushar Sharma. \\u003cem\\u003eRefactoring for Software Design Smells: Managing Technical Debt\\u003c/em\\u003e. Boston: Morgan Kaufmann, 2014.\\u003c/li\\u003e\\n\\u003cli\\u003eGamma, Erich. \\u0026ldquo;Reflections on 25 Years of Design Patterns.\\u0026rdquo; \\u003cem\\u003eIEEE Software\\u003c/em\\u003e 36, no. 6 (2019): 13\\u0026ndash;15.\\u003c/li\\u003e\\n\\u003cli\\u003eYacoub, Sherif G., and Hany H. Ammar. \\u0026ldquo;Pattern-Oriented Analysis and Design: Composing Patterns to Design Software Systems.\\u0026rdquo; In \\u003cem\\u003eProceedings of the 6th International Conference on Software Reuse\\u003c/em\\u003e, 2000.\\u003c/li\\u003e\\n\\u003cli\\u003eAvgeriou, Paris, and Uwe Zdun. \\u0026ldquo;Architectural Patterns Revisited: A Pattern Language.\\u0026rdquo; In \\u003cem\\u003eProceedings of the 10th European Conference on Pattern Languages of Programs (EuroPLoP)\\u003c/em\\u003e, 2005.\\u003c/li\\u003e\\n\\u003cli\\u003ePautasso, Cesare. \\u0026ldquo;Composing RESTful Services and Collaborative Workflows: Patterns and Best Practices.\\u0026rdquo; \\u003cem\\u003eInformation and Software Technology\\u003c/em\\u003e 55, no. 10 (2013): 1699\\u0026ndash;1720.\\u003c/li\\u003e\\n\\u003cli\\u003eTaibi, Davide, Valentina Lenarduzzi, and Claus Pahl. \\u0026ldquo;Architectural Patterns for Microservices: A Systematic Mapping Study.\\u0026rdquo; In \\u003cem\\u003eProceedings of the 8th International Conference on Cloud Computing and Services Science (CLOSER)\\u003c/em\\u003e, 2018.\\u003c/li\\u003e\\n\\u003cli\\u003eDragoni, Nicola, et al. \\u0026ldquo;Microservices: Yesterday, Today, and Tomorrow.\\u0026rdquo; In \\u003cem\\u003ePresent and Ulterior Software Engineering\\u003c/em\\u003e, edited by Manuel Mazzara and Bertrand Meyer, 195\\u0026ndash;216. Cham: Springer, 2017.\\u003c/li\\u003e\\n\\u003cli\\u003eFehling, Christoph, et al. \\u003cem\\u003eCloud Computing Patterns: Fundamentals to Design, Build, and Manage Cloud Applications\\u003c/em\\u003e. Heidelberg: Springer, 2014.\\u003c/li\\u003e\\n\\u003cli\\u003eSoni, Dhiraj K., and UmeshBellur. \\u0026ldquo;Performance Evaluation of Software Design Patterns.\\u0026rdquo; \\u003cem\\u003eJournal of Systems and Software\\u003c/em\\u003e 132 (2017): 1\\u0026ndash;14.\\u003c/li\\u003e\\n\\u003cli\\u003eBhamare, Deval, et al. \\u0026ldquo;A Survey on SDN and NFV Architectures for 5G Mobile Networks.\\u0026rdquo; \\u003cem\\u003eIEEE Communications Surveys \\u0026amp; Tutorials\\u003c/em\\u003e 21, no. 1 (2019): 703\\u0026ndash;735.\\u003c/li\\u003e\\n\\u003cli\\u003eKruchten, Philippe. \\u0026ldquo;An Architectural Approach to Software Design.\\u0026rdquo; In \\u003cem\\u003eProceedings of the International Conference on Software Engineering (ICSE)\\u003c/em\\u003e, 1995.\\u003c/li\\u003e\\n\\u003cli\\u003eBuschmann, Frank, and Kevin Henney. \\u0026ldquo;Trends in Pattern-Oriented Software Architecture.\\u0026rdquo; \\u003cem\\u003eIEEE Software\\u003c/em\\u003e 31, no. 2 (2014): 50\\u0026ndash;57.\\u003c/li\\u003e\\n\\u003cli\\u003ePahl, Claus, and Pooyan Jamshidi. \\u0026ldquo;Microservices: A Systematic Mapping Study.\\u0026rdquo; \\u003cem\\u003eSoftware: Practice and Experience\\u003c/em\\u003e 47, no. 10 (2017): 1297\\u0026ndash;1330.\\u003c/li\\u003e\\n\\u003c/ol\\u003e\"}],\"fulltextSource\":\"\",\"fullText\":\"\",\"funders\":[],\"hasAdminPriorityOnWorkflow\":false,\"hasManuscriptDocX\":true,\"hasOptedInToPreprint\":true,\"hasPassedJournalQc\":\"\",\"hasAnyPriority\":true,\"hideJournal\":true,\"highlight\":\"\",\"institution\":\"\",\"isAcceptedByJournal\":false,\"isAuthorSuppliedPdf\":false,\"isDeskRejected\":\"\",\"isHiddenFromSearch\":false,\"isInQc\":false,\"isInWorkflow\":false,\"isPdf\":false,\"isPdfUpToDate\":true,\"isWithdrawnOrRetracted\":false,\"journal\":{\"display\":true,\"email\":\"info@researchsquare.com\",\"identity\":\"researchsquare\",\"isNatureJournal\":false,\"hasQc\":true,\"allowDirectSubmit\":true,\"externalIdentity\":\"\",\"sideBox\":\"\",\"snPcode\":\"\",\"submissionUrl\":\"/submission\",\"title\":\"Research Square\",\"twitterHandle\":\"researchsquare\",\"acdcEnabled\":true,\"dfaEnabled\":false,\"editorialSystem\":\"\",\"reportingPortfolio\":\"\",\"inReviewEnabled\":false,\"inReviewRevisionsEnabled\":true},\"keywords\":\"Software Design Patterns, Software Architecture, Distributed Systems, Pattern Evolution, Qualitative Review, Software Engineering\",\"lastPublishedDoi\":\"10.21203/rs.3.rs-7437898/v1\",\"lastPublishedDoiUrl\":\"https://doi.org/10.21203/rs.3.rs-7437898/v1\",\"license\":{\"name\":\"CC BY 4.0\",\"url\":\"https://creativecommons.org/licenses/by/4.0/\"},\"manuscriptAbstract\":\"\\u003cp\\u003e\\u003cstrong\\u003eSoftware design patterns offer modular, maintainable, and scalable approaches for contemporary software engineering. This research offers a qualitative systematic review performed following PRISMA guidelines. Out of an initial search of 226 publications, 84 articles underwent full-text screening, leading to the inclusion of 42 peer-reviewed studies (published from 2013 to 2024) in the final synthesis. The evaluation was directed by four research inquiries focusing on categorization, contextual application, compromises, and the development of design patterns. Results showed that architectural patterns (MVC, layered architecture, microservices) were the most frequently referenced, with 41 mentions, followed by cloud-native and microservice-related patterns (37 mentions), creational patterns (31 mentions), structural patterns (28 mentions), and event-driven/reactive patterns (25 mentions). Concurrency patterns were mentioned the least (14 occurrences), indicating their growing incorporation into frameworks. In various sectors, web, mobile, enterprise, and cloud applications displayed unique adoption patterns, with MVC leading in web environments, MVVM common in mobile platforms, and microservices and CQRS fundamental to cloud architectures. Analysis of trade-offs highlighted recurring conflicts like simplicity versus testability (Singleton), flexibility versus readability (Factory Method), and independence versus integration complexity (Microservices). Timeline mapping illustrated the transition from monolithic models to distributed, event-driven, and serverless architectures from 2010 to 2024, showing a distinct increase in cloud-native adoption after 2018. The study ends with suggestions for context-sensitive pattern choice and emphasizes the importance of further investigation into AI-automated patterns, edge-native orchestration, and quantum-ready software designs, framing design patterns as an ever-evolving structure for tackling software engineering challenges in the 21st century.\\u003c/strong\\u003e\\u003c/p\\u003e\",\"manuscriptTitle\":\"Software Patterns for the 21st Century: From Monolithic Designs to AI-Driven Architectures\",\"msid\":\"\",\"msnumber\":\"\",\"nonDraftVersions\":[{\"code\":1,\"date\":\"2025-08-27 15:52:08\",\"doi\":\"10.21203/rs.3.rs-7437898/v1\",\"editorialEvents\":[{\"type\":\"communityComments\",\"content\":0}],\"status\":\"published\",\"journal\":{\"display\":true,\"email\":\"info@researchsquare.com\",\"identity\":\"researchsquare\",\"isNatureJournal\":false,\"hasQc\":true,\"allowDirectSubmit\":true,\"externalIdentity\":\"\",\"sideBox\":\"\",\"snPcode\":\"\",\"submissionUrl\":\"/submission\",\"title\":\"Research Square\",\"twitterHandle\":\"researchsquare\",\"acdcEnabled\":true,\"dfaEnabled\":false,\"editorialSystem\":\"\",\"reportingPortfolio\":\"\",\"inReviewEnabled\":false,\"inReviewRevisionsEnabled\":true}}],\"origin\":\"\",\"ownerIdentity\":\"6254ff2e-f4df-4f5c-85fe-7fae86909cd0\",\"owner\":[],\"postedDate\":\"August 27th, 2025\",\"published\":true,\"recentEditorialEvents\":[],\"rejectedJournal\":[],\"revision\":\"\",\"amendment\":\"\",\"status\":\"posted\",\"subjectAreas\":[{\"id\":53593940,\"name\":\"Artificial Intelligence and Machine Learning\"}],\"tags\":[],\"updatedAt\":\"2025-08-27T15:52:08+00:00\",\"versionOfRecord\":[],\"versionCreatedAt\":\"2025-08-27 15:52:08\",\"video\":\"\",\"vorDoi\":\"\",\"vorDoiUrl\":\"\",\"workflowStages\":[]},\"version\":\"v1\",\"identity\":\"rs-7437898\",\"journalConfig\":\"researchsquare\"},\"__N_SSP\":true},\"page\":\"/article/[identity]/[[...version]]\",\"query\":{\"redirect\":\"/article/rs-7437898\",\"identity\":\"rs-7437898\",\"version\":[\"v1\"]},\"buildId\":\"8U1c8b4HqxoKbykW_rLl7\",\"isFallback\":false,\"isExperimentalCompile\":false,\"dynamicIds\":[84888],\"gssp\":true,\"scriptLoader\":[]}","source_license":"CC-BY-4.0","license_restricted":false}