Chapter 10: Software Engineering

Slides:



Advertisements
Similar presentations
Chapter 1: Computer Systems
Advertisements

ICT Class System Life Cycle.  Large systems development projects may involve dozens of people working over several months or even years, so they cannot.
10 Software Engineering Foundations of Computer Science ã Cengage Learning.
CS487 Software Engineering Omar Aldawud
1 Chapter 4 - Part 1 Software Processes. 2 Software Processes is: Coherent (logically connected) sets of activities for specifying, designing, implementing,
What is Software Design?. Systems Development Life- Cycle Planning Analysis Design Implementation Design.
The software process A software process is a set of activities and associated results which lead to the production of a software product. This may involve.
CHAPTER 1 SOFTWARE DEVELOPMENT. 2 Goals of software development Aspects of software quality Development life cycle models Basic concepts of algorithm.
Chapter 6: Design of Expert Systems
Chapter 10: Software Engineering Presentation slides for Java Software Solutions Foundations of Program Design Second Edition by John Lewis and William.
Chapter 1 Software Development. Copyright © 2005 Pearson Addison-Wesley. All rights reserved. 1-2 Chapter Objectives Discuss the goals of software development.
CS 501: Software Engineering
CS 501: Software Engineering
© Lethbridge/Laganière 2001 Chapter 7: Focusing on Users and Their Tasks1 7.1 User Centred Design (UCD) Software development should focus on the needs.
Chapter 1 Principles of Programming and Software Engineering.
Chapter 1 Software Engineering. Homework ► Read Section 2.2 (pages 79-98) ► Answer questions: ► 7, 8, 11, 12, & 13 on page 134. ► Answer on paper, hand.
© 2006 Pearson Addison-Wesley. All rights reserved2-1 Chapter 2 Principles of Programming & Software Engineering.
The Software Product Life Cycle. Views of the Software Product Life Cycle  Management  Software engineering  Engineering design  Architectural design.
Introduction to Software Design Chapter 1. Chapter 1: Introduction to Software Design2 Chapter Objectives To become familiar with the software challenge.
Software Life Cycle Model
Copyright © 2009 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Java Software Solutions Foundations of Program Design Sixth Edition by Lewis.
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 8 Slide 1 Software Prototyping l Rapid software development to validate requirements l.
PowerPoint Presentation for Dennis, Wixom, & Tegarden Systems Analysis and Design with UML, 3rd Edition Copyright © 2009 John Wiley & Sons, Inc. All rights.
Chapter 2 The process Process, Methods, and Tools
Chapter 1: Introduction to Systems Analysis and Design
Understand Application Lifecycle Management
CS 360 Lecture 3.  The software process is a structured set of activities required to develop a software system.  Fundamental Assumption:  Good software.
CS CS 5150 Software Engineering Lecture 3 Software Processes 2.
Chapter 11: Software Prototyping Omar Meqdadi SE 273 Lecture 11 Department of Computer Science and Software Engineering University of Wisconsin-Platteville.
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 8 Slide 1 Software Prototyping l Rapid software development to validate requirements.
Programming in Java Unit 3. Learning outcome:  LO2:Be able to design Java solutions  LO3:Be able to implement Java solutions Assessment criteria: 
Database System Development Lifecycle 1.  Main components of the Infn System  What is Database System Development Life Cycle (DSDLC)  Phases of the.
Software Development Cycle What is Software? Instructions (computer programs) that when executed provide desired function and performance Data structures.
1 Systems Analysis and Design in a Changing World, Thursday, January 18, 2007.
1 Software Development Software Engineering is the study of the techniques and theory that support the development of high-quality software The focus is.
The System and Software Development Process Instructor: Dr. Hany H. Ammar Dept. of Computer Science and Electrical Engineering, WVU.
Systems Analysis and Design in a Changing World, Fourth Edition
1 CS 501 Spring 2004 CS 501: Software Engineering Lecture 2 Software Processes.
Cmpe 589 Spring 2006 Lecture 2. Software Engineering Definition –A strategy for producing high quality software.
1 (c) elsaddik CSI 1102 Abdulmotaleb El Saddik University of Ottawa School of Information Technology and Engineering (SITE)
1-1 Software Development Objectives: Discuss the goals of software development Identify various aspects of software quality Examine two development life.
Software Prototyping Rapid software development to validate requirements.
Copyright © 2009 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Java Software Solutions Foundations of Program Design Sixth Edition by Lewis.
Data Structures Using C++ 2E
Connecting with Computer Science2 Objectives Learn how software engineering is used to create applications Learn some of the different software engineering.
© 2006 Pearson Addison-Wesley. All rights reserved2-1 Chapter 2 Principles of Programming & Software Engineering.
© 2006 Pearson Addison-Wesley. All rights reserved 2-1 Chapter 2 Principles of Programming & Software Engineering.
Java Software Solutions Lewis and Loftus Chapter 15 Copyright 1997 by John Lewis and William Loftus. All rights reserved. 1 Software Development Process.
Winter 2011SEG Chapter 11 Chapter 1 (Part 1) Review from previous courses Subject 1: The Software Development Process.
Process Asad Ur Rehman Chief Technology Officer Feditec Enterprise.
1 Program Development  The creation of software involves four basic activities: establishing the requirements creating a design implementing the code.
 Many models have been proposed to deal with the problems of defining activities and associating them with each other  The first model proposed was the.
