Introduction to Software Architecture

What is Architecture

Where there is a system, an architecture is needed. From an aviation aircraft to a functional component in an e-commerce system, design and architecture are required.In terms of abstraction, architecture is the abstract description of the entities in the system and the relationship between entities, the allocation of the correspondence between the functions of objects/information and the formal elements, and the relationship between the elements.and the definition of the element's relationship to its surroundings.Architecture can divide the target system according to a certain principle. The principle of segmentation is to facilitate the parallel work of different roles. Well-structured creative activities are better than unstructured creative activities.

Characteristics of a large website

• Many users, widely distributed
• High traffic, high concurrency
• Massive data, high service availability
• The security environment is harsh and vulnerable to network attacks
• Multiple features, faster, frequent releases
• From small to large, gradual development
• User-centric
• Free service, paid experience

Large Site Architecture Goals

• High Performance: Provides a fast access experience.
• High availability: Website services can always be accessed normally.
• Scalable: Increase/decrease processing power through hardware increase/decrease.
• Security: Provides policies for secure website access, data encryption, and secure storage.
• Extensibility: It is convenient to add/remove new functions/modules by adding/removing.
• Agility: on-demand, fast response;

Sources of system complexity

An important point that distinguishes software development from other industries is that programmers often do not need to consider the constraints of the laws of reality. The design and development of a software completely depends on the creative thinking and thinking organization ability of the programmer, which means that in software developmentThe biggest limitation is actually whether we can properly understand the objects we are creating.
With the evolution of the software, adding more function points, the system becomes more and more complex: there are various subtle dependencies among each module (Module).The complexity of a system accumulates over time, and it becomes increasingly difficult for a programmer to consider all relevant factors when modifying a system.This will slow down the software development progress and introduce bugs, which will further delay the development progress and increase the development cost.Over the life cycle of any system, complexity inevitably increases; the larger the system, the more people will be required to develop it, and the more difficult the job of managing the complexity of the system will be.

Complexity does not come out of thin air, and it is often not intentional, which means that the increase in complexity often does not depend on our subjective will.Like the elephant in the room, we cannot escape and we cannot turn a blind eye.Sources of complexity can be:

• Accretion and continuous iteration: Incremental design means that software design never ends, design continues to occur in the life cycle of the system, and programmers must always consider design issues.Incremental development also means continuous refactoring.The initial design of a system is almost never the best solution.As experience increases, better designs are bound to be discovered.
• Interactive and non-scalable design: When the large-scale system caused by the accretion effect, combined with the interactive feature, will make the technical system more complex.In addition to acting on itself, a technical system also interacts with a large number of other systems.For example, when an order is placed to buy a commodity, the order system, commodity system, payment system, logistics system, and card and coupon system will interact and cooperate.The complexity of such accretion, due to the emergence of interactive characteristics, will show a geometric progression.
• Unreasonable business encapsulation: Unreasonable business encapsulation is a relatively broad concept, and its specific manifestations are process-oriented rather than object-oriented, unreasonable layering, etc.
• Lack of a unified language: In a typical agile development structure, each role on the assembly line tends to focus on the links that they are responsible for, and the refined division of labor also limits the overall perspective of each role; although we often advocate the so-called sense of ownership, but it is difficult to advance when landing.
• Lack of constraints and specifications: In the context of team collaborative development, lack of specifications and constraints will seriously damage the consistency of the architecture (Consistency), and the maintainability of the code will drop sharply.Maybe the specification is at the implementation level, such as naming, subcontracting and other small issues that do not affect the operation of the code, but the embankment of a thousand miles collapses in the ant's nest, it is these subtle inattentions that lead to the avalanche of overall complexity.

Coping with complexity will never be done once and for all. We need to constantly innovate and reshape our understanding of software systems dynamically and incrementally, constantly recognizing problems and finding better solutions.The first way to control complexity is simple code and clear intent (Obvious).For example: reducing the processing of special scenarios, or variable naming consistency can reduce system complexity.Another way is to abstract complex problems and then divide and conquer.