Agile Software Development

Agile Software Development for C++ and Java Programmers

A foundation for a full life-cycle model

Agile development has proven itself in terms of being able to engage colleagues and developers and to improve "software velocity" in the short term, and for simple projects. However, too many people adopt an extreme approach that discards the benefits of architecture, the creation of reusable assets, and the creation of a sound infrastructure that can sustain software velocity in the long term. Some large projects have intrinsically complex structure that cannot be subdivided into the small, independent groups on which common Agile methods thrive. It is important to run software development in a way that increases revenues and reduces costs. How do you do both together?

Good Agile development can start with a lightweight domain analysis designed to sustain change in the long term. If one uses Use Cases to capture ensuing generations of features and new requirements, then one can use the techniques of Responsibility-Driven Design to match new Use Case responsibilities with the interfaces in the infrastructure. CRC cards provide an approach to iterate both the infrastructure and the Use Cases to converge on powerful, up-to-date designs that meet user needs and retain the highest possible degree of flexibility.

This course describes a complete life cycle for program development in C++ and Java based on the domain analysis portion of Multi-Paradigm Design for C++, on Use Cases, and on the use of CRC cards. The course focuses on how to use the above design techniques to create and manage roles (that capture collections of responsibilities to support user functionality), classes (that capture the stable, long-term assets of the system) and objects (the lifeblood of a running system). Other important constructs such as templates are also addressed.


    • Project Managers

    • System Designers

    • Architects

    • Programmers

Course Objectives

To meet the overarching goals of Agile development:

    • Reduced development effort, frustration and cost

    • Increased customer satisfaction, higher revenues by building design techniques on Agile values.


The student should be familiar with basic Java or C++ programming constructs including member functions, inheritance, and information hiding. The student should also be familiar with a typical software development life cycle. The course focuses on software developers, project leads, and software architects as its audience. However, the course presents simple techniques such as use cases and CRC cards that offer powerful foundations for project management; as such, the course is also useful to managers.

Day 1: System Analysis

Analysis is understanding a system. We analyze systems to understand what we have to work with as a base for extension. We analyze domains to understand long-term recurring architectural structures. And we work with customers to understand their needs, and in particular to make sure that the solution will add value to the enterprise. Value comes from reducing cost and increasing profit - and on this first day, we lay the foundations for tools that will address both sides of profitability.

The Software World

    • The major constituencies

    • Economic Drivers

Agile and Systems Thinking

    • The Agile Manifesto: what Agile means

    • The limitations of Process

    • Systems Engineering

    • Systems Thinking and Emergent Behavior

    • A systems thinking approach to software design

Problem Identification and Definition

    • Definition of problem

    • Problem Definition and Systems Thinking

    • Common Classes of Problems

      • Economic: revenue, and cost

      • Technical

      • Organizational

      • Interpersonal

      • Communication

The Economic Model: Cost and Revenues

    • Object-Oriented Analysis

      • Analysis

      • Objects

    • What the system does: the functional view

      • Use cases

    • What the system is: the structural view

      • Agile Architecture

      • OOA as a simplistic view

    • Implementing in an OO language

    • Testing

Use Case Review

    • Fat, Thin, and Recommended Use Case templates

    • Extensions

    • Use Cases in:

      • Analysis

      • Design

      • Other phases

Agile Architecture

    • Domain Analysis

    • How Design Relates to Analysis

    • Object-Oriented Design

Day 2: Domain Analysis Foundations

Objects are just one tool in the toolkit of a Java or C++ programmer. Using only object-oriented techniques causes one to miss out on much of the expressive power of these languages and to ignore how they were intended to be used. A good knowledge of multi-paradigm design will not only help designers use templates, state machines, and other techniques at the right time, but will help designers use objects in a way that supports robust system evolution to reduce maintenance costs.

The Goals of Architecture and Design

    • Architecture: The First Design Product

    • Architecture, Paradigm, Organization, and Process

Paradigms, Design and Analysis

    • Agile Design

    • Dimensions of analysis and design

Domain Analysis

    • Text Editor Example

    • Fundamental Partitioning

    • Commonality and Variability Analysis

    • Application and Solution Analysis

    • Negative Variability

    • Solution Domain Analysis

    • The paradigms

Example Transformational Analysis and Design

    • Text Editor Example

Day 3: Fundamentals of the Object Paradigm

The object paradigm is one form of commonality and variability—a form supported by many programming languages. The first part of Day 3 looks at what the object paradigm can (and cannot!) do. The section presents basic definitions that emphasize a modern view that is more focused on objects rather than classes – a mistake the past decade has taught us to correct. This lays a foundation for roles and for techniques such as Java interfaces and C++ abstract base classes used as interfaces.

This three-day seminar ends on a note that is an almost paradoxical mixture of “returning to the basics” and integrative techniques – both in the guise of the genius of CRC cards. CRC cards are an informal, accessible tool (using index cards) for a socially oriented design exercise. We will cover techniques to help attendees become expert CRC facilitators — techniques that were developed together with Kent Beck and Ward Cunningham, the originators of the techniques, early in their development. We will look at other commonly available tools, methods, and development approaches.

The Object Paradigm

    • Short Definitions:

        • Object

        • Instantiation

        • Class

        • Abstract Data Type

        • Role

        • Modularity

Inheritance and Subtyping

    • Defining object-oriented programming

    • Programming by extension

    • Laws of inheritance

Aggregation, Inheritance, and Collaboration Roles

    • Solving the problem of multiple classification

    • Business value of roles in meeting customer needs

    • Roles and Abstract Data Types

CRC cards: Classes, Responsibilities, and Collaborators

    • "Who” is responsible?

    • Class naming, responsibility naming, etc.

Fine points of CRC facilitation

    • Process and Practical Issues

    • Spiral development

    • Combining business and user needs

Implementing the Design

    • Simple C++ Implementation

    • Simple Java Implementation

    • Aggregating Responsibilities