 In this video I'm going to talk about architectural design decisions that software engineers and architects need to make. Look at this picture. Remember, the architecture is a critical link between requirements and the software that will be built. Software engineers make various mistakes in software construction phase. These mistakes can be corrected with less or more effort. The mistakes that are made in the software architecture are costly and very hard to correct. One cannot correct architecture mistakes with a quality code. Sometimes software needs to be rebuilt from the ground. If we build a wooden house and later we find out that a house needs to be built using concrete, we will have to destroy that wooden house first. Therefore, it is crucial to make appropriate design decisions. When designing our system, we structure our system by decomposing the system into smaller subsystems and components creating a statical model of a system. Also, we define the dynamic relations between subsystems and components. We may provide details on how the control is passed from one component to another. We may describe our data entities and flow of the data between processing components. What can be modeled? It is covered in detail in the system modeling module. When choosing appropriate architecture, the software engineer or architect needs to take into account non-functional requirements or so-called architectural attributes such as performance, security, safety, availability, maintainability, testability, portability, scalability and many other. For example, if performance is the key attribute, then we should choose the architecture that localizes operations to minimize subsystem communication overhead. If the priority is security, then we could choose layered architecture hiding critical assets in inner layers. If safety is very important, we should choose the architecture that allows isolating safety critical components. If the system needs to be available 24-7, then our architecture should include redundant components. If maintainability is important, maybe we will choose the component-based architecture that will allow creation of self-contained fine-grained components. If it is expected to port software to many different platforms, probably we will use architectures that will allow the same code base for different platforms. As you can see, there are many ifs. What's making the decision even more complicated is that some of these attributes contradict each other. For example, increasing system security will reduce the performance because of communication overhead between additional layers that will be added for the security reasons. Architects have to choose a trade-off between space and time, dependability and performance, security and performance, and others. During the decision-making process, first are considered architectures that allow reducing identified risks. Also, it is necessary to assess the impact of architecture on quality attributes that are identified in the requirement process. Even if architects agree on what architecture is best for their project, it doesn't mean that it will be the final decision. Various other criteria might come into play that comes from stakeholders. It might appear that it is impossible to use the chosen architecture because of the budget and time to market. Therefore, final architecture needs to be negotiated with the stakeholders. Let's summarize this lecture. So, architectural design decisions are the choices that bind the final product. It is very costly and sometimes impossible to fix design mistakes. Various non-functional requirements influence the design decisions. An architecture usually deals with trade-offs between different architectural attributes. Non-technical factors, such as management, the market, may play a big role in making architectural choices. If you are going to become a software engineer, probably you will have to make architectural decisions. Be sure to find appropriate ones. Thank you for watching.