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.
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
Agile and Systems Thinking
The Agile Manifesto: what Agile means
The limitations of Process
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
The Economic Model: Cost and Revenues
What the system does: the functional view
What the system is: the structural view
OOA as a simplistic view
Implementing in an OO language
Use Case Review
Fat, Thin, and Recommended Use Case templates
Use Cases in:
How Design Relates to Analysis
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
Dimensions of analysis and design
Text Editor Example
Commonality and Variability Analysis
Application and Solution Analysis
Solution Domain Analysis
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
Abstract Data Type
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
Combining business and user needs
Implementing the Design
Simple C++ Implementation
Simple Java Implementation