1. Building a “System”
Moving from writing a program to building a system. What’s the difference?!
Complexity, size, complexity, size complexity
Breadth of complexity
Depth of complexity

2. Increase of Complexity Everywhere
Solution
Problem
transformation
Increase in
size & complexity
Increase in
size & complexity
Increase in
size & complexity

3. Complexity (Breadth) More Functionalities
More Features within each functionality
More varieties of Interfaces (internal & external)
More Users and varieties of users
More data, varieties of data, data structures

4. Complexity (Depth) More Linkages and Connections
Data sharing among the functionalities
Control Passing among functionalities

5. Examples for in-class Discussion
Assignment compute and show the “average” of the read-in numbers
“Modified” Assignment show the largest and the smallest of the read-in numbers
Where is the complexity?
“Further Modified” Assignment show the read-in numbers in a sorted ascending order.

6. Handling Complexities (A)
Via “Simplification”
Decomposition of the problem and of the solution
Modularization of solution
Separation of Concerns of problem and of solution
Incrementally resolve problems
*** Not “advertised” but a sometimes used technique is: REDUCE the problem

7. Handling Complexities (B)
Via “Improving Technology and Tools”
Database to handle information and structures of information
Programming & Dev. Platforms
Computing Network
Multi-Developer Configuration Management
Modeling techniques of problem and solution
Automated Testing

8. Handling Complexities (C)
Via “Improving Process and Methodologies”
Coordinate multiple and different people performing different tasks
Guidance for overlapping incremental tasks
Guidance for measuring separate artifacts and outcomes

9. Example of Size and Complexity Increases
(b) Increased Size and Complexity
(a) Simple
Start
Start
Wait for signal
Perform task A
Signal is?
Perform task B
‘a’
other
‘b’
Perform task A
Perform task C
Perform task C
Perform task A2
Perform task B
Stop
Stop
Example of Size and Complexity Increases

10. Task Breakdown Example (Handling Complexity)
Requirements
Definition
Support &
Problem Fixes
Code/Unit Test
Design
Integration &
System Test
1. Who performs what task?
2. How is the task completed with what technique or tool?
3. When should which task start and end?
4. Who should coordinate the people and the tasks?

11. Iterative Process Example (Handling Complexity)
Understanding the Broad Problem (Req.)
Architecture and High Level Design
Specific
Requirements
Specific
Requirements
Detail design
Detail design
Code
Code
Integration
Test / Fix
Test / Fix

12. Handling the “Details” separately
Integration
Test / Fix
Test / Fix
Seemingly “simple” Test/Fix and Integrate steps:
Should there be separate & independent test group?
How should problem be reported and to whom?
How much information must accompany a problem report?
Who decides on the priority of the problem?
How is the problem fix returned?
Should all problems be fixed?
What should we do with non-fixed problem?
How are fixes integrated back to the system?

13. Some ‘Non-technical’ Considerations for Developing & Supporting a System
Effort & Schedule Expansion
How does one estimate and handle this?
Assignment and Communications Expansion?
Do we need some process?
Do we need some tools?

14. With the increase in system complexity, there is a corresponding
increase in the “manpower” or human resources.
2 people:
1 path
4 people:
possibly 6 paths
6 people:
increase to potentially 15 paths
For n people, number of potential communications paths = ∑ (n-1) = [nx(n-1)] / 2
Increase in Amount of Communications as # of People Increases. Also, an increase in the number of communications errors committed

15. A Large, Complex System
Building “Mission critical” or “Business critical” system (e.g. payroll - in textbook) requires (1)several separate activities performed by (2)more than 1 person (e.g. 50 ~ 100):
Requirements: gathering, analysis, specification, and agreement
Design: abstraction, decomposition, cohesion, interaction and coupling analysis
Implementation: coding and unit testing
Integration and tracking of pieces and parts
Separate testing: functional testing, component testing, system testing, and performance testing
Packaging and releasing the system

16. Also, Need to ‘Support’ the “Payroll” System (for real production)
Pre-release: preparation for education & support:
Number of expected users
Number of “known problems” and expected quality
Amount of user and support personnel training
number of fix and maintenance cycle
Post-release: preparation for user and customer support:
Call center and problem resolutions
Major problem fixes and code changes
Functional modifications and enhancements

17. Coordination Efforts Required in Systems Development and Support
Because there are i) more parts, ii) more developers and iii) more users to consider in “Large Systems” than a single program developed by a single person for a limited number of users, there is the need for Coordination of:
Processes and methodologies to be used
Final product and intermediate artifacts
People (developers, support personnel, and users)
The previous diagram on people increase and potential communication paths
increase provides a clue to the importance of coordination efforts.