Designing Software for Ease of Extension and Contraction Presented by William Greenwell February 27, 2002.

Slides:



Advertisements
Similar presentations
Chapter 2: Software Process
Advertisements

Software Engineering Key design concepts Design heuristics Design practices.
Lecture 2 1 Introduction to Software Engineering.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 4 Slide 1 Software Processes.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 4 Slide 1 Software Processes.
OBP Research Oy for simpler creation of embedded systems.
Matt Klein. Decorator Pattern  Intent  Attach Additional responsibilities to an object by dynamically. Decorators provide a flexible alternative to.
Alternative Software Life Cycle Models By Edward R. Corner vol. 2, chapter 8, pp Presented by: Gleyner Garden EEL6883 Software Engineering II.
Designing Software for Ease of Extension and Contraction Bob Hazen Tim Santucci Chris Dahn A Team One Presentation.
Architecture III Uses and Process Structures 1. Outline Lecture: –Design for extension and contraction: the “uses” structure –Design for run-time separation.
Software Architecture for DSD DSD Team. Overview What is software architecture and why is it so important? The role of architecture in determining system.
Lecturer: Sebastian Coope Ashton Building, Room G.18 COMP 201 web-page: Lecture.
Families of Software Systems Notkin: 3 of 3 lectures on change.
On the Criteria to Be Used in Decomposing Systems into Modules Written by D.L. Parnas Presented by Conner Hansen.
Designing Software for Ease of Extension and Contraction
SWE Introduction to Software Engineering
Shivkumar Kalyanaraman Rensselaer Polytechnic Institute 1 Understanding Linux Kernel to Build Software Routers (Qualitative Discussion) Shiv Kalyanaraman,
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 4 Slide 1 Software Process Models.
Object-oriented Programming Concepts
Designing Software for Ease of Extension and Contraction Group 1: Lisa Anthony Erik Hayes Luiza Da Silva Diana Tetelman CS575 – Software Design Fall 2001.
SDLC. Information Systems Development Terms SDLC - the development method used by most organizations today for large, complex systems Systems Analysts.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 4 Slide 1 Software Processes.
The Modular Structure of Complex Systems D.L. Parnas, P.C. Clement, and D.M. Weiss Published in IEEE Transactions on Software Engineering, March 1985 Presented.
CMSC 345, Version 1/03 An Overview of Software Processes Reference: Software Engineering, by Ian Sommerville, 6 th edition, Chapter 3.
03 - ParnasCSC4071 A Sketchy Evolution of Software Design 1960s –Structured Programming (“Goto Considered Harmful”, E.W.Dijkstra) Emerged from considerations.
Software Architecture for DSD The “Uses” Relation.
SEG Software Maintenance1 Software Maintenance “The modification of a software product after delivery to correct faults, to improve performance or.
University of Toronto Department of Computer Science CSC444 Lec04- 1 Lecture 4: Software Lifecycles The Software Process Waterfall model Rapid Prototyping.
CSE 303 – Software Design and Architecture
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 10Slide 1 Architectural Design l Establishing the overall structure of a software system.
On the Criteria to Be Used in Decomposing Systems into Modules Team 3 Nupur Choudhary Aparna Nanjappa Mark Zeits.
Dependences & coupling Daniel Jackson 6898 April 17, 2003.
(Business) Process Centric Exchanges
Silberschatz, Galvin and Gagne  2002 Modified for CSCI 399, Royden, Operating System Concepts Operating Systems Lecture 7 OS System Structure.
Some Software Engineering Principles by D. L. Parnas Presented by Team 7: Amitkumar Dhameja Cincy Francis Rong Gu CS575 - Software Design, Team 7.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 4 Slide 1 Software Processes.
Introduction CS 3358 Data Structures. What is Computer Science? Computer Science is the study of algorithms, including their  Formal and mathematical.
1 The Modular Structure of Complex Systems Presented by: SeyedMasoud Sadjadi and Wei Zhu David L. Parnas, Paul C. Clement, and David M. Weiss ICSE 1984.
An Introduction to Software Engineering
Design Patterns -- Omkar. Introduction  When do we use design patterns  Uses of design patterns  Classification of design patterns  Creational design.
1 CSCD 326 Data Structures I Software Design. 2 The Software Life Cycle 1. Specification 2. Design 3. Risk Analysis 4. Verification 5. Coding 6. Testing.
AP-1 4. Agile Processes. AP-2 Agile Processes Focus on creating a working system Different attitude on measuring progress XP Scrum.
© 2006 Pearson Addison-Wesley. All rights reserved 2-1 Chapter 2 Principles of Programming & Software Engineering.
CS 1120: Computer Science II Software Life Cycle Slides courtesy of: Prof. Ajay Gupta and Prof. James Yang (format and other minor modifications by by.
1 Unified Modeling Language, Version 2.0 Chapter 2.
“Architecture” The outcome of top-level design, reflecting principal design decisions Can (and should) be modified and updated Analogous to architecture.
CS223: Software Engineering Lecture 2: Introduction to Software Engineering.
©Ian Sommerville 2006Software Engineering, 8th edition. Chapter 4 Slide 1 Software Processes.
CSCI 3428: Software Engineering Tami Meredith Chapter 6 Designing the Modules.
Lesson 1 1 LESSON 1 l Background information l Introduction to Java Introduction and a Taste of Java.
Lectures 2 & 3: Software Process Models Neelam Gupta.
From Use Cases to Implementation 1. Structural and Behavioral Aspects of Collaborations  Two aspects of Collaborations Structural – specifies the static.
From Use Cases to Implementation 1. Mapping Requirements Directly to Design and Code  For many, if not most, of our requirements it is relatively easy.
1 slc5 TTYP – C++ revisited 1 Which of the following statements are reasonable after the following statement: char* fred = new char[5]; a. fred = bill;
1 SYS366 Week 2 - Lecture Visual Modeling and Process.
Software Engineering Salihu Ibrahim Dasuki (PhD) CSC102 INTRODUCTION TO COMPUTER SCIENCE.
Advanced Software Engineering Dr. Cheng
Chapter3:Software Processes
Classifications of Software Requirements
Requirements Analysis Scenes
Systems Analysis and Design With UML 2
Designing Software for Ease of Extension and Contraction
Software Processes.
Design for Ease in Contraction and Extension
CS 1120: Computer Science II Software Life Cycle
On the Criteria To Be Used in Decomposing Systems into Modules D. L
Software Fundamentals
PPT and video are due no later than February 15, 2019
CS 1120: Computer Science II Software Life Cycle
From Use Cases to Implementation
Presentation transcript:

Designing Software for Ease of Extension and Contraction Presented by William Greenwell February 27, 2002

Volunteer Today!

About This Paper Written to address a real industry need. ICSE Most Influential Paper Award, 1991  Parnas: Was is really that influential? [1] Published in 1978, but many software professionals still don’t get it. [1] Parnas, D.L., “On ICSE’s ‘Most Influential Papers’”, ACM Software Engineering Notes, vol. 20, no 3, July 1995, pp

Software Flexibility Software should be written so that it can easily be extended and contracted. Programmers should think in terms of a family of programs, not a single product. Anticipate the likely changes, and design to be flexible toward them.

Why bother with all this?

Flexibility vs. Generality Generality – the ability of a system, without modification, to be valid for several applications. Flexibility – the ability of a design to be easily changed to accommodate new applications.

Extension & Contraction We extend software to add new features to existing versions. Why subset software?  Need to meet delivery deadline  Remove unneeded functionality  Test & debug prototypes

Inhibiting Factors Excessive information distribution Chain of data-transforming components  Typical consequence of flow-chart method Multi-function components Loops in the “uses” relation

Parnas’ Four-Step Plan 1. Identify possible subsets during requirements elicitation. 2. Exploit information hiding in interface and module descriptions. 3. Implement the system as several levels of virtual machines. 4. Make the “uses” structure a DAG.

Identifying the Subsets First identify the minimal useful subset of functionality, then add incremental extensions. Benefits:  Easier to create prototypes  System more adaptive to changes

Information Hiding Revisited 1. Identify the items likely to change. Parnas calls these secrets. 2. Locate each secret in its own module. 3. Design module interfaces that are insensitive to perceived changes. Q: If these are secrets, who/what are they being hidden from?

Virtual Machine Methodology

Defining the Uses Relation Program A uses Program B if there exist situations in which the correct functioning of A depends on the availability of a correct implementation of B. How uses differs from invokes:  A does not use B if A must only invoke B to satisfy A’s specification.  A does use B if A may implicitly invoke B (e.g. as an interrupt handler)

The Uses Hierarchy

When should A use B? A is essentially simpler because it uses B; B is not substantially more complex because it is not allowed to use A; There is a useful subset containing B and not A; and There is no conceivably useful subset containing A but not B.

Sandwiching A B1B1 B2B2 B

Advice Include subsets & extensions in the requirements document. Design software as a set of virtual machines layered on top one another. Remember that flexibility ≠ generality. In general, isolate design decisions (secrets) into their own modules.