Preface of the book Object-Oriented Software Engineering: Practical Software Development using UML and Java

Our focus in this book is software engineering knowledge and skills that readers can put into immediate practical use. The book is designed to be used in second-year post-secondary software engineering courses. It will also be valuable to people who have some programming background, but want to get a better understanding of modern software engineering.

We have taught software engineering courses for ten years, and have used preliminary versions of the material in this book for three years with positive feedback from students. Our industrial experience performing software development, consulting and professional training has also allowed us to focus on material that is important to the employers of these students.

Using the book in a software engineering degree program

Software engineering is becoming an established discipline, separate from computer science and computer engineering. A major part of this trend is the establishment of specialized software engineering degree programs in post-secondary institutions throughout the world. We designed this book to introduce the most important concepts in software engineering to students in such programs.

At the University of Ottawa, we teach the material in this book over a 12-week period during the first semester of second year. By that time, students have completed two semesters of computer science -- including object-oriented programming in Java. They take a course in data structures and algorithms in parallel with this course, and subsequently take advanced software engineering courses which expand their knowledge of the material we introduce here.

Students who have studied the material in this course should be particularly employable in co-op or summer jobs. Employers are looking for students who understand what constitutes a good requirement, can apply fundamental design principles, can use UML properly, can translate requirements and designs into good quality programs, and can effectively test those programs. This book gives a practical grounding in all of these skills.

The book is structured so that in a 12-week course or unit, it can be taught using three hours a week of classroom instruction, plus regular supervised and unsupervised laboratory time. Each year we assign a selection of the exercises, many of which students work on in groups.

Using the book to upgrade your skills and knowledge

In addition to software engineering students, the book is also suitable for those who have some programming background and need a practical introduction to software engineering. Such people might be 're-skilling' to meet the demands of the knowledge economy, or upgrading their knowledge after years of working as a coder.

Suggested background

Prior to studying this book, readers should understand the basic notions of object oriented programming, although Chapter 2 gives a brief review of these concepts. We have selected Java as the language used for programming examples since it is a complete, simple and popular object-oriented language. Motivated readers who know other object-oriented languages should be able to pick up the necessary Java from the Chapter 2 overview and as they work through the exercises in this book.

Material on the web site

We have prepared a web site with many resources to support readers and teachers. The address is: www.lloseng.com.

Here you will find sets of presentation slides, source code, answers to exercises, links to all the web-based references, a knowledge base summarizing many of the concepts presented, and various other learning aids.

We look forward to receiving feedback from readers. The web site contains a form for that purpose.

Themes taught throughout the book

Woven throughout the book are eight themes that we think are basic to the software engineering of the 2000s. Each of these themes is revisited in many chapters, and is taught in the context of concrete examples and exercises.

1. Understanding the customer and the user: We emphasise domain analysis as well as gathering and validating requirements. We place this in the context of use case analysis and usability. Readers are asked to think in terms of what the customerÕs problem really is, what is realistic, etc. The purpose of software engineering is described at the beginning of the book as solving customersÕ problems, rather than developing software for its own sake.

2. Basing development on solid principles and reusable technology: We emphasize the necessity for software engineers to understand design principles and have a thorough grasp of suitable technology before embarking on a project. To ensure this is the case for the design work in this book, we first review object-oriented principles and Java. Later we discuss, frameworks, a series of design principles, and many design patterns.

3. Visual modelling using UML: We present key elements of UML, particularly class and interactions diagrams, and to a lesser extent, state diagrams. We do not cover all of UML and we do not restrict our discussion to UML alone since it does not cover all of software engineering. We emphasize that UML diagrams do not solve problems by themselves, but are one of the many tools that software engineers should use as a regular part of their work.

4. Evaluation of alternatives in requirements and design: Throughout the book we present alternatives with their advantages and disadvantages, as well as the rationale for each choice. Students will practice assessing alternatives.

5. Object orientation: We cover all aspects of object oriented development, including analysis, design and programming. Ensuring that the reader sees how to take projects all the way to implementation means that he or she gets more than just an abstract view of the development process, and appreciates the reasons for many design principles.

6. Iterative development: We strongly emphasize that readers should follow the iterative approach. As project work, readers are asked to perform requirements, design and implementation very near the beginning of the book, and then again several times throughout the book. To accomplish this we introduce a complete project in Chapter 3. Initially, readers are asked to make only a small change to this project in order to begin to understand it. In Chapter 4, readers are then asked to write and review requirements for new features to add to the system -- again they design and implement the features. Later, readers learn more details of topics such as design and quality assurance, and are asked to apply what they learn to successively more advanced changes to their project.

