Software Architecture

[anitsh]

Business goals are the foundation on which software systems are justified, analyzed, and built. Software systems are constructed to realize business or mission goals. Software architecture is the bridge between the business goals and the realized system. Those claims about business goals underlie many methods for designing and analyzing software architectures. However, precisely eliciting and characterizing business goals has always been problematic. Business goals come in many forms and at many levels of abstraction, and the stakeholders of the system are usually not accustomed to making goals explicit.

The quality and longevity of a software-reliant system is largely determined by its architecture.

What Is an Architecture?
Informally, an architecture is the blueprint describing the structure of a system.
Formal Definition - “The software architecture of a computing system is the set of structures needed to reason about the system, which comprise software components, relations among them and properties of both.”

"Architecture represents the significant design decisions that shape a system, where significant is measured by cost of change." - Grady Booch

"Every software-intensive system has an architecture. In some cases that architecture is intentional, while in others it is accidental. Most of the time it is both, born of the consequences of a myriad of design decisions made by its architects and its developers over the lifetime of a system" - Grady Booch

"Check capabilities, not ingredients." - Gregor Hophe

“Architecture is selling options.”- Gregor Hophe

"An architecture picture without lines or an architecture defined by a bill of material, raise your hand and proclaim that this isn't an architecture discussion at all" - Gregor Hophe

• https://www.linkedin.com/pulse/boxes-lines-budgets-gregor-hohpe

Good Architecture Starts With Modularity
It is generally a good architectural practice to make the code base more modular, more manageable. Start with the data and pay close attention to how they’re being accessed. Make sure each module/service owns and controls access to its own data, and that data access only happens through clearly defined API contracts.

Start #344 #192 #439 #462

Remember YAGNI!

The pattern-analysis scoring for some of the architecture patterns. This summary will
help you determine which pattern might be best for your situation.
For example, if your primary architectural concern is scalability, you
can look across this chart and see that the event-driven pattern,
microservices pattern, and space-based pattern are probably good
architecture pattern choices. Similarly, if you choose the layered
architecture pattern for your application, you can refer to the chart
to see that deployment, performance, and scalability might be risk
areas in your architecture.

While this chart will help guide you in choosing the right pattern, there is much more to consider when choosing an architecture pattern. You must analyze all aspects of your environment, including infrastructure support, developer skill set, project budget, project deadlines, and application size (to name a few). Choosing the right architecture pattern is critical, because once an architecture is in place, it is very hard (and expensive) to change. -
Mark Richards, Software Architecture Patterns

Architecture Decision Template

Look for code and data that are often changed and deployed together to determine features or functionalities that are more tightly coupled. Use these as natural groupings for what can be iterated on and deployed independently from other areas.

Resource

