Software Engineering: A Hands-On Approach

Roger Y. Lee

Software Engineering:A Hands-On Approach

Roger Y. LeeSoftware Engineering and Information

Technology InstituteCentral Michigan UniversityMount Pleasant, MIUSA

ISBN 978-94-6239-005-8 ISBN 978-94-6239-006-5 (eBook)DOI 10.2991/978-94-6239-006-5

Library of Congress Control Number: 2013938755

� Atlantis Press and the author 2013This book, or any parts thereof, may not be reproduced for commercial purposes in any form or by anymeans, electronic or mechanical, including photocopying, recording or any information storage andretrieval system known or to be invented, without prior permission from the Publisher.

Printed on acid-free paper

I dedicate this book to my wife Kay and mychildren Eric, Joseph, and Ryan

Preface

Theme

Developing efficient software in a timely manner continues to be a struggle formany students and software developers in the real world. As both the size andscope of software systems continues to grow, the complexity of the solutionsrequired to fill the needs of clients, too, increases. Software development hasexceeded the mere practice of programming to involve much more planning,analyzing, designing, and delivering; as a result, students must learn how toapproach software projects and complete them from start to finish. In light of thistrend, a plethora of tools and solutions to any given problem now exists, anddevelopers must know when and how to appropriately use these tools to accom-plish the various tasks that come with software engineering projects.

It is not unusual, though, for students to complete many courses only havingapplied lessons to small problem sets that have limited complexity and freedom. Itis also not uncommon for students to learn the science of software engineeringwithout significant hands-on experience. This book aims to ameliorate such gapsin the education of those studying Software Engineering. It recognizes the need toteach key principles, but to also allow the students to gain deeper knowledge thatonly direct practice can teach. The project-based approach taken by this bookreflects the needs observed amongst the students who will one day be a part ofteams completing large software projects.

Tools

While many tools for software engineering exist, this book uses some of the mostwidely used and effective tools available. Most significantly, the object-orientedparadigm and its fundamental principles are used as the primary way to organizeand design software. Introduced in phases, the completion of the hands-on projectlaid out in this book uses various tools for the completion of each phase built onthis foundation. UML (Unified Modeling Language), for example, is a choice tool

vii

used to model software and is put into practice by the student for their hands-onproject. Also extending the object-oriented paradigm are key object-orienteddesign patterns and analysis tools that will aid the student during requirementsspecification, system design, and implementation phases of the project. Lastly,standard documentation for each project phase is presented, exposing students toorganizational tools often lacking by those new to software engineering.

Principles

In order to better teach software engineering from a practical approach, this bookis written with the following principles as a foundation:

Hands-On Learning: Some skills applicable to software engineering are onlylearned by being fully engrossed in a project with others. Hands-on learning isvery important to bridge the gap between academia and the real world as it givesstudents the chance to learn from mistakes and successes. Professional skills thatare both useful and marketable will be learned by students by working with groupmembers, interacting with clients, and applying the tools and techniques taughtthroughout the book.

Teamwork: The complex software systems of today do not allow any onedeveloper to create solutions on their own; hence, working in teams is a necessaryskill all students must learn and experience. Teamwork requires students to worktogether to define goals and responsibilities, organize tasks, and provide opencommunication and feedback. These traits of successful teamwork are just asimportant as the technical knowledge acquired in this book.

Problem Solving: Every software project begins with a problem that must bedefined and solved. The solution to such problems will inherently bring aboutother subsequent problems along the way. A good developer, while knowing theavailable approaches and methods, must also know how to solve problems thatwill likely arise as software engineering projects move from phase to phase. Thepractice of software engineering is always changing solutions to improve toaccommodate the endless number of potential problems and ways to solve them.

The Book

This book covers the process, core concepts, and tools of software engineering,from a primarily object-oriented approach, with a hands-on project as the back-bone to support the learning and skill development of the student. Divided intoparts, the first set of chapters introduce software engineering principles before thesubsequent chapters describe the development of a software project from start tofinish. A more detailed description of this book’s parts and chapters is givenbelow:

viii Preface

Part I: What Is Software Engineering?

In this first part of the text, a brief history and introduction into the science ofsoftware engineering and object-oriented principles used in its process aredescribed.

Chapter 1: In this chapter, Introduction to Software Engineering, a summary ofthe definition and need for software engineering is laid out in a historical context;the complexity of software and lack of success rates are detailed as support. Thepeople, tasks, and activities involved in software engineering are also described toprovide evidence that software engineering is not merely limited to programming.Lastly, the life cycles of the development process are depicted.

