One Liners

  • Selenium tests: painful to write, but incredibly useful for UI stuff.
  • continuous integration billboard: invaluable for grokking the current state of your tests.
  • "tracer bullet" development technique: like candle-making (dip wick in wax, you get a thin but functional candle; keep dipping until you get a fully formed one)
  • remote pair programming works really well: each of the two is accountable to the other
  • writing unit tests for code you did not write: great way to learn or understand code or 3rd party library
  • revisit unit tests, e.g. when writing "agile documentation": you can discover bugs that weren't caught by your initial unit tests.
  • a tool such as Trac proves to be very useful for an agile approach to development and testing
  • profiling your unit tests isn't useful: they're not typical uses of your code.
  • keep your unit tests short & sweet. it may be worth breaking out long tests into your continuous integration setup rather than expecting developers to run them regularly.

Lessons Learned

Setting up a good unit test structure (with paths, locations of files, etc.) is painful.

  • tests should not depend on your environment
  • run unit/acceptance tests as 'buildbot' user and iron out all environment-specific issues (OS version, Python version, required package version)

As you work through the prototype, enter all of the random thoughts about future features/stories into the tracker or into the milestones.

Acceptance tests at the business logic/back-end layer (written for example in Fit/FitNesse) prove to be extremely resilient in the presence of code changes; acceptance tests at the GUI layer prove to be more fragile and need frequent changes to keep up with changes in the UI.

Trac combines:

  • a Wiki -- which allows easy editing/jotting down of ideas and encourages brainstorming
  • a defect tracking system -- which simplifies keeping track of not only bugs, but also tasks and enhancements
  • a source browser -- which makes it easy to see all the SVN changesets
  • a roadmap -- where you define milestones that are tied into the tracker
  • a timeline -- which is a constantly-updated, RSS-ified chronological image of all the important events that happened in the project: code checkins, ticket changes, wiki changes, milestones

Trac can be used as an agile project management tool by defining:

  • iterations as milestones
  • user stories as tickets of type "enhancement"
  • stories split into tasks, which are tickets of type "task"
  • Trac offers a nice "tickets per milestone" view which allows you to see your progress in completing tasks/stories associated with a particular iteration/milestone