طراحی و مدل کردن مولفه ها

طراحی و مدل کردن مولفه ها

اسلاید 1: Designing the Architecture

اسلاید 2: OutlineArchitecture in the life cycleDesigning the architectureForming the team structure and its relationship to the architectureCreating a skeletal system

اسلاید 3: Architecture in the Life CycleThe evolutionary delivery life cycleGet customer feedbackIterate through several releases, each with new or modified functionalityDeliver limited versions if necessaryWhen does one begin designing?Some idea of system requirements is needed – the shaping requirements are called architectural drivers

اسلاید 4: Architecture in the Life Cycle (Cont’d)When does one begin designing? (cont’d)Identify the highest priority business goals and turn them into quality scenarios or use casesThe ones that have the most impact on the architecture are the architectural drivers (there should be fewer than 10)Once the architectural drivers are known, the architectural design can beginThe requirements analysis process will then be influenced by questions generated during the architectural design,

اسلاید 5: Evolutionary Delivery Life CycleSoftwareConceptPreliminaryRequirementsAnalysisDesign ofArchitectureand System CoreDevelopa VersionDeliver the VersionIncorporateCustomerFeedbackElicitCustomerFeedbackDeliverFinalVersion

اسلاید 6: Designing the ArchitectureA method called Attribute Driven Design (ADD) can be used to design an architecture to satisfy both quality and functional requirements.ADD can be viewed as an extension to other developments methods, such as the Rational Unified Process (RUP).

اسلاید 7: Attribute-Driven DesignADD bases the decomposition process on the quality attributes the software has to fulfill.It is a recursive decomposition process, where, at each stage, tactics and architectural patterns are chosen to satisfy a set of quality scenarios and then functionality is allocated to instantiate the module types provided by the pattern.

اسلاید 8: Attribute-Driven Design (Cont’d)The system is described as a set of containers for functionality and the interactions among them.This is a coarse grained framework for achieving the functionality.

اسلاید 9: Example Application of ADDSample problem: A garage door opener within a home information system.The system is responsible for raising and lowering the door via a switch, remote control, or the home information system. It is also possible to diagnose problems with the opener from within the home information system.

اسلاید 10: Input to ADDA set of requirements (typically expressed as use cases) and constraintsA set of quality requirements expressed as system-specific quality scenarios including, in this case:The device and controls for opening and closing the door are different for the various products in the product line. They may include controls from within a home information system

اسلاید 11: Input to ADD (Cont’d)A set of quality requirements (cont’d):The processor used in different products will differ.If an obstacle (person or object) is detected by the garage door during descent, it must halt (alternately re-open) within 0.1 second.The garage door opener should be accessible for diagnosis and administration from within the home information system using a product-specific diagnosis protocol.

اسلاید 12: ADD StepsChoose the module to decompose – the module to start with is usually the whole system.Refine the module according to the following steps:Choose the architectural drivers from the set of concrete quality scenarios and functional requirements.Choose an architectural pattern that satisfies the architectural drivers based on the tactics that can be used to achieve the drivers.

اسلاید 13: ADD Steps (Cont’d)Refine the module according to the following steps (cont’d):Instantiate modules and allocate functionality from the use cases and represent using multiple views.Define interfaces of the child modules. The decomposition provides modules and constraints on the types of module interactions. Document this information in the interface document for each module.

اسلاید 14: ADD Steps (Cont’d)Refine the module according to the following steps (cont’d):Verify and refine use cases and quality scenarios and make them constraints for child modules.Repeat the steps above for every module that needs further decomposition.

اسلاید 15: 1. Choose the Modules to DecomposeIn our example, we start with the whole system, the garage door opener system.One constraint at this level is that the opener must interoperate with the home information system.

اسلاید 16: 2a. Choose the Architectural DriversThe four scenarios previously given indicate requirements for: real-time performancemodifiability to support product linesonline diagnosisIn general, a detailed investigation may be required to determine whether given requirements are really drivers.

اسلاید 17: 2a. Choose the Architectural Drivers (Cont’d)We do not treat all requirements as equal.The less important requirements are satisfied within the constraints of the most important.This is a significant difference between ADD and other architecture design methods.

اسلاید 18: 2b. Choose an Architectural PatternThe use of an interpreter is an excellent technique for achieving modifiability at runtime, but it has a negative influence on performance.The decision to use an interpreter depends on the relative importance of modifiability versus performance.A possible decision is to use an interpreter for only a portion of the pattern.

اسلاید 19: 2b. Choose an Architectural Pattern (Cont’d)The modifiability tactics are “localize changes,” “prevent the ripple effect,” and “defer binding time.”In this case, where we are concerned primarily with changes that will occur during system design, the primary tactic is “localize changes.”We choose semantic coherence and information hiding as our tactics and combine them to define virtual machines for the affected areas.