• http://systemarchitect.mit.edu
• https://martinfowler.com/architecture
• http://fundamentalsofsoftwarearchitecture.com
• http://www.lix.polytechnique.fr/~golden/systems_architecture.html
• https://trello.com/c/M0G4wGXB/111-software-architecture
• https://www.ruthmalan.com
• https://chrisrichardson.net/post/architecture/2019/07/23/who-does-architecture.html
• https://dev.to/simonbrown/software-architecture-isn-t-about-big-design-up-front-4hol
• https://medium.com/nick-tune-tech-strategy-blog/self-documenting-architecture-80c8c2429cb8
• https://en.wikipedia.org/wiki/Systems_architecture
• https://en.wikipedia.org/wiki/Software_architecture
• https://en.wikipedia.org/wiki/Systems_architect
• https://en.wikipedia.org/wiki/Architecture_framework
• https://en.wikipedia.org/wiki/Department_of_Defense_Architecture_Framework
• https://en.wikipedia.org/wiki/Architectural_pattern
• https://www.developertoarchitect.com/downloads/worksheets.html
• https://www.ibm.com/developerworks/rational/library/feb06/eeles/index.html
• http://files.catwell.info/misc/mirror/2003-martin-fowler-who-needs-an-architect.pdf
• https://developertoarchitect.com
• http://evolutionaryarchitecture.com
• https://www.slideshare.net/TechWellPresentations/modern-evolutionary-software-architectures
• https://herbertograca.com/2017/07/03/the-software-architecture-chronicles
• https://www.visual-paradigm.com/guide/enterprise-architecture/enterprise-architects-vs-solution-architects-vs-domain-architects
• https://subscription.packtpub.com/book/application_development/9781786468529/1/ch01lvl1sec07/defining-software-architecture
• https://architectelevator.com/architecture/architects-zoom
• https://martinfowler.com/tags/application%20architecture.html
• https://docs.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/
• https://jimmybogard.com/vertical-slice-architecture/
• https://vaadin.com/learn/tutorials/ddd/ddd_and_hexagonal
• https://herbertograca.com/2017/11/16/explicit-architecture-01-ddd-hexagonal-onion-clean-cqrs-how-i-put-it-all-together
• https://axoniq.io/resources/cqrs
• https://www.educba.com/security-architecture
• https://www.codeproject.com/articles/20467/software-architecture-review-guidelines
• https://resources.sei.cmu.edu/library/asset-view.cfm?assetid=513908
• https://riskstorming.com
• http://swarchitectonics.blogspot.com/2016/08/a-toolbox-of-software-architecture.html
• https://link.springer.com/content/pdf/10.1007/978-0-387-35563-4_26.pdf Structural Analysis of the Software Architecture - A Maintenance Assessment Case Study
• https://twitter.com/ruthmalan/status/1298215743809556482
• https://twitter.com/Grady_Booch/status/1301810362119905285
• Could be a good resource for architectural decision making : https://www.infoq.com/presentations/150-infrastructures
• Why Google stores billions of lines of code in a single repository
• https://medium.com/the-innovation/emergent-architecture-architecture-in-the-age-of-agile-9f21ba654845
• https://www.linkedin.com/pulse/revisiting-how-people-prioritise-software-work-eoin-woods
• https://handbookofsoftwarearchitecture.com/books
• https://medium.com/swlh/software-architect-path-4-architectural-drivers-46b27af869f9
• Patterns in System Architecture Decisions - MIT Abstract- This paper proposes a set of six canonical classes of architectural decisions derived from the tasks described
  in the system architecture body of knowledge and from real system architecture problems. These patterns
  can be useful in modeling architectural decisions in a wide range of complex engineering systems. They
  lead to intelligible problem formulations with simple constraint structures and facilitate the extraction of
  relevant architectural features for the application of data mining and knowledge discovery techniques. For
  each pattern, we provide a description, a few examples of its application, and briefly discuss quantitative
  and qualitative insights and heuristics. A few important theoretical properties of the corresponding set of
  patterns are discussed, such as completeness, degradedness, and computational complexity, as well as some
  practical guidance to be taken into account when applying them to real-life architecture problems. These
  patterns are intended to be a useful tool for researchers, practitioners and educators alike by: facilitating
  instruction and communication among system architects and with researchers from other fields such as
  combinatorics, computer science and operations research; and fostering reuse of domain-independent
  knowledge necessary to develop architecture decision support tools (and thus development time and cost
  reductions for such tools).
• The Architecture of Complex Systems: Do Core-periphery Structures Dominate? - Harvard Business School
• The Architecture of Platforms: A Unified View - Harvard Business School
• http://weblog.tetradian.com/2015/01/15/declaring-the-assumptions
• https://www.oreilly.com/content/topics/software-architecture
• https://www.sciencedirect.com/topics/computer-science/architectural-tactic
• https://www.enterpriseintegrationpatterns.com/ramblings/86_isthisarchitecture.html Gregor Hope
• https://www.linkedin.com/pulse/dont-check-ingredients-abilities-gregor-hohpe
• https://www.linkedin.com/pulse/boxes-lines-budgets-gregor-hohpe
• https://open.spotify.com/episode/4gRhjFeMAw7mz0fTRi5fBF Mark Richards on Software Architecture
• https://www.linkedin.com/pulse/decisions-ruth-malan/, https://www.linkedin.com/pulse/architecture-decisions-ruth-malan, https://www.linkedin.com/pulse/architecture-clues-heuristics-part-i-scars-ruth-malan/, https://www.linkedin.com/pulse/architecture-clues-heuristics-part-ii-decisions-change-ruth-malan/
• https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions
• https://resources.sei.cmu.edu/library/asset-view.cfm?assetID=513908

Architectural Paradigms

• https://en.wikipedia.org/wiki/Search-oriented_architecture
• https://en.wikipedia.org/wiki/Resource-oriented_architecture
• https://en.wikipedia.org/wiki/Service-oriented_architecture
• https://en.wikipedia.org/wiki/Event-driven_architecture

