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

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, although it has been used in introductory software engineering courses at all levels. It will also be valuable to programming practitioners who want to develop a better understanding of modern software engineering.

We have taught software engineering courses for fourteen years, and have attempted to tune the book so it is both useful and enjoyable to students. Feedback from former students has been gratifying - some have reported that they regularly use it as a reference in their jobs. 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. As a witness to this, in 2004 The IEEE Computer Society and the ACM approved Software Engineering 2004 (SE2004), a document outlining what should be taught in any undergraduate software engineering program. The first author of this book played a leading role in that project, and this book is specifically designed as a textbook for CCSE course SE201. See the web site sites.computer.org/ccse .

At the University of Ottawa, we teach the material in this book over a 12-week period during the first semester of the 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 that 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. This second edition of the book updates many exercises and introduces many new ones.

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 material provided in Chapter 2 and the book's website, and as they work through the exercises.

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, videotapes of lectures, and various other learning aids.

Themes taught throughout the book

Woven throughout the book are nine themes that we believe are basic to contemporary software engineering. 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 emphasize domain analysis as well as gathering and validating requirements. We place these 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. Later we discuss frameworks, a series of design principles, and many design and architectural patterns.

3. Visual modeling using UML. We present key elements of UML, particularly class, interaction and 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. For the second edition, we have updated the book so that it is compliant with UML 2.0.

4. Evaluation of alternatives in requirements and design. Throughout the book we present alternatives with their advantages and disadvantages. We encourage readers to record the rationale for each choice.

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. Quantitative and logical thinking. We cover the essentials of software metrics in several different chapters so that students can learn to think quantitatively. We also promote the judicious application of logic as embodied in OCL and assertions.

7. Iterative and agile development. We strongly emphasize that readers should follow an iterative approach to development. As project work, readers are asked to perform requirements analysis, 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. Concepts from the agile movement are also emphasized: developing in very small increments, test-first development, etc.

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

9. 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.

Changes in the second edition

In the second edition, we have made a wide variety of small changes to keep up with changes in the field. The following are some of the more significant changes:

• Covers UML 2.0

• Moves all discussion of use cases to Chapter 4.

• Introduces model-driven development.

• Discusses web-based software architectures and middleware.

• Integrates discussion of agile approaches, and techniques made popular by those approaches including refactoring and test-driven development.

• Covers more of the essentials of measurement and metrics.

• Incorporates many new and changed exercises. All exercises have been given a new numbering scheme to prevent confusion with those in the first edition.

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. One set of project exercises is 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 available in the student's answer manual; other answers are available in a manual only available to instructors.

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 use cases and static modeling. Later, we introduce dynamic modeling.

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 the core material in 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, use cases and requirements (1.5 weeks).

  Project work: adding features following requirements analysis.

• Weeks 4-5: Chapter 5 - OO analysis and modeling (1.5 weeks).

  Project work: adding features that require considerable modeling.

• Week 6: Chapter 6 - Design patterns (1 week).

• Week 7: Chapter 7 - User interfaces (0.5 weeks).

  Project work: adding a GUI.

• Weeks 8-9: Chapter 8 - Dynamic modeling (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 this book:

• Those who have contributed insights or helped edit the book. There are too many to mention them all, but we would especially like to thank Rohit Bahl, Bob Probert, K. Teresa Khidir, Francois Belanger and Klaas van den Berg who made particularly large contributions.

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

Back to the book's main page