Chapter 2: In Object-Oriented Concepts, object-orientation is introduced andunderlying concepts such as classes, modularity, inheritance, and abstraction arediscussed. This chapter defines key ideas used by more complex tasks describedlater in this book.

Chapter 3: Entitled Modeling with UML, this chapter describes and depicts thevariety of diagrams the Unified Modeling Language provides developers. Class,use case, sequence, component diagrams, and others are discussed as well as thebasic parts and association types used by many of them.

Part II: The Software Engineering Project

Part II of this book covers the various phases common to software engineeringprojects. From defining the problem and requirements to implementing designsand models, these chapters describe the tools and methods used by developers tosystematically complete a software project.

Chapter 4: Starting the Project provides an overview of the project and non-technical activities such as scheduling, communicating, handling problems, anddocumenting. The skills covered in this section are practical as they help teams tostay on task, work with each other, and quickly adapt to change.

Chapter 5: The topic of this chapter, Requirements Elicitation, is the process ofdefining the different types of requirements that exist for software projects. First,what exactly a requirement is and the difference between functional versus non-functional, and domain requirements versus constraints is described. Next, themethods of requirements elicitation are discussed as well as the issues and prob-lems concerning requirements. Finally, the production of use case models fromrequirements is outlined.

Chapter 6: This chapter, Object-Oriented Analysis, uses object-oriented con-cepts to cover the analysis phase of the software development process. In thisintermediary phase before design, system requirements are evaluated and refinedby identifying objects and their relations, identifying use cases, developing

Preface ix

scenarios, diagramming, and more. The process and issues in analysis are dis-cussed and demonstrated in this chapter.

Chapter 7: In System Design, a chapter covering the transition from analysis todesign, different design approaches are detailed for the reader. After learning thecategories of system design, approaches detailed include function-oriented,structure-oriented, and finally object-oriented. The key design concepts for eachapproach are covered and differences between them are analyzed. This phase ofthe process is important to learn as it allows developers to define how variouscomponents will provide functionality to the system.

Chapter 8: The Object-Oriented Design chapter is concerned with filling thegaps left by analysis and system design. It describes how object design preciselydefines objects, subsystems, and constraints to be used by the software to provide adetailed object model. This stage is the important precursor to implementation inthe object-oriented paradigm.

Chapter 9: This chapter, Implementation, is about the last phase of the systemdevelopment life cycle. Described in its contents is the process of planning andexecuting system design plans using the various tasks of implementation. Thesetasks are divided amongst the different roles and responsibilities of the stake-holders involved. Furthermore, this chapter uncovers some of the standards forintegration, code reuse, language choice, and issues arising from implementation.

Chapter 10: The Testing chapter tells students about the ins and outs of softwaretesting. First, the importance of testing is highlighted by describing its importantrole in the creation of correct software. Then, this chapter details how to plan andmanage tests, develop tests, and utilize tests. The appropriate tests to use forcertain cases are laid out in this chapter as well. The importance of testing is alsohighlighted as a means for determining the readiness of a software to be released.

Chapter 11: Project Wrap-up, Delivery, and Maintenance is a chapter on theimprovement of project management and definition of success criteria. Studentswill learn about the purpose and importance of project termination and release,wrap-up and presentation to clients, and post-release maintenance as well as howthese phases fit into the software development life cycle.

Chapter 12: The chapter Software Metrics and Measurements is a description ofthe theory and practice of establishing and using metrics of many varieties. Metricsare defined and their importance in measuring software quality are detailed in thesections of this chapter. Many broads types of metrics, including design metrics,object-oriented metrics, and project metrics are discussed in relation to theappropriate phases of development they are used in. Similarly, the benefits anddrawbacks that inherently exist are detailed.

Chapter 13: Perhaps the most important chapter, Hands-On Software Engi-neering Project provides a complete guideline for completing an academic soft-ware project. Presented in order of phase, this chapter clearly introduces thecomplete software development life cycle and describes important tools to be usedto complete the project.

x Preface

Courses

Geared towards students with a background in an object-oriented language such asJava or C??, this book is intended for courses in introductory software engi-neering with a semester-long project. This book can be used for other courses,however, with limited or altered use of the book’s parts and chapters.

Project-based course: For a project-based course in software engineering, werecommend using the book nearly as-is, following the chapters in the order pro-vided. This provides a smooth transition between concepts and practical use aswell as between phases of the development life-cycle. A semester-long projectshould accompany course instruction and students should practice models, docu-mentation, and other tools detailed by the book, especially those in Chap. 13.

