Software Engineering Ch 8 Quiz
Advantages of Explicit Architecture
System analysis. Means that analysis of whether the system can meet its non-functional requirements is possible.
Interaction Modeling
All system involve interaction of some kind of: User interaction which involves user inputs and outputs, interaction between the system being developed and other system, interaction between the components (or subsystems) of the system.
Pipe and Filter Pattern: Filter
process and transform data
Distributed Systems
They are typically decomposed into multiple processes that collaborate through the network. They are common today due to wireless networks and internet technology.
Hierarchical Systems
Conceptually, components residing at higher levels of the hierarchy structure dispatch requests and rely on the services of those in lower levels of the hierarchy. Leads to well-structured and modular syste
Architectural Design
Often carried out in parallel with some specification activities.
Architectural Design
Particularly important topic in software engineering and UML component, package, and deployment diagrams may all be used when presenting architectural models.
Sequence Diagrams
The subsystems, objects, and actors involved are listed along the top of the diagram, with a dotted line drawn vertically from these.
Client-Server Pattern
are particularly useful for distributed systems with a large client base, since they provide localization of data in one central place. Therefore, making updates or adding new information in one central place is all that is needed for a multitude of clients to receive this information.
Pipe and Filter Pattern: Pipe
components that transfer data between components
Physical view
represents the development aspects of software systems where the main elements of analysis are nodes, connection between nodes, and maps of software artifacts to nodes. focuses on modeling of elements that directly affect quality requirements, such as availability, performance and scalability.
Architectural Design
An early stage of the system design process.
Patterns (architectural patterns)
Patterns may be represented using tabular and graphical descriptions.
Layered Patterns
A constrained form of hierarchical structures involves each layer having. one main component which can be composed internally of multiple components that provides a unified interface for communicating with components residing immediately below the hierarchy structure.
Use Case Modeling
Actors in this may be people or other systems.
4 + 1 View Model
Adoption of the model varies from organization to organization, and from project to project. For example, when concurrency is not issue, modeling the system from a process view makes little to no sense. Similarly, for systems that reside in one node and in which the physical properties of their development are not of concern, modeling them using the physical view provides little to no benefit. Typically, all software systems benefit from the logical view; therefore, designs elements from this view should be incorporated into the software architecture.
Architecture Reuse
Application product lines are built around a core architecture with variants that satisfy particular customer requirements.
System Boundaries
Are established to define what is inside and what is outside the system. The show other systems that are used or depend on the system being developed.
Sequence Diagrams
Are part of the UML and are used to model the interactions between the actors and the subsystems, and objects within a system.
Architectural Models
Are used as a way of documenting an architecture that has been designed. The aim here is to produce a complete system model that shows the different components in a system, their interfaces, and their connections.
Architectural Models
Are used as a way of facilitating discussion about the system design. A high-level architectural view of a system is useful for communication with system stakeholders and project planning because it is not cluttered with detail. Stakeholders can relate to it and understand an abstract view of the system. They can then discuss the system as a whole without being confused by detail.
Architectural Design
Can begin as early as the analysis activity of the requirements, where conceptual models of the system are devised.
Architecture In The Large
Concerned with the architecture of complex enterprise systems that include other systems, programs, and program components. These enterprise systems are distributed over different computers, which may be owned and managed by different companies.
Architecture In the Small
Concerned with the architecture of individual programs. At this level, we are concerned with the way that an individual program is decomposed into components.
Structural Modeling
Created when you are discussing and designing the system architecture.
Data-Centered System
Data-centered systems are systems primarily decomposed around a main central repository of data. Contains a data manager which functions to controls, provides, and manages access to system data, while worker components execute operations and perform work based on the data
System Boundaries
Defining one is a political judgement. There may be pressures to develop these that increase/decrease the influence or workload of different parts of an organization.
Use Case Modeling
Developed originally to support requirements elicitation and now incorporated into the UML.
Structural Modeling
Display the organization of a system in terms of the components that make up that system and their relationships.
Behavioral Modeling
Event-driven modeling that shows how a system responds to external and internal events.
4 + 1 View Model
Four main views: Logical, process, development, and physical.
System Modeling
Has now come to mean representing a system using some kind of graphical notation, which is now almost always based on notations in the Unified Modeling Language (UML).
System Modeling
Helps the analyst to understand the functionality of the system and models are used to communicate with users.
Interaction Modeling
Helps to identify user requirements.
4 + 1 View Model
In 1995, Philippe Kruchten published an influential paper that proposed modeling software architectures using different perspectives; each perspective provides avenues for addressing problems from different angles, and, when combined, the set of models created from each perspective helps form the software architecture.
Physical view and applicationd
In some applications, modeling system deployment may require one or more UML deployment diagrams. Different deployment diagrams may be necessary to model different deployment configurations of the same software system, for example, deployments of software systems in testing environments or in different locations where deployment configurations may differ.
Use Case Modeling
In this, each use case represents a discrete task that involves external interaction with a system.
Sequence Diagrams
In this, interactions between subsystems, objects are indicated by annotated arrows.
Availability
Include redundant components and mechanisms for fault tolerance.
Architectural Design
Is a creative process so the process differs depending on the type of system being developed.
Architectural Design
It involves identifying major system components and their communications.
Behavioral Modeling
It is based on the assumption that a system has a finite number of states and that events (stimuli) may cause a transition from one state to another.
Layered pattern
It is used when systems can be decomposed into cohesive layers with a structured way of interfacing between layers. The layered architecture is widely used in systems software, such as an operating system's communication stack, where each layer is an abstraction of a major function of communication systems.
Advantages of Explicit Architecture
Large-scale reuse. The architecture may be reusable across a range of systems. Product-line architectures may be developed.
Performance
Localize critical operations and minimize communications. Use large rather than fine-grain components.
Safety
Localize safety-critical features in a small number of sub-systems.
MVC architectural pattern
Mainstream architectural pattern employed in most interactive systems in the model-view-controller. This is an architectural pattern is used in interactive applications that are flexible incorporation of human computer interfaces.
Process Modeling
Model how the system being developed is used in broader business processes.
Context Modeling
Model the context or environment of the system.
Behavioral Modeling
Model the dynamic behavior of the system and how it responds to events.
Interaction Modeling
Model the interactions between a system and its environment, or between the components of a system.
Structure Modeling
Model the organization of a system or the structure of the data that is processed by the system.
4 + 1 View Model
Modeling systems from each view requires addressing design problems of different natures, such as problems that deal with the logical system structure or problems that deal with dynamic, concurrency system issues.
Behavioral Modeling
Models of the dynamic behavior of the system as it is executing.
Architectural Design
Most popular model is Kruchten's (1995) 4 + 1 view model
Architectural Patterns
Patterns are used to represent , share and reuse knowledge. It is a stylized description of good design practice, which has been tried and tested in different environments. They should include information about when they are and when they re not useful.
Architecture and System Characteristics
Performance, security, safety, availability, maintainability
4 + 1 View Model
Provides an adequate framework for modeling the architecture of most software systems.
Use Case Modeling
Represented diagrammatically to provide an overview of the use case and in a more detailed textual form.
User View
Represents the behavior that the system exhibits to its users. Specifically, the user view depicts how users interact with depicts sequences of inputs and outputs occur during.......................
Architectural Design
Represents the link between specification and design processes.
Architectural Design
Require the selection of particular perspectives for design that are appropriate for describing the system to be developed.
Process Modeling
Reveal how the system being developed is used in broader business processes, which can be defined through UML activity diagrams.
Sequence Diagrams
Show the sequence of interactions that take place during a particular use case or use case instance.
Architectural Models
Show the system and its relationship with other systems.
Context Modeling
Simply shows the others systems in the environment, not how the system being developed is used in that environment.
Context Modeling
Social and organizational concerns may affect the decision on where to position system boundaries.
Advantages of Explicit Architecture
Stakeholder communication. Architecture may be used as a focus of discussion by system stakeholders.
Architecture Reuse
Systems in the same domain often have similar architectures that reflect domain concepts.
Architecture Reuse
The architecture of a system may be designed around one or more architectural patterns or 'styles'. These capture the essence of an architecture and can be instantiated in different ways.
Architectural Design
The design process for identifying the sub-systems making up a system and the framework for sub-system control and communication.
Software Architecture
The output of the architectural design process is a description of this.
System Boundaries
The position of the system boundary has a profound effect on the system requirements.
System Modeling
The process of developing abstract models of a system, with each model presenting a different view of perspective of that system.
Development View
These analyses can be employed to address concerns that deal with ease of development, re usability, constraints imposed by tool sets, allocation of work to teams, cost evaluation and planning, monitoring the project's progress, portability, and security. Hierarchy of files in the file system and their interrelationships and process for building one or more versions of the software system can be carefully specified.
Behavioral Modeling
They show what happens or what is supposed to happen when a system responds to a stimulus from its environment.
4 + 1 View Model
To ensure consistency among all four views, the user's perspective is captured through several key use cases.
System Modeling
Types of this are Context Modeling, Process Modeling, Interaction Modeling, Behavioral Modeling, Structure Modeling.
Security
Use a layered architecture with critical assets in the inner layers.
Interaction Modeling
Use case diagrams and sequence diagrams may be used for this. Use case modeling is mostly used to model interactions between a system and external actors (users or other systems). Sequence diagrams are used to model interactions between system components (subsystems) or external systems.
Maintainability phase
Use fine-grain, replaceable components.
Context Modeling
Used to illustrate the operational context of a system - they show what lies outside the system boundaries.
Use Case Modeling
Used to model interactions between a system and external actors.
Blackboard (Repository) Pattern
Using the blackboard architectural pattern, systems can be broken down to include a common repository where data and solutions to particular problems reside (i.e., the blackboard), a controller, and various agents that work to refine and further solutions to arrive at an acceptable solution.
Data Flow Systems
decomposed around the central theme of transporting data (or data streams) and transforming the data along the way to meet application specific requirements. There for in this system there exists worker components(work on data) and also transform components(which transfer data among worker components) Data-flow systems provide the means for data transformation to take place in series or in parallel fashion, which helps the system improve performance by adding concurrency to the system.
Pipe and Filter Pattern
decomposes software systems into components that carry out two major functions: processing and transforming data and transferring data between components. The pipes and filters architectural pattern is commonly seen in data-flow systems, where data inputs need to be transformed into data output through a series of computational or manipulative components
Process View
is behavior in nature and UML diagrams can be used to efficiently address issues pertinent to process views. This view is necessary for projects that need to meet performance and availability requirements by modeling aspects of concurrency, distribution and fault tolerance.
Logical View
is used to decompose systems into logical components that represent the structural integrity that supports functional and nonfunctional requirements. Using this static view the system can be modeled using high-level diagrams to decompose, abstract and encapsulate the services that the system needs to provides to its users.
Process VIew
represents the dynamic or behavioral aspects of the software system where the main units of analysis are processed and threads. Using this view software systems are decomposed into processes and threads to address design issues that deal with the dynamic flow of control between architectural elements, such as concurrency, distribution, system's integrity, fault tolerance, and other nonfunctional requirements
Development view
software system represents the software development configuration aspects of the software system, where the main units of decomposition are actual physical files and directories. Used to analyze the system from the perspective how logical components map to physical files and directories.
MVC components
system input, processing, and output. By separating the system's output from its core processing functions, different representations of the system core can be easily supported
Hierarchical Systems
systems in which in which component can be in which components can restructured in hierarchical fashion so that components exist at different levels addresses a particular concern of the software system. For each level identified in the hierarchical system, one or more components can be identified, each possibly branching downward