Index / 001 EN
Software Engineering cover

Computer Science

Computer Science

Software Engineering

Ian Sommerville

A broad introductory textbook on software engineering that balances plan-driven and agile approaches. It follows the life of a software system from requirements and architecture through implementation, testing and evolution, and uses recurring case studies, including an insulin pump and a patient-record system, to connect principles with realistic systems.

Prerequisites: Programming experience in at least one language and some exposure to building a program larger than a single exercise.

Difficulty Level
Intermediate
Academic Level
Undergraduate
software engineeringsoftware processrequirementssystem designagileTextbook

01 / Reading Guide

Reading Guide

Citation

Sommerville, I. (2015). Software Engineering (10th ed.). Pearson.

Chapter Summary

The tenth edition has twenty-five chapters in four parts, plus a glossary and an index, in about 800 pages. Sommerville's own site says the book was published in April 2015 and describes its changes from the ninth edition: a completely rewritten agile chapter with new material on Scrum, self-contained chapters on reliability, safety and security, and new chapters on resilience engineering, systems engineering and systems of systems. Pearson presents the book as introducing students to the proven processes and techniques behind reliable software, guiding the reader through widely used agile methods and plan-based approaches alike.

Part 1, Chapters 1–3: Introduction; Software Processes; Agile Software Development

Chapter 1 covers professional software development, software engineering ethics and the case studies. Chapter 2 covers process models and activities, coping with change and process improvement. Chapter 3 covers agile methods and techniques, agile project management and scaling agile methods.

Part 1, Chapters 4–5: Requirements Engineering; System Modeling

Chapter 4 treats functional and non-functional requirements and the processes of elicitation, specification, validation and change. Chapter 5 presents context, interaction, structural and behavioural models, and model-driven engineering.

Part 1, Chapters 6–7: Architectural Design; Design and Implementation

Chapter 6 covers architectural design decisions, views, patterns and application architectures. Chapter 7 covers object-oriented design with UML, design patterns, implementation issues and open-source development.

Part 1, Chapters 8–9: Software Testing; Software Evolution

Chapter 8 distinguishes development testing, test-driven development, release testing and user testing. Chapter 9 covers evolution processes, legacy systems and software maintenance; the author notes that legacy systems receive more detail than in the previous edition.

Part 2, Chapters 10–14: Dependable Systems; Reliability Engineering; Safety Engineering; Security Engineering; Resilience Engineering

This part is system dependability and security. Chapter 10 introduces dependability properties, sociotechnical systems, redundancy and diversity, dependable processes and formal methods. Reliability, safety and security each have a chapter of their own, which Sommerville says makes it easier to teach one topic inside a more general course. Chapter 14, new in this edition, treats cybersecurity, sociotechnical resilience and resilient systems design. (Pearson's online contents list omits Chapter 14; the author's contents list includes it.)

Part 3, Chapters 15–18: Software Reuse; Component-Based Software Engineering; Distributed Software Engineering; Service-Oriented Software Engineering

Reuse (including application frameworks and software product lines), components and their composition, distributed systems and client-server computing, and service-oriented architectures with RESTful services.

Part 3, Chapters 19–21: Systems Engineering; Systems of Systems; Real-Time Software Engineering

Two of the three chapters are new in this edition: systems engineering and systems of systems. Chapter 21 covers embedded systems design, real-time architectural patterns, timing analysis and real-time operating systems.

Part 4, Chapters 22–25: Project Management; Project Planning; Quality Management; Configuration Management

Risk management, people and teamwork; pricing, plan-driven and agile planning, estimation and COCOMO; quality, standards, reviews and measurement; and version, build, change and release management. The configuration chapter is updated for distributed version control.

Key Concepts

Part 1: Introduction to Software Engineering

  • Software process models and agile methods: plan-driven and agile ways of organising work.
  • Requirements engineering: elicitation, specification and validation of functional and non-functional requirements.
  • System modelling and architectural design: models and views of a system, architectural patterns.
  • Testing and evolution: development, release and user testing; maintaining legacy systems.

Part 2: System Dependability and Security

  • Dependability, reliability, safety, security and resilience: the family of properties treated one chapter at a time.
  • Redundancy and diversity, safety cases, secure systems design.

Parts 3–4: Advanced Topics and Management

  • Reuse and component-based engineering; service-oriented architecture.
  • Systems of systems; real-time systems.
  • Risk management, estimation and quality management; version management.

Critical Analysis

Strengths

  • Balance between process traditions. Pearson presents the book as covering agile and plan-based approaches; the agile chapter was rewritten for this edition, and planning appears in both forms (plan-driven development and agile planning).
  • Dependability as a sequence of focused chapters. Reliability, safety, security and resilience each have a self-contained chapter, so a course can take one of them.
  • Case studies spread across the book. The author deliberately uses several: the iLearn digital learning environment, the Mentcare mental-health system, an insulin pump, a wilderness weather station, the Airbus 340 flight control system and the Ariane 5 launch accident.
  • Free supporting material. Sommerville's site offers slides for every chapter, an instructor's guide with solutions to selected exercises and quizzes, case-study write-ups, over forty videos, sample chapters (1, 12 and 20) and web chapters from earlier editions.

Limitations

  • Breadth over depth. Twenty-five chapters in about 800 pages means that most topics (real-time, distributed, service-oriented software) receive three to five sections each, so the book surveys rather than specialises.
  • Some earlier content is only on the web. Process improvement and aspect-oriented engineering were moved out of the print edition; the author says the web chapters have not been updated since they were first published and are out of date in places.
  • A 2015 snapshot. The contents list and the author's change list name Scrum, RESTful services and distributed version control, but not DevOps or continuous delivery, so courses on current delivery practice need supplements.

Where It Fits in the Course

Sommerville is the broad, survey-style textbook of the course, and the other books are focused studies that go deeper on a single topic. Ousterhout's A Philosophy of Software Design is a short book on managing complexity through module design; Bass, Clements and Kazman's Software Architecture in Practice deals with architecture and quality attributes in depth; and Jackson's Software Abstractions introduces lightweight formal methods with Alloy. Ousterhout follows naturally from Chapters 6 and 7 (architecture, design and implementation), Bass, Clements and Kazman from Chapter 6, and Jackson from Chapter 5 on system modelling.

Software Engineering at Google is a free collection of essays on how a large organisation sustains software over time, and The Pragmatic Programmer collects habits and techniques for working developers; both suit a reader who has already met the vocabulary of Part 1 and wants practice-oriented perspectives.

How to Use This Book

The book is aimed at students in a first software engineering course, at graduate students from other fields who need an overview, and at practitioners. Prior programming experience, including a program larger than a single exercise, is the sensible prerequisite.

A practical plan:

  • Core: Part 1 in order (Chapters 1–9), with the sample Chapter 1 as a trial read. Pair Chapters 2–3 with a team project that follows one process.
  • Choose by interest: from Part 2, Chapter 11 (reliability), 12 (safety) or 13 (security), and Chapter 14 (resilience); from Part 3, reuse, services or real-time topics.
  • Management: Chapters 22–25 for project courses, particularly project planning and configuration management.

Keep notes on the recurring case studies, which reappear in different chapters, and use the author's slides, videos and instructor's guide as study aids.