Introductory course: For a course introducing the concepts of object-orientedprogramming, we suggest primary attention being paid to the first three chapters ofthis book. Also, various sections of other chapters can be used as necessary tohighlight practical uses of material covered in these first three chapters. Forexample, parts of Chap. 7 cover object-oriented design concepts that rest onprinciples of the object-oriented paradigm covered in Chap. 2.

Management course: For a course geared towards project management, focusshould be placed primarily on Chaps. 4, 5, 9, 10, 11 and 13 as these covers aspectsof overall management such as team work, communication, working with clients,project delivery, etc.

Technical course: For students learning object-orientation and softwaredevelopment beyond and introductory level, this books provides a core set ofchapters teaching concepts such as modeling with UML, object-oriented design,implementation, and testing. In this case, Chaps. 2, 3, 6–9 and 12 are worthemphasizing.

Support Materials

To better the learning and teaching experience of those using this software engi-neering textbook, support materials have been provided to enhance courses in thesubject. These include:

• PowerPoint presentations for each chapter of the text.• Multiple choice tests and answers covering the topics discussed in the book.

For more information and support you may contact the author, Dr. Roger Lee, atlee1ry@cmich.edu.

Preface xi

Acknowledgments

There are many individuals and organizations to thank for their dedication andassistance in the creation of this book. Whether it be their influence on my work,support of this endeavor, or review of this text, gratitude and appreciation is due toall of those who helped.

I thank the following colleagues and friends for their help with the completionof this book:

• Chia-Chu Chiang, University of Arkansas–Little Rock• Dale Karolak, Dart Container Corportation• Justin Zablocki, Software Engineering and Information Technology Institute• Lawrence Chung, University of Texas–Dallas

Lastly, I would also like to thank Central Michigan University for its continuedsupport of my research and endeavors. I appreciate this opportunity to contributeto the field of software engineering and, hence, shape its growth. It is my hope thatthis textbook will be used to better the knowledge and practice of softwareengineering amongst students and professionals. Thank you again to all.

xiii

Contents

Part I What is Software Engineering?

1 Introduction to Software Engineering . . . . . . . . . . . . . . . . . . . . . 31.1 Why Do We Need Software Engineering? . . . . . . . . . . . . . . 3

1.1.1 Brief Historical Summary . . . . . . . . . . . . . . . . . . . 31.1.2 Success Rate of Software. . . . . . . . . . . . . . . . . . . . 41.1.3 The Complexity of Software . . . . . . . . . . . . . . . . . 4

1.2 The Software Engineering Project. . . . . . . . . . . . . . . . . . . . 51.2.1 Defining the Software Engineering Project . . . . . . . 51.2.2 Who is Involved in a Software Engineering

Project? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.3 Software Engineering Activities . . . . . . . . . . . . . . . . . . . . . 6

1.3.1 Planning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.3.2 Problem Solving . . . . . . . . . . . . . . . . . . . . . . . . . . 71.3.3 Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.3.4 Communication . . . . . . . . . . . . . . . . . . . . . . . . . . 81.3.5 Using and Managing Resources . . . . . . . . . . . . . . . 91.3.6 Reaching Milestones and Producing Deliverables . . . 91.3.7 Maintaining a Product . . . . . . . . . . . . . . . . . . . . . . 9

1.4 Software Engineering is Not Limited to Programming . . . . . 101.4.1 Computer Science Related . . . . . . . . . . . . . . . . . . . 101.4.2 Business Related. . . . . . . . . . . . . . . . . . . . . . . . . . 101.4.3 Psychology Related. . . . . . . . . . . . . . . . . . . . . . . . 111.4.4 Engineering Related . . . . . . . . . . . . . . . . . . . . . . . 11

1.5 Software Life-Cycles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.5.1 Understanding the Software Development Process . . 111.5.2 Evaluation of the Waterfall Model . . . . . . . . . . . . . 121.5.3 Evaluation of the Spiral Model. . . . . . . . . . . . . . . . 14

1.6 Chapter Conclusion and Summary . . . . . . . . . . . . . . . . . . . 151.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

xv

2 Object-Oriented Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.1 What is an Object? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.2 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.2.1 Classes Versus Objects . . . . . . . . . . . . . . . . . . . . . 202.2.2 The Class-Object Hierarchy . . . . . . . . . . . . . . . . . . 212.2.3 Why Use Objects and Classes?. . . . . . . . . . . . . . . . 21

2.3 Modularity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.3.1 Reuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.3.2 Encapsulation and Information Hiding. . . . . . . . . . . 232.3.3 Access Levels . . . . . . . . . . . . . . . . . . . . . . . . . . . 242.3.4 Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.4 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.4.1 Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.4.2 Overriding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.4.3 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.5 Abstraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322.5.1 Abstract Classes . . . . . . . . . . . . . . . . . . . . . . . . . . 322.5.2 Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342.5.3 Generic Components . . . . . . . . . . . . . . . . . . . . . . . 352.5.4 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

