Cerrisian Blog

So, I’ve basically finished my refactor/resuscitation of PyGP (except for the part where I actually package it and release it). So it’s time to select my next victim.

Since I mostly do Java at work, I thought I’d select a Java project. I’ve found such a project in YAJII, a java implementation for an IRC client. It doesn’t appear to have any unit tests (or a build system) but it does have some documentation. The author’s current webpage is here.

My real goal would be to use this as a project for a coding Kata, potentially to be presented at the OSUG, depending on the interest I get, I could then spin off a sub-group or another meetup for code Katas in general.

Before I’m able to do a Kata I’ll have to do the following:

1. Get it to build with ant or some other build tool (ant + ivy, maven, buildr, scons…)
2. Run the “testbed” application through it’s paces.
   • This would follow the context driven testing methodology, maybe a 1/2 hour session to find a big problem to fix. “Go through all the menus to get a feel, read the user manual create a test outline.”
3. After the problem the big problems from the testing perspective have been found, I’ll use the saff squeeze to isolate it with a unit test. This will be an iterative process of getting the program into a test framework, starting with a “smoke test” covering much of the stack and iterating towards the point that the saff squeeze will lead me to. These will use various techniques from Working Effectively With Legacy Code to get the code unter test.
4. Finally, use techniques from WEWLC to fix the problem/add the feature found in exploratory testing.

Since this is a Kata, it will mostly focus on getting good technique. It’s okay to go down false allies to figure out what’s happening. The techniques that will be covered are:

1. Dealing with build systems, especially of code that isn’t under one yet.
2. Exploratory testing (Context-driven school). A very different skill that most developers don’t have.
3. Getting code under automated tests.
4. Converting a exploratory test into a fully automated test. Both acceptance level and unit level.
   1. This includes dependency breaking, the saff squeeze and test doubles.
5. Fixing code based on automated tests.
6. Verifying a code fix manually after automated tests.

I think this would hit a lot of the skills needed for software maintenance. This seems to be large enough to break into multiple Katas.

My concern is that it may be too big to do as an introductory Kata, maybe something else would be better? Bowling scores, or maybe one of the problems from S.Lott’s blog?

A lot of small businesses basically just need a “brochure” website, multiple pages consisting of contact information, advertising copy, testimonials, schedules, maps, etc. Currently I don’t know of any specific django app to easily do this (that meets the following requirements)

• Easy for endusers to update and edit (CMS with WYSIWYG editor, preferably usable with MS Word)
• Easy for endusers or developer to change templates (dbTemplates, good presets such as YUI or blueprint)?
• Easy to deploy on cheap shared hosting (Django already meets this requirement with flup and its FastCGI interface).

A simple brochure site using Django could probably be created using the following:

• Django Page CMS for the CMS part
• A Django Admin Widget like this one for editing pages
• And finally dbTemplates to allow for client-editable templates

This was from August 2008, just found it now…

It’s amazing how just being exposed to people arguing can tire you out. Maybe it has something to do with the topics being important being argued about. In any case, all my reserves of energy were totally shot today.

I just did my mnemosyne cards, an extremely small amount on OS, uploaded my latest drawing, drew a bit (that was really relaxing.) Looked up how to mock datetime in python, did some research on the newforms admin in Django, and…that’s it, I guess. Huh, I did a lot for someone who’s nerves were totally fried.

When I draw on the picture plane now I’m developing some spatial memory. This really helps with dealing with the slight changes in position of my viewpoint as I draw. It’s interesting, just be repeating the exercise over and over, I’m able to gain just new skills and understanding. It’s really interesting how we are able to learn new things, repetition is reinforcement and discovery, or at least that’s how I perceive it.

I notice the same thing with my mnemosyne cards, when I forget something, I think about how it fits in with my other knowledge, which is usually a discovery process, at the same time, the repetition of learned cards reinforces the memories. The same type of thing happens with drawing, but each “atom” of knowledge can’t be separated like it can be in mnemosyne.

Which reminds me, I still need to add the diagrams to class to mnemosyne for Physics and Operating Systems…