Final Flashcards
Requirements
state the purpose of the system. Expression of desired behavior
Typical parts of requirements documentation
- Functional requirements
- unstructured text
- use cases - Nonfunctional requirements
- unstructured text
- use cases - Diagrams
- self explanatory
Requirements definition
Stated from the viewpoint of someone outside of the system. Role of the system
Requirements specification
Stated from the viewpoint of someone inside the system. How the system works
External viewpoint
Stated from someone outside the system
Internal viewpoint
Stated from someone inside the system
Whats in a basic use case
Use case name: Name of the case Actor: Who/what is using it Preconditions: Postconditions: Flow of events: The steps taken in the system
non-functional requirements
Describe how well the system should do something. in terms of fit criteria
Use case diagram
Shows supported activities
- Stick man for user
- Ovals for cases
- Simple arrows when UC calls another
- Hollow arrowheads for specialization
UML class diagrams
Show entities, attributes relationships
- One box per kind of activity
- Lines with arrowheads show references
- Lines with hollow arrowheads for specialization
- Lines with regular arrowheads indicate dependencies
Dataflow diagram
Shows flow of information
- Each oval is a function
- Each rectangle is an actor
- Each half rectangle is a datastore
- Separate for use cases
Message sequence diagram
Shows flow of control
- One box per entity involved
- Arrows show messages
- Conditionals are written with brackets []
State chart
Shows change over time
- One box per state
- Arrows show state transition
- Filled circles show where you start
- nested circles show where you stop
Entity relationship diagrams
- Database design
- One box per entity
- List entities on branches
- Numbers or variables on lines show cardinality
Architecture
Shows a piece of a system and their relationships
Component
Self contained piece of a system with clearly defined linkages
Connector
A linkage between components with an interface
Common architectural styles
client-server peer-to-peer publish-subscribe repositories pipe and filter layering
client-server
server - component that provides services
client - component that interacts with the user and calls server
peer to peer
peer - component that provides services and may signal other peers
publish - subscribe
publish - when a component advertises it can send certain events
subscribe - when a component registers to receive certain events
repositories
client-server design provided storages for storing/accessing data
pipe and filter
filter - component that transforms data
pipe - connector that passes data between filters
layering
layer - components that can provide service to the next layer. Components hide lower levels
decomposition
taking application and breaking it down into smaller components. Layered architecture is really easy to decompose.
approaches for decomposing an architecture
- Functional decomposition
- Data-oriented decomposition
- Object-oriented decomposition
- Process oriented decomposition
- Feature-oriented decomposition
- Event-oriented decomposition
Functional decomposition
break each requirement into function and then into sub-functions.
Data-oriented decomposition
Identify data structures in requirements. Break down recursively. Each data structure contains part of the data.
Object oriented decomposition
Essentially the same as functional aligned with data-oriented.
Process-oriented
Each subset completes one part of a task. IE: Authenticate user, display data, store results
Feature-oriented
Each feature makes the service a little better.
Event-oriented decomposition
Each component is broken into states such as clicking the mouse down and clicking the mouse up.
4 basic ways to evaluate architecture design
- Compare against desired quality models
- Check for problematic failure modes
- Walk through use-cases
- verify conformance to checklist of principles
Quality attributes
- Maintainability
- How hard will it be to make required changes - Efficiency
- Can the system respond quickly? - Reliability
- Will it perform under assumed conditions - Integrity
- Is it possible to put the system into a bad state - Usability
- Can real users interact with the system
Error
Discrepancy between intended behavior and actual behavior
Fault
Defect in the system. My or may not lead to failure
Failure
Undesirable event caused by fault
Coupling
When one module is involved in another modules concern. Reduced maintainability
Cohesion
When a module is devoted to its concern. Increases maintainability.
Levels of coupling
- Content coupling(worst)
- A modifies B - Common coupling
- A and B both modify the same data - Control coupling
- A calls B - Stamp coupling
- A provides structured data to B - Data coupling
- A provides unstructured data to B - Uncoupled (best)
- No coupling
Levels of cohesion
- Functional/informational cohesion(best)
- A and B work together for just one purpose - Communicational cohesion
- A and B use the same data - Procedural cohesion
- A executes, then B executes, and A and B have vaguely related purpose - Temporal cohesion
- A executes, then B executes, but A and B have no related purpose - Logical cohesion
- Either A or B might be executed - Coincidental cohesion(worst)
- None of the above
Incremental development
When much of the systems values resides in one subsection
When one part of the system must be completed logically before another
IE: security systems