2.6 Chapter Conclusion and Summary . . . . . . . . . . . . . . . . . . . 372.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3 Modeling with UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393.1 Introduction to the Unified Modeling Language . . . . . . . . . . 39

3.1.1 What is Modeling? . . . . . . . . . . . . . . . . . . . . . . . . 403.1.2 What is the Unified Modeling Language? . . . . . . . . 40

3.2 Object, Classes and Actors. . . . . . . . . . . . . . . . . . . . . . . . . 413.2.1 Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413.2.2 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423.2.3 Actors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.3 Associations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443.3.1 Aggregation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443.3.2 Generalization . . . . . . . . . . . . . . . . . . . . . . . . . . . 453.3.3 Dependency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453.3.4 Uses and Extends . . . . . . . . . . . . . . . . . . . . . . . . . 453.3.5 Multiplicity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.4 Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473.4.1 Class Diagram . . . . . . . . . . . . . . . . . . . . . . . . . . . 473.4.2 Use Case Diagram . . . . . . . . . . . . . . . . . . . . . . . . 483.4.3 Sequence Diagram . . . . . . . . . . . . . . . . . . . . . . . . 493.4.4 State Diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.4.5 Activity Diagram . . . . . . . . . . . . . . . . . . . . . . . . . 51

xvi Contents

3.4.6 Collaboration Diagram . . . . . . . . . . . . . . . . . . . . . 533.4.7 Component Diagram . . . . . . . . . . . . . . . . . . . . . . . 543.4.8 Deployment Diagram . . . . . . . . . . . . . . . . . . . . . . 54

3.5 Interfaces, Notes, and Packages . . . . . . . . . . . . . . . . . . . . . 543.5.1 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.5.2 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553.5.3 Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

3.6 Chapter Conclusion and Summary . . . . . . . . . . . . . . . . . . . 563.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

Part II The Software Engineering Project

4 Starting the Project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.1 Overview of Project and Planning. . . . . . . . . . . . . . . . . . . . 61

4.1.1 Identifying the Purpose of the Project . . . . . . . . . . . 624.1.2 Identifying the Deliverables of the Project . . . . . . . . 634.1.3 Cost Estimation . . . . . . . . . . . . . . . . . . . . . . . . . . 63

4.2 Staying on Task and on Schedule . . . . . . . . . . . . . . . . . . . . 644.2.1 Deadlines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654.2.2 Work Breakdown Structures. . . . . . . . . . . . . . . . . . 654.2.3 Gantt Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

4.3 Communicating Ideas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 674.3.1 Assessing Employee Skill Levels . . . . . . . . . . . . . . 694.3.2 Team Organization and Role Assignment . . . . . . . . 704.3.3 Project Communication . . . . . . . . . . . . . . . . . . . . . 71

4.4 Handling Problems and Change . . . . . . . . . . . . . . . . . . . . . 724.5 Document Format Specification . . . . . . . . . . . . . . . . . . . . . 734.6 Software Project Management Plan. . . . . . . . . . . . . . . . . . . 764.7 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 784.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

5 Requirements Elicitation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 815.1 What are Requirements? . . . . . . . . . . . . . . . . . . . . . . . . . . 81

5.1.1 Functional Requirements . . . . . . . . . . . . . . . . . . . . 815.1.2 Non-Functional Requirements or Constraints . . . . . . 825.1.3 Domain Requirements . . . . . . . . . . . . . . . . . . . . . . 83

5.2 Requirement Elicitation . . . . . . . . . . . . . . . . . . . . . . . . . . . 835.2.1 Communicating with the Client . . . . . . . . . . . . . . . 835.2.2 Gathering Information . . . . . . . . . . . . . . . . . . . . . . 845.2.3 Issues in Requirement Elicitation . . . . . . . . . . . . . . 85

Contents xvii

5.3 Identifying the Requirements . . . . . . . . . . . . . . . . . . . . . . . 865.3.1 Identifying the Functional Requirements . . . . . . . . . 865.3.2 Identifying the Non-Functional Requirements. . . . . . 875.3.3 Identifying the Application Domain . . . . . . . . . . . . 89

5.4 Common Problems Concerning Requirements . . . . . . . . . . . 905.4.1 Problems of Scope . . . . . . . . . . . . . . . . . . . . . . . . 905.4.2 Problems of Understanding . . . . . . . . . . . . . . . . . . 915.4.3 Problems of Volatility . . . . . . . . . . . . . . . . . . . . . . 93

