Software Architecture and Design InfoQ Trends Report 2021

Resilience in Modern Software Architectures

• Architects are increasingly focused on designing for resilience in modern software architectures, particularly in the context of microservices and serverless computing, where distributed systems and network interactions introduce new challenges. (2m28s)
• The adoption of pre-built solutions like service meshes and technologies like Dapper simplifies the implementation of resilience patterns, freeing up architects and developers to focus on higher-level design considerations. (3m32s)

Event-Driven Architectures and Asynchronous Systems

• The growing popularity of event-driven architectures, facilitated by technologies like message queues, is contributing to more resilient systems by decoupling components and reducing the reliance on complex mechanisms like circuit breakers and load balancers. (4m18s)
• Asynchronous systems can be difficult to reason about and understand, even if they appear elegant on paper. (5m44s)

Observability and Understandability

• Observability tools can aid in building resilient systems by providing insights into system behavior and facilitating troubleshooting. (6m18s)
• Observability and understandability are crucial aspects of software architecture, with observability being more relevant at runtime and understandability being more important during design time. (6m45s)

Multi-Cloud Strategies

• There are regulatory and practical reasons why companies pursue multi-cloud strategies, including avoiding vendor lock-in and addressing limitations of specific cloud providers or regions. (10m39s)
• While multi-cloud can be beneficial, it's important to prioritize standardizing workflows (building, releasing, observing code) over aiming for complete system portability across clouds. (13m10s)

Sustainability in Software Architecture

• The increasing focus on sustainability in software architecture stems from the recognition that the tech industry contributes significantly to carbon emissions, similar to the aviation industry. (14m40s)
• There is a correlation between cost and carbon emissions in cloud computing, meaning that reducing costs often leads to reduced carbon emissions. (17m20s)

Cloud Provider Transparency

• Cloud providers like Amazon and Azure are improving the transparency of their energy usage, but customers should still inquire about the sustainability of their services. (18m43s)

Microservices and Modular Monoliths

• Distributed systems and microservices are no longer considered novel or exciting technologies, with some companies even reverting back from microservices architectures. (19m3s)
• Microservices are not always the right solution, especially for small teams or startups looking to launch quickly. Instead, a modular monolith approach can offer benefits while allowing for future separation if needed. (20m40s)

Justification for Microservices

• It's crucial to understand the reasoning behind choosing microservices. If the justification goes beyond simply following trends and demonstrates an understanding of coupling and cohesion, it's a good sign. (21m38s)

Design Principles and Domain-Driven Design (DDD)

• Good design principles, such as those found in domain-driven design (DDD) and concepts like encapsulation and information hiding, are essential for building well-architected systems, regardless of whether they are microservices or modular monoliths. (22m29s)
• Domain-driven design (DDD) helps encapsulate systems and create well-designed distributed systems, whether or not they use microservices. (24m25s)

Shift Away from Microservices

• The software architecture industry is shifting away from microservices towards larger components, incorporating lessons learned from past experiences. (25m10s)

Data Architecture and Data Mesh

• Data architecture is becoming increasingly important in software architecture, with concepts like data mesh, data gateways, and DataOps gaining traction. (27m6s)
• There is a growing emphasis on understanding user needs and data ownership in data architecture, as advocated by Zhamak Dehghani and her team at Thoughtworks. (28m2s)

Data Flow and Decentralization

• Data should flow freely based on specific needs, avoiding centralized pipelines that can cause bottlenecks. (28m42s)

Communication and Empathy in Architecture

• Architects should possess strong communication and empathy skills, enabling them to effectively convey technical strategies to both high-level executives and development teams. (31m7s)
• Architects should actively engage with developers, understanding their challenges and incorporating their feedback to ensure the practicality and feasibility of architectural designs. (32m10s)

Feedback from Developers

• Architects need to receive feedback from developers, even in companies where architects are paid significantly more than developers. Developers can provide valuable insights into the practicality and efficiency of architectural designs. (33m31s)

Collaborative Architecture Diagrams

• Architecture diagrams, often used by architects, should be constantly updated and treated as collaborative tools. A whiteboard in a shared workspace, rather than a static digital diagram, can facilitate better communication and real-time updates during discussions. (33m58s)

Remote Work and Communication Challenges

• The COVID-19 pandemic and the shift to remote work have impacted communication in software development. The lack of physical proximity makes it more challenging for architects to overhear developers' discussions and identify potential issues early on. (37m1s)
• The increased use of digital communication tools like Slack and Teams has made it more difficult to acquire knowledge organically compared to in-person office settings. (37m52s)

Disciplined Communication and Collaboration Tools

• The reliance on digital communication tools necessitates a more disciplined approach to communication, including the use of architecture decision records and updated documentation. (38m2s)
• The shift to remote work has highlighted the importance of collaboration tools, particularly for design reviews and code reviews, to maintain awareness of project decisions and progress. (38m36s)

Dapper: Distributed Application Abstraction

• Dapper, an abstraction for writing distributed applications, has recently become generally available. (42m11s)
• Dapper focuses on application-level aspects like state management and service invocation, unlike service meshes that focus on networking. (43m1s)

WebAssembly (Wasm)

• WebAssembly, while promising, hasn't seen widespread adoption yet for building large-scale applications. (46m21s)
• WebAssembly (Wasm) provides a standardized way to deploy applications with less overhead than Docker and offers inherent cross-platform compatibility and security. (47m53s)
• Wasm's ability to run the same language on the front end and back end simplifies team structure, release processes, and enables full-stack development. (48m30s)

GraphQL Federation

• GraphQL Federation, as implemented by companies like Netflix, addresses the growing complexity of managing numerous microservices and APIs by providing a unified layer for querying and interacting with distributed systems. (50m30s)
• Netflix uses GraphQL Federation and GraphQL microservices. (51m35s)
• GraphQL solves some problems but creates others. (51m42s)
• Using GraphQL could be a good option if an application needs rapid innovation on the front end without the front end team being reliant on the back end team. (52m5s)