Flexible, Reliable Software
Using Patterns and Agile Development

In this description, I will describe the main contents and pedagogical concerns of the book. Parts of it is identical to the preface of the book that you may download from this link: preface (PDF).


The book has an ambitious goal: to provide the best learning context for a student to become a good software engineer. Building flexible and reliable software is a major challenge in itself even for seasoned developers. To a young student it is even more challenging! First, many software engineering techniques are basically solutions to problems that an inexperienced programmer has never had. For instance, why introduce a design pattern to increase flexibility if the program will never be maintained as is the case with most programming assignments in teaching? Second, real software design and development require numerous techniques to be combined - picking the right technique at the right time for the problem at hand. While many text books treat relevant software engineering techniques, they fail to show how to effectively combine them in practice: instead each technique is presented as isolated topics in separate chapters and with small exercises focusing only on the particular technique in question.


The Flexible, Reliable Software book is aimed at students as well as seasoned developers looking for a treatment of modern software engineering techniques for developing maintainable and reliable software. The contents of the book covers topics like agile and test-driven development, design patterns, responsibility-driven design, and frameworks, as well as covers tools and techniques in the areas of build management, version control, and systematic testing.

The main point of the book, however, is its novel treatment of these topics.

Pedagogical Treatment

To facilitate the learning of software engineering topics in a way that supports both establishing a context for appreciating the techniques as well as see them combined, the book uses a story-telling approach, by explaining the design and programming process, and by using projects as a learning context. Many chapters in the book are telling the story of a company developing software for parking lot pay stations and the students are invited to join the development team. The software is continuously exposed to new requirements as new customers buy variations of the system. This story thus sets a natural context for students to understand why a given technique is required and why techniques must be combined to overcome the challenges facing the developers. An agile and test-driven approach is applied and space is devoted to explaining the programming and design process in detail - because often the devil is in the detail. Finally, the projects in the last part of the book define larger contexts, similar to real, industrial, development, in which the students via a set of assignments apply and learn the techniques of the book.

Just as agile development works in small releases or sprints defining self-contained and well-defined milestones, the book organizes the learning contents in eight learning iterations.

Each learning iteration defines learning contents that can be used and applied right away and mark a clear learning milestone. It also, however, defines a stepping stone for the next topics, the next learning iteration, that builds upon as well as reinforce the learning outcomes of previous learning iterations. Most of the learning iterations also embody a real product release of the case study used in the book.

The eight learning iterations in the book are:

  • Basic Terminology: After this iteration, the learner will know basic definitions and terminology for agile development, maintainability, reliability and testing.
  • The Programming Process: The learner masters test-driven development, and build management using Apache Ant.
  • The First Design Pattern: The learner can analyze simple variability, classify techniques used, and implement the Strategy pattern. The learner has also done refactorings and seen simple integration testing, and been exposed to the classic definitions of design patterns, coupling, and cohesion.
  • Variability Management and 3-1-2: The learner extends his/her knowledge of design patterns with State and Abstract Factory and uses test stubs to increase testability. The 3-1-2 process can be applied to create compositional designs for handling variability.
  • Compositional Design: The learner augments his/her theoretical undertanding of compositional designs by contrasting it to the language-centered and model-centered perspective on object-oriented design, and analyzes and implements multi-dimensional variance.
  • A Design Pattern Catalogue: The learner is now ready to acquire a large vocabulary of design pattern because of a deep knowledge of the underlying principles of compositional design.
  • Frameworks: The learner works with frameworks which are high pattern density designs, both in a concrete example, MiniDraw, as well as at a theoretical level.
  • Outlook: The learner acquires basic knowledge and abilities in the areas of software configuration management and systematic black-box testing.

Exercises and Projects

People do not learn the practical aspects of software engineering from reading a book but by applying techniques in practice. While chapters do contain small exercises, the key learning context envisioned is within a large project.

The book comes complete with two large-scale projects. These projects are large systems that are developed through a set of assignments covering the learning objectives of the book. Each project is structured into releases or iterations that roughly match the learning iterations of the book. Thus by completing the exercises in, say, project HotCiv's iteration on frameworks the learner will practice the skills and learning objectives defined in the framework learning iteration of the book. Each iteration results in a working product, and if you complete most or all iterations in a project you will end up with a reliable, flexible, and usable implementation of a large and complex software system, complete with a graphical user interface.

The two projects are:

  • HotGammmon: This project develops a framework for defining both the standard board game, backgammon, as well as a number of variants of this game. The project is complete with a graphical user interface and an opponent artificial intelligence player.
  • HotCiv: This project develops a framework for defining strategy games similar to the classic computer game, Civilization. This project also includes a graphical user interface.

Sample Chapters

I have selected two chapters as samples from the book, one that is highly focused upon concrete application and one that is theoretical and sums up the learnings of previous iterations.

Chapter 5's learning objective is test-driven development and shows the book's story-telling approach and attention to detail in the programming process. A concrete development task is presented, and test-driven development principles are introduced as we need them in our iterations to complete a reliable implementation of the case. As it is the first hands-on chapter, attention is paid to the details also at the concrete coding level.

Chapter 16 is a theoretical chapter whose learning objective is the compositional design principles. It builds upon the learning of previous chapters that have introduced strategy, state, abstract factory design patterns as well as test stubs as a response to concrete new functional requirements to the case. In these previous chapters, much focus has been on the process of introducing these design patterns: if you encapsulate what varies behind an interface and then delegate the work, then many design patterns appear automatically. Chapter 16 revisits this learning and puts it into a theoretical context.

Chapter Overview


The programming language used is Java, and tools used are JUnit 4.x, and Ant. The first code examples (until Ant is introduced) come with scripts for Windows command prompt and Linux Bash. Examples are easily adapted to popular IDE's like Eclipse and IntelliJ.

Of course, the theory and techniques apply equally well to modern object-oriented languages, like C#. The contributions page also contains a port to C++ by Robert Benkoczi at University of Lethbridge, Canada.

Back to main page