Conquering Complex and Changing Systems Object-Oriented Software Engineering TJSS System Design Lecture 12 Päivi Ovaska.

Slides:



Advertisements
Similar presentations
Conquering Complex and Changing Systems Object-Oriented Software Engineering Chapter 12, Software Life Cycle.
Advertisements

Computer Science Department
Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 1 Software Engineering September 12, 2001 Capturing.
Using UML, Patterns, and Java Object-Oriented Software Engineering Chapter 11: Integration- and System Testing.
4+1 View Model of Software Architecture “Software architecture” course Presented By: Mazeiar Salehie October 2004.
Conquering Complex and Changing Systems Object-Oriented Software Engineering Chapter 4, Requirements Elicitation.
Outline About author. The problem that discussed in the article.
Conquering Complex and Changing Systems Object-Oriented Software Engineering Chapter 6, System Design Lecture 1 Utdrag ur Bruegges OH-bilder för första.
Using UML, Patterns, and Java Object-Oriented Software Engineering Royce’s Methodology Chapter 16, Royce’ Methodology.
Conquering Complex and Changing Systems Object-Oriented Software Engineering TJSS: Defining access control, example Päivi Ovaska.
Conquering Complex and Changing Systems Object-Oriented Software Engineering TJSS: Defining persistent data stores, example Päivi Ovaska.
“Chapter 9” Managing Object Design Done By: Alia Waled.
Conquering Complex and Changing Systems Object-Oriented Software Engineering TJSS Design goals and System Decomposition, example Päivi Ovaska.
Component-Level Design
Conquering Complex and Changing Systems Object-Oriented Software Engineering TJSS: Identifying boundary conditions, example Päivi Ovaska.
1 System Design: Addressing Design Goals We are starting from an initial design, along with a set of design goals. What is the next step?
Conquering Complex and Changing Systems Object-Oriented Software Engineering System Design:Hardware/ software mapping, example Päivi Ovaska.
Modified from Sommerville’s originalsSoftware Engineering, 7th edition. Chapter 8 Slide 1 System models.
CS350/550 Software Engineering Lecture 1. Class Work The main part of the class is a practical software engineering project, in teams of 3-5 people There.
Using UML, Patterns, and Java Object-Oriented Software Engineering Chapter 3, Project Organization and Communication.
1 A Student Guide to Object- Orientated Development Chapter 9 Design.
Outline Types of errors Component Testing Testing Strategy
Course Instructor: Aisha Azeem
Using UML, Patterns, and Java Object-Oriented Software Engineering Chapter 11: Integration- and System Testing.
CSC230 Software Design (Engineering)
Architectural Design Establishing the overall structure of a software system Objectives To introduce architectural design and to discuss its importance.
Software Architecture. Agenda " Why architect? " What is architecture? " What does an architect do? " What principles guide the process of architecting?
What is Software Architecture?
Using UML, Patterns, and Java Object-Oriented Software Engineering Chapter 3, Project Organization and Communication.
Bernd Bruegge & Allen H. Dutoit Object-Oriented Software Engineering: Using UML, Patterns, and Java 1 Introduction to Software Engineering CEN 4010.
© Drexel University Software Engineering Research Group (SERG) 1 Based on the paper by Philippe Kruchten from Rational Software.
UML - Development Process 1 Software Development Process Using UML (2)
ECE 355: Software Engineering
1 Object-Oriented Testing CIS 375 Bruce R. Maxim UM-Dearborn.
Conquering Complex and Changing Systems Object-Oriented Software Engineering Chapter 1, Introduction to Software Engineering.
Conquering Complex and Changing Systems Object-Oriented Software Engineering Art for Chapter 11, Project Management.
Design Patterns OOD. Course topics Design Principles UML –Class Diagrams –Sequence Diagrams Design Patterns C#,.NET (all the course examples) Design Principles.
1/19 Component Design On-demand Learning Series Software Engineering of Web Application - Principles of Good Component Design Hunan University, Software.
Using UML, Patterns, and Java Object-Oriented Software Engineering Art for Chapter 3, Project Communication.
An Introduction to Software Architecture
Addressing design Goals  We decompose the system to address complexity  Assigning each subsystem to team to work on  But we also need to address system.
Instructor: Peter Clarke
Conquering Complex and Changing Systems Object-Oriented Software Engineering Chapter 6, System Design Lecture 2.
Chapter Five–Part III Object Oriented Design More Design issues.
Software Engineering Chapter 7 Fall Capturing the Requirements as Use Cases Capturing the Requirements as Use Cases By using use cases analysts.
OOI CI LCA REVIEW August 2010 Ocean Observatories Initiative OOI Cyberinfrastructure Architecture Overview Michael Meisinger Life Cycle Architecture Review.
Architectural Design lecture 10. Topics covered Architectural design decisions System organisation Control styles Reference architectures.
Conquering Complex and Changing Systems Object-Oriented Software Engineering Chapter 6, System Design Lecture 2.
Chapter 6 Architectural Design.
Software Engineering, 8th edition Chapter 8 1 Courtesy: ©Ian Somerville 2006 April 06 th, 2009 Lecture # 13 System models.
Requirements as Usecases Capturing the REQUIREMENT ANALYSIS DESIGN IMPLEMENTATION TEST.
Chapter 10 Analysis and Design Discipline. 2 Purpose The purpose is to translate the requirements into a specification that describes how to implement.
SOFTWARE DESIGN AND ARCHITECTURE LECTURE 05. Review Software design methods Design Paradigms Typical Design Trade-offs.
Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 1 Software Engineering November 7, 2001 Project.
Example: object diagram for Scheduler, v What is wrong with this diagram? Seems like a lot of similarity between Task and UnplannedTask Can use.
Architecture View Models A model is a complete, simplified description of a system from a particular perspective or viewpoint. There is no single view.
Feb. 9, 2004CS WPI1 CS 509 Design of Software Systems Lecture #4 Monday, Feb. 9, 2004.
1 Advanced Software Architecture Muhammad Bilal Bashir PhD Scholar (Computer Science) Mohammad Ali Jinnah University.
Using UML, Patterns, and Java Object-Oriented Software Engineering 15. Software Life Cycle (Waterfall)
Conquering Complex and Changing Systems Object-Oriented Software Engineering Chapter 6, System Design Lecture 1.
OOD OO Design. OOD-2 OO Development Requirements Use case analysis OO Analysis –Models from the domain and application OO Design –Mapping of model.
Conquering Complex and Changing Systems Object-Oriented Software Engineering Chapter 6, System Design Lecture 1.
Two New UML Diagram Types Component Diagram Deployment Diagram.
Wrap up. Structures and views Quality attribute scenarios Achieving quality attributes via tactics Architectural pattern and styles.
Why is Design so Difficult? Analysis: Focuses on the application domain Design: Focuses on the solution domain –The solution domain is changing very rapidly.
IEEE Std 1074: Standard for Software Lifecycle
An Introduction to Software Architecture
Addressing Design Goals
Design Yaodong Bi.
Design.
Presentation transcript:

