Object-Oriented Software Engineering – Timothy C. Lethbridge, Robert Laganière – 2nd Edition


Written by two of academia’s experts in software engineering, Object-Oriented Software Engineering: Practical software development using UML and Java provides a modern introduction to the subject for today’s students.

This important new book gives an in-depth treatment of key principles that have broad applicability and relevance. Lethbridge and Laganiere have packed the text with examples and integrated exercises. In addition there are examples and exercises to give students practice on a variety of interesting problems and to help maintain their motivation.

Key Features:
– Understanding the customer and the user in the context of use cases, requirements and user interface design
– Development based on solid principles and reuseable technology: reuseable software and sets of principles are provided on which students can base their work
– Visual modelling using UML as the standard
– Evaluation of alternatives in requirements and design teaches students how to make decisions in software engineering
– Object-Orientation: in-depth coverage of analysis and design, as well as implementation using Java; object-oriented design patterns are also covered
– Iterative development: promoted as the preferred way to develop software
– Communicating effectively using documentation: flexible formats are suggested for documentation, with guidelines on how to review it

View more
  • Preface

    1. Software and Software Engineering
    1.1 The Nature of Software
    1.2 What is Software Engineering?
    1.3 Software Engineering as a Branch of the Engineering Profession
    1.4 Stakeholders in Software Engineering
    1.5 Software Quality
    1.6 Software Engineering Projects
    1.7 Activities Common to Software Projects
    1.8 The Eight Themes Emphasized in this Book
    1.9 Difficulties And Risks In Software Engineering as a Whole

    2. Review of Object Orientation
    2.1 What is Object Orientation?
    2.2 Classes and Objects
    2.3 Instance Variables
    2.4 Methods, Operations and Polymorphism
    2.5 Organizing Classes Into Inheritance Hierarchies
    2.6 The Effect of Inheritance Hierarchies on Polymorphism and Variable Declarations
    2.7 Concepts that Define Object Orientation
    2.8 Detailed Example: A Program for Manipulating Postal Codes
    2.9 Detailed Example: Classes for Representing Geometric Points
    2.10 Difficulties and Risks in Programming Language Choice and Object-Oriented Programming

    3. Basing Software Development on Reusable Technology
    3.1 Reuse: Building on the Work and Experience Of Others
    3.2 Incorporating Reusability and Reuse Into Software Engineering
    3.3 Frameworks: Reusable Subsystems
    3.4 The Client-Server Architecture
    3.5 Technology Needed to Build Client-Server Systems
    3.6 The Object Client-Server Framework (OCSF)
    3.7 Basic Description of OCSF Ð Client Side
    3.8 Basic Description of OCSF Ð Server Side
    3.9 An Instant Messaging Application Using the OCSF
    3.10 Difficulties and Risks When Considering Reusable Technology and Client-Server Systems

    4. Developing Requirements
    4.1 Domain Analysis
    4.2 The Starting Point for Software Projects
    4.3 Defining The Problem and the Scope
    4.4 What Is a Requirement?
    4.5 Types of Requirements
    4.6 Some Techniques for Gathering and Analyzing Requirements
    4.7 Types of Requirements Document
    4.8 Reviewing Requirements
    4.9 Managing Changing Requirements
    4.10 Detailed Example: GPS-Based Automobile Navigation Assistant (GANA)
    4.11 Detailed Example: Requirements for a Feature Of The SimpleChat Instant Messaging Program
    4.12 Difficulties and Risks In Domain and Requirements Analysis

    5. Modelling With Classes
    5.1 What is UML?
    5.2 Essentials of UML Class Diagrams
    5.3 Associations and Multiplicity
    5.4 Generalization
    5.5 Instance Diagrams
    5.6 More Advanced Features of Class Diagrams
    5.7 Detailed Example: A Class Diagram for Genealogy
    5.8 The Process Of Developing Class Diagrams
    5.9 Implementing Class Diagrams in Java
    5.10 Difficulties and Risks When Creating Class Diagrams

    6. Using Design Patterns
    6.1 Introduction to Patterns
    6.2 The Abstraction-Occurrence Pattern
    6.3 The General Hierarchy Pattern
    6.4 The Player-Role Pattern
    6.5 The Singleton Pattern
    6.6 The Observer Pattern
    6.7 The Delegation Pattern
    6.8 The Adapter Pattern
    6.9 The Facade Pattern
    6.10 The Immutable Pattern
    6.11 The Read-Only Interface Pattern
    6.12 The Proxy Pattern
    6.13 Detailed Example: The Observable Layer of OCSF
    6.14 Difficulties and Risks When Using Design Patterns

    7. Focusing on Users and Their Tasks
    7.1 User Centred Design
    7.2 Characteristics of Users
    7.3 Developing Use Case Models of Systems
    7.4 The Basics of User Interface Design
    7.5 Usability Principles
    7.6 Evaluating User Interfaces
    7.7 Implementing a Simple GUI in Java
    7.8 Difficulties and Risks in Use Case Modelling and UI Design

    8. Modelling Interactions and Behaviour
    8.1 Interaction Diagrams
    8.2 State Diagrams
    8.3 Activity Diagrams
    8.4 Difficulties and Risks in Modelling Interactions and Behaviour

    9. Architecting and Designing Software
    9.1 The Process of Design
    9.2 Principles Leading to Good Design
    9.3 Techniques for Making Good Design Decisions
    9.4 Software Architecture
    9.5 Architectural Patterns
    9.6 Writing a Good Design Document
    9.7 Detailed Example: Design of a Feature for The SimpleChat Instant
    Messaging Application
    9.8 Difficulties and Risks in Design

    10. Testing and Inspecting to Ensure High Quality
    10.1 Basic Definitions
    10.2 Effective and Efficient Testing
    10.3 Defects in Ordinary Algorithms
    10.4 Defects in Numerical Algorithms
    10.5 Defects in Timing and Co-Ordination: Deadlock, Livelocks and Critical Races
    10.6 Defects in Handling Stress and Unusual Situations
    10.7 Documentation Defects
    10.8 Writing Formal Test Cases and Test Plans
    10.9 Strategies for Testing Large Systems
    10.10 Inspections
    10.11 Quality Assurance in General
    10.12 Detailed Example: Testcases for Phase 2 of the SimpleChat Instant Messaging System
    10.13 Difficulties and Risks in Quality Assurance

    11. Managing the Software Process
    11.1 What is Project Management?
    11.2 Software Process Models
    11.3 Cost Estimation
    11.4 Building Software Engineering Teams
    11.5 Project Scheduling and Tracking
    11.6 Contents of a Project Plan
    11.6 Difficulties and Risks in Project Management

    12. Review
    12.1 Understanding the Customer and User
    12.2 Basing Development on Solid Principles and Reusable Technology
    12.3 Object Orientation
    12.4 Visual Modelling Using UML
    12.5 Evaluation of Alternatives in Requirements and Design
    12.6 Iterative Development
    12.7 Communicating Effectively Using Documentation
    12.8 Risk Management in All Software Engineering Activities
    12.9 Where Next?

    Appendix A: Summary of UML Notation Used in his Book
    Appendix B: Summary of the Documentation Types Recommended in This Book
    Appendix C: System Descriptions

  • Citation

Leave us a comment

No Comments

Notify of
Inline Feedbacks
View all comments
Would love your thoughts, please comment.x