5.5 Validating the Requirements . . . . . . . . . . . . . . . . . . . . . . . 935.6 Producing the Use Case Model. . . . . . . . . . . . . . . . . . . . . . 94

5.6.1 Structuring Use Cases . . . . . . . . . . . . . . . . . . . . . . 955.6.2 Use Case Guidelines . . . . . . . . . . . . . . . . . . . . . . . 95

5.7 The Software Requirements Specification Document . . . . . . 965.8 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 985.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

6 Object-Oriented Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1036.1 Introduction to Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . 103

6.1.1 What is Object-Oriented Analysis? . . . . . . . . . . . . . 1046.2 Requirements Specification and the Specification

Document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1056.2.1 Evaluating Requirements Specification . . . . . . . . . . 1066.2.2 Refining Requirements Specification

Through Prototyping . . . . . . . . . . . . . . . . . . . . . . . 1076.2.3 Verifying Requirements Specification . . . . . . . . . . . 108

6.3 Analysis Modeling Concepts . . . . . . . . . . . . . . . . . . . . . . . 1096.3.1 Analysis Object Models. . . . . . . . . . . . . . . . . . . . . 1106.3.2 Entity, Boundary, and Control Objects . . . . . . . . . . 111

6.4 Scenario-Based Modeling . . . . . . . . . . . . . . . . . . . . . . . . . 1126.5 Class-Based Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1136.6 Analysis Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

6.6.1 Identifying Entity, Boundary,and Control Objects . . . . . . . . . . . . . . . . . . . . . . . 115

6.6.2 Identifying Use Cases . . . . . . . . . . . . . . . . . . . . . . 1166.6.3 Scenario Development. . . . . . . . . . . . . . . . . . . . . . 1186.6.4 Modeling the System . . . . . . . . . . . . . . . . . . . . . . 1196.6.5 Class Diagrams. . . . . . . . . . . . . . . . . . . . . . . . . . . 1196.6.6 Use Case Diagrams. . . . . . . . . . . . . . . . . . . . . . . . 120

6.7 Issues in Object-Oriented Analysis . . . . . . . . . . . . . . . . . . . 1216.8 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 1226.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

xviii Contents

7 System Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1257.1 Categories of System Design . . . . . . . . . . . . . . . . . . . . . . . 126

7.1.1 Global-Based Systems . . . . . . . . . . . . . . . . . . . . . . 1267.1.2 Group-Based Systems . . . . . . . . . . . . . . . . . . . . . . 1267.1.3 Local-Based Systems . . . . . . . . . . . . . . . . . . . . . . 127

7.2 Function-Oriented Approach . . . . . . . . . . . . . . . . . . . . . . . 1277.3 Structure-Oriented Approach . . . . . . . . . . . . . . . . . . . . . . . 128

7.3.1 Process-Oriented Approach . . . . . . . . . . . . . . . . . . 1287.3.2 Data-Oriented Approach . . . . . . . . . . . . . . . . . . . . 1287.3.3 Creating the Data Dictionary . . . . . . . . . . . . . . . . . 129

7.4 Object-Oriented Approach . . . . . . . . . . . . . . . . . . . . . . . . . 1297.4.1 Component-Based Design . . . . . . . . . . . . . . . . . . . 1317.4.2 Components and Objects . . . . . . . . . . . . . . . . . . . . 1317.4.3 Component Models . . . . . . . . . . . . . . . . . . . . . . . . 1317.4.4 The Component Concept . . . . . . . . . . . . . . . . . . . . 132

7.5 Structured Versus Object-Oriented System Design . . . . . . . . 1347.5.1 Modularity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1347.5.2 Top-Down Versus Bottom-Up Design . . . . . . . . . . . 1357.5.3 Reusability. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

7.6 Object-Oriented Design Concepts . . . . . . . . . . . . . . . . . . . . 1367.6.1 Abstractions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1367.6.2 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1377.6.3 Design Patterns. . . . . . . . . . . . . . . . . . . . . . . . . . . 1377.6.4 Modularity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1377.6.5 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1387.6.6 Refinement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1387.6.7 Class Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1397.6.8 Subsystems and Classes. . . . . . . . . . . . . . . . . . . . . 1397.6.9 Services and Subsystem Interfaces . . . . . . . . . . . . . 1407.6.10 Coupling and Cohesion . . . . . . . . . . . . . . . . . . . . . 141

7.7 Architectural System Design . . . . . . . . . . . . . . . . . . . . . . . 1417.7.1 Data Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1427.7.2 Organization and Refinement . . . . . . . . . . . . . . . . . 143

