Appropriate Software Architecture: A risk-driven design method -- Reading Notes

I personally think that there are too many concepts in this book. The architecture and development of software are not a combination of concepts. Just use the appropriate words to describe some empirical things.

The so-called risk-driven model selects the appropriate design strength based on the project situation to avoid over-design. For complex software systems, careful design is still very important, and there will be design issues before and during development.

In addition, a software engineer needs to have some knowledge about some architecture models and build the so-called "conceptual model" in his mind. Each model is abstract and constrained.

It also introduces Domain Models, design models, code models, encapsulation and segmentation, model elements (components), and model relationships.

The architectural style is a so-called conceptual model.

The second part is worth watching.

 

 

The core issue should be:"How much architecture design work should be done for a specific system?"

One answer: "An appropriate architecture ".

Fairbanks believes that the core criterion for determining whether architecture work is adequate is to see if it can reduce risks. If the risk in the design is small, you do not need to do much architecture work. If the system design has a major problem, the architecture is a good tool. This book selects technology from the engineering point of view in terms of cost and benefit. Particularly valuable, it balances the benefits of the project and the cost of Architecture Design by focusing on the reduction of risks, so as to obtain the best results.

Naturally, there are still many questions to answer.

What risks are best solved through the software architecture?

How to solve a design problem using the architecture design principle?

Which architectures promise to be written down for reference by others?

How can we ensure that the architecture commitment is followed by implementers?

0. Overview

In order to solve the software complexity and the problems brought about by the growth of the scale, the solution is far-fetched into three categories:Divide governance, knowledge, abstraction.

Developers divide the problem into several subproblems that are smaller and easier to handle,

In this way, they can use knowledge of similar problems to solve some subproblems,

In addition, abstraction helps them make inferences and judgments.

 

When building a system, we should select the architecture that best meets the current needs and implement functions under the framework of this architecture.

 

Conceptual Model-abstraction and constraints

 

Risk is recommended in this book to weigh the degree of implementation architecture.

 

I. Risk-Driven Software Architecture

 

 

Ii. Architecture Modeling

 

Classic model structure: domain model, design model, and code model ).

Domain Models correspond to things in the real world,

The design model is designed for the software being built,

The code model corresponds to the source code.

We can also build some additional models to show specific details, called views ). These views can be classified into different view types ).

 

Build encapsulation boundariesIt is a key skill in software architecture. Users of components or modules usually ignore the internal working mechanism and focus on solving other problems. For encapsulated components or modules, You can freely change their internal implementations without affecting their users.

 

Appropriate Software Architecture: A risk-driven design method -- Reading Notes