Architecture Decision Records

• https://adr.github.io

[anitsh]

Back to basics: For wanna be architects, when building system and services, always start with a system context diagram. Don't fall into trendy stuff like micro-services, kubernetes, big data, AI or cloud-native at onset.
A system context diagram looks basic, simple and obvious. Context diagrams should be non-technical so that everyone in the team can understand it. In my experience I found SCD to be very helpful in uncovering user personas, roles, information flow and system boundaries.

#systemsdesign #architecture #microservices #enterprisearchitecture

As per wikipedia :
A system context diagram (SCD) in engineering is a diagram that defines the boundary between the system, or part of a system, and its environment, showing the entities that interact with it.[2] This diagram is a high level view of a system. It is similar to a block diagram.

https://www.linkedin.com/posts/ajaykhandelwal_systemsdesign-architecture-microservices-activity-6742943530420887552-wura

[anitsh]

4 principles to guide successful architects and architecture

1. Contextual Understanding Over Siloed Decision Making

It is rare that a decision can be made without consideration of any trade-offs. Often, the quality of a decision is directly impacted by the experience and knowledge of the person that made it. The caution here is to avoid being an aloof architect. An aloof architect is someone who makes decisions based solely on one’s own experiences and siloed considerations. An aloof architect typically has good intentions but will miss important considerations and that inevitably leads to flawed decision making.
Rather, be an aware architect. An aware architect provides context from many different perspectives, ranging from business to technical, across different disciplines and subject matter domains. An aware architect is always learning and able to bring in their context to inform the decision making process. An aware architect is also self-aware in understanding his or her own limits, and will bring in additional expertise as needed to supplement their own contextual understanding. Decisions made with contextual understanding are likely to be less brittle and more sustainable than otherwise. This is key in architectural decision making since, while architectures do evolve over time, changing certain architectural decisions after implementation can be very painful and very difficult. Enabling flexibility as an outcome is key to evolutionary architecture.

2. Tangible Direction Over Stale Documentation

The adage that a picture is worth a thousand words is still true, and having a reference architecture document that multiple parties can use to understand their proposed target state is also useful. The caution here is to avoid being an archaeological architect. An archaeological architect is someone stuck in the cycle of documenting current state and forever updating current state as the delivery teams continue to release. This is a trap of reactive thinking and offers very little value.
Rather, be an ambitious architect. The ambitious architect is someone who upholds the documentation focus to be on the proposed future, and the decisions made to define that future, to sustain consistent thinking for posterity. This allows for the right kind of conversations and deliberations to be proactive and strategic. To point out what is feasible and what is a constraint, and to formulate a tangible plan to overcome challenges to achieve the proposed target. This kind of conversation and partnership is key to the success of the architect.

3. Driving Behavior Over Enforcing Standards

While an important outcome of architecture strategy is standardization and re-use of patterns, technologies, and solutions, that doesn’t mean that architects should strive to only be enforcers of standards. The caution here is to avoid being the administrative architect. An administrative architect is someone who focuses on compliance to the rules and regulations to the detriment of everything else.
Rather, be an ambassador architect. An ambassador architect is someone who understands the rules and regulations, the acceptable proven patterns and solutions, to guide the delivery teams on the expectations of adherence. This position allows for driving the right behaviors with the flexibility for delivery teams to innovate within the guardrails that are laid out in the pursuit of safety and security. An ambassador architect is someone who is also willing to listen to feedback, and able to relay that feedback into improving the standards. Evolving standards and challenging the status-quo based on reality and innovation is necessary to improve the overall architecture guidance.

4. Evolution Over Frameworks

A good framework can provide a re-usable, clear methodology for solving problems and enabling consistency. The caution here is to avoid being an afraid architect. An afraid architect is someone who performs rigidly by the details of expansive frameworks to try to output what is needed. This is problematic in that it does very little to move the needle strategically. A strategy will be produced, yes; but it likely will not offer as many benefits as it could.
Rather, be an audacious architect. An audacious architect understands the framework well enough to focus on its value driven output. An audacious architect can evolve the framework itself if needed and moreover understands that architecture solutions can evolve over time. Embracing change to inform better architectures can be risky, yet it is often a risk well worth taking. An audacious architect is always learning and keeps skills and knowledge of business and technology up to date.

• https://medium.com/capital-one-tech/a-manifesto-for-effective-enterprise-architecture-7e887185f587