7.8 Issues in Object-Oriented Analysis . . . . . . . . . . . . . . . . . . . 1437.9 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 1447.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

8 Object-Oriented Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1478.1 Overview of Object-Oriented Design. . . . . . . . . . . . . . . . . . 147

8.1.1 First Steps to OOD . . . . . . . . . . . . . . . . . . . . . . . . 1498.1.2 Activities in OOD. . . . . . . . . . . . . . . . . . . . . . . . . 150

Contents xix

8.2 Object-Oriented Design Concepts . . . . . . . . . . . . . . . . . . . . 1518.2.1 Functional and Non-Functional Requirements . . . . . 1518.2.2 Types, Signatures and Visibility . . . . . . . . . . . . . . . 1518.2.3 Object Contracts: Invariants, Preconditions

and Postconditions . . . . . . . . . . . . . . . . . . . . . . . . 1528.3 Reuse Concepts: Objects and Design Patterns . . . . . . . . . . . 152

8.3.1 Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1528.3.2 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1538.3.3 The Liskov Substitution Principle . . . . . . . . . . . . . . 153

8.4 Specifying Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1538.5 Interface Specification Concepts . . . . . . . . . . . . . . . . . . . . . 154

8.5.1 Class Implementer . . . . . . . . . . . . . . . . . . . . . . . . 1548.5.2 Object Constraint Language . . . . . . . . . . . . . . . . . . 1568.5.3 OCL Collections. . . . . . . . . . . . . . . . . . . . . . . . . . 1608.5.4 OCL Quantifiers . . . . . . . . . . . . . . . . . . . . . . . . . . 161

8.6 Managing Object Design . . . . . . . . . . . . . . . . . . . . . . . . . . 1618.6.1 Documenting Object Design. . . . . . . . . . . . . . . . . . 1618.6.2 Roles in OOD . . . . . . . . . . . . . . . . . . . . . . . . . . . 1628.6.3 The Unified Process . . . . . . . . . . . . . . . . . . . . . . . 163

8.7 Objects as Models. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1638.7.1 Forward Engineering . . . . . . . . . . . . . . . . . . . . . . . 1648.7.2 Reverse Engineering . . . . . . . . . . . . . . . . . . . . . . . 164

8.8 Design Tips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1648.9 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 1658.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

9 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1699.1 Introduction to the Implementation Phase . . . . . . . . . . . . . . 169

9.1.1 Implementation Standards . . . . . . . . . . . . . . . . . . . 1709.1.2 Library Utilization and Management . . . . . . . . . . . . 1719.1.3 Version Controls. . . . . . . . . . . . . . . . . . . . . . . . . . 171

9.2 Tasks and Activities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1729.2.1 Implementation Updates . . . . . . . . . . . . . . . . . . . . 1729.2.2 New Model Training Plan . . . . . . . . . . . . . . . . . . . 1739.2.3 Data Entry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1749.2.4 Post-Implementation Assessment . . . . . . . . . . . . . . 1749.2.5 Documenting Updates . . . . . . . . . . . . . . . . . . . . . . 174

9.3 Roles and Responsibilities . . . . . . . . . . . . . . . . . . . . . . . . . 1749.4 Deliverables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

9.4.1 Delivered System . . . . . . . . . . . . . . . . . . . . . . . . . 1759.4.2 Change Notice . . . . . . . . . . . . . . . . . . . . . . . . . . . 1759.4.3 Version Description . . . . . . . . . . . . . . . . . . . . . . . 1759.4.4 Post-Implementation Review . . . . . . . . . . . . . . . . . 176

xx Contents

9.5 Post-Implementation Considerations . . . . . . . . . . . . . . . . . . 1789.6 Language Choice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1789.7 Development Paradigms . . . . . . . . . . . . . . . . . . . . . . . . . . 179

9.7.1 Component-Based Development . . . . . . . . . . . . . . . 1799.7.2 Extreme Programming. . . . . . . . . . . . . . . . . . . . . . 179

9.8 Code Style Standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1809.9 Code Reuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1819.10 Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

9.10.1 Top-Down Integration . . . . . . . . . . . . . . . . . . . . . . 1829.10.2 Bottom-Up Integration. . . . . . . . . . . . . . . . . . . . . . 1839.10.3 Sandwich Integration. . . . . . . . . . . . . . . . . . . . . . . 1849.10.4 Integration of Object-Oriented Products. . . . . . . . . . 1859.10.5 Integration Management . . . . . . . . . . . . . . . . . . . . 185

