Journal de Jacques

So I’ve started working on exercise 2A. I was about an hour in before remembering I’m supposed to be tracking every defect, no matter how minor. So I have two in the defect log so far, both with estimated repair times.

Otherwise, uneventful so far. Writing a physical LOC counter is pretty straightforward. A logical counter will be more interesting.

Remarkable how productive one can be when the internet is broken.

My thinking for exercise 2A (which is based on R1 and R2) is to build a SLOC counter using LPeg and Leg. This exposes what is to me a hole in the PSP 0.1. How does one account for researching time? Does it go under Design? In a more elaborate PSP I can only imagine that it deserve its own heading.

So I’ve just finished exercise 1A from A Discipline for Software Engineering.

Switching to more idiomatic Lua (see my last post) made a big difference in the subjective easiness of the work; but I still spent almost as much time in the Test phase as I did in the first design.

Nevertheless, the code now runs and passes the miniscule test suite based on the data in the book (Table D5). I wonder whether it would have been worth to write a fuller suite to cover the functions I put together — for example, the std_dev function is tested directly by the suite, but not the avg or sum functions.

I’ve also started putting my work online at Github. Pretty rudimentary stuff, but at least it gives me a motivation to do the exercises if I imagine that somebody is checking out the code & logs and going over them.

For testing I used the lunatest package. Missing from lunatest is a capability to provide precision deltas on the assert_equal function. In ADFSE, the standard deviations of the sample data are given to 2 decimal places and are rounded. Lua doesn’t have rounding built in, so it was necessary for me to include a little rounding function to equalise the results. Other testing frameworks I’ve seen allow you to pass in a delta value — a degree of permissible variance that still counts as “equal” — which saves a lot of the bother.

So that’s it. I’m looking forward to the next exercise.

So I’ve been working on the first of the PSP exercises. The requirement is to write code that calculates the average and standard deviation of a linked list.

My first attempt hasn’t ended in failure, so much as the realisation that I took the wrong approach. I’ve marked this down as a design defect in my error log.

The emphasis really ought to be on the standard deviation and not on the data structure. I’m writing in Lua, a language which among other things includes a flexible standard data structure called ‘tables’, which can at various times behave like arrays, hashes, stacks, queues and so on.

My next revision of the code will focus on using tables as-is, rather than bodging up a linked-list structure composed of tables with two elements. I expect it will probably be much easier to write, too, due to Lua’s support for easy iteration over table structures.