اسلاید 20: 2b. Choose an Architectural Pattern (Cont’d)The performance tactics are “resource demand” and “resource arbitration.” We choose one example of each: “increase computational efficiency” and “choose scheduling policy.”The final set of tactics is therefore:Semantic coherence and information hiding – Separate responsibilities dealing with the user interface, communication, and sensors into their own modules (virtual machines).

اسلاید 21: 2b. Choose an Architectural Pattern (Cont’d)The final set of tactics (cont’d):Increase computational efficiency – The performance-critical computations should be made as efficient as possible.Schedule wisely – The performance-critical computations should be scheduled to ensure the achievement of the timing deadline.

اسلاید 22: Architectural Pattern that Utilizes Tactics to Achieve Garage Door DriversUser InterfaceNon-Performance-Critical ComputationVirtualMachinePerformance-CriticalComputationSchedule thatGuarantees Deadlines

اسلاید 23: 2c. Instantiate Modules and Allocate Functionality Using Multiple ViewsWe allocate the responsibility for managing obstacle detection and halting the garage door to the performance-critical section since the functionality has a deadline.The management of the normal raising and lowering of the door has no timing deadline so we can treat it as non-performance-critical

اسلاید 24: 2c. Instantiate Modules and Allocate Functionality Using Multiple Views (Cont’d)The diagnosis capabilities are also non-performance-critical.Thus, the non-performance-critical module becomes instantiated as diagnosis and raising/lowering door modules.We also identify several responsibilities of the virtual machine: communication and sensor reading and actuator control.

اسلاید 25: First-Level Decomposition of Garage Door OpenerUser InterfaceDiagnoseCommunicationVirtual MachineRaising/LoweringDoorSensor/ActuatorVirtual MachineObstacleDetectionScheduler thatGuaranteesDeadlines

اسلاید 26: 2c. Instantiate Modules and Allocate Functionality Using Multiple Views (Cont’d)Applying use cases that pertain to the parent module helps the architect gain a better understanding of the distribution of functionality.Ultimately, every use case of the parent module must be representable by a sequence of responsibilities within the child modules.Enough must be done to gain confidence that the system can deliver the desired functionality.The architecture should be represented by one view from each of the three major groups.

اسلاید 27: 2c. Instantiate Modules and Allocate Functionality Using Multiple Views (Cont’d)The three common viewsModule decomposition view – Containers for holding responsibilities and the major flow relationships among the modulesConcurrency view – Dynamic aspects of a system such as parallel activities and synchronization can be modeled

اسلاید 28: 2c. Instantiate Modules and Allocate Functionality Using Multiple Views (Cont’d)The three common views (cont’d)Deployment view – The virtual threads of the concurrency view are decomposed into virtual threads within a particular processor and messages that travel between processors to initiate the next entry in the sequence of actions (thus is a basis for analyzing network traffic). Additionally, this view helps to decide if multiple instances of some modules are needed and supports reasoning about special purpose hardware.

اسلاید 29: Understanding Concurrency in a System – Helpful Use CasesTwo users doing similar things at the same timeOne user performing multiple activities simultaneouslyStarting up the systemShutting down the system

اسلاید 30: 2d. Define Interfaces of the Child ModulesAn interface of a module shows the services and properties provided and required.It documents what others can use and on what they can depend.Analyzing and documenting the decomposition in terms of structure (module decomposition view), dynamism (concurrency view) and runtime (deployment view) uncovers the interaction assumptions for the child modules.

اسلاید 31: 2d. Define Interfaces of the Child Modules (Cont’d)The module view documents:Producers/consumers of informationPatterns of interaction that require modules to provide services and to use themThe concurrency view documents:Interactions among threads that lead to the interface of a module providing or using a serviceThe information that a component is activeThe information that a component synchronizes, sequentializes, and perhaps blocks calls

اسلاید 32: 2d. Define Interfaces of the Child Modules (Cont’d)The deployment view documents:The hardware requirements, such as special-purpose hardwareSome timing requirements, e.g., the computational speed of a processorCommunication requirements, e.g., the information should not be updated more than once a secondAll this information should be available in the modules’ interface documentation.

اسلاید 33: 2e. Verify and Refine Use Cases and Quality Scenarios as Constraints for the Child ModulesEach child module has responsibilities that need to be translated into use cases for the module. Use case can also be defined by splitting and refining the parent use cases.For the garage door opener system, the responsibilities are decomposed into the following functional groupsUser interface – recognize user requests and translate them into the form expected by the raising/lowering door module

اسلاید 34: 2e. Verify and Refine Use Cases and Quality Scenarios as Constraints for the Child Modules For the garage door opener system, the responsibilities are decomposed into the following functional groups (cont’d):Raising/lowering door module – Control actuators to raise or lower the door. Stop the door when it reaches either fully open or fully closed.Obstacle detection – recognize when an obstacle is detected and either stop the descent of the door or reverse it.