9.11 Implementation Workflow . . . . . . . . . . . . . . . . . . . . . . . . . 1859.11.1 Challenges of Implementation Workflow . . . . . . . . . 1869.11.2 Metrics of Implementation Workflow . . . . . . . . . . . 186

9.12 Managing Implementation . . . . . . . . . . . . . . . . . . . . . . . . . 1879.12.1 Documenting Transformations . . . . . . . . . . . . . . . . 1879.12.2 Assigning Responsibilities . . . . . . . . . . . . . . . . . . . 188

9.13 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 1889.14 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

10 Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19110.1 Introduction to Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

10.1.1 Objective of Testing . . . . . . . . . . . . . . . . . . . . . . . 19210.1.2 Testing Concepts and Theory . . . . . . . . . . . . . . . . . 19210.1.3 Test Planning . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

10.2 Quality and Internal Controls . . . . . . . . . . . . . . . . . . . . . . . 19410.2.1 Assuring Quality Software . . . . . . . . . . . . . . . . . . . 19410.2.2 Managerial Independence. . . . . . . . . . . . . . . . . . . . 195

10.3 Testing Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19510.4 Non-Execution Based Testing . . . . . . . . . . . . . . . . . . . . . . 196

10.4.1 Walkthrough . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19610.4.2 Managing Walkthroughs . . . . . . . . . . . . . . . . . . . . 19610.4.3 Inspections. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

10.5 Things to be Tested . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19810.5.1 Utility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19910.5.2 Reliability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19910.5.3 Robustness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19910.5.4 Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20010.5.5 Correctness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20010.5.6 Usability Testing . . . . . . . . . . . . . . . . . . . . . . . . . 20010.5.7 System Integration . . . . . . . . . . . . . . . . . . . . . . . . 201

Contents xxi

10.6 Mathematically Proving Correctness . . . . . . . . . . . . . . . . . . 20110.7 Execution-Based Testing . . . . . . . . . . . . . . . . . . . . . . . . . . 202

10.7.1 Who Should Perform Execution-Based Testing? . . . . 20310.8 Levels of Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203

10.8.1 Systems Testing . . . . . . . . . . . . . . . . . . . . . . . . . . 20410.8.2 Web Application Testing . . . . . . . . . . . . . . . . . . . . 204

10.9 Unit Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20510.10 Acceptance Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

10.10.1 Alpha Testing. . . . . . . . . . . . . . . . . . . . . . . . . . . . 20610.10.2 Beta Testing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

10.11 UML Model Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20910.12 Testing for Object-Oriented Systems . . . . . . . . . . . . . . . . . . 21110.13 Testing in a Box. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

10.13.1 Black-Box Testing . . . . . . . . . . . . . . . . . . . . . . . . 21210.13.2 White-Box Testing . . . . . . . . . . . . . . . . . . . . . . . . 212

10.14 Testing Alternatives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21310.15 When to Release the Software . . . . . . . . . . . . . . . . . . . . . . 21310.16 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 21410.17 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

11 Project Wrap-Up, Delivery, and Maintenance . . . . . . . . . . . . . . . 21711.1 Project Management and Success Criteria . . . . . . . . . . . . . . 217

11.1.1 Define Project Success Criteria. . . . . . . . . . . . . . . . 21711.1.2 Define Business Objectives . . . . . . . . . . . . . . . . . . 21811.1.3 Identify Project Constraints . . . . . . . . . . . . . . . . . . 22211.1.4 Derive Project Success Criteria. . . . . . . . . . . . . . . . 223

11.2 Project Termination and Release. . . . . . . . . . . . . . . . . . . . . 22511.3 Project Wrap-Up and Result Presentation . . . . . . . . . . . . . . 225

11.3.1 Postmortem Review . . . . . . . . . . . . . . . . . . . . . . . 22611.3.2 Release Management. . . . . . . . . . . . . . . . . . . . . . . 227

11.4 Development and Maintenance . . . . . . . . . . . . . . . . . . . . . . 22911.5 Why Post-Delivery Maintenance is Necessary . . . . . . . . . . . 22911.6 What is Required of Post-Delivery Maintenance

Programmers? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22911.7 Managing Post-Delivery Maintenance . . . . . . . . . . . . . . . . . 230

11.7.1 Defect Reports . . . . . . . . . . . . . . . . . . . . . . . . . . . 23011.7.2 Authorizing Changes to the Product . . . . . . . . . . . . 23111.7.3 Ensuring Maintainability . . . . . . . . . . . . . . . . . . . . 23111.7.4 Problem of Repeated Maintenance . . . . . . . . . . . . . 231

11.8 Maintenance of Object-Oriented Software . . . . . . . . . . . . . . 23211.9 Post-Delivery Maintenance Skill Versus