Conquering Complex and Changing Systems Object-Oriented Software Engineering TJSS System Design Lecture 12 Päivi Ovaska

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 2 System Design From previous lecture  How to decompose the system  How to distribute use cases among subsystems  Where to store data  How to achieve access control and ensure security This lecture  Identifying boundary conditions  Reviewing system design  Managing system design

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 3 Identifying Boundary Conditions  Modify the analysis model to include the use cases, which considers  how the sysem is started, initialized, and shut down  how we deal with major failures  Possible changes to subsystem decomposition  Also need to investigate exceptional use cases  Exception is an unexpected event or error that occurs during the execution of the system  a user error  a hardware error  software bug  Exception handling is the mechanism by which a system treats an exception  Examples:  in the case of a user error, the system should display a meaningful error message to the user  in the case of network link failure, the system needs to save its temporary state in order to recover once the network comes back on line

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 4 Reviewing System Design  Evolutionary and iterative activity  Many ways to organise the review process:  use the developers who were not involved in the system design to act as  use the developers from other project  System design model should be  correct  complete  consistent  realistic  readable

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 5 Review questions  Correctnes  Can every subsystem be traced back to a use case or a nonfunctional requirement?  Can every use case be mapped to a set of subsystems?  Can every design goal be traced back to a nonfunctional requirement?  Is every nonfunctional requirement addressed in the system design model?  Does each actor have an access policy?  Is it consistent with the nonfunctional security requirement?  Completenes  Have the boundary conditions been handled?  Was there a walkthrough of the use cases to identify missing functionality in the system design  Have all use cases been examined and assigned a control object?  Have all aspects of system design (i.e. harware allocation, persistent storage, access control, legacy code, boundary conditions) been addressed?  Do all subsystems have definitions?

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 6 Review questions  Consistency  Are conflicting design goals prioritozed?  Are there design goals that violate a nonfunctional requirement?  Are there multiple subsystems or classes with the same name?  Are collections of objects exchanged among subsystems in a consistent manner?  Realistic  Are there any new technologies of components in the system?  Were there any studies to evaluate the appropriateness or robustness of these technologies or components?  Have performance and realiability requirements been reviewed int he context of the subsystem decomposition? For example, is there a network connection on the critical path of the system?  Have concurrency issues been addressed?  Readable  Are subsystem names understandable  Do entities with similar names denote similar phenomena?  Are all entities described at the same level of detail?

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 7 Managing System Design  Maintain consistency  The software architecture should describe a single coherent systems understandable by a single person  Documenting system design  Assigning responsibilities  Communicating about system design

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 8 Assigning Responsibilities  Architect  main role of the system design  ensures the consistency in design decisions and interface styles  ensures the consistency of the design in the configuration management and testing functions  Architecture team in big systems  the number of subsystem determines the size of the architecture team  For complex systems, an architecture team is introduced for each level of abstraction  Single individual architect should be responsible of consistency of the whole system

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 9 Communicating about System Design  Identify and prioritize the design goals for the system and make them explicit  Make the current version of the system decomposition available to all concerned  Maintain an up-to-date glossary  Confront design problems  Iterate, make prototypes