lecture 10: system design - eth...
TRANSCRIPT
![Page 1: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/1.jpg)
Software EngineeringProf. Dr. Bertrand Meyer
March 2007 – June 2007
Chair of Software Engineering
Lecture 10:System Design
Based on material by Prof. Peter Müller; includes elements from course “Software Engineering I” by Prof. Bernd Brügge, TU München.
![Page 2: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/2.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 2
System design
1 Overview2 Subsystem decomposition3 Assessing O-O architectures4 Architectural styles5 Advanced issues
![Page 3: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/3.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3
Simplicity
• There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obviousdeficiencies.
• C.A.R. HoareThe Emperor’s Old Clothes
• 1980 Turing Award lecture• http://tinyurl.com/3yk3v2
Tony Hoare
![Page 4: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/4.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 4
System design: scope
Bridge the gap between a problem and an existing systemDivide and conquer: model new system as a set of subsystems
Problem
ExistingSystem
New System
![Page 5: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/5.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 5
Goals and tasks
Identify design goals
Refine subsystem decomposition to
address design goals
Design initial subsystem
decomposition
Design goalsQualities to be optimized
Software architectureSubsystem responsibilitiesSubsystems dependenciesSubsystem mapping to hardwarePolicy decisions: control flow, access control, data storage…
![Page 6: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/6.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 6
The “ilities” of software engineering
Scalability
Repairability
Portability
Reusability
Understandability
Maintainability
Security
Usability
Reliability
Robustness
Performance
Correctness
Interoperability
Verifiability
Evolvability
![Page 7: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/7.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 7
Typical design trade-offs
Portability
Understandability
Usability
Robustness
Performance
ReusabilityCost
Rapid development Functionality
Functionality
Cost
Backward Compatibility
![Page 8: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/8.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 8
System design
1 Overview2 Subsystem decomposition3 Assessing O-O architectures4 Architectural styles5 Advanced issues
![Page 9: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/9.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 9
Why decompose a system?
Management- Partition effort- Clear assignment of requirements to modules
Modification- Decouple parts so that changes to one don’t affect others
Understanding- Allow understanding system one chunk at a time
![Page 10: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/10.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 10
Subsystems
Collection of closely interrelated classes Deduced from natural groupings in analysis
Eiffel: clusters
In UML: packages
Other programming languages: modules, packages (Java), or conventions, e.g. directories
P
![Page 11: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/11.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 11
Services and Subsystem Interfaces
Traditional distinction:Service: Set of related operations
Provided by one subsystemShare a common purposeInputs, outputs & high-level behavior defined in system design
Subsystem interface: Set of fully-typed operationsSpecifies interaction and information flow from and to subsystem boundaries (not inside subsystem)Refinement of servicesDefined in detailed design
In object-oriented design, the distinction fades out
![Page 12: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/12.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 12
Decomposition Example: Compiler
Service: Scan input file and provide stream of tokensInitialize symbol tableReport lexical errors
Features :next_token (File, ST )
Lexer ParserService:
Parse token stream and build abstract syntax treeEnter symbol table informationReport syntax errors
Features:AST( File, ST )
Static AnalyzerService:
Perform semantic analysisFill symbol tableReport type errors
Features :perform_analysis (AST, ST )
Code Generator
Service: Generate target code from analyzed syntax tree
Features :generate_code( AST, ST )
![Page 13: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/13.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 13
Cohesion and coupling
Cohesion: interdependence of elements of one moduleCoupling: interdependence between different modulesGoal: high cohesion and low coupling
Low cohesion
High coupling
Low coupling
High cohesion
![Page 14: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/14.jpg)
14
Modularity: increase cohesion, decrease coupling
Favored by architectural techniques tending to ensure decentralization of modules
![Page 15: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/15.jpg)
15
Decomposability
Decompose complex systems into subsystems
COROLLARY: Division of labor. Example: Top-down design method (see next). Counter-example: General initialization module.
![Page 16: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/16.jpg)
16
Top-down functional design
A
B D C
C1 I1 C2 I2I
Topmost functional abstraction
Loop Conditional
Sequence
![Page 17: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/17.jpg)
17
Build software elements so that they may be freely combined withothers to produce new software.
Composability
![Page 18: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/18.jpg)
18
Direct mapping
Maintain a close connection between the structure of the design and the structure of the analysis model
![Page 19: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/19.jpg)
19
Few interfaces principle
Every module communicates with as few others as possible.
(A) (B) (C)
![Page 20: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/20.jpg)
20
Small interfaces principle
If two modules communicate, they exchange as little information as possible.
x, y
z
![Page 21: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/21.jpg)
21
Explicit interfaces principle
Whenever two modules A and B communicate, this is obvious from the text of A or B or both.
Module A Module B
Data item
x
Modifies Accesses
![Page 22: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/22.jpg)
22
Continuity
Ensure that small changes in specifications yield small changes in architecture.
Design method: Specification → Architecture
Example: Principle of Uniform Access (see next)Counter-example: Programs with patterns after the physical implementation of data structures.
![Page 23: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/23.jpg)
23
Uniform Access Principle
A module’s facilities are accessible to its clients in the same way whether implemented by computation or storage.
![Page 24: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/24.jpg)
24
Uniform Access: An example
balance = list_of_deposits.total – list_of_withdrawals.total
Not uniform access: Uniform access:a.balance a.balancebalance (a) a.balance()
list_of_deposits
list_of_withdrawals
balance
list_of_deposits
list_of_withdrawals(A2)
(A1)
![Page 25: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/25.jpg)
25
Uniform access principle
A call such as
your_account.balance
could use an attribute or a function
It doesn‘t matter to the clientwhether you look up or compute
![Page 26: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/26.jpg)
26
Information hiding (Parnas, 1972)
Underlying question: how does one “advertise” the capabilities of a module?
Every module should be known to the outside world through an official, “public” interface.
The rest of the module’s properties comprises its “secrets”.
It should be impossible to access the secrets from the outside.
David Parnas
![Page 27: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/27.jpg)
27
Information Hiding Principle
The designer of every module must select a subset of the module’s properties as the official information about the module, to be made available to authors of client modules.
![Page 28: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/28.jpg)
28
Information hiding
Public
Secret
![Page 29: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/29.jpg)
29
Information hiding
Justifications:ContinuityDecomposability
![Page 30: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/30.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 30
System design
1 Overview2 Subsystem decomposition3 Assessing O-O architectures4 Architectural styles5 Advanced issues
![Page 31: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/31.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 31
Good architecture
Result of a consistent set of principles and techniques, applied consistently through all phases of a projectResilient in the face of (inevitable) changesSource of guidance throughout the product lifetime
Reuse of established engineering knowledge- Application of architectural styles- Analogous to design patterns in detailed design
![Page 32: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/32.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 32
The five secrets of good architecture
Simplicity of designConsistency of designEase of learning of the APIsSupport for changeSupport for reuse
![Page 33: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/33.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 33
The contribution of object technology
Single decomposition criterion: ADTPrecision of specification: contractsClear client-supplier separation, information hidingOrganize abstractions in hierarchies: inheritancePolymorphism and dynamic bindingEasily add new typesParameterize classes: genericityAbstract behaviors into objects: agents, delegatesSupport for reuse, librariesKnown, published collections of design patterns
![Page 34: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/34.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 34
O-O is for high cohesion and low coupling
CohesionFeatures work on same dataImplement one ADT
Low couplingSmall interfacesInformation hidingNo global dataInteractions are within subsystem rather than across subsystem boundaries
![Page 35: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/35.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 35
The key task in O-O
Finding the right data abstractions
![Page 36: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/36.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 36
Judging good and bad architectures
This is the basis of “refactoring”Never take a design for grantedBut: don’t delay good design (GIGO)
![Page 37: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/37.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 37
Judging good and bad architectures
Examples:CompilerMath routinesLibrary design: listsObserver patternTop-down vs O-O: the multi-display panel exampleVisitor pattern
![Page 38: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/38.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 38
Decomposition Example: Compiler
Service: Scan input file and provide stream of tokensInitialize symbol tableReport lexical errors
Features :next_token (File, ST )
Lexer ParserService:
Parse token stream and build abstract syntax treeEnter symbol table informationReport syntax errors
Features:AST( File, ST )
Static AnalyzerService:
Perform semantic analysisFill symbol tableReport type errors
Features :perform_analysis (AST, ST )
Code Generator
Service: Generate target code from analyzed syntax tree
Features :generate_code( AST, ST )
![Page 39: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/39.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 39
Cohesion and coupling in compiler example
Cohesion- Each subsystem has a clear responsibility- Very high cohesion in compiler
Coupling- Small interfaces between subsystems- But: All subsystems read and update the symbol table
(global data)- Changes of symbol table structure have effect on all
subsystems- Coupling can be further reduced
![Page 40: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/40.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 40
Compiler example revisited
Lexer
Service: Manage symbol table
Operations:enter_identifier (Ident, Line )type (Ident )…
Symbol Table
Parser CodeGenerator
StaticAnalyzer
Root
![Page 41: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/41.jpg)
41
Architecture assessment: lists
Original API:l.insert (i, x)l.remove (i )pos := l.search (x)l.insert_by_value (…)l.insert_by_position (…)l.search_by_position (…)
New interface:Queries:
l.index l.item l.before l.after
Commands:l.start l.forth l.finish l.backl.go (i)l.search (x) l.put (x) l.remove
-- Typical use:
j := l.search (x)l.insert ( j + 1, y)
Features Perfect
Desirable
?
(Re)uses
![Page 42: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/42.jpg)
42
A list seen as an active data structure
“Spain"
Cursor
item
index
count1
forthback
finishstart
afterbefore
![Page 43: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/43.jpg)
43
Architecture assessment: numerical library
Classical, non-O-O library style: NAGnonlinear_ode
(equation_count : in INTEGERepsilon : in out DOUBLEfunc : procedure
(eq_count : INTEGER; a : DOUBLE; eps : DOUBLE; b : ARRAY [DOUBLE];cm : pointer Libtype)
left_count, coupled_count : INTEGER …)
[Altogether 19 arguments, including:4 in out values;3 arrays, used both as input and output;6 functions, each with 6 or 7 arguments, of which 2 or 3
arrays!]
Ordinary differential
equation
![Page 44: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/44.jpg)
44
O-O equivalent (EiffelMath)
... Create e and set-up its values(other than defaults) ...
e.solve
... Answer available in e.x and e.y ...
The key to an O-O numerical library: abstractions such as EQUATION, PROBABILITY_DISTRIBUTION, INTEGRATABLE_FUNCTION, INTEGRATOR, RANDOM_SEQUENCE…
![Page 45: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/45.jpg)
45
Numerical library example: lessons
Separate the auxiliary from the essential
Turn non-essential arguments into options
Each option is settable through its own command
“Option-operand separation principle”
But: this is a stateful solution (see next)
![Page 46: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/46.jpg)
46
The statefulness issue
Subsystems can beStateless (e.g. HTTP)
Pro: simpler to program; no synchronizationissueCon: all information must be passed to everycall, through arguments
Stateful (e.g. database, option-operand style, statefulfirewalls)
Pro: simplicity of API; each callonly passes new information
Con: client needs to have exclusive access, or supplier needs to maintain list of clients
![Page 47: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/47.jpg)
47
Architecture assessment: Observer Pattern
PUBLISHER*
PUB_1
SUBSCRIBER*
SUB_1
update*
update+
Deferred (abstract)Effective (implemented)
*+
Inherits from
Client (uses)
subscribe+unsubscribe+subscribed: LIST […]
attachdetach
+ +
(secret)
SUB_2SUB_3
PUB_2PUB_3
SUB_4
![Page 48: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/48.jpg)
48
Observer pattern
To register itself, a subscriber executes:
subscribe (some_publisher)
where subscribe is defined in SUBSCRIBER as:
subscribe (p: PUBLISHER)-- Make current object observe p.
requirepublisher_exists : p /= Void
dop.attach (Current)
end
![Page 49: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/49.jpg)
49
Attaching an observer
In class PUBLISHER :feature {SUBSCRIBER }
attach (s : SUBSCRIBER)-- Register s as subscriber to current publisher.
requiresubscriber_exists : s /= Void
dosubscribed.extend (s )
end
(selective export)
s
sub1
subscriberssub2 subn
![Page 50: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/50.jpg)
50
Observer pattern
Subscriber may subscribe to at most one publisher
May subscribe at most one operation
Not reusable — must be coded anew for each application
Analysis: this uses the wrong data abstractions
![Page 51: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/51.jpg)
51
The Event library
Fundamental data abstraction: event type
Simple solution:One generic class: EVENT_TYPETwo features: publish and subscribe
A publisher:Statically, defines an event typeDynamically, uses publish to publish events
A subscriber:Subscribes an agent to an event typeThat’s all!
![Page 52: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/52.jpg)
52
Publish-subscribe example lessons
Initial solution:Direct coupling between publishers and subscribersPartly wrong abstractions: subscriber (observer)
Revised solution: relies on single, directly adapted abstraction (event type); no direct coupling between publishers and subscribers)
![Page 53: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/53.jpg)
53
Architecture assessment: panel-driven system
Flight sought from: To:
Depart no earlier than: No later than:18 Mar 2006
Choose next action:0 – Exit1 – Help2 – Further enquiry3 – Reserve a seat
18 Mar 2006
Santa Barbara Zurich
ERROR: Choose a date in the future
![Page 54: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/54.jpg)
54
The transition diagram
Help HelpInitial
Flight_query
Seat_query
Confirmation
Reservation
Help Help
11
11
2 3 32
2
2
23 33
1 1 1 1
1
52
43
![Page 55: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/55.jpg)
55
Top-down system architecture
execute_session
initial transition execute_state is_final
display read correct message process
Level 3
Level 2
Level 1
![Page 56: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/56.jpg)
56
Top-down system architecture
execute_session-- Execute full session
localcurrent_state, choice : INTEGER
docurrent_state := initialrepeat
choice := execute_state (current_state)current_state := transition (current_state, choice)
untilis_final (current_state)
endend
![Page 57: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/57.jpg)
57
Actions in a stateexecute_state (current_state : INTEGER): INTEGER
-- Execute actions for current_state ; return user’s exit choice.local
answer : ANSWERgood : BOOLEANchoice : INTEGER
dorepeat
display (current_state)[answer, choice] := read (current_state)good := correct (current_state, answer)if not good then message (current_state, answer) end
untilgood
endprocess (current_state, answer)return choice
end
![Page 58: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/58.jpg)
58
Criticism
How amenable is this solution to change and adaptation?New transition? New state? New application?
Routine signatures:
execute_state (state : INTEGER): INTEGERdisplay (state : INTEGER)read (state : INTEGER): [ANSWER, INTEGER]correct (state : INTEGER; a: ANSWER): BOOLEANmessage (state : INTEGER; a: ANSWER)process (state : INTEGER; a: ANSWER)is_final (state : INTEGER)
![Page 59: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/59.jpg)
59
Data transmission
All routines share the state as input argument. They must discriminate on it, e.g. :
display (current_state : INTEGER) isdo
inspect current_statewhen state1 then
...when state2 then
...when staten then
...endendConsequences:
Long and complicated routines. Must know about one possibly complex application. To change one transition, or add a state, need to change all.
![Page 60: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/60.jpg)
60
The visible architecture
execute_session
initial transition execute_state is_final
display read correct message process
Level 3
Level 2
Level 1
![Page 61: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/61.jpg)
61
The real story
execute_session
initial transition execute_state is_final
display read correct message process
Level 3
Level 2
Level 1
state
statestatestatestatestate
![Page 62: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/62.jpg)
62
Going O-O
Use STATE as the basic abstract data type (and class).
Among features of every state:
The routines of level 1 (deferred in class STATE )
execute_state, as above but without the argumentcurrent_state
![Page 63: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/63.jpg)
63
Grouping by data abstractions
execute_session
initial transition execute_state is_final
display read correct message process
Level 3
Level 2
Level 1
STATE
![Page 64: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/64.jpg)
64
Class STATE
deferred classSTATE
featurechoice : INTEGER -- User’s selection for next stepinput : ANSWER -- User’s answer for this stepdisplay is
-- Show screen for this step.deferredend
read is-- Get user’s answer and exit choice, -- recording them into input and choice.
deferredensure
input /= Voidend
![Page 65: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/65.jpg)
65
Class STATE
correct : BOOLEAN is-- Is input acceptable?
deferredend
message is-- Display message for erroneous input.
requirenot correct
deferredend
process is-- Process correct input.
requirecorrect
deferredend
![Page 66: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/66.jpg)
66
Class STATE
execute_state islocal
good : BOOLEANdo
fromuntil
goodloop
displayreadgood := correctif not good then message end
endprocesschoice := input.choice
endend
![Page 67: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/67.jpg)
67
Class structure
STATE*
INITIAL FLIGHT_QUERY RESERVATION
…
execute_state +
display +
read +
correct +
message +
process +
display +
read +
correct +
message +
process +
display +
read +
correct +
message +
process +
display *read *correct *message *process *
![Page 68: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/68.jpg)
68
Grouping by data abstractions
execute_session
initial transition execute_state is_final
display read correct message process
Level 3
Level 2
Level 1STATE
APPLICATION
![Page 69: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/69.jpg)
69
To build an application
Necessary states — instances of STATE — should be available.
Initialize application: create a.make (state_count, choice_count)
Assign a number to every relevant state s : a.put_state (s, n)
Choose initial state n0 : a.choose_initial (n0 )
Enter transitions: a.put_transition (sou, tar, lab)
May now run:a.execute_session
![Page 70: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/70.jpg)
70
Note on the architecture
Procedure execute_session is not ‘‘the function of the system” but just one routine of APPLICATION.
Other uses of an application: Build and modify: add or delete state, transition, etc. Simulate, e.g. in batch (replaying a previous session’s script), or on a line-oriented terminal. Collect statistics, a log, a script of an execution. Store into a file or data base, and retrieve.
Each such extension only requires incremental addition of routines. Doesn’t affect structure of APPLICATION and clients.
![Page 71: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/71.jpg)
71
Architecture assessment: panel-driven system
Analyze data transmissionData elements transmitted too far into the structure are usually the sign of an unrecognized abstractionKey to openness of last solution: architecture based on types of the problem’s objects (state, transition graph, application)Ignore “the function” of the system. Usually a superficial property, subject to change. Systems usually don’t have a functional “top”Keep system open for evolutionKey is search for data abstraction
![Page 72: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/72.jpg)
72
Architecture assessment: use of contracts
Describing active structures properly: can after also be before?
Symmetry:
For symmetry and consistency, it is desirable to have the invariant properties.
after = (index = count + 1)before = (index = 0)
start finish
forth back
after before
before
item
after
count
not beforenot after
Valid cursor positions
A
![Page 73: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/73.jpg)
73
Designing for consistency
Typical iteration: from
startuntil
afterloop
some_action (item)forth
end
Conventions for an empty structure?after must be true for the iteration. For symmetry: before should be true too.
But this does not work for an empty structure (count = 0, seeinvariant A): should index be 0 or 1?
![Page 74: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/74.jpg)
74
Designing for consistency
To obtain a consistent convention we may transform the invariant into:
after = (is_empty or (index = count + 1))before = (is_empty or (index = 0)-- Hence: is_empty = (before and after)
Symmetric but unpleasant. Leads to frequent tests
if after and not is_empty then ...
instead of just
if after then ...
B
![Page 75: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/75.jpg)
75
Introducing sentinel items
Invariant (partial): 0 <= indexindex <= count + 1before = (index = 0)after = (index = count + 1)not (after and before)
A
not afterbefore
not beforeafter
item count count + 10 1
not after; not before1 <= index; index <= count
Valid cursor positions
![Page 76: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/76.jpg)
76
The case of an empty structure
not afterbefore
not beforeafter
1 (i.e. count + 1)0
Valid cursor positions
![Page 77: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/77.jpg)
77
List structure example: lessons
General principles:Consistency
A posteriori: “How do I make this design decision compatible with the previous ones?”. A priori: “How do I take this design decision so that it will be easy – or at least possible – to make future ones compatible with it?”.
Use assertions, especially invariants, to clarify the issues. Importance of symmetry concerns (cf. physics and mathematics). Importance of limit cases (empty or full structures).
![Page 78: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/78.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 78
System design
1 Overview2 Subsystem decomposition3 Assessing O-O architectures4 Architectural styles5 Advanced issues
![Page 79: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/79.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 79
Elements of a Software Architecture
Subsystems (components)- Computational units with specified interface- Examples: filters, databases, layers, objects
Connectors - Interactions between components- Examples: routine calls, pipes, event broadcasts, shared
data
See M. Shaw, D. Garlan: Software Architecture. Prentice Hall, 1996.
![Page 80: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/80.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 80
Architectural Styles
Data flow systems- Batch sequential, pipe-
and-filterCall-and-return system- Main program and
subroutineIndependent components- Interacting processes,
event system
Data-centered systems (repositories)- Databases, blackboards
Hierarchical systems- Layers- Interpreters, rule-based
systemsClient-server systemsPeer-to-peer systems
![Page 81: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/81.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 81
Data Flow Systems
The availability of data controls the computationThe structure is determined by the orderly motion of data from component to componentData flow is the only form of communication between componentsVariations- How control is exerted (e.g., push versus pull)- Degree of concurrency between processes- Topology
![Page 82: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/82.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 82
Data Flow Systems
Components: data flow components- Interfaces are input and output ports- Input ports read data; output ports write data- Computational model: read data from input ports,
compute, write data to output portsConnectors: data streams- Uni-directional- Usually asynchronous, buffered- Computational model: transport data from writer to
reader
![Page 83: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/83.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 83
Batch Sequential Style
Components are independent programsConnectors are some type of mediaEach step runs to completion before next step begins
Program Program Program
Component
Data flow via media
![Page 84: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/84.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 84
Batch Sequential Style: Properties
History: Mainframes and magnetic tapeApplications: Business data processing- Discrete transactions of predetermined type and
occurring at periodic intervals- Creation of periodic reports based on periodic data
updatesExamples- Payroll computations- Tax reports
![Page 85: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/85.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 85
Pipe-and-Filter Style
Components (Filters)- Read streams of input data- Locally transform input data- Produce streams of output data
Connectors (Pipes)- Streams, e.g., first-in-first-out buffer
FilterFilter
Filter
Component: Filter
FilterFilter
Connector: Pipe
![Page 86: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/86.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 86
Pipe-and-Filter Style: Properties
Data is processed incrementally as it arrivesOutput usually begins before input is consumed Filters must be independent, no shared stateFilters don’t know upstream or downstream filters
Examples- lex/yacc-based compiler (scan, parse, generate code, …)- Unix pipes- Image / signal processing
![Page 87: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/87.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 87
Push Pipeline with Active Source
Source of each pipe pushes data downstreamExample: Unix pipes: grep pattern * ¦ wc
dataSource filter1 filter2 dataSink
write( data )
write( data )
f1( data )
write( data )
f2( data )Active source
PushPushPush
![Page 88: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/88.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 88
Pull Pipeline with Active Sink
dataSink filter1 filter2 dataSource
data := next data := next
f1 (data)
data := next
f2 (data)Active sink
Pull
Sink of each pipe pulls data upstreamExample: Compiler: t := lexer.next_token
PullPull
![Page 89: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/89.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 89
Mixed Pipeline With Passive Source and Sink
If more than one filter is pushing / pulling, synchronization is needed
dataSink filter1 filter2 dataSource
data := read( )
f1( data )
data := read( )
f2( data )
Push
Pull
write( data )
Active filter
![Page 90: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/90.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 90
Pipe-and-Filter Style: Discussion
StrengthsReuse: any two filters can be connected if they agree on that data format that is transmittedEase of maintenance: filters can be added or replacedPotential for parallelism: filters implemented as separate tasks, consuming and producing data incrementally
WeaknessesSharing global data is expensive or limitingCan be difficult to design incremental filtersNot appropriate for interactive applicationsError handling is Achilles heel, e.g., some intermediate filter crashesOften lowest common denominator on data transmission, e.g., ASCII in Unix pipes
![Page 91: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/91.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 91
Call-and-Return Style (Explicit Invocation)
Components: ObjectsConnections: Messages (routine invocations)Key aspects- Object preserves integrity of representation
(encapsulation)- Representation is hidden from client objects
Variations- Objects as concurrent tasks
![Page 92: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/92.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 92
Call-and-Return Style: Discussion
StrengthsChange implementation without affecting clients Can break problems into interacting agents (distributed across multiple machines / networks)
WeaknessesObjects must know their interaction partners (in contrast to Pipe-and-Filter)When partner changes, objects that explicitly invoke it must change Side effects: if A uses B and C uses B, then C’s effects on B can be unexpected to A
![Page 93: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/93.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 93
Event-Based Style (Implicit Invocation)
Characterized by the style of communication between components- Component announces (broadcasts) one or more events
Generalized Observer Design PatternComponents- May announce events- May register for events of other components with a
callbackConnectors- Bindings between event announcements and routine
calls (callbacks)
![Page 94: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/94.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 94
Event-Based Style: Properties
Announcers of events do not know which components will be affected by those eventsComponents cannot make assumptions about ordering of processing, or what processing will occur as a result of their events
Examples- Programming environment tool integration- User interfaces (Model-View-Controller)- Syntax-directed editors to support incremental semantic
checking
![Page 95: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/95.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 95
Event-Based Style: Example
Integrating tools in a shared environment
Editor announces it has finished editing a module- Compiler registers for such announcements and
automatically re-compiles module- Editor shows syntax errors reported by compiler
Debugger announces it has reached a breakpoint- Editor registers for such announcements and
automatically scrolls to relevant source line
![Page 96: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/96.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 96
Event-Based Style: Discussion
StrengthsStrong support for reuse: plug in new components by registering it for eventsMaintenance: add and replace components with minimum effect on other components in the system
WeaknessesLoss of control- What components will
respond to an event?- In which order will
components be invoked?- Are invoked components
finished?Ensuring correctness is difficult because it depends on context in which invoked
In practice, call-and-return style and event-based style are combined
![Page 97: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/97.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 97
Data-Centered Style (Repository Style)
Components- Central data store component represents systems state- Independent components operate on the data store
RepositoryKnowledgeSource
KnowledgeSource
KnowledgeSource
KnowledgeSource
KnowledgeSource
KnowledgeSource
Computation
Direct access
![Page 98: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/98.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 98
Special Case: Blackboard Architectures
Interactions among knowledge sources solelythrough repositoryKnowledge sources make changes to the shared data that lead incrementally to solutionControl is driven entirely by the state of the blackboard
Example- Repository: modern compilers act on shared data:
symbol table, abstract syntax tree- Blackboard: signal and speech processing
![Page 99: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/99.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 99
Data-Centered Style: Discussion
StrengthsEfficient way to share large amounts of dataData integrity localized to repository module
WeaknessesSubsystems must agree (i.e., compromise) on a repository data modelSchema evolution is difficult and expensiveDistribution can be a problem
![Page 100: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/100.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 100
Hierarchical Style (Layered Style)
Components- Group of subtasks which implement an abstraction at
some layer in the hierarchyConnectors- Protocols that define how the layers interact
![Page 101: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/101.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 101
Hierarchical Style: Properties
Each layer provides service to the layer above it and acts as a client of the layer belowEach layer collects services at a particular level of abstractionA layer depends only on lower layers- Has no knowledge of higher layers
Example- Communication protocols- Operating systems
![Page 102: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/102.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 102
Hierarchical Style: Example
THE operating system (Dijkstra)The OSI Networking Model - Each level supports communication at a level of
abstraction- Protocol specifies behavior at each level of abstraction- Each layer deals with specific level of communication
and uses services of the next lower level
Layers can be exchanged- Example: Token Ring for Ethernet on Data Link Layer
![Page 103: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/103.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 103
OSI Model Layers and Their Responsibilities
The system you are designing
Performs data transformation services, such as byte swapping and encryptionInitializes a connection, including authenticationReliably transmits messages
Transmits and routes data within the network
Sends and receives frames without error
Sends and receives bits over a channelPhysical
Data Link
Network
Transport
Session
Presentation
Application
![Page 104: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/104.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 104
Hierarchical Style: Example (cont’d)
Physical
Data Link
Network
Transport
Session
Presentation
Application
Physical
Data Link
Network
Transport
Session
Presentation
Application
Physical
Data Link
Network
Use service of lower layer
Virtual connection
![Page 105: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/105.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 105
Hierarchical Style: Discussion
StrengthsIncreasing levels of abstraction as we move up through layers: partitions complex problemsMaintenance: in theory, a layer only interacts with layer below (low coupling)Reuse: different implementations of the same level can be interchanged
WeaknessesPerformance: communicating down through layers and back up, hence bypassing may occur for efficiency reasons
![Page 106: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/106.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 106
Interpreters
Architecture is based on a virtual machineproduced in softwareSpecial kind of a layered architecture where a layer is implemented as a true language interpreterComponents- “Program” being executed and its data- Interpretation engine and its state
Example: Java Virtual Machine- Java code translated to platform independent bytecode- JVM is platform specific and interprets the bytecode
![Page 107: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/107.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 107
Client Server Style
Components- Subsystems are independent processes- Servers provide specific services such as printing, etc.- Clients use these services
Connectors - Data streams, typically over a communication network
Internet Server
Client
Client
Client
![Page 108: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/108.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 108
Client Server Style Example: Databases
Front-end: User application (client)- Customized user interface- Front-end processing of data- Initiation of server remote procedure calls- Access to database server across the network
Back-end: Database access and manipulation (server)- Centralized data management- Data integrity and database consistency- Database security- Concurrent operations (multiple user access)- Centralized processing (for example archiving)
![Page 109: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/109.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 109
Client Server Style: Variants
Thick / fat client- Does as much processing as possible- Passes only data required for communications and
archival storage to the server- Advantages: less network bandwidth, fewer server
requirementsThin client- Has little or no application logic- Depends primarily on the server for processing activities - Advantages: lower IT admin costs, easier to secure,
lower hardware costs.
![Page 110: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/110.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 110
Client Server Style: Discussion
StrengthsMakes effective use of networked systemsMay allow for cheaper hardwareEasy to add new servers or upgrade existing serversAvailability (redundancy) may be straightforward
WeaknessesData interchange can be hampered by different data layoutsCommunication may be expensiveData integrity functionality must be implemented for each serverSingle point of failure
![Page 111: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/111.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 111
Peer-to-Peer Style
Similar to client-server style, but each component is both client and serverPure peer-to-peer style- No central server, no central router
Hybrid peer-to-peer style- Central server keeps information on peers and responds
to requests for that information
Examples- File sharing applications, e.g., Napster, Gnutella, Kazaa- Communication and collaboration, e.g., Skype
![Page 112: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/112.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 112
Peer-to-Peer: Discussion
StrengthsEfficiency- All clients provide resources
Scalability- System capacity grows with
number of clients
Robustness- Data is replicated over peers- No single point of failure in
the system (in pure peer-to-peer style)
WeaknessesArchitectural complexityResources are distributed and not always availableMore demanding of peers (compared to client-server)New technology not fully understood
![Page 113: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/113.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 113
Assessing architectures
General style can be discussed ahead of timeKnow pros and consArchitectural styles Patterns Components
![Page 114: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/114.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 114
System design
1 Overview2 Subsystem decomposition3 Assessing O-O architectures4 Architectural styles5 Advanced issues
![Page 115: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/115.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 115
Areas of System Design: Specific Issues
Identify design goals
Refine subsystem decomposition to
address design goals
Design initial subsystem
decomposition
Concurrency
Hardware / Software Mapping
Data Management
Global Resource Handling
Software Control
Boundary Conditions
![Page 116: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/116.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 116
Concurrency: Threads
Execution threads are sequences of atomic actions during a program executionConcurrent programs can have more than one threadExecution of threads can be parallel(on several processors) or virtually parallel (on one processor)Design goal: response time, performance
![Page 117: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/117.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 117
Concurrency Questions
Which objects of the object model are independent?- Candidates for separate threads
Does the system support multiple users?- Example: Client-server architecture with several clients
Can a single request to the system be decomposed into multiple requests? Can these requests be handled in parallel?- Search in a distributed database- Image recognition by decomposing the image into stripes
![Page 118: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/118.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 118
Hardware / Software Mapping
This activity addresses two questions:- How shall we realize the subsystems: with hardware or
with software?- How do we map the object model on the chosen
hardware and software?
Much of the difficulty of designing a system comes from meeting externally-imposed hardware and software constraints
![Page 119: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/119.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 119
Mapping the Objects
Processor issues- Is the computation rate too demanding for a single
processor?- Can we get a speedup by distributing tasks across
several processors?- How many processors are required to maintain steady
state load?Memory issues- Is there enough memory to buffer bursts of requests?
![Page 120: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/120.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 120
Mapping the Objects (cont’d)
Example: stock trading- Usually steady rate of stock orders per day- Extreme peaks for important IPOs
Bank is liable for loss of orders- System must be able to handle peak load
![Page 121: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/121.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 121
Mapping the Associations
Which of the client-supplier relationships in the analysis / design model correspond to physicalconnections?
Describe the logical connectivity (subsystem associations)
Identify associations that do not directly map into physical connections- How should these associations be implemented?
![Page 122: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/122.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 122
Hardware / Software Mapping Questions
What is the connectivity among physical units?- Tree, star, matrix, ring
What is the appropriate communication protocolbetween the subsystems?- Function of required bandwidth, latency and desired
reliability, desired quality of service (QoS)Is certain functionality already available inhardware?General system performance question- What is the desired response time?
![Page 123: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/123.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 123
Example: ATM Machine and Host System
Backend software runs on mainframe; one for
the whole country
Connected via leased line (low latency)
Client software runs on common PC; one PC
per ATM
Connected via backbone
Server software runs on workstations; one per region
![Page 124: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/124.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 124
Data Management
Some objects in the models need to be persistentPersistency is achieved by files and databasesFiles- Cheap, simple, permanent storage- Low level (read, write)- Applications must add code to provide suitable level of
abstractionDatabase- Powerful, easy to port- Supports multiple writers and readers
![Page 125: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/125.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 125
File or Database?
When should you choose a file?- Is the data voluminous (bit maps)?- Do you have lots of raw data (core dump, event trace)?- Do you need to keep the data only for a short time?
When should you choose a database?- Does the data require access by multiple users?- Must the data be ported across multiple platforms
(heterogeneous systems)?- Do multiple application programs access the data?- Does the data management require a lot of
infrastructure (e.g., indexing, transactions)?
![Page 126: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/126.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 126
Database Management System
Contains mechanisms for describing data, managing persistent storage and for providing a backup mechanism
Provides concurrent access to the stored data
Contains information about the data (“meta-data”)- Also called data schema
![Page 127: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/127.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 127
Object-Oriented Databases
An object-oriented database supports all the fundamental object modeling concepts- Classes, Attributes, Routines, Associations, Inheritance
Mapping an object model to an OO-database- Determine which objects are persistent- Perform normal requirement analysis and detailed design- Do the mapping specific to commercially available
productSuitable for medium-sized data set,irregular associations among objects
![Page 128: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/128.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 128
Relational Databases
Data is presented as two-dimensional tablesTables have a specific number of columns and arbitrary numbers of rows- Primary key: Combination of attributes that uniquely
identify a row in a table- Foreign key: Reference to a primary key in another table
SQL is the standard language for defining and manipulating tablesSuitable for large data set, complex queries over attributes
![Page 129: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/129.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 129
Mapping an Object Model to a Relational DB
UML object models can be mapped to relational databasesUML mappings- Each class is mapped to a table- Each class attribute is mapped onto a column in the table- An instance of a class represents a row in the table- A one-to-many association is implemented as foreign key- A many-to-many association is mapped into its own table
Methods are not mapped
![Page 130: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/130.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 130
Mapping 1:n and n:1 Associations
Buried Foreign Keys
Transaction
transactionID
PortfolioportfolioID…
*
transactionID portfolioIDTransactionTable
portfolioID …PortfolioTable
Foreign Key
Primary Key
Primary Key
![Page 131: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/131.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 131
Mapping Many-to-Many Associations
Separate table for association
City
cityName
AirportairportCodeairportName
* Serves *
cityName airportCodeHouston IAHHouston HOUAlbany ALBMunich MUCHamburg HAM
ServesTableairportCode airportNameIAH IntercontinentalHOU HobbyALB Albany CountyMUC Munich AirportHAM Hamburg Airport
AirportTableCityTablecityNameHoustonAlbanyMunichHamburg
Primary Key Separate
Table
![Page 132: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/132.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 132
Mapping Inheritance
Option 1: separate table Personname
Assistantoffice
Studentlegi
id office79 RZ F02
AssistantTableid legi56 123456
StudentTableid name56 Urs79 Sile
PersonTable
![Page 133: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/133.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 133
Mapping Inheritance (cont‘d)
Option 2: duplicating columns Personname
Assistantoffice
Studentlegi
id legi name56 123456 Urs
StudentTableid office name79 RZ F02 Sile
AssistantTable
![Page 134: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/134.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 134
Separate Tables vs. Duplicated Columns
Separate table mapping- Pro: Adding attributes to
the superclass is easy (adding a column to the superclass table)
- Con: Searching for the attributes of an object requires a join operation
Duplicated columns- Con: Modifying the
database schema is more complex and error-prone
- Pro: Individual objects are not fragmented across a number of tables (faster queries)
Trade-off between modifiability and response time- How likely is a change of the superclass?- What are the performance requirements for queries?
![Page 135: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/135.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 135
Data Management Questions
Should the data be distributed?Should the database be extensible?How often is the database accessed?What is the expected request rate? In the worst case?What is the size of typical and worst case requests?Does the data need to be archived?Does the system design try to hide the location of the databases (location transparency)?Is there a need for a single interface to access the data?What is the query format?Should the database be relational or object-oriented?
![Page 136: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/136.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 136
Boundary Conditions
Most of the system design effort is concerned with the steady-state behavior described in the analysis phaseAdditional administration use cases describe:Initialization ("startup use cases”)Termination ("termination use cases")- What resources are cleaned up and which systems are
notified upon terminationFailure (“failure use cases”)- Many possible causes: Bugs, errors, external problems- Good system design foresees fatal failures
![Page 137: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/137.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 137
Boundary Condition Questions
Initialization- How does the system start up?- What data needs to be accessed at startup time?- What services have to be registered?- What does the user interface do at start up time?- How does it present itself to the user?
Termination- Are single subsystems allowed to terminate?- Are other subsystems notified if a single subsystem
terminates?- How are local updates communicated to the database?
![Page 138: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/138.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 138
Boundary Condition Questions (cont’d)
Failure- How does the system behave when a node or
communication link fails? Are there backup communication links?
- How does the system recover from failure? Is this different from initialization?
![Page 139: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/139.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 139
Modeling Boundary Conditions
Boundary conditions are best modeled as usecases with actors and objectsActor: often the system administratorInteresting use cases:- Start up of a subsystem- Start up of the full system- Termination of a subsystem- Error in a subsystem or component, failure of a
subsystem or component
![Page 140: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/140.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 140
Influences from Requirements Analysis
Finally: The subsystem decomposition influences boundary conditions
Nonfunctional Requirements Definition of Design Goals
Functional model Subsystem Decomposition
Object model Hardware/software Mapping, Data Management
Dynamic model Identification of Concurrency
![Page 141: Lecture 10: System Design - ETH Zse.inf.ethz.ch/old/teaching/ss2007/252-0204-00/slides/11-softeng... · ETH Software Engineering, lecture 10: System Design (after Peter Müller) 3](https://reader033.vdocuments.site/reader033/viewer/2022050206/5f590806adcf6b108f464d71/html5/thumbnails/141.jpg)
ETH Software Engineering, lecture 10: System Design (after Peter Müller) 141
Summary: System Design
Design goals definition- Describes and prioritizes the qualities that are important
for the systemSubsystem decomposition- Decomposes the overall system into manageable parts
by using the principles of cohesion and coherenceArchitectural style- A pattern of a typical subsystem decomposition
Software architecture- An instance of an architectural style