Introduction to Agile Programming

Request more details:

submit request
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.
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.