Introduction to Software Engineering Lecture 4

1. Introduction to Software EngineeringLecture 4 André van der Hoek

2. Today’s Lecture • Quick recap • Recurring and fundamental principles of software engineering

3. Operations mode Retirement Build-and-Fix Build first version Modify until client is satisfied Development Maintenance

4. Waterfall Requirements phase Changed requirements Verify Verify Specification phase Verify Design phase Verify Implementation phase Test Integration phase Development Maintenance Test Operations mode Retirement

5. Changed requirements Specification phase Design phase Implementation phase Verify Verify Verify Test Operations mode Retirement Rapid Prototyping Build and discardsimple prototype Verify Integration phase Development Maintenance Test

6. Requirements phase Specification phase Verify Verify Operations mode Retirement Incremental Architectural design Verify FOR EACH BUILD Perform detailed design, implementation, and integration. Test. Deliver to client. Development Maintenance

7. . . . . . . . . . Synchronize-and-Stabilize Specifications Design Implementation, Integration Deliver to client (version 1) Specifications Design Implementation, Integration Deliver to client (version 2) Specifications Design Implementation, Integration Deliver to client (version 3) Specifications Design Implementation, Integration Deliver to client (version n) Specification team Design team Implementation/integration team

8. Spiral Risk analysis Risk analysis Risk analysis Risk analysis Rapid prototype Verify Verify Specification Verify Design Verify Implementation

9. A Comparison of Life Cycle Models

10. ICS 52 Software Life Cycle • Requirements specification • Interview customer (TA) • Focus on “what”, not “how” • Architectural and module design • Based on provided “official” requirements specification • Focus on interfaces • Implementation • Based on provided “official” design • Focus on good implementation techniques • Testing • Based on provided “official” implementation • Focus on fault coverage and discovery

11. Recurring, Fundamental Principles • Rigor and formality • Separation of concerns • Modularity • Abstraction • Anticipation of change • Generality • Incrementality These principles apply to all aspects of software engineering

12. Rigor and Formality • Creativity often leads to imprecision and inaccuracy • Software development is a creative process • Software development can tolerate neither imprecision nor inaccuracy • Rigor helps to… • …produce more reliable products • …control cost • …increase confidence in products • Formality is “rigor – mathematically sound” • Often used for mission critical systems

13. Separation of Concerns • Trying to do too many things at the same time often leads to mistakes • Software development is comprised of many parallel tasks, goals, and responsibilities • Software development cannot tolerate mistakes • Separation of concerns helps to… • …divide a problem into parts that can be dealt with separately • …create an understanding of how the parts depend on/relate to each other

14. Example Dimensions of Separation • Time • Requirements, design, implementation, testing, … • Dial, receive confirmation, connect, talk, … • Qualities • Efficiency and user friendliness • Correctness and portability • Views • Data flow and control flow • Management and development

15. Modularity • Separation into individual, physical parts • Decomposability • Divide and conquer • Composability • Component assembly • Reuse • Understanding • Localization • Special case of separation of concerns • Divide and conquer “horizontally” • “Brick”-effect

16. Modularity Big Small Small Small Small

17. Abstraction • Separation into individual, logical parts • Relevant versus irrelevant details • Use relevant details to solve task at hand • Ignore irrelevant details • Special case of separation of concerns • Divide and conquer “vertically” • “Iceberg”-effect

18. Abstraction Big Abstraction Details

19. Modularity + Abstraction Big Details Details Details Abstraction Details Abstraction Abstraction Abstraction

20. Anticipation of Change • Not anticipating change often leads to high cost and unmanageable software • Software development deals with inherently changing requirements • Software development can tolerate neither high cost nor unmanageable software • Anticipation of change helps to… • …create a software infrastructure that absorbs changes easily • …enhance reusability of components • …control cost in the long run

21. Generality • Not generalizing often leads to continuous redevelopment of similar solutions • Software development involves building many similar kinds of software (components) • Software development cannot tolerate building the same thing over and over again • Generality leads to… • …increased reusability • …increased reliability • …faster development • …reduced cost

22. Incrementality • Delivering a large product as a whole, and in one shot, often leads to dissatisfaction and a product that is “not quite right” • Software development typically delivers one final product • Software development cannot tolerate a product that is not quite right or dissatisfies the customer • Incrementality leads to… • …the development of better products • …early identification of problems • …an increase in customer satisfaction • Active involvement of customer

23. Cohesion VERSUS

24. Coupling VERSUS

25. A Good Separation of Concerns, 1 Provided Interface Implementation Required Interface Provided Interface Provided Interface Provided Interface Implementation Implementation Implementation Required Interface Required Interface Required Interface Provided Interface Provided Interface Provided Interface Provided Interface Provided Interface Implementation Implementation Implementation Implementation Implementation Required Interface Required Interface Required Interface Required Interface Required Interface Abstraction through the use of provided/required interfaces Modularity through the use of components Low coupling through the use of hierarchies High cohesion through the use of coherent implementations

26. Provided Interface Implementation A Good Separation of Concerns, 2 Provided Interface Implementation Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Abstraction through the use of provided/required interfaces Modularity through the use of components Low coupling through the use of a central “blackboard” High cohesion through the use of coherent implementations

27. Benefit 1: Anticipating Change Provided Interface Implementation Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Implementation Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Separating concerns anticipates change

28. Benefit 1: Anticipating Change Provided Interface Implementation Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Implementation Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Separating concerns anticipates change

29. Benefit 2: Promoting Generality Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Provided Interface Provided Interface Implementation Implementation Implementation Required Interface Required Interface Required Interface Provided Interface Provided Interface Provided Interface Provided Interface Provided Interface Implementation Implementation Implementation Implementation Implementation Required Interface Required Interface Required Interface Required Interface Required Interface Separating concerns promotes generality

30. Provided Interface Implementation Benefit 3: Facilitating Incrementality Provided Interface Implementation Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Provided Interface Implementation Implementation Required Interface Required Interface Provided Interface Provided Interface Implementation Implementation Provided Interface Provided Interface Required Interface Required Interface Implementation Implementation Required Interface Required Interface Separating concerns facilitates incrementality

31. Recurring, Fundamental Principles • Rigor and formality • Separation of concerns • Modularity • Abstraction • Anticipation of change • Generality • Incrementality These principles apply to all aspects of software engineering

32. Your Tasks • Read and study slides of this lecture • Read Chapters 6.2, 12.1.1, 12.1.2 of van Vliet