©Ian Sommerville 2006Software Engineering, 8th edition. Chapter 4 Slide 1 Software Processes.
Chapter 1 Software Engineering Principles. Problem analysis Requirements elicitation Software specification High- and low-level design Implementation.
ANALYSIS PHASE OF BUSINESS SYSTEM DEVELOPMENT METHODOLOGY.
Software Development Process CS 360 Lecture 3. Software Process The software process is a structured set of activities required to develop a software.
Chapter 2 Principles of Programming and Software Engineering.
Your Interactive Guide to the Digital World Discovering Computers 2012 Chapter 12 Exploring Information System Development.
5. 2Object-Oriented Analysis and Design with the Unified Process Objectives  Describe the activities of the requirements discipline  Describe the difference.
Program Design. Simple Program Design, Fourth Edition Chapter 1 2 Objectives In this chapter you will be able to: Describe the steps in the program development.
1 Chapter 2 SW Process Models. 2 Objectives  Understand various process models  Understand the pros and cons of each model  Evaluate the applicability.
UML Diagrams and Software Testing Instructor: Scott Kristjanson CMPT 135 SFU Surrey, Spring 2016.
Principles of Programming & Software Engineering
About the Presentations
Chapter 3: Program Statements
CS310 Software Engineering Lecturer Dr.Doaa Sami
Chapter 10: Software Engineering
Presentation transcript:

Chapter 10: Software Engineering Presentation slides for Java Software Solutions Foundations of Program Design Third Edition by John Lewis and William Loftus Java Software Solutions is published by Addison-Wesley Presentation slides are copyright 2002 by John Lewis and William Loftus. All rights reserved. Instructors using the textbook may use and modify these slides for pedagogical purposes.

Software Engineering The quality of the software is a direct result of the process we follow to create it Chapter 10 focuses on: software development models the software life cycle and its implications linear vs. iterative development approaches goals and techniques of testing an evolutionary approach to object-oriented development a nontrivial evolutionary development example

The Software Life Cycle The overall life cycle of a program includes use and maintenance: A version of the software that is made available to the user is called a release Use Development Maintenance

Maintenance Maintenance tasks include any modifications to an existing program; it includes enhancements and defect removal The characteristics of a program that make it easy to develop also make it easy to maintain Maintenance efforts tend to far outweigh the development effort in today’s software Small increases in effort at the development stage greatly reduce maintenance tasks The goal is to minimize the overall effort required to create and to maintain the program

Development vs. Maintenance Use and Maintenance Development

Development and Maintenance Effort Development Maintenance Development Maintenance Small increases in development effort can reduce maintenance effort

Development and Maintenance Effort Often the maintainers of a program are not the program’s original developers Maintainers must be able to understand a program they didn’t design The ability to read and understand a program depends on how clearly the requirements are established how well the program is designed how well the program is implemented how well the program is documented

Software Development Models A software development model is an organized approach to creating quality software Too many programmers follow a build-and-fix approach They write a program and modify it until it is functional, without regard to system design Errors are addressed haphazardly if and as they are discovered It is not really a development model at all

The Build-and-Fix Approach Write program Modify

The Waterfall Model The waterfall model was developed in the mid 1970s Activities that must be specifically addressed during development include: Establishing clear and unambiguous requirements Creating a clean design from the requirements Implementing the design Testing the implementation Originally it was proposed as a linear model, without backtracking It is a nice goal, but it is generally unrealistic

The Waterfall Model Establish requirements Create design Implement code Test system

Iterative Development Iterative development allows the developer to cycle through the different development stages It is essentially the waterfall model with backtracking However backtracking should not be used irresponsibly It should be used as a technique available to the developer to deal with unexpected problems that may arise in later stages of development

An Iterative Development Process Establish requirements Create design Implement code Test system

Testing The results of each stage should be evaluated carefully prior to going on to the next stage Before moving on to the design, for example, the requirements should be evaluated to ensure completeness, consistency, and clarity A design evaluation should ensure that each requirement was addressed adequately

Testing Techniques A design or an implementation may be evaluated during a walkthrough The goal of a walkthrough is to identify problems, not to solve them

Testing Techniques Generally, the goal of testing is to find errors Often it is called defect testing A good test uncovers problems in a program A test case includes a set of inputs user actions or other initial conditions expected output It is not feasible to test every possible case