Development Skills . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23211.10 Reverse Engineering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

xxii Contents

11.11 Agile Modeling and Extreme Programming . . . . . . . . . . . . . 23411.12 Testing During Post-Delivery Maintenance . . . . . . . . . . . . . 23511.13 Metrics and Challenges of Post-Delivery Maintenance . . . . . 23511.14 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 23611.15 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

12 Software Metrics and Measurements. . . . . . . . . . . . . . . . . . . . . . 23912.1 Theory and Practice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

12.1.1 Challenges Using and Understanding Metrics. . . . . . 24012.1.2 Properties of a Good Measurement or Metric . . . . . . 24112.1.3 Etiquette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24112.1.4 Private Versus Public Metrics . . . . . . . . . . . . . . . . 24212.1.5 Baseline Measurements . . . . . . . . . . . . . . . . . . . . . 24212.1.6 Attributes of a Good Metric . . . . . . . . . . . . . . . . . . 24312.1.7 Establishing Uniform Measures . . . . . . . . . . . . . . . 244

12.2 Quality Metrics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24412.2.1 Garvin’s Quality Dimensions . . . . . . . . . . . . . . . . . 24512.2.2 McCall’s Quality Factors . . . . . . . . . . . . . . . . . . . . 24612.2.3 ISO 9126 Quality Factors . . . . . . . . . . . . . . . . . . . 24712.2.4 The Quantitative View . . . . . . . . . . . . . . . . . . . . . 247

12.3 Design Metrics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24712.3.1 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24812.3.2 Web Design Evaluation . . . . . . . . . . . . . . . . . . . . . 24812.3.3 Object-Oriented Design Metrics . . . . . . . . . . . . . . . 24912.3.4 Architectural Design Evaluation . . . . . . . . . . . . . . . 250

12.4 Object-Oriented Metrics . . . . . . . . . . . . . . . . . . . . . . . . . . 25012.5 Project Metrics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251

12.5.1 Use-Case Metrics . . . . . . . . . . . . . . . . . . . . . . . . . 25212.5.2 Size Metrics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252

12.6 Process Metrics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25212.7 Post Release Metrics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25312.8 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 25312.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254

13 Hands-On Software Engineering Project . . . . . . . . . . . . . . . . . . . 25513.1 Phase I: Team Composition and Problem Definition . . . . . . . 255

13.1.1 Team Composition . . . . . . . . . . . . . . . . . . . . . . . . 25613.1.2 Writing for Software Engineering . . . . . . . . . . . . . . 25713.1.3 Time and Resource Management . . . . . . . . . . . . . . 258

13.2 Phase II: Object-Oriented Software RequirementsSpecification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26113.2.1 Specification Documentation . . . . . . . . . . . . . . . . . 26413.2.2 Change Management . . . . . . . . . . . . . . . . . . . . . . . 265

Contents xxiii

13.3 Phase III: Object Oriented System Design . . . . . . . . . . . . . . 26613.3.1 Stake Holders and Interests List . . . . . . . . . . . . . . . 26613.3.2 Use Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26613.3.3 Use Case Diagrams. . . . . . . . . . . . . . . . . . . . . . . . 26813.3.4 Class and Object Diagrams . . . . . . . . . . . . . . . . . . 268

13.4 Phase IV: Implementation . . . . . . . . . . . . . . . . . . . . . . . . . 27113.4.1 Commenting Code . . . . . . . . . . . . . . . . . . . . . . . . 272

13.5 Phase V: System Integration and Testing. . . . . . . . . . . . . . . 27313.5.1 Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27313.5.2 Quality Testing. . . . . . . . . . . . . . . . . . . . . . . . . . . 27413.5.3 Performance Testing . . . . . . . . . . . . . . . . . . . . . . . 27513.5.4 Reporting Test Results . . . . . . . . . . . . . . . . . . . . . 27513.5.5 When and How to Comprise Time

and Functionality . . . . . . . . . . . . . . . . . . . . . . . . . 27613.6 Phase VI: System Demonstration . . . . . . . . . . . . . . . . . . . . 277

13.6.1 What to Bring . . . . . . . . . . . . . . . . . . . . . . . . . . . 27713.6.2 The Demonstration . . . . . . . . . . . . . . . . . . . . . . . . 27813.6.3 Presenting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

13.7 Phase VII: Product Delivery With Documentation . . . . . . . . 27913.7.1 Peer Reviews . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

13.8 Chapter Summary and Conclusions. . . . . . . . . . . . . . . . . . . 28013.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

About the Author . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

xxiv Contents