Agile Software Development Training

Delivery Options

• Customized Onsite Training (5 days): Request a Proposal

Class Description

Class Overview

Class Goals

• Learn to apply useful principles from several agile methodologies
• Learn to be pragmatic and not dogmatic about agile principles
• Learn to use your judgment to decide which practices apply when and to what extent
• Understand techniques to create good unit tests
• Learn to use various tools that can help with agile development
• Learn to be adaptive
• Learn techniques for estimation, planning, and execution

Class Outline

1. Software Development Process
   1. Software Development Process and challenges
   2. Development approaches
   3. Strengths and Weakness of The Unified Process
   4. What is Agile Development?
   5. Study of Agile Manifesto and Agile Principles
   6. Modeling and Agile Modeling
   7. The Gist of Agile Processes
2. Agile Methodologies
   1. Reasons for Agility
   2. Methodologies for developing software
   3. Why care about methodologies?
   4. Agile processes strength and weakness
   5. Understanding XP, Scrum, Evo, Unified Process, Crystal, Lean Development, ASD, DSDM, and FDD
   6. Comparison of methodologies
   7. Choosing a methodology
   8. Customizing a methodology
3. Software Planning
   1. Planning software projects
   2. Minimizing risk and managing requirements
   3. What are User Stories?
   4. Developing User Stories
   5. Exploration and scoping
   6. Approach to Estimation
   7. Planning your Project Release Cycle and iteration
   8. Task planning, spiking, halfway point, slippage
   9. Tools and techniques for project estimation, planning and tracking
4. Design Considerations
   1. Risk in development
   2. Efforts to minimize Risk
   3. What is design?
   4. Up-front design vs. Agile Design
   5. How to validate designs
   6. Motivations for TDD
   7. Work through a design example
5. Test Driven Development
   1. How we typically create classes
   2. Benefits and differences of TDD and Test First Coding
   3. Programming by Intention
   4. Types of Tests: Acceptance Testing, Unit Testing
   5. System functionality and relation to TDD
   6. Tenets of TDD, TDD Mantra, TDD Concepts
   7. Practices for Unit Testing
   8. When and where to write tests, and when not to write
6. Tools and Techniques for TDD
   1. Tools for unit testing
   2. Developing and running test cases
   3. Extensions and related tools
   4. Organizing tests
   5. Practices to follow while writing unit tests
   6. What to do when a bug is detected
   7. How to accommodate change
7. Mock Objects
   1. Unit testing Challenges
   2. What are Mock Objects?
   3. Advantages of mocking
   4. How to implement a mock object
   5. Using mocks and * mock object frameworks
   6. Which framework to use
   7. When to mock and when not to mock
8. Refactoring your code
   1. What is refactoring?
   2. Why refactor?
   3. Refactoring prerequisites
   4. What to refactor
   5. Reconciling differences
   6. Specific refactoring recommendations
   7. Tools that help with refactoring
9. Continuous Integration and TDD
   1. Why unit test?
   2. What is hard about it?
   3. What tests to run
   4. How often to run them
   5. Integrate early and frequently
   6. Continuous Integration
   7. Tools for Continuous Integration
   8. Extreme Feedback Devices
10. TDD Patterns
    1. Automate, Isolate, Task List, Test First, Assert First
    2. Test Data, Evident Data, One step test, Starter test
    3. Explanation test, Learning test, Regression test
    4. Fake It, Triangulate, Test stub, Quality
    5. What to do when bugs are found
    6. Accomodating change
    7. The Right-BICEP and CORRECT
11. Dynamic Languages as Testing Aid
    1. What are Dynamic Languages?
    2. How dynamic languages help with testing
    3. Using dynamic languages to test your code
12. Beyond Unit Testing
    1. Functional and Integration Testing
    2. Fit and FitNesse
    3. Integration testing web applications
    4. Tools for integration testing
    5. Acceptance testing with Selenium
13. Object-Oriented Design Principles I
    1. Measuring Quality of an Abstraction
    2. Coupling, Cohesion
    3. Law of Demeter
    4. Characteristics of a Poor design
    5. Viscosity, Opacity, Rigidity, Immobility, Fragility, Needless Complexity, Needless Repetition
    6. Characteristics of a Good design
    7. YAGNI, DRY
    8. Difficulties with Inheritance
14. Object-Oriented Design Principles II
    1. Single Responsibility Principle
    2. Open-Closed Principle
    3. Liskov Substitution Principle
    4. Dependency Inversion Principle
    5. Interface Segregation Principle
    6. Bearing on reusability and extensibility
    7. Other Design Principles
    8. Measuring design quality
    9. Tools for measuring design quality
15. Open Source Tools for Agile Development
    1. Agility and Tools
    2. Measuring Progress
    3. Tools to measure coverage, design quality, and code quality
    4. Performance measurement tools
    5. Modeling and process tools
16. Practices for Agile Development
    1. Beneath the basics of agile development
    2. Select practices for you and your team
    3. Beginning Agility
    4. Feeding Agility
    5. Delivering what users want
    6. Agile feedback, debugging, and collaboration
    7. Ways to approach agility

Class Materials

All students receive a course manual or book and all the class examples.

Students in private onsite classes will also receive:

• Technical Reference Library

Class Prerequisites

Experience in the following areas is required:

• Understand software development and programming in general
• Create, test, and execute programs (preferably in Java, C#, Ruby, or Groovy)

Technical Requirements

Our computer technical requirements and setup process is easy, with support just a click away.

• Course technical requirements and setup instructions.