The latest trends from the Agile Alliance Technical Conference
Source – techtarget.com
The Agile movement took over software development; now most of the teams I work with use standups, stories, and sprints. Meanwhile the Agile Alliance conference, which has grown from 900 attendees to 1,500 attendees in the four years I have attended, has been consistently decreasing its technical content. There are exceptions — the DevOps track is growing — but the programming and testing tracks have less interest. The decreasing interest in technical subjects mean fewer technical people are attending the conference, fewer are going to attend technical sessions, and the organizers, who will then see fewer attendees at technical sessions, will schedule fewer for the next year.
Something had to change, and it did.
In 2016, the Agile Alliance scheduled their first Agile Alliance Technical Conference, or AATC. This year I decided to attend to see what was happening.
The opening talk of the Agile Alliance Technical Conference 2017 was given by Ron Jeffries and Chet Hendrickson on test-driven development. The two speakers performed the bowling game kata, a form of deliberate practice in which a programmer (or two) solves a known problem, again and again, building skill while it’s happening. In this case the skill was test-driven development, and along the way, the two discussed quality, going faster, pair programming, and other aspects of “modern” Agile development.
Because a Ron and Chet talk is never quite the same talk twice, the two have been doing the bowling game kata as an exercise for at least a dozen years — still, it seemed new to the audience.
Other sessions at the Agile Alliance Technical Conference included a keynote on extreme programming — even though this practice just turned twenty years old — as well as others on the fundamentals of test-driven development, refactoring and other introductory topics.
What was happening?
The technical renaissance
It’s easy to look at the data above and conclude that this change is a “very bad thing.” The industry seems to be post-agile, which, interpreted at its worst, means “doing the stuff that is easy to adapt, and being pragmatic, which is code for never really doing the hard technical things at all.”
But there is another explanation.
The night before the Agile Alliance Technical Conference, I ran into Linda Cook, an Alliance board member. Over dinner she explained that the whole purpose of the event was to draw a different crowd — people who were not plugged into the conference circuit, and did not know about the new methods, but were hungry to learn.
The Agile Alliance Technical Conference filled up the ballroom of a major hotel in Boston with people interested in getting started with technical practices like TDD, refactoring, and clean code.
It is possible the Agile technical practices have reached the mainstream.
The diffusion of innovation
When Everett Rogers created his diffusion of innovation theory he described five steps: Innovators, Early Adopters, Early Majority, the Late Majority, and Laggards.
Instead, people were talking about good code.
Proto-Agile, Agile, post-Agile
Each morning, before the conference, a few of us got together for Lean Coffee, an unplanned conversational meeting. Attendees would propose topics that interested them, then we would vote to decide what to talk about. One of the topics we discussed was the state of technical practices in the industry, specifically “Is extreme programming dead?” Again, the idea of post-Agile was floated.
That was when Woody Zuill, who sat at the table, began to talk. According to Woody, proto-Agile is “we know what we had before isn’t working, and now we are discovering new things;” Agile is “We actually understand these modern methods and do them well;” and post-Agile is about continuing to innovate. Woody said that XP can’t be dead, because he uses it every day.
It’s very hard to judge the temperature of the Agile Alliance Technical Conference, and even harder to take the temperature of an industry. What I see for certain is that people are still learning, still experimenting, still innovating in technical practices, while the older, tried practices that have been accepted as true are starting to spread. Test-driven development, refactoring, and “run clean” have gone from being strange ideas to things people want to learn about and make excuses for not doing.