7. Communicating effectively using documentation: We encourage readers to practice writing informative documentation; we provide templates and examples of each type of document.

8. Risk management in all software engineering activities: Throughout the book, we discuss many aspects of risk management including evaluating potential costs and risks on a regular basis, balancing risks with benefits, avoiding doing work that is not worthwhile, and evolving plans as we learn more information. We point out that the knowledge learned from the other themes above can be applied to reduce risk.

Structure of the book

• Size: The book is small enough so that instructors can realistically require students to read it all during a 12 week course We present a suggested schedule below.

• Depth: Rather than covering all aspects of software engineering; we present in reasonable depth a cohesive collection of material that will give readers a foundation in topics central to the field. We focus on material that is immediately applicable in industrial software projects.

• Examples and exercises: Readers can practice applying the concepts, since we provide an extensive set of examples and exercises. The in-depth project exercises are based on a fully-implemented small system, which we provide. This means that rather than always programming from scratch, readers are able to spend their time thinking about higher level analysis and design issues, yet they can still practice implementation of their ideas. Readers also come to appreciate reuse, since the implemented system is based on a framework that is applicable to a wide variety of client-server systems. The exercises vary widely in difficulty; some are easy and simply encourage the reader to think about what they have read; others are intended to motivate advanced readers. Many exercises have fully explained answers on our web site.

• Sequencing: The sequence of material in the book is designed to allow students to rapidly start work on real problems requiring analysis, design and implementation. As readers perform several iterations of project work, we introduce topics they will need in each iteration. The early part of the book, for example, introduces the knowledge about object orientation and architecture that they will need to understand the project work. Then we move on to requirements and object oriented analysis, focusing initially on static modelling. Later, we introduce use-case modelling and dynamic modelling as the exercises become more demanding and hence require such material.

Use of this book in a 12-week course

The following is a suggested schedule for using this book in a second-year university course. For the main body of the book, Chapters 3 to 10, the allocated time corresponds roughly to the length of each chapter.

The authors use this book in a 12-week course, where each week has three hours of lecture as well as three hours of lab and tutorial time. Students are expected to read all the chapters, although the lectures focus most heavily on Chapters 3 through 10, and particularly chapters 3, 5, 8 and 9.

We also anticipate that students work on a selection of exercises with deliverables about four times during the course. We also expect them to deliver three iterations of the project. We have provided suggested project activities at the end of many chapters.

• Week 1 Chapters 1 and 2 - Introduction and review (1 week)
• Weeks 2-3: Chapter 3 - Reuse and the client server framework (1.5 weeks). Project work: Learning to use the client-server framework by making a minor change to a system implemented using it
• Weeks 3-4: Chapter 4 - Domain analysis and requirements (1 week) Project work: Adding features following requirements analysis
• Weeks 4-5: Chapter 5 - OO analysis and modelling (1.5 weeks) Project work: Adding features that require considerable modelling
• Week 6: Chapter 6 - Design patterns (1 week)
• Week 7: Chapter 7 - Use cases and user interfaces (1 week) Project work: Adding a GUI
• Weeks 8-9: Chapter 8 - Dynamic modelling (1.5 weeks)
• Weeks 9-10: Chapter 9 - Design principles and architecture (1.5 weeks) Project work: Detailed design of some features
• Week 11: Chapter 10 - Testing (1 week) Project work: Preparing a test plan
• Week 12: Chapters 11 and 12 - Introduction to project management and review (1 week)

Other orderings are possible. In particular, the order in which Chapters 6 through 11 can be covered is flexible. Also, parts of many chapters could be skipped in order to give greater emphasis to other material.

Acknowledgements

We would like to thank the following people who helped us improve early drafts of this book:

• Reviewers of early drafts who made many useful suggestions, including Hausi Müller, Mike Lutz, Carol Greswell, Rohit Bahl, Bob Probert, Lionel Briand and Mike Bennett.

• K. Teresa Khidir who carefully edited much of the beta version of the book.

• François Bélanger who painstakingly and repeatedly modified the code as we refined the specifications.

• Judy Kavanagh, who worked on the knowledge base of the accompanying web site and helped refine the glossary.

• The University of Ottawa students in SEG 2100 and SEG 2500 on whom we tested early versions of this book and the software, and who provided much useful feedback. Especially Dan Danis, Ali Echihabi, Stephane Jacoby, Meng Han, Mudassar Hayee, Patrice LaFlamme, Aleksandar Lukic, Vinh Mai, Ryan Rebello, Jim Sellers, James Ward, Karen Williamson, and others who wish to remain anonymous.

Table of Contents

Back to the book's main page