Application Architecture Guide Chapter 1 application architecture Basics

Fundamental concepts of software architecture

Basic concepts of software architecture 

Software Architecture is often described as the organization or structure of a system, while the system represents a collection of components that accomplish a specific function or set of functions. in other words, architecture is focused on organizing components to support specific ality. this organization of functionality is often referred to as grouping components into "areas of concern."

The software architecture is generally described as the structure of an organization or system, and the system is a collection of components that complete a specific set of functions or functions. In other words, the focus of the architecture is to organize components to support specific functions. The organization of this function is called to group components to the areas of interest.

Why do we need architecture?

Why do we need architecture? 

Like any other complex structure, software must be built on a solid foundation. failing to consider key scenarios, failing to design for common problems, or failing to appreciate the long-term consequences of key decisions can put your application at risk. modern tools and platforms help to simplify the tasks of building applications, but they do not replace the requirement to design your application based on your specific scenarios. the risks exposed by poor architecture include software that is unstable, is unable to support business requirements, or cocould even prevent the application from working when deployed into a production environment.

Like any other complex structure, software must be built on a solid foundation. Your applications can be at risk without considering critical scenarios, designing for common issues, or being fully aware of the long-term consequences of key decisions. Modern tools and platforms help simplify application build tasks, but they do not replace the need to design applications based on your specific needs. Risks exposed by poor architecture include unstable software, inability to support business needs, or failure to work when deployed to a production environment.

Consider the following high-level concerns when thinking about software architecture:

When thinking about software architecture, consider the following high-level concerns:

> How will the application be deployed into production?

> How can applications be deployed to the production environment?

> How will the users be using the application?

> How Will users use this application?

> What are the quality attribute requirements, such as security, performance, concurrency, internationalization, and configuration?

> What are quality attribute requirements, such as security, performance, concurrency, internationalization and configuration?

> What are the specified tural trends that might impact your application now or after it has been deployed?

> What is the trend of architecture? Is it that the application may be affected now or after deployment?

The goals of Architecture

Architecture goals 

Application architecture seeks to build a bridge between business requirements and technical requirements by understanding use cases, and then finding ways to implement those use cases in the software. the goal of architecture is to identify the requirements that impact the structure of the application. good architecture has CES the business risks associated with building a technical solution. A good design is sufficiently flexible to be able to handle the natural drift that will occur over time in hardware and software technology, as well as in user scenarios and requirements. an impact ect must consider the overall impact of design decisions, the inherent tradeoffs between quality attributes (such as performance and security), and the tradeoffs required to address user, system, and business requirements.

Application architecture seeks to build a beam between business and technical needs, understand use cases, and then find ways to implement these use cases in software. The goal of the architecture is to determine the needs that affect the application structure. A good architecture reduces business risks by building a technical solution. Excellent Design is flexible enough for processing. Over time, it will take place in hardware and software technologies, as well as natural changes in user scenarios and needs. Architects must consider the inherent trade-offs between design decisions, quality attributes (such as performance and security), and the full impact of the trade-offs between users, systems, and business needs.

Keep in mind that the architecture shoshould:

Remember, the architecture should be:

> Expose the structure of the system but hide the implementation details.

> Expose the system structure, but hide the implementation details.

> Realize all of the use-case scenarios.

> Implement all use cases.

> Try to address the concerns of various stakeholders.

> Try to solve various stakeholder concerns.

> Handle both functional and quality requirements.

> Both functional and quality requirements are handled.

Approach to Architecture

Architecture Method 

There are key decisions that must be addressed with any architecture, regardless of your tural approach. at a minimum, you must determine the type of application that you are building, the specified tural styles that will be used, and how you will handle cross-cutting concerns. throughout this guide, we use an appropriate tural baseline for framing out the different areas that must be addressed in your architecture. the specified tural baseline is shown in the following disince.

There are critical decisions that must be addressed by any architecture, regardless of the architecture method. At least, you must determine the type of the application you are building, the architectural style to be used, and how you will handle cross-cutting concerns ). In this guide, we use architecture benchmarks for the Framework, through different areas that must be addressed in the architecture. The architecture benchmark is shown in the following chart. 

In addition to the specified tural baseline, you can use the following approach to help define your architecture. the first step is to identify the type of application you plan to build. next, you must understand how the application will be deployed. once you know what type of application you are building and how it will be deployed, you can start to drill down into the architecture to identify styles and technologies that you will use. finally, you must consider how quality attributes and cross-cutting concerns will be insigated into the design of your system.

In addition to the architecture benchmark, you can use the following methods to help determine your architecture. The first step is to determine the type of application you plan to build. Next, you must understand how the application will be deployed. Once you know what type of application you are building and how to deploy it, you can start to consider the architecture to determine the style and technology you will use. Finally, you must consider how to incorporate quality attributes and cross-cutting concerns into your system design.

Cross-cutting concerns represent key areas of your design that are not related to a specific layer in your application. for example, you might want to cache data in the presentation layer, the business layer, and the data access layer. the key cross-cutting concerns: authentication, authorization, caching, communication, exception management, instrumentation and logging.

A cross-cutting concern represents a key field in the design and is not associated with a specific layer in the application. For example, you may want to cache data at the presentation layer, business layer, and data access layer. Key cross-cutting concerns: authentication, authorization, caching, communication, exception management, detection, and logs.

Designing Your architecture

Design Architecture

Consider the following questions as you create an elastic tural design with agility in mind:

To create a flexible architecture design, consider the following:

> What are the foundational parts of the architecture that represent the greatest risk if you get them wrong?

> What is the basis of the architecture? If they fail, they represent the greatest risk?

> What are the parts of the architecture that are most likely to change, or whose design you can delay until later with little impact?

> Which part of the architecture is most likely to change, or which part of the design can be postponed until it has a small impact and then processed?

> What are your key assumptions, and how will you test them?

> What are your primary assumptions and how will you test them?

> What conditions may require you to refactor the design?

> What conditions may require you to reconstruct the design?

Key Architecture Principles

Key Architecture Principles 

Consider the following key principles when designing your architecture:

When designing the architecture, consider the following main principles:

>Build to change over build to last.Wherever possible, design your application so that it can change over time to address new requirements and challenges.

>Continuous changes.Design an application whenever possible so that it can change over time to address new needs and challenges.

>Model to analyze and reduce risk.Use threat models to understand risks and vulnerabilities. Use design tools and modeling systems such as Unified Modeling Language (UML) where appropriate.

>Analyze the model and reduce risks.Use threat models to understand risks and vulnerabilities. Use design tools and modeling systems, such as the Unified Modeling Language (UML), as appropriate ).

>Models and views are a communication and collaboration tool.Efficient communication of design principles and design changes is critical to good architecture. Use Models and other visualizations to communicate your design efficiently and to enable rapid communication of changes to the design.

>Models and views are tools for communication and collaboration.Effective communication between design principles and design changes is crucial to a good architecture. Use Models and other visual tools to effectively communicate the design, so that design changes can be quickly communicated.

>Identify key engineering decisions.Use the architecture frame in this Guide to understand the key engineering decisions and the areas where mistakes are most often made. invest in getting these key decisions right the first time so that the design is more flexible and less likely to be broken by changes.

>Determine critical engineering decisions.Use the architecture framework in this Guide to understand key engineering decisions and the most common areas of error. These key decisions are obtained immediately, making the design more flexible and not possibly damaged by changes.