اسلاید 35: 2e. Verify and Refine Use Cases and Quality Scenarios as Constraints for the Child Modules For the garage door opener system, the responsibilities are decomposed into the following functional groups (cont’d):Communication virtual machine – Manage all communication with the home information system.Sensor/actuator virtual machine – Manage all interactions with the sensors and actuators.Scheduler – Guarantee that the obstacle detector will meet its deadlines.Diagnosis – Manage the interactions with the home information system devoted to diagnosis.

اسلاید 36: 2e. Verify and Refine Use Cases and Quality Scenarios as Constraints for the Child Modules The constraints of the parent module can be satisfied in one of the following ways:The decomposition satisfies the constraint, e.g., if the constraint is to use a certain operating system, by defining the operating system as a child the constraint is satisfied.The constraint is satisfied by a single child module, e.g., if the constraint is to use a special protocol, it can be satisfied by defining an encapsulation child module for the protocol.

اسلاید 37: 2e. Verify and Refine Use Cases and Quality Scenarios as Constraints for the Child Modules The constraints of the parent module can be satisfied in one of the following ways (cont’d):The constraint is satisfied by multiple child modules, e.g., using the Web requires two modules (client and server) to implement the necessary protocols.

اسلاید 38: 2e. Verify and Refine Use Cases and Quality Scenarios as Constraints for the Child Modules In the garage door opener system, one constraint is that the communication with the home information system is maintained.The communication virtual machine will recognize if this communication is unavailable, so the constraint is satisfied by a single child.

اسلاید 39: 2e. Verify and Refine Use Cases and Quality Scenarios as Constraints for the Child Modules Quality scenarios also need to be refined and assigned to child modules:A quality scenario may be completely satisfied by the decomposition without any additional impact and thereby marked as satisfied.A quality scenario may be satisfied by the current decomposition with constraints on child modules.

اسلاید 40: 2e. Verify and Refine Use Cases and Quality Scenarios as Constraints for the Child Modules Quality scenarios also need to be refined and assigned to child modules (cont’d):The decomposition may be neutral with respect to a quality scenario, e.g., a usability scenario, in which case it should be assigned to one of the child modules.A quality scenario may not be satisfiable with the current decomposition. Either the decomposition should be reconsidered or rationale justifying its omission must be provided.

اسلاید 41: Refined Quality Scenarios for the Garage Door Opener ExampleThe devices and controls for opening and closing the door are different for different products in the product line. They may include controls from within a home information system. This scenario is delegated to the user interface module.The processor used in different products will differ. This scenario is delegated to all of the modules. Each module becomes responsible for not using processor-specific features not supported by standard compilers.

اسلاید 42: Refined Quality Scenarios for the Garage Door Opener Example (Cont’d)If an obstacle is detected by the garage door during descent, the door must halt (or re-open) within 0.1 second. This scenario is delegated to the scheduler and the obstacle detection module.The garage door opener should be accessible for diagnosis and administration from within the home information system using a product-specific diagnosis protocol. This scenario is split between the diagnosis and communication modules. The communication module is responsible for the protocol to communicate with the home information system, and the diagnosis module is responsible for other diagnosis interactions.

اسلاید 43: Status at the End of the IterationWe now have a decomposition of a module into its children.Each child has a collection of responsibilities:A set of use casesAn interfaceQuality scenariosA collection of constraintsThis is sufficient to start the next iteration of the decomposition

اسلاید 44: Things We Still Do Not Know Regarding Our Sample ProblemThe language for communication between the user interface module and the raising/lowering modulesThe algorithm for performing obstacle detectionHow the performance-critical section communicates with the non-performance critical section

اسلاید 45: Forming the Team StructureOnce the first few levels of the architecture’s module decomposition structure are fairly stable, those modules can be allocated to development teams.Within teams there needs to be high-bandwidth communications.Between teams, low-bandwidth communications are sufficient (and in fact crucial).

اسلاید 46: Forming the Team Structure (Cont’d)If interactions between the teams is complex, either:The interactions among the elements they are creating are needlessly complexOr, the requirements for those elements were not sufficiently “hardened” before development commencedLike software systems, teams should strive for high cohesion and low coupling.

اسلاید 47: Forming the Team Structure (Cont’d)Each module of the system constitutes its own small domain (area of specialized knowledge or expertise).This makes for a natural fit between teams and modules of the decomposition structure.The effective use of staff, therefore, is to assign members to a team based on their expertise.

اسلاید 48: Forming the Team Structure (Cont’d)The organizational structure also affects the architecture.Organizational entities formed for one project are motivated to preserve their existence and will want to maximize their importance in new projects.

اسلاید 49: Creating a Skeletal SystemOnce an architecture is sufficiently designed and teams are in place to build it, a skeletal system can be constructed.The architecture provides a guide as to the order in which portions of the system should be implemented.First implement the software that deals with the execution and interaction of architectural components.Add some simple functions.The result is a running system onto which useful functionality can be added

اسلاید 50: Creating a Skeletal System (Cont’d)To lower risk the most problematic functions should be added first.Then the functionality needed to support those problematic functions is added.This process is continued, growing larger and larger increments of the system until it is complete.