Introduction to Agile Programming

Course Description

This course focuses on the core development cycle of test, code and refactor at the heart of a successful Agile project. The practices of Test First Programming and Refactoring are introduced individually and then in concert. In addition, the concept of driving development from a customer perspective through automated acceptance testing is introduced. Intended for: Software developers that want to master the test, code and refactor development cycle. Attendees will also learn how to drive this development cycle through automated acceptance testing.
3 days
Contact us for pricing

Prerequisites

Course Objectives

Master the test, code and refactor development cycle.
Introduce the Test Driven Development practice and its underlying techniques.
Introduce Refactoring and the concept of code smells and their associated catalog of refactorings
Place the test, code and refactor cycle into context within the broader arena of agile development

Course content

1. Test Driven Development

Introduction to the key ideas and benefits of Test Driven Development.
Introduction to the xUnit test framework.
Covers the key concepts of the framework, naming and organising tests in your project.

The instructor will demonstrate the practical application of the xUnit framework and Test Driven Development practices. Course attendees practice what they have learnt by developing an application following Test Driven Development practices. The instructor will lead a discussion on the issues raised during the practical exercise and any issues the attendees might have adopting Test First Programming within their particular environment.

Topics covered:
Justification and benefits of Test Driven Development
Process of Test Driven Development
Driving design with tests
Introduction to xUnit framework
Organising and running tests
xUnit demonstration
Student exercise

Objectives:
Following this module, the students should be able to demonstrate basic use of the tools involved in Test Driven Development and have an awareness of the purpose and benefits of Test Driven Development. They should be able to develop simple programs using the Test Driven Development approach.

2. Test By Contract

Introduction to the principles of software contracts and their role within Test Driven Development. Course attendees apply what they have learned to the previously developed application

Topics covered:
Pre-conditions
Post-conditions
Class invariants
Testing contracts
Command Query Separation principle
Student exercise

Objectives:
Upon completion of this module, students should understand the principles of pre-conditions, post-conditions and class invariants. Students should be able to apply these concepts to programs developed using Test Driven Development.

3. Mocks & Stubs

Introduction and comparison of the use of Stubs and Mock Objects to test aspects of an application normally considered difficult to test. Course attendees apply Mocks and Stubs to a system of collaborating objects.

Topics covered:
Fake objects
Flavours of fake objects
Application of fake objects
Stubs
Mock objects
State based versus interaction based testing
Student exercise

Objectives
On completion of this module, students should be able to show an understanding of more advanced Test Driven Development techniques. Students should have; a working knowledge of how and when to use fake objects.

4. Testing Patterns

Introduction to solutions for commonly occurring problems in the application of Test Driven Development.

Topics covered:
Starter test
Fake it til you make it
Testing for exceptions
Crash test dummy

Objectives:
Students should be able to apply to patterns presented when faced with the associated problem.

5. Smells & Refactoring

Introduction to the notion of a code smell, a poor design decision, and the application of refactoring to improve the design while keeping the behavior of the system unchanged. Course attendees identify poor design decisions in a piece of smelly code. The instructor will demonstrate the refactoring of an existing piece of code in order to improve its design. Course attendees will refactor an existing piece of code to improve its design before adding a new feature.

Topics covered:
Identifying code smells
Defining refactoring
Incremental design
Matching smells and refactorings
Refactoring and design patterns
Refactoring demonstration
Student exercise

Objectives:
Successful completion of this module will enable the student to perform refactoring at an intermediate level and equip the student with the skills to detect and remedy smells in the code base.

6. Automated Acceptance Testing

Introduction to the role of acceptance testing as part of Agile software development and frameworks supporting automation of acceptance testing. The instructor will demonstrate the use of automated frameworks for the development of acceptance tests. Course attendees will utilise an automated acceptance test framework while adding additional features to the previously developed application.

Topics covered:
Role of automated acceptance testing in an Agile project
Introduction to acceptance testing frameworks
Acceptance testing framework demonstration
Student exercise

Objectives:
At the end of this module, the student should understand the key role of automated acceptance testing in an agile development environment and why it should not be treated as an option. In addition, they will have practical experience of acceptance testing frameworks.

7. Story of a Story

Introduction to the broader context of Agile software development.

Topics covered:
Agile process overview
Release planning overview
Iteration planning overview

Objectives:
Following this module, students should understand how Agile programming techniques fit in to an Agile software project.

8. Putting It All Together

Course attendees practice what they have learnt by developing an application following Test Driven Development practices.

Topics covered:
Student exercise

Objectives:
Students should be able to apply the techniques they have learnt to their own projects.

Agileagile programmingagile testingSoftware testingSoftware test