October 15, 2009 § Leave a Comment
This is question has been asked for many years now. And let me tell you right now, I won’t preach about it in this post.
Trying to understand Agile has been very difficult for me. Agile defines many things, it is a collection of techniques and methodologies, it is a subset of software industry, and it is an overly positive adjective. It’s been quite a journey between me and Agile, and this post is my way of sharing the experience and as you will find out later, I’m struggling in some of them.
- Customer: Can be your clients or management.
The following are the ones that I’ve been exposed to, definitely not a complete Agile list.
(Technique) Pair programming
There are enough people who said that pair programming may not be effective, and not for everyone. The reason is that, while 1 programmer is coding, the other one is bored to death.
It’s easy for me to see why other people can have terrible experience while pair programming. Even though pair programming sounds easy, there are a lot of hidden requirement behind pairing:
- Both programmers need to be at about the same speed/skills, kind of like badminton.
- If one is a much better programmer, then s/he needs to have a good verbal communication skills (another implicit requirement). There’s no way for slower programmer to keep up with vim windows without verbal guidance.
I see that pairing is valuable because it distributes risks. Some programming decision making is far riskier than others. By having another programmer to weigh in other options, I feel less stress already.
I have no doubt in this technique. Should I do it all the time? I don’t think so, many tasks are simple enough to be done solo.
(Technique) Write tests
A few popular programmers said that writing tests slow them down. I could see that, because is a different way of doing things than they are used to. And since startup software development cycle is quite harsh, picking up a habit of writing tests will always be low in priority.
To me, writing unit tests have 1 obvious value, to prevent regression. I am willing to sacrifice speed in favor of stable code base. Nobody like to fix the same damn bug introduced by different (in few unfortunate case, same) people.
I also struggle with behavior driven tests. Should I always NOT test implementation detail? Many times, I’m interested in how the implementation actually works.
(Technique) Write tests first
I struggle with this hands down. Writing tests first is like asking me to write with left hand and I’m a righty. I need to understand the problem domain and perform a couple of spikes to further understand it. And I cannot do that if I have to write tests first. Because of this I can never call myself a TDD programmer.
(Process) Quick feedback cycle
From Agile perspective, customer should have quick feedback cycle so that they could be flexible in their planning. I agree with that. It is unrealistic to set a far reaching, fixed schedule in software world because there are too many moving parts (new features or solved problems in the past).
That said, I’m looking at this process with a grain of salt. What’s stopping the customer running around in circles accomplishing menial successes? It’s of course the developers job to remind the customer but alas, often times we are too busy duct taping.
(Process) Planning game
I like this process. This is the most concrete, easiest way to inform customer whether xyz is feasible or not. There are many tangible benefits that come from planning game:
- Customer is aware of development progress.
- It’s easier to ground customer to reality because they are aware of what developers can or cannot do given velocity X.
- It invites customer into creative thinking process because they need to think hard in choosing their features.
(Process) Estimates velocity
IMHO, any developers who are doing contract work need this skills. From business perspective, that’s pretty much the whole point. How can developers profit from selling services if s/he has no idea how much s/he can produce in X time?
This skill is also important for full time developer to set expectation to management. By knowing your velocity, you can prevent your own burnt-out.
Implicitly, this skill gives developer ability to say no to overly ambitious schedule. Does customer always listen to your estimates? probably not. If they never agree to your sensible estimates, then your alarm bell should ring.
Working in team setting is heavily underscored in Agile. Pair programming is subset of this. In general, this makes sense. Cooperation of many people almost always yield greater results. But collaboration is not silver bullet, there’s implicit requirement to have a functioning collaboration.
Most importantly is trust. It’s impossible to have any kind of collaboration if there’s no trust among members of the team. Even in family setting it wouldn’t work. For companies that have distrust or paranoia environment, they have bigger problem to solve and I don’t think Agile could help.
(Meta) The simplest thing that could work
I believe this is why we are paid to do programming, to exercise our technical judgment in creating simple solutions. Any type of users/customers always demand simple solutions even if the requirement is complex, Mint.com is a great example. I believe this mindset is useful even outside Agile context.
(Meta) YAGNI “You Ain’t Gonna Need It”
YAGNI is the subset of “the simplest thing that could work”. YAGNI mindset can help developers to avoid becoming architecture astronaut. It’s far too easy to architect something that’s far in the future, especially if the development team is shielded from financial reality. It’s dangerous for development team to spend too much time designing for issues that may never arrive (this issue might be more relevant to startups). Again, I think this mindset is useful in general.