Philippe Kruchten, Grady Booch, Kurt Bittner, and Rich Reitman derived and refined a definition of architecture based on work by Mary Shaw and David Garlan Shaw and Garlan 1996 Their definition is "Software architecture encompasses the set of significant decisions concerning the organization of a software system including the selection of the structural elements and their interfaces by which the system is composed; behavior as specified in collaboration among those elements; composition of the structural and behavioral elements into larger subsystems; and an architectural style that guides this organization Software architecture also involves functionality, usability, resilience, performance, reuse, comprehensibility, economic and technology constraints, tradeoffs and aesthetic concerns" In Patterns of Enterprise Application Architecture, Martin Fowler outlines some typically common recurring themes when explaining architecture He identifies these themes as "The highest-level breakdown of something into its parts; the decisions which are Hard to change; you can find multiple architectures in a system; what is architecturally Significant can transform over a system's lifetime; and, ultimately, architecture boils Down to regardless of the important stuff is" Software application architecture is the process of defining and creating a solution that is well structured and meets each of the technical and operational requirements The architecture will be able to consider and improve upon the common quality attributes such as performance, security, and manageability The main focus of the program architecture is how the major elements and components within an application are employed by, or interact with, other major elements and components within the application Selecting data structures and algorithms or the implementation information on individual components are design concerns, they're not an architectural concerns but sometimes Design and Architecture concerns overlap Prior to starting the architecting of any software, there are some basic questions that we should make an effort to get answers for They are as follows How the users of the system will be interacting with the machine How will the application form be deployed into production and managed Do you know the various non-functional requirements for the application form, such as security, performance, concurrency, internationalization, and configuration How can the application be designed to be flexible and maintainable as time passes What are the architectural trends that may impact the application now or after it's been deployed Goals of Software Architecture Building the bridge between business requirements and technical requirements is the definitive goal of any software architecture The purpose of architecture is to identify certain requirements that affect the basic structure of the application Good architecture reduces the business enterprise risks associated with building a technical solution while an excellent design is flexible enough to be able to handle the changes that will occur over time in hardware and software technology, in addition to in user scenarios and requirements An architect must think about the overall effect 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 Principles of Software Architecture The basic assumption of any architecture ought to be the belief that the design will evolve over time and that certain cannot know everything one have to know up front The design will generally have to evolve during the implementation stages of the application form as one learn more, and as one tests the look against real world requirements Keeping the above statement in mind, let's try to list down a few of the Architectural principles The system should be built to change rather than building to last Model the architecture to investigate and reduce risk Use models and visualizations as a communication and collaboration tool The key engineering decisions ought to be identified and applied upfront Architects should consider utilizing an incremental and iterative approach to refining their architecture Focus on baseline architecture to get the big picture right, and then evolve candidate architectures as you iteratively test and improve one's architecture Do not try to get it all right the first time-design just as much as you can in order to start testing the design against requirements and assumptions Iteratively add details to the look over multiple passes to ensure that you obtain the big decisions right first, and then focus on the details A common pitfall is to dive into the details too quickly and get the big decisions wrong by making incorrect assumptions, or by failing to evaluate your architecture effectively When testing your architecture, think about the following questions What were the primary assumptions that were made while architecting the machine What are the requirements both explicit and implicit this architecture is satisfying Do you know the key risks with this particular architectural approach What countermeasures are in spot to mitigate key risks In what ways is this architecture an improvement over the baseline or the final candidate architecture Design Principles When getting started off with Software design, one should take into account the proven principles and the principles that adheres to minimizes costs and maintenance requirements, and promotes usability and extensibility The key principles of any Software Design are Separation of concerns The main element factor to be considered is minimization of interaction points between independent feature sets to achieve high cohesion and low coupling Single Responsibility principle Each component or module ought to be independent in itself and in charge of only a specific feature or functionality Principle of Least Knowledge An element or object should not know about internal information on other components or objects Don't repeat yourself DRY The intent or implementation of any feature or functionality should be done at only one place It should never be repeated in some other component or module Minimize upfront design This principle is also sometimes referred to as YAGNI "You ain't gonna require it" https//troywjwe69247wikiannouncementcom/7080579/innovation_hubs_cities_at_the_vanguard_of_architectural_ingenuity what's necessary Specifically for agile development, you can avoid big design upfront BDUF If the application form requirements are unclear, or if you have a possibility of the look evolving over time, one should avoid making a large design effort prematurely Design Practices Keep design patterns consistent within each layer Do not duplicate functionality within an application Prefer composition to inheritance If possible, use composition over inheritance when reusing functionality because inheritance escalates the dependency between parent and ***** classes, thereby limiting the reuse of ***** classes This also reduces the inheritance hierarchies, that may become very difficult to cope with Establish a coding style and naming convention for development Maintain system quality using automated QA techniques during development Use unit testing along with other automated Quality Analysis techniques, such as for example dependency analysis and static code analysis, during development Not only development, also consider the operation of your application Know what metrics and operational data are needed by the IT infrastructure to guarantee the efficient deployment and operation of your application Application Layers While architecting and designing the machine, one needs to carefully consider the various layers into which the application will be divided There are several key considerations that need to be considered while doing that Separate the areas of concern Break your application into distinct features that overlap in functionality as little as possible The advantage of this approach is that a feature or functionality can be optimized independently of other features or functionality Be explicit about how layers communicate with each other Abstraction ought to be used to implement loose coupling between layers Do not mix several types of components in the same logical layer For instance, the UI layer should not contain business processing components, but instead should contain components used to handle user input and process user requests Keep the data format consistent inside a layer or component