Practically Agile
Using Agile in less-than-perfect situations since Y2K
Improving Podcasts!
The one or two of you who actually come to the site to read these posts may have noticed that a few weeks ago, I added a link to Improving Podcasts in my sidebar. Allen Hurst, I, and a few other Improving employees have started producing a bi-weekly (every other Tuesday) podcast covering software development topics.
We have three episodes produced, and the latest was posted just this afternoon. (It may take some time for it to show up in iTunes.) The topics to date have centered around Agile projects management and development practices. Head over there, listen, subscribe, and please provide feedback. We really would love some positive feedback in iTunes, but to suggest topics, ask questions, or invite yourself to join us, the best place is the web site itself.
Tags: agile, improving, podcast
. 14 Jul 09 | Conferences and Talks | Comments (0)
Formality, Not Rigidity
Many people conflate formality and rigidity, treating them as inseparable. It is easy to see why. Formality leads to rigidity as mechanisms are put into place to ensure formalized practices and processes are followed. You have likely seen this go wrong as I know I have. Architecture groups and PMOs shift their focus. No longer an aid to progress, they become an obstruction. They keep their formality, but lose their purpose as they become rigid.
Agile is, in part, a reaction to the rigid process models of the past. It is no surprise that many throw formality out as well. However, without a degree of formality, we lose repeatability. This has happened in countless efforts to implement Agile methods. The team, seeing a chance to break from the rigidity, pushes off any attempts at formality as well. As the project progresses, cracks begin to form. There is no formal test plan, so high-level bugs creep in. That is, while the expressed stories may work as requested, certain aspects are simply not covered. Because there was no formal effort to design the user interface flow, usability of the product starts to plummet as the complexity of the combined requirements weighs upon each successive screen.
These, and other aspects, are things we as software development professionals have learned to do reasonably well in the last 30-plus years. Ignoring them hurts our chances of success. Are these things non-Agile or anti-Agile?
No they are not. To completely ignore formality would be to throw even Agile practices out the window. Software development requires people to coordinate actions. The amount of formality to do so varies based upon the team and its goal. However, some degree of formality can be an aid when more than one person is involved.
It is all in how we apply formality. Things such as test plans, information architecture and user interface flow, and domain modeling applied in an “all up front” fashion would be difficult to reconcile. However, none of these things has to be rigid. They can adapt just as easily as we can refactor our code. If the plans are designed with this in mind, small adaptations are easy while larger ones remain possible.
It is worth repeating that not every effort requires the same degree or type of formality. If a project is just starting or has only minimal and very simple user interactions, perhaps a comprehensive outline of user interface flow really isn’t necessary. However, we must train ourselves to recognize when it becomes necessary. As soon as anyone in a retrospective or user demo says, “I can’t find a screen where I can do X,” it might be time to examine the flow. In fact, it may be worth formalizing a list of “smells” that point to the need for adding some of these practices. Somewhat similar to those in Agile Adoption Patterns
Tags: agile, retrospectives
. 19 Jun 09 | Process | Comments (0)
Full-Court Press and the Evils of Local Optimization
Great post from Bill Mill. Go on, read it. When you’re done, here’s the key quote:
The Warriors could optimize like crazy for the press, but they’d be training and working and trading and drafting to be, at best, a pretty good team.
This is why those that preach from the gospel of Lean try to impress upon us that local optimization is an insidious evil. It often looks good from a certain viewpoint, but it can hide other improvements that would provide a more holistic benefit. It can even prevent you from reaching your true goal.
. 02 Jun 09 | Process | Comments (0)
Aligning Agile with Enterprise Architecture
A mailing list pointed me to a recent post by Jeremy Miller on Agile design and an older one by Joe Ocampo. Both discuss how design happens in an Agile project. Both are great posts. Jeremy’s post sticks largely to what is considered the Agile “party line”: design is done all the time rather than up front. Joe’s post talks about using Domain-Driven Design to develop the “ubiquitous language” that teams need for communication. Jeremy admits in the comments that a bit of up-front establishment of a domain is useful as context, but distinguishes it from design. Presumably he is equating it with analysis. Having written a book that, in part, shows how use of consistent domain modeling patterns can inform design and implementation, I would say it’s both. But that’s not what I want to talk about….
Reading these posts and exploring a bit further, I began to relate the establishing of a domain context for stories with establishing an architectural context.
One of the main challenges I have faced and hear others describe is how to maintain agility when there is a scope of multiple Agile projects (what the PMBOK would call a program) or an enterprise portfolio that really needs consistent architecture. I am generally a believer in simple, evolutionary design. However, as Jeremy points out in his post, it requires people with the proper skills to maintain an open design/architecture and who know how to tell when they have reached the last responsible moment. What I have discovered is that as the scope of systems under development scale, the last responsible moment for certain architectural decisions tends to shift earlier.
As such, a reasonable step would be to include a (short) architectural analysis session for each release that would mirror the domain modeling exercises Joe mentions late in his post. In that way, those with architectural knowledge could get involved and discuss what architectures support the features required and which decisions need to be agreed up front. Provided this is timeboxed and the group puts appropriate emphasis on postponing that which can be, this is in line with Agile values as well.
I should also note that I would only add this practice if the team found it necessary. As a coach, I might recommend it upon seeing the following things either in a retrospective or during planning or other working sessions:
- multiple components, libraries, and/or frameworks in use that accomplish the same goals
- “not invented here” syndrome
- lack of integration testing between project teams’ output
- failure of or difficulty with coordinated deployment (usually preceded by the lack of integration testing)
- no or limited consideration of nonfunctional requirements (performance, stability, etc.)
- failure to meet nonfunctional requirements
I’m sure there are other smells that would indicate a need for architectural planning. If you think of others, let me know in the comments.
Tags: agile, design, domain modeling, streamlined object modeling
. 08 Jul 08 | Architecture | Comments (6)