Black-Box Testing Black-box testing maps a set of specific inputs to a set of expected outputs An equivalence category is a collection of input sets Two input sets belong to the same equivalence category if there is reason to believe that if one works, it will work for the other Therefore testing one input set essentially tests the entire category

White-Box Testing White-box testing also is referred to as glass-box testing It focuses on the internal logic such as the implementation of a method Statement coverage guarantees that all statements in a method are executed Condition coverage guarantees that all paths through a method are executed

Prototypes A prototype is a program created to explore a particular concept Prototyping is more useful, time-effective, and cost-effective than merely acting on an assumption that later may backfire Usually a prototype is created to communicate to the client: a particular task the feasibility of a requirement a user interface It is a way of validating requirements

Throw-away vs. Evolutionary Prototypes A “quick and dirty” prototype to test an idea or a concept is called a throw-away prototype Throw-away prototypes should not be incorporated into final systems Because it is designed more carefully, an evolutionary prototype can be incorporated into the final system Evolutionary prototypes provide a double benefit, but at a higher cost

Evolutionary Development Evolutionary development divides the design process into architectural design - primary classes and interaction detailed design - specific classes, methods, and algorithms This allows us to create refinement cycles Each refinement cycle focuses on one aspect of the system As each refinement cycle is addressed, the system evolves

An Evolutionary Development Model Establish requirements Architectural design Establish refinement scope Unit and integration test Implementation System test Identify classes & objects Identify relationships Detailed design

Refinement Cycle First, we establish the refinement scope to define the specific nature of the next refinement For example: the user interface the feasibility of a particular requirement utility classes for general program support Object-oriented programming is well suited to this approach Choosing the most appropriate next refinement is important and requires experience

Refinement Cycle Next, we identify classes and objects that relate to the current refinement Look at the nouns in the requirements document Candidates categories include physical objects people places containers occurrences information stores Categories may overlap Consider reusing existing classes

Refinement Cycle Next we identify relationships among classes general association (“uses”) aggregation (“has-a”) inheritance (“is-a”) Associated objects use each other for the services they provide Aggregation, also called composition, permits one object to become part of another object Cardinality describes the numeric relationship between the objects For example, a car might have four wheels associated with it

Refinement Cycle Inheritance, discussed in detail in Chapter 7, may lead to the creation of a new class whose sole purpose is to gather common data and common methods in one place Relationships can be described using UML class diagrams

Refinement Cycle Finally, a refinement cycle includes detailed design, implementation, and testing All the members of each class need to be defined Each class must be implemented (coded) Stubs sometimes are created to permit the refinement code to be tested A unit test focuses on one particular component, such as a method or a class An integration test focuses on the interaction between components

The PaintBox Project Now we explore the evolutionary development model using a project larger than any we’ve seen so far The PaintBox program allows the user to create drawings with various shapes and colors After establishing the requirements, the following refinement steps are established: create the basic user interface allow the user to draw and fill shapes and to change color allow the user to select, to move, and to modify shapes allow the user to cut, copy, and paste shapes allow the user to save and to reload drawings allow the user to begin a new drawing at any time

The PaintBox Project (Figure 10.8 here)

The PaintBox Project Discussions with the client lead to additional requirements which are integrated into the requirements document Next the architectural design is prepared Refinement steps are determined the basic user interface drawing basic shapes using different stroke colors cutting, copying, and pasting shapes selecting, moving, and filling shapes modifying the dimensions of shapes saving and reloading drawings final touches such as the splash screen

The PaintBox Project The order of refinements is determined (Figure 10.9 here)

PaintBox Refinement #1 The first refinement establishes the basic user interface (Figure 10.10 here)

PaintBox Refinement #1 (Editor: please remove the underlining of “(page xxx)”) See PaintBox.java (page xxx) See PaintFrame.java (page xxx) See ButtonBar.java (page xxx) See DrawingPanel.java (page xxx)

PaintBox.java

PaintFrame.jave

ButtonBar.java

DrawingPanel.java

PaintBox Refinement #2 The second refinement allows the user to draw shapes and change colors (Figure 10.12 here)

(Editor: please remove the underlining of “(page xxx)”) See PaintBox.java (page xxx) See PaintFrame.java (page xxx) See ButtonBar.java (page xxx) See DrawingPanel.java (page xxx) See Shape.java (page xxx) See Line.java (page xxx) See BoundedShape.java (page xxx) See Rect.java (page xxx) See Oval.java (page xxx) See Poly.java (page xxx)

PaintBox.java

PaintFrame.java

ButtonBar.java

DrawingPanel.java

Shape.java

Line.java

BoundedShape.java

Rect.java

Oval.java

Poly.java

Remaining PaintBox Refinements The full implementation of the first two refinements can be downloaded The remaining five refinements are left as programming projects (Figure 10.14 here)

Summary Chapter 10 has focused on: software development models the software life cycle and its implications linear vs. iterative development approaches goals and techniques of testing an evolutionary approach to object-oriented development a nontrivial evolutionary development example