Does Agile work?

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.

Short Terminology:

  • 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.

How about other tests such as integration or behavior-driven? This is the part that trips me. When it comes to integration tests, how integrated should it be? All the way up to javascript layer? Launching browser to run tests isn’t exactly a speedy experience.

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.

(Process) Collaboration

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, 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.


The Male Programmer Privilege Checklist

May 25, 2009 § Leave a comment

Original Article here:

The article is thoroughly descriptive and I didn’t even realize some of them until I read it.

Import Statements

April 22, 2008 § Leave a comment

Import statement is always different among programming languages. Not only the syntax, but also the concept of how codes are managed and called. Below are import statements from a couple of languages for your entertainment.


Python keeps track of its own modules (via PYTHONPATH) and perform import on those modules.

In Python, a module is just a file with definitions and statements. A module can also be a directory with in it.

There are multiple ways of using import syntax in Python:

  • import [identifier] #identifier can be Class, variable, or function name
  • from [module_name] import [identifier] #specify which module do you want to import from
  • from [module_name] import [identifier] as [alias] #alias your imported identifier
  • from [package_name.submodule_name] import [identifier] #in Python you can have modules inside a package

Interestingly, Modula-3 seemed to have the same style of importing as Python.


Now let’s move on to Ruby’s require.

Ruby found its libraries, and all modules inside them, by checking each directory inside $LOAD_PATH.

At first glance, Ruby seemed to just know where all its modules are. The require statement doesn’t need any description about path/location at all. Passing the path helps readability though.


There’s not much to say here.

In short, when PHP interprets, it will appends all the imported files and evaluates them all at once.

To import, use:

require_once [relative_path/file.php]


Perl import statement is called use. I am not a Perl expert, but here is the syntax:

use [module_name] [list_of_imported_things]


Disclaimer: I am not LISP expert, these are things that I’ve read.

LISP codes are broken into packages. To import those packages, use this syntax:

use-package [comma_seperated_packages]


Basically the syntax is:



Where Am I?

You are currently browsing the programming category at RAPD.