Agile Software Development: Hands-on Practices, Principles, Agile Modeling, and TDD
4-5 days. If the 4-day version; the sessions are 8:15am-5:45pm (for example). If the 5-day session, sessions are 9:00am-5:00pm (for example)
This popular, high-impact, and hands-on course on agile & lean development is aimed at team members looking for solid core development skills (ranging from analysis to design to programming), and is based on industry leader Craig Larman’s extensive experience coaching and applying agile modeling and development for decades.
What really matters is not a set of diagrams and documents, but a quality, running system that meets the needs and constraints of various stakeholders. Thus, how can we effectively apply modeling in an agile value-adding practical approach that emphasizes collaboration and creativity, and how can it be integrated with programming and automated tests to create great software? How can we more easily and effectively understand the user experience and needs, and design product experiences that make an impact on solving their goals? And how can we design software with technical agility to enable business agility? Finally, what are the overarching principles to the design of elegant, understandable, and extensible systems?
You will leave this course with appreciation for the value of this dictum (Larman's Law of Modeling): We model to have a conversation. And for the importance of clean code to enable agility, going faster, better quality, and collective code ownership.
In this intensive hands-on seminar you will find the answer these questions. There is a little lecture time, but the majority of the time is spent in high-value-education small modeling teams at the whiteboards while the coach rotates and works with each team, coaching the case studies while applying agile modeling, principles and patterns. The coach will also help you implement your systems, while you lean the powerful practice of test-driven development (TDD) with refactoring. Plus, acceptance TDD to move towards "requirements as executable tests."
The course involves multiple iterations of several case studies, in which the teams go through repeating cycles of agile modeling for user experience and interfaces and for analysis and design, "specification by examples" table-tests that support acceptance TDD, and then development with unit TDD to create clean code. On each cycle, the coach gradually introduces more principles and techniques to build software with agility.
We apply a variety of education techniques established over 20 years of coaching and mentoring to maximize the learning, value, and fun, including buzz groups, multi-modal learning, and lots of hands-on practice.
You will leave this workshop with much deeper core skills in agile software development, supporting business agility and creative, collaborative product creation.
Methods of Education
Discussion, presentation, Q&A, workshop exercises
Developers, architects and other technical leaders
Intermediate: This course introduces concepts and techniques that the attendee will apply during the workshop.
Familiarity with an object-oriented programming language
Upon completion of this course, students should be able to:
- do agile modeling related to user experience, requirements, and design
- think and design in in low coupled components or objects
- design with core principles and patterns that enable software with agility
- do acceptance test-driven development with Specification by Example
- do unit test-driven development
- apply basic refactorings and refactoring tools
- write clean code
- transform agile models into code and tests
- take a problem through requirements analysis, design, automated tests, and well-crafted software in the context of an iterative and agile process
- Agile & Lean Development and Design Agility — Agile and/or lean development frameworks (such as Scrum) aim to increase flexibility or agility in the development organization, and thereby enable business agility. All this requires frameworks that encourage flexibility, and software designs and code that encourages agility and reduction of the lean wastes.
- Agile & Lean Development — We briefly introduce the family of agile development frameworks, such as Scrum, and Lean Software Development. These frameworks require practices to enable the agility that they are trying create in the development and business units.
- Agile Modeling — One key enabler of agility is agile modeling, a collaborative technique of modeling together in small groups at giant whiteboard areas or with other simple collaborative tools for creativity and collaboration, such as paper, Post-It Notes, etc. Agile modeling is used throughout this course and you will leave with lots of hands-on experience in this important skill.
- Grasping the User Experience and Designing Better Interfaces, with Empathy for the Users — We explore and apply some concepts and techniques from the vast field of user experience and design modeling, human-centered design, and user-centered design, such as field studies -- discussion only ;) --, user task analysis, and more. We practice agile modeling with low-fidelity UI prototype mockups, discuss larger-scale techniques such as story mapping for user-task analysis and solution mapping, and some of the Design Thinking values and principles.
- Requirements with Agility — We explore the techniques and models of agile requirements, including use-case diagrams, user-stories, impact mapping, and more.
- Specification by Example — This simple and powerful technique for detailed requirements analysis is an important component of the agile toolkit. In this section, we practice, in detail, how to do specification by example. This involves coming to a shared understanding of a small requirement based on a set of (typically) 10-30 very concrete examples related to the requirement. In this way, the people use an inductive learning method to comprehend a requirement.
- Acceptance Test-Driven Development — ATDD is a powerful high-impact practice in which the automated acceptance tests for a requirement are implemented before the solution code. And typically, these acceptance tests are distilled from the examples in a prior specification by example activity. We use a free open-source ATDD tool to implement these acceptance tests first, which then drives us to thereafter implement a solution so that the tests are passing.
- Lightweight Domain Modeling — Domain modeling involves creating an object-oriented domain analysis model to identify the noteworthy concepts, attributes, and associations in the domain of requirements under development. We apply agile modeling to do collaboratively create a domain model, which will be useful input to subsequent design modeling.
- Sketches for Dynamic and Static Views — In agile modeling, the team may create views that emphasize understanding or designing the dynamics of the system under development, such as collaboration diagrams of software object interactions. And they may create views that emphasize the static aspects of the system, such as design-class diagrams. In this section, we learn to create these views, and apply that knowledge the major case study under development.
- Agile Architecture Based on the Hexagonal Architecture Pattern — We learn about the large-scale hexagonal architecture pattern and its relationship to the Layers pattern, and designing with Ports and Adapters. We apply this to our project, while agile modeling.
- a SOLID GRASP: Core Principles and Patterns of Great Software — What are the key principles of object-oriented software development, and how to apply them while agile modeling or hands-on programming? In this section we learn to apply the GRASP and SOLID principles of design to our case study project. These include Information Expert, High Cohesion, Low Coupling, Polymorphism, and many more.
- Clean Code — A majority of this intensive course involves hands-on agile programming, in which we learn to create clean code. We examine key elements of clean code (including names, good methods, and error handling) and the many code smells associated with dirty code.
- Unit Test-Driven Development — Unit TDD (or just TDD) is a key aspect of clean code and agile software development. In short, it implies writing a unit test for one logic path of one method, before we implement the method, and vigorously refactoring the method after it is written. All this leads to designs with lower coupling and easy dependency injection. We learn the TDD cycle and develop all our code in the course using TDD.
- Refactoring — This is the critical third step in the TDD cycle, in which take the time to identify dirty code and code smells, and clean the code. We apply refactoring to all the code we create throughout the course, and learn many key refactorings, include Extract Method and many more.
- Introduction to High-Frequency Design Patterns — Design patterns are a key enabler of flexible software, and therefore can enhance agility. We learn to apply some of the most common design patterns while developing our case study system, including Simple Factory and Adapter.
- Agile TDD and Refactoring
- Agile Design and Modeling for Advanced Object Design with Patterns
- Agile Acceptance Test-Driven Development: Requirements as Executable Tests
- Agile Architecture: Process and Design Tips to Support Flexible Systems