Agile Software Development Essentials

Short iterations and ongoing customer involvement in an agile process means software needs to change frequently. This makes architecture and design even more important in agile software development. Without paying attention to how software is constructed, the agile process of iterative development can soon degrade code into a maintenance nightmare. To build software successfully the team must know which decisions have to be made up front and which ones can and should be deferred until later. This unique course covers the critical skills needed to build software that can easily change. The course addresses both architecture and quality software design that emerges over time.

Level:

Basic through advanced

Length:

3 days

Intended Audience:

Developers, designers, architects, technical leads and mangers of development teams.

Pre-requisites:

Familiarity with basic Object-Oriented (OO) concepts and terminology.

Learning objectives:

• Identify six code qualities that make software easier to maintain
• Understand how applying key principles lead to easily extensrible designs
• Evaluate the tradeoffs of alternate designs without having to code them
• Learn twelve core patterns that every developer should know and use
• See how to apply patterns just-in-time and avoid up-front overdesign
• Employ proven techniques to dramatically reduce defects
• Recognize pathologies of poor code and how to fix them
• Discover how to refactor code without breaking callers
• Master an easy way to find patterns in any problem

Description:

People have said that architecture and design is not needed in an agile software development process. This is simply untrue. Unfortunately, the bulk of agile training today is focused on process and not architecture, design or coding. In order for an agile project to thrive it must embrace constant change by building software that is resilient.

This course identfies and give names to the qualities that make software flexible so all team members can get on the same page and communicate with high fidelity. It also looks at specific principles and practices which support the development of quality software. In addition to covering a core set of patterns every developer should know the course will also examine the forces underlying patterns that make them valuable to agility. This expanded view of patterns gives attendees a powerful framework allowing them to encapsulate and abstract virtually any problem for maximum flexibility without overcomplicating the solution. These techniques apply equally well to new development as they do to maintaining or extending existing systems.

Attendees will learn how to find elegant solutions by understanding the forces of problems which lead to discovering the right abstractions that make software less complex and more manageable. Using advanced techniques like commonality-variability analysis, “refactoring to the open-closed”, encapsulating construction and pattern-oriented design, participants learn how to emerge designs “just enough, just in time” leading to minimal waste.

There are no “magic bullets” in software development but we will make better choices if we understand the tradeoffs of our decisions. This training helps attendees evaluate tradeoffs in design that can then be immediately applied to virtually any problem. This practical approach will impact the way attendees create software on a day to day basis. Participants leave this training confident and empowered to improve the quality of the software they produce.

The course contains exercises done with groups at whiteboards. Examples and demonstrations are provided in Java using Eclipse. C# examples are also provided and issues specific to C++ are discussed.