bitwix

Coincidence?

2012-01-27T14:29:00.002Z

Google Predict through the API Explorer - tick.
Through Google's sample code - tick.
Cut down to my own DLL - failed.

I tried various things. It was when I chose to reference my own DLL from the Google sample that it said my project was targetting a different .Net framework. So I changed it to be .Net 3.5. I ran the test.

As it was passing, TweetDeck showed me Uncle Bob Martin's re-tweet : RT @jon_cham: Prolific developers don't always write a lot of code, instead they solve a lot of problems. The two things are not the same.

Make it fast

2011-12-29T10:59:00.001Z

I spent an afternoon on the Word Chain kata. The challenge is given two words of equal length (e.g. CODE and MESS) to find words that change one into the other, altering one letter at a time, so CODE MODE MODS MOSS MESS.

I got it to work, using the SCOWL dictionary. I improved my algorithm, by searching from both ends rather than just one. I split classes into smaller ones with limited responsibilities - a ChainSeeker, a Tentacle, a Route. It was better.

I then decided, uncharacteristically for me, to make it fast. So a list of used words was replaced by a hashmap. It was faster.

As I proceeded, the slowest part was finding the possible words to go next. Input CODE, output a list of MODE, NODE, COPE, CODA etc. Here's the final code I used:

public List<string> GetPossibleNextWords(string word)
{
    List<string> result = new List<string>();
    int wordhash = HashMap.MyHash(word);

    for (int i = 0; i < word.Length; i++)
    {
        string before = String.Empty, after = String.Empty;
        long hash0 = wordhash - HashMap.HashAt(word[i], i, word.Length);

        char skipc = word[i];
        for (char c = 'a'; c <= 'z'; c++)
        {
            if (c == skipc)
                continue;
            long hash = HashMap.HashAt(c, i, word.Length);
            if (KnownHash(hash + hash0))
            {
                if (before == String.Empty && after == String.Empty)
                {
                    before = i > 0 ? word.Substring(0, i) : String.Empty;
                    after = i + 1 < word.Length ? word.Substring(i + 1) : String.Empty;
                }
                result.Add(before + c + after);
            }
        }
    }
    return result;
}

It's faster, but it's worse. I'm taking advantage of understanding the hash algorithm to calculate the new hash from changing a letter. I'm keeping these strings before and after blank until I really need them, then holding them in memory on the off-chance that I need them again.

I daresay it could be made faster still. I'm sure that creating and passing List<string> objects is inefficient. But I think I've learned something, which is that I can keep making code faster, but at the expense of legibility.

Judicious use of decoration

2011-11-06T12:05:00.001Z

essica Hische has this great blog, Daily Drop Cap, with letters to use at the beginning of paragraphs. Just last month, I read Roads to Quoz by William Least Heat-Moon where he admits to a fondness for the letter Q. Johns, Jemimas, Jacks and Juliets around the world may share with me a preference for the tenth letter of our alphabet. Judge me not for having married another. Jump on the opportunity to admit your passion! Jettison timidity and celebrate the letter in whatever way you choose!

Algol for Interviewing

2011-10-30T11:22:00.000Z

Next time I'm interviewing a programmer for a job, I'd like to use this fragment of Algol. It comes from Electronic Computers by Hollingdale and Tootill (published 1965) which I stole from my brother-in-law's bookshelves.


begin comment Evaluate pi from Vieta's formula;
  real e, f, product; integer count;
  e := read tape;
  f := 0; product := 1; count := 0;
  for count := count + 1 while f < 2 - e do
    begin f:= sqrt( 2 + f );
      product := product x f/2
    end;
  newline; print (2/product); print (count)
end

Good algorithm, better maths. Sixteenth century Italy was an advanced place intellectually.

Je suis un bricoleur

2011-09-12T14:47:00.001+01:00

... the 'bricoleur' is still someone who works with his hands and uses devious means compared to those of a craftsman. The 'bricoleur' is adept at performing a large number of diverse tasks; but, unlike the engineer, he does not subordinate each of them to the availability of raw materials and tools conceived and procured for the purpose of the project. His universe of instruments is closed and the rules of his game are always to make do with 'whatever is at hand' ... the engineer is always trying to make his way out of and go beyond the constraints imposed by a particular state of civilization while the 'bricoleur' by inclination or necessity always remains within them.
Claude Lévi-Strauss, The Savage Mind, pp 16-19, quoted in Adhocism

The distinction is between appropriateness and urgency. The scientist is intent on using the tools and hypothesis appropriate to his job, whereas the bricoleur or adhocist is intent on undertaking his job immediately, with whatever resources are available.
Charles Jencks, Adhocism, p 17

I am a bricoleur. That explains my divergence from some colleagues who want me to embrace a new language, and from greater agile minds who want me to use mock objects. I can make do with what I've got. Note, however, that Jencks insists that the bricoleur and scientist are equally objective and deal equally rigorously with the facts. The distinction is not one of kind or quality.

SquareOnBoard Wordle

2011-08-17T14:53:00.008+01:00

Wordle of code. This is heavily commented for Intellisense, causing the popularity of see, summary and returns. The class itself, SquareOnBoard, is more common than other classes such as MGCell or ExportParameter so not too bad on the feature envy front. I see there are both string.Empty and String.Empty, and we're using null rather than a Null object.

Here's a second class. In this case I got Wordle to include common words, so if appears. I also used the alphabetic sort option. This one has no Intellisense comments. The effect of these changes is to see that I use r and c variables, and increment both with ++. The class itself, Surface, is hardly mentioned while the work it does is clearly on squares of various sorts. m is actually the m_ prefix on a member variable.

What fun www.wordle.net is!

Agile 2011 Sessions, Notes and Links

2011-08-15T10:53:00.005+01:00

MONDAY

Fluency over Proficiency: Accelerating Agile Learning and “Hunting Language”, Willem Larsen
Also known as who I crashed and burned at learning American Sign Language

The Transformation Priority Premise, Robert C. Martin
Bowling score game : designed 400 lines, test driven 14 lines

TUESDAY

Fluency over Proficiency again, as an Open Jam session. I moved on a little bit.

Powerful Questions, Carlton Nettleton

Adaptive Leadership: Accelerating Organizational Agility, Jim Highsmith

Lightning Talks including Michael Feathers on limits of agile

WEDNESDAY

Creating an Environment by Making, Keeping, and Amending Agreements, Amr Elssamadisy

Continuous Integration, Jez Humble

Agile Game Incubator, Michael McCulloch and Don McGreal
Zhong Zhi, a one-handed agile game invented and refined

Making Hard Choices about Technical Debt, Nanette Brown, Robert Nord
Board game fun, and yay I beat Elisabeth Hendrickson
See Ward Cunningham's OOPSLA 92 presentation

Lightning Talks including www.prezi.com

THURSDAY

Creating Customer Delight, Stephen Denning
Net Promoter Score = Reichheld’s single question to customers. How likely are you to recommend us? 0 No – 10 Definitely. Count 9s +10s less 0-6s. Positive territory is good.

Experimentation: a Missing Agile Practice, Arlo Belshee

The Kata In The Hat, Emmanuel Gaillot & Jonathan Perret

Slackers and Debtors: Meet Commitments, Reduce Debt, and Improve Performance, James Shore

FRIDAY

Code, Kevlin Henney
The Agile Mindset, Linda Rising

QUOTATIONS ETC

WILL TEACH CLOJURE FOR FOOD
I think middle management gets a bad rap [applause] Jim Highsmith
Without exception, all of my biggest mistakes occurred because I moved too slowly. John Chambers, CISCO CEO, quoted by Jim Highsmith
“It’s not an act, is it Bob?” friend of Robert Martin, on finding him playing with his laser pointer in a mirrored bathroom
As TDD developers, after doing a design, the first thing we do is ignore it RCMartin

“What’s the chance of changing my wife?”
“I divorced mine”
“You gave up on changing your wife”
“No, she gave up on me”

SUGAR HOUSE

Wildflowers Bed and Breakfast
Sugar House Coffee
Omar's Rawtopia
Wasatch Jazz Project

Easy does it

2011-07-28T16:38:00.003+01:00

I applaud Brian Marick's argument that Ease should be a core value at work. In a talk at the SDC 2010 Conference he spoke of the smooth cadence of good work, such as the nurse who has ready the next instrument a surgeon needs.

Javascript I do not find easy. I'm trying to relax into it, kick off my compile-time error expectations, use its freedom and informality. But I still aim for ease. To this end, I'm getting Intellisense to work for me and I'm learning which functions I need to add to make jQuery even more natural. I JSLint everything, and built a tiny publication application for combining and minifying the .js files.

Perhaps I'm getting there, perhaps I will end up liking Javascript.

What could possibly go wrong?

2011-06-22T19:03:00.001+01:00

So that's the architecture decided. We're building an MVC C#4 LINQ and EF server talking to an HTML5 JSLint-compliant JQuery and Knockout client. What could possibly go wrong?

Pairfectionist Programming

2011-05-30T11:30:00.004+01:00

I've signed up for Pair Programming. It's a much richer way of spending my day.

I hadn't thought through what it would be like to PP with a perfectionist. The kind of guy who wants all user messages to be consistently formatted, in "real" and helpful English. The emotional arc goes from "how can this pedantic nuisance waste so much of my valuable time?" while we're programming to "what a lovely program - I must show it off to my friends" when we're done.

My conclusion : Pairfectionist Programming is another example of PP getting the best out of everyone. Give it a chance!

One either meets...

2011-04-16T08:38:00.004+01:00

I described my "deskspace" office arrangement to a friend. "Are there meeting rooms as well?" she asked. I said something about the lunch tables at one end, but you could tell she wasn't convinced.

Later that week I came across this quotation from Peter Drucker. One either meets or one works. That's what I should have said back. That, and if her job involves lots of meetings, then I'm glad I don't work for her company.

TAD Happier

2011-03-30T12:09:00.004+01:00

Yesterday afternoon, it was not going well. Trying to write visualisation code, I was getting some unexpected null links. It was difficult code and tricky design, and I'd not been doing any test first work.

This morning, I aggressively changed it so that it could have tests. Test After Development, or TAD for short. Yes, I found the error (out by one). Code is testable. New feature added as a test first. Much happier.

Pocket PC Tests

2011-02-08T10:15:00.004Z

There's no current framework for unit tests on the Pocket PC Emulator. I found a few old blog posts, but nothing looked like it was still supported. So I rolled my own.

Interesting exercise. A trade-off between usefulness and ease of development. Highlights are:

I really wanted a red/green bar for visualising success

Attribute programming and reflection is easy enough if you're following a model

Run one test with the debugger in Visual Studio is helpful

The tests are slow by comparison with say NUnit and C# libraries

They are not Unit tests, by and large. I respect Michael Feathers' definition

Clever Code and Simple Names

2011-01-31T12:30:00.003Z

A new departure this month has been writing code for a handheld device running .Net Compact Framework and talking to a web service. It's gone well.

One challenge has been to hold a cookie on the handheld so that the web service session can be held. Credit goes to a fine bit of code by Alex Feinman which provided everything I need. Here's the code in action:


public List FetchReferenceData()
{
    Service w = new Service();
    RequestData ReqData = new RequestData(w.Url);

That's the only reference to the ReqData object, while the service w logs in, downloads data and logs out. So when I copied the code to do an upload as well, I removed the RequestData line as being redundant. The upload failed, of course, because the "redundant" code was actually causing the cookied web request to work.

What to conclude? My class now talks to a lazily created Service as shown below. But I feel that I should rename RequestData so that its usefulness is made clear. Does RequestWithCookie sound better than CookiedRequest?


        private Service MyService
        {
            get
            {
                if (m_service == null)
                {
                    m_service = new Service();
                    m_requestdata = new RequestData(m_service.Url);
                }
                return m_service;
            }
        }

Coat Hanger of Power

2010-12-06T10:00:00.003Z

Liz Keogh ran a session at XpDay 2010 called Wow I Wish I'd Known That Earlier. I mentioned my Coat Hanger of Power as an example of improvising an informative workspace. The idea amused people, so here's a photo of the original.

Role Play Your Worst Enemy

2010-11-29T13:43:00.003Z

This is a record of an Open Space session at XPDay 2010 in London.

The group shouted out a few difficult conversations they'd been part of. Then a pair of volunteers acted out that conversation. The rest of us watched, and afterwards discussed our reactions.

Here are the opening line for the conversations:
I don't want to Pair Program!
The tests must inject these thousand objects into the system!
Why do we have to have so much documentation?

I was pleased by the session, with fascinating suggestions and challenges coming from everyone there. Personally, I had to face up to a willingness to "sideline" someone in order to move the project along.

Thanks to all who were there: Ikenna, Liz, Ian, Benjamin, David, Nader and Squirrel.

(I'm All) Over Comprehensive Documentation

2010-10-25T10:21:00.002+01:00

As an Agile Developer, I value working software over comprehensive documentation.

So it's a good sign when, as the software goes into full use by the customer, I find the time to write a user manual. I'd previously mastered the table of contents features, so the challenge was to find a shared location on the customer's network to put it. Writing the text I don't mind, and screenshots do make it look complete.

I intend to find out after a month who has used the manual. That's my problem with documentation - no feedback loop. Maybe this time will be different.

It's worth being dogmatic as a learning tool

2010-10-16T13:37:00.002+01:00

That's a quotation from Kent Beck on Software Engineering Radio www.se-radio.net Episode 167.

I think it's important he says "learning" tool, not "teaching". Inflict your dogma on yourself, not others. I went after 100% test coverage, and I learned a lot. I know I'd have had a mutiny if I'd demanded it of colleagues.

Scientists A-G

2010-10-10T17:44:00.000+01:00

Mary Anning (1799–1847) was a British fossil collector, dealer and palaeontologist. Ichthyosaur
http://en.wikipedia.org/wiki/Mary_Anning

Jocelyn Bell Burnell (born 1943) British astrophysicist. Pulsars
http://en.wikipedia.org/wiki/Jocelyn_Bell_Burnell

Margaret Cavendish (1623–1673) English aristocrat, a prolific writer, and a scientist. "Blazing World"
http://en.wikipedia.org/wiki/Margaret_Cavendish,_Duchess_of_Newcastle-upon-Tyne

Mary Douglas (1921–2007) British anthropologist. "Purity and Danger"
http://en.wikipedia.org/wiki/Mary_Douglas

Gertrude Elion (1918–1999) American biochemist and pharmacologist, 1988 Nobel Prize for Medicine. 6-mercaptopurine
http://en.wikipedia.org/wiki/Gertrude_B._Elion

Rosalind Franklin (1920–1958) was a British biophysicist, physicist, chemist, biologist and X-ray crystallographer. DNA.
http://en.wikipedia.org/wiki/Rosalind_Franklin

Jane Goodall (born 1934) British primatologist, ethologist, anthropologist, and UN Messenger of Peace. Chimpanzees.
http://en.wikipedia.org/wiki/Jane_Goodall

Full Coverage

2010-09-07T17:19:00.001+01:00

On the value of Maths exams

2010-09-02T09:49:00.002+01:00

'A window cleaner carries a uniform 60-lb. ladder 15 ft. long, at one end of which a bucket of water weighing 40 lb. is hung. At what point must he support the ladder to carry it horizontally? Where is the c.g. of his load?' Miss Brodie looked at the paper, after reading out this questions as if to indicate that she could not believe her eyes. Many a time she gave the girls to understand that the solution to such problems would be quite useless to Sybil Thorndike, Anna Pavlova and the late Helen of Troy.
The Prime of Miss Jean Brodie, Muriel Spark

What happens when I aim for 100% Test Coverage

2010-08-26T16:30:00.004+01:00

I resent guard clauses, but they're better than nested ifs

I resent lazy initialisation

I move code, for instance making a Filler that talks to the database

I find bugs

I feel giddy with the effort

A Big Leap

2010-07-29T16:10:00.004+01:00

I had an interesting example of a Responsive Design Leap this week.
My application had a set of global data dictionaries. I decided to make them members of a Universe class, so that I could compare different data sets. I moved one, simple dictionary, fixed the broken tests, went on to the next. As the dictionaries became more significant to the application, the tests were becoming harder to fix. Some of them only broke under certain circumstances, my least favourite thing.

The leap was to choose to complete moving the dictionaries across, without fixing the tests. I did this because I suspected that some of the bizarre behaviours were down to the mixed state, with some global and some local dictionaries.

And so it turned out. Once the full set of dictionaries were in the Universe class, my tests passed. Rare and counter-intuitive, and therefore interesting.

Build your test data

2010-06-28T08:30:00.003+01:00

My new favourite line of code is return this;

Credit for this is due to Steve Freeman and Nat Pryce, for Chapter 22 of their book Growing Object-Oriented Software, Guided By Tests, chapter title Constructing Complex Test Data.

It's been beyond my skills to write tests for systems like CMR.Net which are heavily data dependent. So the data builder approach in Steve and Nat's book has changed everything. Here's how a test now appears.


        [Test]
        public void Formula()
        {
            MicroGrid mg = new GridBuilder()
                .WithTextCell("A1", "2")
                .WithFormulaCell("A2", "=A1*2")
                .Build();
            Stitch();
            MGCell c = mg.CellAt("A2");
            Assert.IsNotNull(c);
            Assert.AreEqual(CellTypeLetter.FORMULA, c.CellType);
            Assert.AreEqual("4", c.DisplayValue);
        }

It's that chained set of statements, starting with a new GridBuilder object, whose WithXX functions add internal data and return 'this'. They can therefore be chained together, until a final call to Build() returns a MicroGrid object. Damn fine.

Responsive Design Examples

2010-05-07T09:06:00.009+01:00

I'd read about Kent Beck's ideas on Responsive Design and went to Sweden to attend his one-day workshop.

In April 2010 I spent a week with a team refactoring and extending some functionality. Here are some examples of how the Responsive Design ideas look to me in practice.

First, Coupling and Cohesion. A change I made was criticised for making one set of classes aware of an area of the system that previously they'd been independent of. It was a data wrapper area, where all classes provided a similar depth of function. I introduced a specific behaviour to one class to do with the particular Configurable Export function.

That change increased the coupling, and therefore decreased the cohesion of the original classes. To preserve the cohesion we implemented the same functionality in a different way which left the data wrapper classes intact.

Next I looked for examples of Kent's four styles of change.

A Leap example came in replacing variables that were over keen on the use of generics. Specifically the declaration of such variable was


Dictionary<string, Dictionary<string, 
List<string, Dictionary<string, string>>>> x;

I could see that we should replace such variables with a new named class, and replace the accessing of the dictionaries and lists with named functions. But I could not see either how to do that in small steps, nor could I see what names to give to the access functions. It was just a leap. The system was broken until the compile errors went away, but then all worked nicely. I then renamed a couple of functions once I'd seen their use and I was done.

The Parallel change I made concerned code which was in the wrong place, making a class way too big. It was not clear to me what set of functions should be moved out, so I created a Helper class and just moved things that looked right from their function signatures and use of class variables. I disabled the functionality in the original class rather than deleting it at this stage. Once I had something that looked better, I got input from the team about whether it was an improvement and what to call the class. Only when everyone was happy did I remove the obsolete functionality from the original class.

The Stepping Stone change was a classic refactor where an enormous class just had to be broken down and simplified. At least we had good tests around it. The crucial insight here was to convince my programming partner that the changes together would result in a complete change. To start with he was daunted by the scale of the task with its three hundred line functions and enormous switch statements. Kent's Power Point slide for Stepping Stones showed the start of a way across a river. The important point is that you can reach the opposite bank.

The Simplification change came when we wanted to write an update screen for all the configuration data involved in the process. We had editable data grids, but didn't have an easy way of maintaining parent-child links across newly inserted data rows. But we realised that just changing text values would be helpful - not letting the user add rows or affect relationships, just literally letting them change USD to U.S.Dollars. We made that change, stopped, agreed that it was worthy of being released.

Was this Responsive Design? For me, the changes felt like the kinds of refactor I've been doing for ages. It's helpful to think of them in the four forms, because each form suggests its own way of reassuring doubters. Perhaps it would have felt like Design if the system was larger, and therefore a "similarity at different levels" argument means that these are helpful, if small, examples.

Languages: The Good Parts

2010-04-24T14:10:00.002+01:00

"Most programming languages contain good and bad parts. I discovered that I could be a better programmers by using only the good parts and avoiding the bad parts."
Douglas Crockford, Javascript: The Good Parts, p1

"Take an existing programming language and make significant improvements to it by making no changes except to exclude the low-value features."
Ibid p.99

So what do I leave out?

In C# I use public a lot, private a bit, internal almost never.
In Excel magic numbers, multi-level formulae

That's probably why I took to jQuery - the Write Less Do More mindset.

Nobody Likes Plastic Flowers

2010-04-16T15:03:00.005+01:00

I'm telling all my friends to read Rework by Jason Fried and David Heinemeier Hansson of 37signals. They have a great mindset on how to start and run a small company, IT or not. And it's a Twitter style of book, concentrating hard on being pithy. The last-but-one draft of the book was 57,000 words, and they cut 30,000 of those. Nice one.

My favourite dicta:

Why grow?
Enough with "entrepreneurs"
Ignore the details early on
Throw less at the problem
Meetings are toxic
Good enough is fine
Underdo your competition
Say no by default
Out-teach your competition
Nobody likes plastic flowers

Perhaps that last one needs an explanation? People accept the imperfections of a fresh flower, even that it will decay. So why bother aiming to sound perfectly "professional"? Be yourself.

36 Heroes

2010-04-16T14:00:00.008+01:00

I just finished Rework by Jason Fried and David Heinemeier Hansson of 37signals. An excellent read.

The last page is a "list of some of the people we know, and don't know, who have inspired us in one way or another." Nice to see heroes of mine like Kent and Dieter. Makes me want to find out more about Marc and Judith.

Frank Lloyd Wright	Seth Godin
Warren Buffett	Jamie Larson
Clayton Christensen	Ralph Nader
Jim Coudal	Benjamin Franklin
Ernest Kim	Jeff Bezos
Scott Heiferman	Antoni Gaudi
Carlos Segura	Larry David
Steve Jobs	Dean Kamen
Bill Maher	Thomas Jefferson
Mies van der Rohe	Ricardo Semler
Christopher Alexander	James Dyson
Kent Beck	Thomas Paine
Gerald Weinberg	Kathy Sierra
Julia Child	Marc Hedlund
Nicholas Karavites	Michael Jordan
Richard Bird	Jeffrey Zeldman
Dieter Rams	Judith Sheindlin
Ron Paul	Timothy Ferriss

Gothenburg SDC 2010

2010-03-19T13:07:00.004Z

Diana Larsen
Management by wishful thinking
Too often, managers either abdicate or clamp down
Five tracker skills, inspired by Gervase Bushe:
1) How would it look if you were a different person, with a different skill or perspective?
2) Look at the “dead zones”, the areas you usually ignore because they’re not the significant / important / dynamic parts. What’s there?
3) Balance your inputs. If you get most of your knowledge in certain ways, use some 40 methods that others use.
4) Learn the patterns you wish to see. Take the part you like most / are proudest of, and break that down into constituent parts.
5) Reduce one’s disturbance, increase one’s awareness. As bosses, we may be told what people think we want to hear. Try to get to unvarnished, unfiltered truths.
"Employees can't change if their leaders don't" McKinsey Quarterly November 2008

Rik Arends
Mentioned Etherpad, which Google have swallowed up, and Bespin

Nathaniel Schutta
Principle of Least Surprise - the JQuery ordering of function arguments sometimes fails here
Look at the Ext grid http://www.extjs.com/products/js/
Jeremy Keith on Behavioral Separation

Thomas Lundström
Behaviour Driven Design demo of Cucumber and Webrat.
"Lots of crooks and nannies"

Brian Marick
Likening an Agile Team to a Monastery - not the cut off aspect
Unremarked Agile Values : naivete, ease, technical skill, reactive, decency, being wrong, joy, working software
The Manifesto for Software Craftsmanship
If you ignore the future, you get good at change. So yes, don't build tomorrow's request even if you're certain that you'll be asked for it.
Work with ease - that's the first step

Kent Beck
The effect of accelerating releases from Annual to Quarterly to Monthly to Weekly to Daily to Hourly
Getting an organisation to stop doing something is even harder than getting it to start
Change "we can't do X because of Y" to "if we did X we'd have to do Z"

Other Observations
Blåbärspaj has the three versions of a, and tastes nice too
The triangular tower blocks of Kortedala should be more famous, especially in Kortedala

Flashy or Anonymous

2010-03-08T14:12:00.008Z

"The students should be trained to work in teams - also with students of related techniques - in order to learn methods of collaboration with others. [...] The nature of teamwork will lead the students to good 'anonymous' architecture rather than to flashy 'stunt' design."

Walter Gropius, The Search for a Better Architectural Education, 7th CIAM Congress, 1949

I know what he means about flashy 'stunt' design in programming. Interesting that the alternative is 'anonymous'. If it's good, maybe that's what you see. Perfect code, without the maker's hand visible.

On The Learning Curve

2010-02-23T10:07:00.003Z

I started a new project with a colleague. We decided we weren't scared of new technologies so we would use the best thing we'd heard of for any given job. Off we went.

He'd been using jQuery and told me that it was neat. I wanted to share code smoothly so we used GitHub which I cleverly got him to set up. We were drawing pretty graphs, so I used ExCanvas until someone told me about Raphael. Thankfully the port of my code only took an hour. Our raw data is often XML, so we opted for LINQ and then map data came as KML.

It's all gone well. Is this the way the future's meant to be? When can I rest on my C Programmer laurels?

Optimal Optimisation

2010-01-15T15:00:00.005Z

I don't write optimised code. Generally speaking, the computer is fast enough that worrying about how often I create a new string object is absurd. Code readability and extensibility is what matters to me.

Every so often, I have a process I want to speed up. So it was in looking at the Flipping Coins problem : http://cplus.about.com/od/programmingchallenges/a/challenge31.htm. I had a brute force method that was taking 30 seconds to solve a five by five grid, and a lot longer to decide there was no solution.

I'm accustomed to colleagues saying they can speed code up by looking for inefficiencies at the code level. Pre-allocate the storage of a StringBuilder class they say, that sort of thing. I'm always saying that we can have a greater effect on by writing a better algorithm - doing the same thing in fewer steps.

So I decided to test my position. I could see that I could make the brute force more efficient by using recursion - I would create fewer objects on the way to finding the solution. So I implemented that, creating code that was very clever and therefore very difficult to read. Result : five times speed increase.

Then I thought hard about how to solve these problems, came up with a new technique. Coding that was easy - none of this tricky recursion. Speed improvement : more than a thousand times faster than the 'optimised' recursive version, five thousand times faster than the brute force version.

I'm convinced!

Brute force method : 30 seconds
Some code optimisation : 6 seconds
Algorithmic change : 1/200 of a second

You Assume, I Bet

2009-11-23T12:09:00.002Z

"That will work," he said. "How do you know?" I said. "I assume it will," he said.

I'm all in favour of intuition. But in Agile programming, I find that the feedback loop when intuition fails is not sharp enough. When my assuming colleague is wrong, he doesn't feel enough pain and goes on to assume another day.

In future, I will require a monetisation of his confidence. Instead of "I assume it will" I will get him to say "I bet it will" followed by the question "how much?" Is this a five pence level of confidence or a five pound one?

It'll be interesting to see how this pans out. Either he's very good and he wins all the bets. Or I have a get-rich-quick scheme. Or he learns to question his assumptions regularly. Any of these results will be good. Or so I'd assume.

Blues and Yellows

2009-10-16T12:38:00.001+01:00

My agile insight of the week came yesterday. My colleagues Ben and Dylan had done a release a couple of weeks ago, then both went on holiday. We had a flipchart covered with blue sticky notes of features. We started moving the done features to one side, and added new features that were requested. It so happened that we used yellow sticky notes for the new things. We then put the tasks to be done next at the top of the chart, with the rest at the bottom. The seven tasks we selected to do were all written on yellow stickies. All of the blue ideas, which seemed relevant a month ago, were no longer important. We checked with the project sponsor and he agreed the priorities. A nice visual proof of why "responding to change" is to be preferred over "following a plan" (agilemanifesto.org/).

How do you say pensées in Danish?

2009-09-16T14:34:00.001+01:00

In order truly to help someone else, I must understand more than he - but certainly first and foremost understand what he understands.

All true helping starts with a humbling.
Chapter 1 A : SS2

Compel a person to an opinion ... that I cannot do. But one thing I can do: I can compel him to become aware.
Chapter 1 A : SS4

I am regarded as a kind of Englishman, a half-mad eccentric, with whom we jolly well all, society people and street urchins, think to have their fun.
Pap IX A 288

The Point of View for my Work as an Author 1851
Søren Kierkegaard
(Volume XXII of Kierkegaard's Writings)
Translated by Howard V. Hong and Edna H. Hong
Princeton 1998

How To Fail With Agile

2009-09-08T17:51:00.002+01:00

Here are the twenty guidelines from How To Fail With Agile: Twenty Tips to Help You Avoid Success, an article by Clinton Keith and Mike Cohn in Better Software Magazine, August 2009. I copied the text from an HTML Version.

I like to use these in the retrospective of a successful project. If it all went well, how did we avoid doing these things?

1-5 are Management Issues, 6-8 are Team Issues, 10-13 are Product Owner Issues, and 14-20 are Process Issues.

Don’t trust the team or agile. Micromanage both your team members and the process.

If agile isn’t a silver bullet,blame agile.

Equate self-managing with self-leading and provide no direction to the team whatsoever.

Ignore the agile practices. They don’t apply to management.

Undermine the team’s belief in agile.

Continually fail to deliver what you committed to deliver during iteration planning.

Cavalierly move work forward from one iteration to the next. It’s good to keep the product owner guessing about what will be delivered.

Do not create cross-functional teams. Put all the testers on one team, all the programmers on another, and so on.

Large projects need large teams. Ignore studies that show productivity decreases with large teams due to increased communication overhead. Since everyone needs to know everything, invite all fifty people to the daily standup.

Don’t communicate a vision for the product to the team or to the other stakeholders.

Don’t pay attention to the progress of each iteration and objectively evaluate the value of that progress.

Replace a plan document with a plan "in your head" that only you know.

Have one person share the roles of ScrumMaster (agile coach) and product owner. In fact, have this person also be an individual contributor on the team.

Start customizing an agile process before you’ve done it by the book.

Drop and customize important agile practices before fully understanding them.

Slavishly follow agile practices without understanding their underlying principles.

Don’t continually improve.

Don’t change the technical practices.

Rather than align pay, incentives, job titles, promotions, and recognition with agile, create incentives for individuals to undermine teamwork and shared responsibility.

Convince yourself that you’ll be able to do all requested work, so the order of your work doesn’t matter.

Pairing as the Junior Partner

2009-09-01T01:50:00.002+01:00

Agile 2009 Conference in Chicago. The Live Aid effort developed an iPhone application to let donors give to the Mano A Mano effort supporting communities in Bolivia. I spent a couple of afternoons helping out.

I knew nothing of the domain, infrastructure or programming languages. It was all being done on Mac Book Pro laptops, so I couldn’t even get a scroll bar to work in Firefox. That’s how useless I was.

Except that no pairing partner is useless. Here’s what I contributed:

Syntax and spell checking as my colleague typed

Fluency in HTML when we were modifying web pages

Discussing the value to be gained from making the pages fully XHTML compliant

Guessing how to enter a bank account number into Pay Pal when it refused my pair’s efforts

Helping a new colleague get starting by just knowing a little of the directory structure

Reminding my pair that the first step was a failing test, not a pretty, well-written or comprehensive test

Congratulating my pair when he got that test to go from red to green

Noticing a precedent in a Cucumber test for how to echo the HTML to the console

Writing down the test cases so my pair could start working through them

Seeking targeted guidance from the Ruby and Rails experts on the team

Speaking up at the stand-ups

I think I did enough. I’m certainly grateful to a partner who fills in those gaps when it’s me who’s meant to know what to do.

Please visit (by iPhone or browser) www.manoamano.org to see what we did, with your credit card at the ready. And a big thanks to all of the team for letting me help out, with a particular mention to Dwight Illk.

And then there's the 5% of the time

2009-07-29T06:49:00.004+01:00

The First Rule of Programming: It's Always Your Fault is right. If something's awry look at your code rather than blame Microsoft etc. If that doesn't work, look at your code again. Repeat until you notice the semi-colon on the end of your while() statement.

In one week I had a doozy of an exception. We had code which put values into an Excel spreadsheet, copied a graph into the clipboard and pasted into a Word Content Control. It worked. It worked. It failed.

We found that certain combinations of data, together with certain blobbiness of a dotted error line on the graph would cause a problem with our pasting code which we could not reproduce by ctrl-c ctrl-v in the applications. We changed the error line to a solid line and haven't seen it fail. But is it fixed? Who knows for sure?

If the problem lies in some other bit of code that you don't control, you'll not only have learned essential troubleshooting and diagnostic skills, you'll also have an audit trail of evidence to back up your claims, too.

That's true. We did learn something about isolating a problem within the Office applications.

Exploratory Testing

2009-06-28T17:34:00.002+01:00

Scenario One I'm rewriting an ASP website into ASP.Net. It's going well. I can now run the two systems side by side, seeing what is different and what's the same. Over a finite site that seems just as good a test as having a specification.

Scenario Two On snother website I was asked to add a confirmation email when a new user registers. I've noticed a lot of errors on this page. My first guess was that this public page is falling prey to web crawlers. After all, my exploratory testing didn't make it fail. But I was wrong. Checking logs yesterday I found that the error was the confirmation email - a badly formed email address (why do users do this?) and it was throwing an error. It's fixed now.

Conclusion Exploring means opening your mind to come up with likely scenarios. Get it right, and its an effective use of time.

Queasing and Pairgramming

2009-04-04T10:07:00.002+01:00

I believe the Financial Times coined 'Queasing' as a shortened form for Quantitive Easing, the economic plan of the month. My breakthrough practice of the month has been applying Queasing to Pair Programming, by introducing a second keyboard and mouse.

My colleague Ben and I were stuck at the "Storming" phase - we were not getting on well. Memorably, when the customer asked what Ben thought of my code, he said nothing at all. A couple of hours later he managed "I've seen worse." Pair programming had been a miserable experience for both of us. He didn't like programming with "someone looking over my shoulder."

One day at the customer site, with a second screen plugged into the back of the laptop, I added a keyboard and mouse. Now we had dual control - no more asking to use the keyboard. He had to use the laptop trackpad, but he was up to that challenge.

The day went much better.

Since then, we've tried it back at our office with two full keyboards and mice. It is an improvement. So Quantitive Easing can help with Pair Programming. Or should that be Queasing helps Pairgramming?

Four Lines of Code in an Afternoon

2009-03-01T12:42:00.003Z

The other day, my pair and I managed four lines of code in a whole afternoon. But they were the right lines of code, so we were very happy.

We wanted to add charts to an application creating MS Word Documents. We knew a little bit about automating Excel and updating Word's Content Controls. The four lines were

set the source cells for an Excel chart
copy the chart to the clipboard
select a content control in Word
paste from the clipboard

No reinvention of any wheels. The end user will be able to edit the look of the graphs as a template in Excel, or as the end result in Word. All graph types supported.

Agile is the art of maximizing work not done, so that was a good afternoon's work.

My Seven Wastefulness

2009-01-31T11:53:00.002Z

I'm reading Mary and Tom Poppendieck's Implementing Lean Software Development, which I recommend highly.

Confession time : here's how my development process on my landlords' website looks in terms of the Seven Wastes (p.74)

Partially Done Work is pretty good. I tend to select modifications that can be done fully in the session I have available.

Extra Features is good, because I am harsh about what I will add. After all, it's free software.

Relearning is problematic. I have to remind myself all sorts of things about MySql and the website database layer each time I work on it.

Handoffs is not a problem, because I don't hand off the work to anyone.

Task Switching is good when I'm working on a feature.

Delays is of course a problem. When exactly will I address that particular issue? Today? This week?

Defects is a challenge, because of the distance between me and the users and because some problems are related to the loading on the server. Some user somewhere has a quote key that breaks my SQL insert statement. What can I do about that?

Yagni and Wisdom

2008-12-11T13:51:00.004Z

I ran an Open Space session entitled YAGNI and Wisdom at the XP Day Conference www.xpday.org

In this session I wanted to explore what happens when a strong You Arent't Gonna Need It (YAGNI) attitude meets insufficient wisdom for the attitude to be safe.

I introduced the sesssion by giving an informal experience report about how my YAGNI attitude caused some problems in a website development. Specifically, I wrote a very light database connection piece of code which turned out to be insufficient. When problems arose I spent my time providing fixes and only later found the time to rewrite enough of the database code for the site to be sufficiently robust.

The audience then took over, asking me pointed questions about why I'd done what I did, what I should have done instead.

On the specific subject of wisdom, we synthesised our views to the realisation that a team dynamic, when it's going well, provides that wisdom. When I suggested the aphorism "Together, we're wiser than we are individually" it was improved to

Together, I'm less stupid

We continued with this thought, looking at the reasons for my mistakes. For instance, we saw that I was not rational in one of the decisions.

Together, I'm less crazy

One issue was why did I not roll back a change when it started failing. Others observed that that it was a financial decision or that it may have seemed just as hard to go back as go forward. I then admitted that it was probably my ego that stopped me retreating - I was going to fix this! Others recalled times where their teams had stopped that happening.

Together, I'm less egotistical

So thanks to Paul, Jason, Pete, Dolan, Ben and the others whose badges I couldn't read.

Jonathan Clarke
11 December 2008

The Thoughts of Chairman Bob

2008-09-30T22:39:00.006+01:00

If you're like me, and mainly program by epithet, then you must read Clean Code by Robert C. Martin. Here are a few of his dicta.

Smart programmers are not professional programmers ... clarity is king (p. 25)

The first rule of functions is that they should be small. The second rule of functions is that they should be smaller than that. (p. 34)

Communication is the professional developer's first order of business (p. 76)

Serious thought needs to be put into the best way to represent the data that an object contains. The worst option os to blithely add getters and setters. (p. 95)

Yes, we have no XP practices

2008-07-30T13:19:00.003+01:00

I joined a team to help them get from a death march project to a demonstrable product. Not being asked to be an XP coach, I’ve been interested to see which XP practices find their way into a team, which are already in place and which are resisted.

Pair Programming : we do some, we enjoy it when we do because we learn so much. We just don’t think it’s necessary for most of the time. That’s the collective “we” – I’d want to use it much more.

Collective Code Ownership : give it time. Currently most of the code “belongs” to P-J (who left months before I arrived) or Nick (who left a week after I started).

Coding Standards : I’m the problem here, because I can’t see the reason for some of the standards used. Blank line between every line of code? A variable of MyCleverDerivedClass is usually myCleverDerivedClass which makes typing much slower. Is it an XP practice to sneak in new conventions to new code, hoping they gain traction over time? I don’t see why not.

Refactoring : I never do this mercilessly, so the issue is whether we do it at all. Yes, some. But I have had a programmer argue that taking out some code from a big class to a small helper class is making it more complicated. I wonder if he’s changing his view.

Automated Testing : not enough, never enough. I use test-driven development for new code, but I haven’t written the coding structures to make the tests either fast or reliable. There’s plenty of testing effort, mainly comparing the new system with the one it’s replacing. Is that a valid alternative?

On-site Customer : pretty good, because the company both use the system and sell it to others to use. So there are team members who really know what it does and have a benchmark in the old system. I’m happy with this; I wonder if the other programmers are.

Short Iterations : pretty good, again, because we want to support the on-site customer in their work and their testing.

Planning Game : didn’t happen in my time - I arrived to a project with defined tasks. However there’s been some low-level action on this, encouraging people to think outside the bug list, consider the value involved in different changes and so on.

Continuous Integration : if God didn’t want us to do this, he wouldn’t have given us Subversion. Admittedly, no-one knows how to add me to the list of people who get the build-broken automatic email. But we’re all checking out the code regularly, so I hear soon enough.

Metaphor : no we don’t – do you? I tried once, but everyone insisted that LongClassNameExplainingWhatItsDerivedFrom is a good practice. In protest I’ve started calling a colleague “Secundus” because that’s a more descriptive name than “Sam”.

Simple Design : not a lot. Too many programmers love complexity, and telling them “you’re not going to need it” gets a response ending in “off”. The only place I’m winning is over next-release features to help with the sales process. There isn’t time to program these “properly” so I’m being allowed to do a quick simple design and then see what emerges.

Forty-hour Week : in place, widely observed. Well, this is the old style City of London.

All Philosophy, No Practices

2008-06-30T17:55:00.002+01:00

In my current project, I'm talking up the XP Philosophy without being able to follow any of the XP Practices. This is how it's working out.

Courage, Simplicity, Feedback and Communication.

Courage was almost instantaneous. The project was veering towards a Death March. I asked the Gold Owner when he wanted it ready to show it to his customers. He said twelve weeks. All I did was to convince the team that this was a deadline worth working to – anything is better than the open-ended march. Sure, scope negotiation became a key issue for a week or two, but only that much. Everyone wants to meet that deadline, and I just “encouraged” them. The next step will be to get the Gold Owner to have the courage to present the product confidently to customers and be convincing about why it’s worth the money. That’s for next month.

“You are a good programmer, but you never listen” said a colleague to me. Notice that I did hear what he said, so I can’t be quite as bad as all that. But communication is an issue; a team gets into a way of communicating, and whether it’s good or bad they stick with it. I don’t. For me it’s all about face-to-face little chats, as often as possible, in a setting that’s most likely to get a shared conclusion. So the team used the internal phone system, but I use the stairs. The team used a bug tracking system, I scribble on flip charts. I’m not saying that my way is better; but if the entrenched methods aren’t working then communicate in the simplest way, which is just a matter of strolling over to a colleague’s desk, smile, ask for a few minutes of time, and then take no more than that. Smile again, say thank you, you’re done.

Simplicity? We have a database layer written using interfaces to allow a new database storage method “later”. We have a naming convention so Product.Business is two things – a project in it’s own right and a sub-directory within the Product project. We have spectacularly “generalised” code for data import which I can’t get to import anything. It all works, but simple it ain’t. However, I’m seeing a few changes. My first fight with a team like this is about not using the debugger. My second fight is wanting to run the code through NUnit. I’m delighted to see that one of the programmers has noticed how much time he saves by doing this, that it is simpler and quicker to work in this way. The current challenge is about new features. One colleague wants to add an Excel API, another wants to rewrite the reporting protocol. Both would take weeks. I’m pushing them towards a simple interface with a spreadsheet, a step-by-step improvement of the reporting. We’ll see whether banning the complex (which I have) makes them find a simpler path.

Writing this makes me realise that Feedback is the challenge. Downstairs from the programmers are the testers. They find an issue and log it in the bug tracking system. The programmers feel they don’t have enough detail. The testers feel the bug shouldn’t have occurred in the first place. The feedback loop is all wrong. We’ll have to fix that. I could work on making the automated tests more helpful – they’re broken in all the usual ways. But the simpler thing is probably to become a one-man feedback mechanism, spending my time running the code, automating where possible but not worrying when I can’t.

Gamma Marx Maciavelli Fowler

2008-05-20T09:43:00.003+01:00

Q: What links Erich Gamma, Karl Marx, Niccolo Machiavelli and Martin Fowler?

A: Amazon.com's top 10 books classified as Books > Nonfiction > Foreign Language Nonfiction > French

On 20 May 2008, Gamma and the Gang of Four are in at number 1, Marx and Engels at number 2 for The Communist Manifesto, Machiavelli gets into the top 5 with The Prince and Fowler's Refactoring is at number 7.

Check top 10 today

Thanks to Vahid M and Chris B for generating the kind of conversation that leads to finding this.

Just enough to test a Windows UI

2008-05-09T23:19:00.003+01:00

Here's just enough code to test a Windows Form. Put this in a Class Library project called Tests which references the DLL or EXE with the form in. The Tests project will need to reference System.Windows.Forms.


using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using Dunwoody;
using NUnit.Framework;

namespace Tests
{
    [TestFixture]
    public class UITests
    {
        Form1 m_f;
        [SetUp]
        public void SetUp()
        {
            m_f = new Form1();
            m_f.Show();
        }
        [TearDown]
        public void TearDown()
        {
            m_f.Dispose();
            m_f = null;
        }

        [Test]
        public void RequiredWidgets()
        {
            Assert.AreEqual( "", HasWidgets(new string[] { 
                "button1", "textbox1" 
            }));
        }

        private string HasWidgets(string[] ctrlnames )
        {
            StringBuilder result = new StringBuilder();
            foreach (string ctrlname in ctrlnames)
            {
                if (GetControl(ctrlname) == null)
                    result.Append(ctrlname + " ");
            }
            return result.ToString().Trim();
        }

        [Test]
        public void HasButton()
        {
            Button b = GetButton( "button1" );
            Assert.IsNotNull(b);
        }
        [Test]
        public void NoSuchButton()
        {
            Assert.IsNull(GetButton("x"));
        }
        [Test]
        public void TextboxNotButton()
        {
            Assert.IsNotNull(GetControl("textbox1"));
            Assert.IsNull(GetButton("textbox1"));
        }
        [Test]
        public void HasTextbox()
        {
            Assert.IsNotNull(GetTextbox("textbox1"));
        }
        [Test]
        public void SetTextbox()
        {
            string test = "Test";
            GetTextbox("textbox1").Text = test;
            Assert.AreEqual(test, GetTextbox("textbox1").Text);
        }
        [Test]
        public void ButtonClick()
        {
            string test = "Test";
            string str = GetTextbox("textbox1").Text;
            GetTextbox("textbox1").Text = test;
            GetButton("button1").PerformClick();
            Assert.AreEqual("[" + test + "]", GetTextbox("textbox1").Text);
        }

        private TextBox GetTextbox(string ctrlname)
        {
            Control ctrl = GetControl(ctrlname);
            if (ctrl != null)
                return ctrl as TextBox;
            return null;
        }

        private Button GetButton(string ctrlname )
        {
            Control ctrl = GetControl(ctrlname);
            if (ctrl != null)
                return ctrl as Button;
            return null;
        }

        private Control GetControl(string ctrlname)
        {
            foreach (Control ctrl in m_f.Controls)
                if (String.Compare(ctrlname.Trim(), ctrl.Name, true) == 0)
                    return ctrl;
            return null;
        }
    }
}

Only The Important Ones

2008-04-25T21:16:00.006+01:00

Some quotations from Extreme Programming Examined ed Giancarlo Succi and Michele Marchesi, Addison-Wesley 2001.

Is Design Dead Martin Fowler

"I certainly still reach for GOF whenever I feel a pattern coming on."

"Don't draw every class - only the important ones. For each class, don't show every attribute and operation - only the important ones. Don't draw sequence diagrams for all use cases and scenarios - only ... you get the picture."

Patterns and XP Joshua Kerievsky

Quotes GOF's concluding remarks : "Design Patterns provide targets for your refactorings."

Learn XP : Host a Boot Camp Christian Wege and Frank Gerhardt

"As workshop instructors we had the coach and the customer roles at the same time. It was not always easy to make the separation between these two roles visible for the participants. Maybe a real hat would have helped."

The Expert-in-Earshot Project Management Pattern Alistair Cockburn

The Costs and Benefits of Pair Programming Alistair Cockburn and Laurie Williams

Discuss eight aspects : Economics, Satisfaction, Design Quality, Continuous Reviews, Problem Solving, Learning, Team Building and Communication, Staff and Project Management. Full text

(Fr)Agile Egos

2008-03-09T12:13:00.004Z

I'm a great believer in customer contact, getting them to think in terms of value to the project and then selecting tasks that deliver most value. It's the right way to run an agile project.

But a recent project is straining my goodwill. The customers have some technical proficiency and are setting the 'how' as well as the 'what'. For instance how should two web pages communicate? I said the simplest thing that could possibly work was a text page, the customer insisted on URL despite issues with length and character encoding.

I built the URL version, it started creaking with those issues, so we needed to change. Text file? No - it's now a web service, which is all modern and lovely. The project wall lost it's pink postit saying "Do the simplest thing..." and has a new postit saying "do the coolest thing that could possibly be coded".

To function in this environment it seems I have to have a very agile ego, where being overruled on technical matters is to be expected. Living by the agile mantra of feedback, I shall let the customers know about this post, and see whether there's any change in working pattern.

Ernest Hemingway on Test Driven Development

2008-02-25T08:27:00.002Z

"Stop when you are going good and when you know what will happen next. If you do that every day ... you will never be stuck."

Ernest Hemingway On Writing

"Finish a solo session by writing a test case and running it to be sure is doesn't pass. When you come back to the code, you then have an obvious place to start. You have an obvious, concrete bookmark to help you remember what you were thinking."

Test-Driven Development By Example Kent Beck

It's not crazy to suggest there is a direct link between these two great minds. Beck picked up the advice with regard to writing, and I know that writing teachers in America get students to read the book of Hemingway's thoughts as guidance.

Pair Requirements Analysis

2008-01-08T11:32:00.000Z

I like to pair program. Two heads are better than one. It's an efficient way of sharing knowledge and ideas.

The challenge on my current project is not the programming, which is in C# and using our libraries that are becoming cool and mature. Instead the challenge is in the Requirements Analysis.

The solution is Pair Requirements Analysis. I sit at a pair workstation with my colleague Tallboy. We both leaf through copies of the documents that have tried to record what the user wants. As we identify a requirement I put it in to the system in some way - as a test, as an item on the wiki, as an index card, as a TODO comment in the code. That hardly interrupts Tallboy's flow - it only takes a few seconds. We then discuss the next thing he's found and what it might mean for the system.

It's an odd process. But it's honest. I know why this project started with a sheaf of mildly disorganised documents, and this is looking like an efficient way of getting from them the tasks to be done. Try it out!

The Art of Agile Development - Book Reactions

2007-12-28T10:21:00.000Z

Here are a few reactions to The Art of Agile Development by James Shore and Shane Warden, O'Reilly, 2007.

It's a deceptively big book. Just over 400 pages and a small type face, so there are a lot of words. The type size means long lines - sixteen or eighteen words per line - which I find a strain to read.

I like the Self-Assessment quiz. I remember doing it on a prior project. You answer questions in each of five areas - Thinking, Collaborating, Releasing, Planning, Developing. 75 out of 100 or less means "immediate improvement required". But the questions are not equally weighted. My favourite is in "collaborating" -

Do programmers ever make guesses rather than getting answers to questions?

... and you lose 75 marks if you answer Yes.

And I get quoted in it, taking a view on how to run stand-up meetings. I've never been so proud :)

ASP.Net and Subsites

2007-10-16T12:28:00.000+01:00

By Subsite I mean www.yourdomain.com/newarea. In my case I wanted to add www.rentroll.co.uk/gwlflickrtagr to help Guess Where London users on Flickr tag their photos. The project had to be completely independent of the code for www.rentroll.co.uk.

There are probably better ways of doing these things. But each workaround is helping me.

Don't use web.config as IIS throws a wobbly if you have the file in a sub-directory

Don't use app_code as the compiled bin classes go in www.rentroll.co.uk/bin and the app_code there is for the main site

Make your own Page parent class requires using statements in all .aspx.cs code but that's a small price to pay for the code sharing

./MasterPage.master instead of tilde-slash. Tilde slash will look in the parent directory.

this.Page.Request.PhysicalPath tells you where your application is installed. This gets away from needing lots of Directory entries in the web.config you're not allowed to have.

Test Delayed Development

2007-09-03T10:52:00.000+01:00

Here's a heterodoxy born out of weakness.

Tests are Delaying my Development.

I love the idea of Test-Driven Development (TDD). C# and NUnit go together like Flintoff and Injuries. But I'm writing an ASP.Net web site and I just can't get going on TDD for it.

I'm trying to change the security model. I have written my own provider. I can test my code using NUnit. But I can't at the moment test the code through NUnit when it touches the Microsoft classes like MembershipUser. I suspect this is because the live environment uses web.config, and I don't know what steps to take to get it to work in NUnit.

So instead I try to test the website using Watir. This means learning a new language, Ruby, just for testing. And open source packages like Watir and Rspec, which take constructive guesswork on how to do things.

All of which delays my development. Preferred solution for me is to have a pair who understands this stuff so I can just get on with the programming. I'm not against new languages and new techniques but by golly they do take time.

Time which delays the development. Hmm. This is written on the first working day of September 2007. I shall see whether I still find this in December, in March.

City Gate House by Giles Gilbert Scott

2007-08-29T11:45:00.000+01:00

Giles Gilbert Scott
1880-1960 Knighted 1924 RIBA President 1933-1935
It was his view that to employ an architect was an act of faith, and that once the problem was set there should be no interference with matters of design Hubert Worthington, RIBA Journal 1960
Let us aim at quality rather than novelty GGS 1933
Last of the Art-Architects. By the 1920s, architects were faced with formidable considerations of planning, construction and technlogy for which a largely artisitic training was inadequate. Some architects opted for a "mechanistic modernism", others restricted themselves to small-scale projects. GGS attempted to come to terms with the Twentieth Century but, like Lutyens, was oftern "consulting architect" applying a cosmetic treatment.

Notable Works
Liverpool Anglican Cathedral 1903-60, fininshed 1980
St Alban and St Michael (Golders Green) designed 1925, built 1932-33
William Booth Memorial College (Camberwell) 1926-29
Battersea Power Station 1929-1934 (West Half; East Half added 1944-45) : Scott was consultant when building was underway; responsible for the elaborate parapet, bases to chimneys etc
New Bodleian Library, Oxford 1935-46 "much abused"
Waterloo Bridge 1935-45 still has the temporary railings and no sculptural groups as designed; note that it is cantilevered, the arches being decorative not structural
House of Commons refurbishment 1950 "neon-Gothic"
St Michael Chester Square
Phoenix Theatre (with others) Charing Cross Road facade
King George V statue plinth at Old Palace Yard
Joshua Reynolds statue plinth at the Royal Academy
Memorial Cross at Our Lady of Victories, Clapham Park Road

Homes
4 Campden Hill
28 Tavistock Square
Chester House, Clarendon Place, Paddington (RIBA medal 1927, lived until his death) Blue Plaque 1990

City Gate House
Built 1930-31
"Associate architects" with Frank Reginald Gould Willis.
"Embarrassingly pedestrian and commercial" according to the RIBA Drawings Collection.
Scott re-designed Willis's facades (1928) in a more disciplined and severe style
Square was planned by George Dance Snr in 1751, laid out by George Dance Jnr in 1777

The Scott Family
George Gilbert Scott Snr (grandfather) : Albert Memorial, St Pancras Station, St Giles Camberwell
George Gilbert Scott Snr (father) : St Agnes Kennington, All Hallows (Pepper Street) Southwark

Web Links
Design Museum

Bob's Not My Uncle

2007-08-23T10:33:00.000+01:00

Here are Uncle Bob's Test-Driven Developers Practitioners Three Laws.

1 You may not write production code unless you've first written a failing unit test.
2 You may not write more of a unit test than is sufficient to fail.
3 You may not write more production code than is sufficient to make the failing unit test pass.

Robert C Martin Professionalism and Test-Driven Development in IEEE Software Magazine, Vol 24 No 3 May/June 2007.

I wanted to add encryption to a C# application, tested under NUnit. So I wrote

[Test]
public void Encrypt()
{
string output = m_sc.Encrpyt(INPUT_1);
Assert.AreNotEqual(INPUT_1, output );
}

The test failed. On to Step 3, sufficient code to make the test pass.

public string Encrpyt(string input )
{
return "_" + input;
}

Next test. Different strings get different encryptions. Passed first time.

[Test]
public void EncryptDifferent()
{
string output1 = m_sc.Encrpyt(INPUT_1);
string output2 = m_sc.Encrpyt(INPUT_2);
Assert.AreNotEqual(output1, output2 );
}

Now, decryption. A test and just enough code.

[Test]
public void Decrypt()
{
string output = m_sc.Decrypt( m_sc.Encrpyt(INPUT_1) );
Assert.AreEqual(INPUT_1, output );
}

public string Decrypt(string p)
{
return p.Substring(1);
}

That passes.

But what should I do now? How do I write a unit test that shows up the insufficiency of this encryption? And if I only write enough code to get past that test, will I have a decent level of encryption. If I encypt SECRET as ___*S*E*C*R*E*T*___ who am I fooling, other than my test which checked for a limited set of items?

No disrespect to Uncle Bob. I am not worthy to put a semi-colon on the end of his statement. I just need to know when to disobey the laws.

The March of IDEs

2007-06-30T11:42:00.000+01:00

I like the way that modern Integrated Development Environments (IDEs) are making programming a physical job. That is, using the IDE's knowledge of what you might be about to type speeds up coding, and knowing how quickly the IDE will react makes this a real-time process.

For instance, a common line in my C# code is entered as r e t (tab) res (tab) ; (return) which gives

return result;

because the IDE correctly guesses the rest. To use this, I have stopped calling a return value "retval" because that slows down this process.

Here's another example u s (tab) n u (ctrl-space) . F (tab) ; (return) gives

using NUnit.Framework;

a s s (tab) . A (tab) S t r (tab) . E (tab) gives

Assert.AreEqual( String.Empty

So how has this changed the way I code?

First long variable names are no problem. As long as they are distinct within the first few characters.

Within ASP.Net, I get to ConfigurationManager by C o n (tab) M (tab)

I try to avoid using System.IO, which is good for various reasons but in this case is because Stream comes before String.

In pair programming this can become a dangerous habit, trying to control the Driver at the individual keystroke level. Apologies to my colleagues.

XP Customers : 9 plus 9

2007-04-20T10:21:00.000+01:00

Credit where credit is due : these come from the presentation Programmers are from Mars, Customers are from Venus by Angela Martin, Robert Biddle and James Noble at XPDay 2006.

Nine Key Roles

Geek Interpreter : talk to the XP programmers

Technical Liaison : talk to the IT department

Political Adviser : identify key players and rules

Acceptance Tester : is it good enough?

UI Designer : does it look OK?

Technical Writer : do we need documentation?

Diplomat : are all views represented?

Super-Secretary : get all stories written down and followed up

Negotiator : agree trade-offs in order to keep moving

Nine Customer Practices

Programmer On-Site : they should see what the business looks like

Customer Apprentice : help writing stories, attending meetings

Programmer Holiday : if the development gets ahead, the geeks take a break

Story Standards : write them in a consistent way

Show and Tell : keep the sponsors informed

Customer Pairing : work with another

Customer Counselor : get help with your role

Look Before You Leap : have a business case and a release plan

Three Month Calibration : expect a sanity / progress check at 3 months

Notes on Simplicity

2006-10-09T11:33:00.000+01:00

First, some inspiration.

Three simple improvements which anyone can understand. RAF planes take off more easily by using a ramp at the end of an aircraft carrier's flight deck. Ski jumpers fly further if they splay their skis. A turned up tip at the end of an aircraft wing improves long-haul efficiency.

I don’t know who came up with these ideas, whether by accident or design, or what percentage improvement they were on what was there before. I just love the simplicity of each of them.

Why Simplicity is a good thing

Because it’s cheap and it’s knowable.

There are established reasons for Simplicity in Extreme Programming. A simple design needs less documentation. It’s easier to improve a simple design than to build perfection from day one. Others have explained these better before. I thought I’d add these two reasons.

Simple things are often cheap in themselves, cheaper to develop and make less expensive the things around them. The ski jumper above has paid no more for his skis to use the splayed pose. The aircraft carrier ramp reduces the overall size of the ship, because it does not need the catapult technology used by the Americans.

And cheap is good because either (a) you get to spend more of the budget on comfy chairs and faster computers, or (b) because it increases the number of people who can get involved in the programming community. Your preference for (a) or (b) may say a lot about you, by the way.

Simple things are easy to use. You can just see what they do, you know how to use them. Whether that’s a door bell or a database connection, the simpler it is to use the better. Steve Krug’s book on web usability Don’t Make Me Think is brilliant on this subject, even down to the title telling you everything you need to know. Web sites must not need manuals – they should just work as the man on the Clapham omnibus expects them to work.

I illustrate this by contrasting two kitchen items made by Hackman in Finland. On the left we have the bottle opener. It’s a joy to use, fits in the hand, reassuring weight so you know you won’t bend it, and it opens bottles. On the right is the salt cellar. It dispenses salt. It’s lovely to use as long as you don’t have wet hands or arthritis. You can distinguish it from the pepper grinder because the little dot on the top is white not black (that’s not visible in the photo). And after owning one for six years I finally found how to fill it with salt without dismantling it completely.

My point is that simplicity and minimalism are not the same thing. You want to see enough of how something works, not too much and not too little. At that point it becomes knowable.

How to get into a simple frame of mind

You could do a Maths degree. I’ve talked to people with English degrees, History degrees and so on, and there was nothing in their university course that was simple – that was the whole point. In my Maths degree we were taught various simple techniques to make complicated problems soluble. Substituting a value in a formula, proof by induction, a single counter example. Use any of these in the right way and you have the answer. Just as significantly, we were taught to celebrate that simplicity.

A three year Maths course may be a bit much. Alternatively, I recommend looking for the simpler thing all the time, in everything you do. Is the music you listen to simple? If the food you eat simple? Do you talk simply? Practice simplicity everywhere and it will get easier.

Let’s start with music. I’m listening to Yo-Yo Ma playing Bach’s cello suites. That’s one man, one cello, no need for anything else. Of course it’s not simple in the sense of trivial. But it is simple in comparison with a whole orchestra bashing out some symphony. There’s no distraction, no waste, just purity.

Apply that to your art form of choice. Realise that The Lord of the Rings, both the book and the film is complexity gone mad. Whereas Doctor Seuss’s Green Eggs and Ham is a masterpiece of simplicity, needing a vocabulary of only 50 words. If that’s too great a disjunction for you, put Moby Dick alongside Bartleby. Prefer Picasso’s single line sketches to Guernica. Go to stand up comedy rather than Shakespeare.

Now food and drink. The best coffee is just coffee. Un espresso in Italy, un café in France. Starbucks is the enemy of this simplicity, all flavours and froths. Just say no. Pasta with a home made tomato sauce is a fine dish. If a dish on a restaurant menu has a two line description using words new to you, then it’s not going to help you to embed a simple mindset.

In conversation, the same thing. Congratulate yourself every time you speak simply. If someone asks a question carefully, a simple "yes" or "no" may be all the answer required. You’re failing if the person you’re talking to needs a word explained, so watch for saying "heuristic" if "guideline" would do just as well.

Do this today and tomorrow. By the weekend you’ll have examples of the simple thing you admire, the moment you took the simple path. It may be a door handle. It may be a three-second input that saved someone three hours. Well done, you kept it simple.

What this means to me as a programmer

Here’s a simple test for you. At a bookshop, pick out the "for Dummies" book on a subject you know about. Flick through it. See what you think.

I went for C for Dummies by Dan Gookin. Here’s a quotation. "Don't forget the ampersand (&) required in front of the variable used in a scanf statement. Without that & there, the program really screws up." I like that. I don’t think the book should be discussing exactly what happens without the ampersand, it should just be drumming the point home that leaving it out is bad bad bad. There’s some discussion about how a preprocessor works but it’s prefaced with "Long, tedious information that you want to miss". As you’re learning C, the important thing is to know to use #define MAXLENGTH 200, not the curious behaviours possible of #define MAX(x,y) (x>y?x:y).

OK, here’s the uncomfortable truth. If you get cross that the surface is being skated over, that the authors are missing out crucial stuff, that no-one should ever read “Firewalls for Dummies”, then you may have to admit you don’t like simplicity. I remember Kent Beck saying that the five values of XP can be used as a test. If a person or an organisation does not intrinsically believe in communication, for instance, then XP is not for them. If you don’t like simplicity, maybe you shouldn’t be doing XP.

Time for a few examples.

Multiple returns from a function can be good. They support simplicity because the moment you have the answer you quit the function. The dogmatists who hate the following coding style are not keeping it simple.


int MyFunction( int param )
{
 if( param <= 0 )  
  return 0;
 for( int i = 0; i < param; i++ )
 {
  if( MySecondFunction( i, param ) )
   return i;
  if( MyThirdFunction( i, param ) ) 
   return i;
 }
 return 0;
}

Database normalisation can be bad. Simple data tables tend to have lots of columns and a fair amount of data duplication. This makes them easy to query – no need for joining multiple tables together. And it makes them tolerant of poor input. If someone puts in an incomplete address, for instance, a simple database design will hold what was entered, whereas a normalised design requiring county or state to be chosen from a predefined list will fail.

Refactor a bit and then stop. Merciless refactoring can take too much time, or just set up too much expectation amongst the programmers. To quote from an Apple report presented at Agile 2006, "refactor … only on demand, when the code is grossly missing the intended functionality or needs major optimization." Beware the salt cellar example where “simplicity” tipped over into minimal unusability.

Enough already

Some people find that the perfection of "simple" solutions makes simplicity difficult to practice. To them I say, "enough". You practice simple design by doing "enough design up front". Ask yourself what "enough" would be in a context, and you’re headed down the simple path.

If a ten-minute build is proving difficult, a simple solution may be beyond your reach. An "enough" solution is to work round a 30 minute build. Then let the team find a rhythm which hits the build button at convenient moments – first person to arrive, at the start of lunch, before any meeting.

A good example came over lunch at Agile 2006. One delegate wanted help with introducing continuous integration. Other delegates, who really knew their stuff, gave him chapter and verse on Subversion, Tortoise, Nant, Cruise Control and the kitchen sink. All I did was to ask how big his company was. When told three people, I suggested that an "enough" solution might not need all of the above.

The great thing about an enough solution is you can improve it the next day. The London Transport map is a classic of design, working from the realisation that it did not need distances to be shown consistently. Even then, the simplicity matured over many years and many editions, as the designers understood how to use their concept. Again it can be carried too far. New Yorkers hated a subway map that took the London Underground approach and simplified Central Park to just a square.

The End

That’s enough from me. Simplicity is good because it is cheap and knowable. Practice it in everything and it will get easier in your work. Enough may be enough – don’t force yourself to over do it.

Agile leadership - make it happy

2006-09-01T11:37:00.001+01:00

Brian Marick blogged An unhappy trend: leadership which I saw supported on Willem van den Ende's post Just enough structure.

I took part in Willem's Drawing Carousel session at Agile 2006.

The most striking comment in the final wrap up was that some of the team were unhappy not knowing the overall state of the project. We traced that to having stuck to the limitation of pairs not communicating during iterations. I checked to see if you would have allowed us to have someone overseeing - Willem said yes - so the restriction was self-imposed or we were too blinkered to think of it.

This is a sign that there is a desire for co-ordination and overseeing - I’m going to call that leadership. And that self-organising teams may well not put someone in this role.

I suggest that “An unhappy trend: leadership” is wrong. The unhappy trend is the Great Man theory being adopted by Agilists. A good scrum master functions by leading in an agile way, not leading in a great man way.

And a self-organising team will benefit from considering appointing a leader in a way that suits the team.

Wireless at the birthplace of Computing

2006-08-31T11:02:00.000+01:00

Ah, the freelance life. No ties, no office to go to, no fixed hours. I can work anywhere, so I choose to work from the home of Charles Babbage, England's claim to be the inventor of the computer.

First, South London has to claim to be his birthplace. The International Biographical Dictionary of Computer Pioneers lists him as born in Teignmouth, Devon, so I prefer the Oxford Dictionary of National Biography which argues that his father's house in Crosby Row, Walworth is the most likely.

His date of birth was 26 December 1791, which makes him 78,410 days old. I calculated this using a Difference Engine, first trying Excel, but it can't handle dates that long ago. Instead I turned to SQL Server - select datediff( d, '26-Dec-1791', '31-Aug-2006' ). Babbage said that he would give up the rest of his life to live three days in 500 years time, guessing that by then we might have inventions worthy of his interest.

We celebrate Babbage for building the Difference Engine, a mechanical devices capable of arithmetic (No. 1, 1832). He had grander plans for an analytic engine, capable of any mathematical calculation, but was not enough of a politician to get the funding to carry it through. The Prime Minister of the day, Robert Peel, suggested that the machine should be set to calculate the time it would be of use.

An extraordinary man, and the calculating machines were only a fraction of his interests. See Wikipedia's biography for more. I respect this source as it also promotes South London as his birthplace.

So, ask yourself, does your workspace provide the following -

High ceilinged room with excellent natural light, and

Excellent public transport connections, and

Free wireless internet (a good use of my Council Tax), and

A deep sense of history?

If not, relocate to the Walworth Road. You'll not regret it.

Regex, Roman Numerals and TDD

2006-06-27T12:39:00.000+01:00

I read a blog on Roman Numeral Conversion and decided to do the reverse, roman to integer conversion. I wanted to use Regular Expressions as I thought they would allow a neat treatment. And I wanted to use Test Driven Development (TDD) to ensure that I had written what I thought I had written.

I started with a simple test, and a simple class (in that order). After one and a half iterations, the code was like this. By one and a half iterations, I mean one working test, one failing test.

[TestFixture]
public class RomanToIntTester
{
    [Test]
    public void TestZero()
    {
        RomanToInt r2i = new RomanToInt();

        Assert.AreEqual(0, r2i.Convert( "" ) );
    }
    [Test]
    public void TestOne()
    {
        RomanToInt r2i = new RomanToInt();

        Assert.AreEqual(1, r2i.Convert("I"));
    }
}

public class RomanToInt
{
    public RomanToInt()
    {
    }
    public int Convert(string str)
    {
        return 0;
    }
}

I chose not to work through tests for II = 2, III = 3, IV = 4, but instead to write the daddy of all tests, using Excel to do the repetitive coding for me. I set up a 4,000 row spreadsheet, and put the following formulae into the cells on row 4000 -

A4000 =A3999+1
B4000 =ROMAN(A4000,0)
C4000 =CONCATENATE("Assert.AreEqual(",A4000,", r2i.Convert(""",B4000,"""));")

I then copied these into rows 1 to 3999, and then typed 0 into cell A1. Column C was now my test code. I copied it into my test class and had the following -

[Test]
public void TestZeroTo3999()
{
    RomanToInt r2i = new RomanToInt();
    Assert.AreEqual(0, r2i.Convert(""));
    Assert.AreEqual(1, r2i.Convert("I"));
    Assert.AreEqual(2, r2i.Convert("II"));
...
    Assert.AreEqual(3997, r2i.Convert("MMMCMXCVII"));
    Assert.AreEqual(3998, r2i.Convert("MMMCMXCVIII"));
    Assert.AreEqual(3999, r2i.Convert("MMMCMXCIX"));
}

I then set about the task. I wrote tests then code to remove say "IV" and replace it with "4". I used a Regex Replace call for this. Then tests and code to replace all two-letter values - IV, IX, XL, XC, CD and CM - with a single digit or a letter not otherwise used - "F" for "XL" (forty), "N" for "XC" (ninety), "A" and "B" for "CD" and "CM".

    Assert.AreEqual("9", r2i.ReplaceAll("IX"));
    Assert.AreEqual("MBN9", r2i.ReplaceAll("MCMXCIX"));

I wrote tests and a function to count the number of occurences of a character and return that count multiplied by a base value.

    Assert.AreEqual(3, r2i.RepeatCountAndMultiply("XXXVIII", "I", 1));
    Assert.AreEqual(5, r2is.RepeatCountAndMultiply("XXXVIII", "V", 5));
    Assert.AreEqual(30, r2i.RepeatCountAndMultiply("XXXVIII", "X", 10));

All that remained was to implement the Convert function in full, as a call to ReplaceAll followed by incrementing a value with successive calls to RepeatCountAndMultiply. And guess what? The TestZeroTo3999 test passed first time. Does the smugness come through in the tone of this post? I quickly
refactored the class and tests to make most of the functions protected, and therefore deriving the tester class from the implementation class (is this a good idea?) and I considered myself done.

Here's the conversion class in full.

namespace MusingsLib
{
    public class RomanToInt
    {
        public RomanToInt()
        {
        }
        public int Convert(string str)
        {
            int retval = 0;
            str = ReplaceAll(str);
            retval += RepeatCountAndMultiply(str, "I", 1);
            retval += RepeatCountAndMultiply(str, "4", 4);
            retval += RepeatCountAndMultiply(str, "V", 5);
            retval += RepeatCountAndMultiply(str, "9", 9);
            retval += RepeatCountAndMultiply(str, "X", 10);
            retval += RepeatCountAndMultiply(str, "F", 40);
            retval += RepeatCountAndMultiply(str, "L", 50);
            retval += RepeatCountAndMultiply(str, "N", 90);
            retval += RepeatCountAndMultiply(str, "C", 100);
            retval += RepeatCountAndMultiply(str, "A", 400);
            retval += RepeatCountAndMultiply(str, "D", 500);
            retval += RepeatCountAndMultiply(str, "B", 900);
            retval += RepeatCountAndMultiply(str, "M", 1000);
            return retval;
        }

        protected string ReplaceAll(string str)
        {
            str = ReplaceRomanWithAlternative(str, "IV", "4");
            str = ReplaceRomanWithAlternative(str, "IX", "9");
            str = ReplaceRomanWithAlternative(str, "XL", "F");
            str = ReplaceRomanWithAlternative(str, "XC", "N");
            str = ReplaceRomanWithAlternative(str, "CD", "A");
            str = ReplaceRomanWithAlternative(str, "CM", "B");
            return str;
        }

        protected int RepeatCountAndMultiply(string inputstr, string roman, int baseval)
        {
            Regex r = new Regex( roman );
            return r.Matches(inputstr).Count * baseval;
        }

        protected string ReplaceRomanWithAlternative(string inputstr, string roman, string alt)
        {
            Regex r = new Regex( roman );
            return r.Replace(inputstr, alt);
        }
    }
}

Reference : www.differentpla.net/node/58

Regex and TDD - sine qua non

2006-06-24T13:44:00.000+01:00

I'm hauling myself up the regular expressions learning curve. What worries me is that it is so easy to use them wrongly. When there's an expression like "(?=(\d\d\d)*$)(\d\d\d)" how sure are you of what it does?
That's where Test Driven Development comes to the rescue. I'm telling myself to write at least half a dozen tests to check that the behaviour is as expected. Take the following function, designed to turn a long value like 1234567 into a string value of 1,234,567. A neat use of regular expressions, processing a set of matches using a lookahead. But can you see the bug?


        public string BignessWithCommas
        {
            get
            {
                string retval = string.Empty;
                string str = m_bigness.ToString();

                Regex r = new Regex(@"(?=(\d\d\d)*$)(\d\d\d)");
                int tripletlen = 0;
                foreach (Match m in r.Matches(str))
                {
                    if (retval != string.Empty)
                        retval += ",";
                    retval += m.Value;
                    tripletlen += 3;
                }
                if( tripletlen < str.Length )
                    retval = str.Substring( 0, str.Length - tripletlen ) + "," + retval;
                return retval;
            }
        }

No, I couldn't see the bug either. Thankfully, I tested it with


        [Test]
        public void ItemWithCommas()
        {
            DuctTop100Item x = new DuctTop100Item("Me", 17);
            Assert.AreEqual("17", x.BignessWithCommas);
            x.Bigness = 179; Assert.AreEqual("179", x.BignessWithCommas);
            x.Bigness = 1790; Assert.AreEqual("1,790", x.BignessWithCommas);
            x.Bigness = 12790; Assert.AreEqual("12,790", x.BignessWithCommas);
            x.Bigness = 123790; Assert.AreEqual("123,790", x.BignessWithCommas);
            x.Bigness = 1234790; Assert.AreEqual("1,234,790", x.BignessWithCommas);
            x.Bigness = 1234567890; Assert.AreEqual("1,234,567,890", x.BignessWithCommas);
        }

and it went wrong immediately. As so often is the case, it failed on the simple example, because my whole brain was used up doing the difficult bit.

BookDiff on XP Explained

2006-06-15T16:36:00.000+01:00

I needed a copy of Kent Beck's Extreme Programming Explained, and was pleased to see a new edition. True to the XP ethos, it has been refactored. But I fear it may not pass a suite of tests, such as repeating all that was good in the first edition.

Kent shares the Second Edition (SE) credit with Cynthia Andres. I wonder whose idea was it to forbid sexual relationships between team members (SE p43), and are they ashamed of their heterosexual stereotyping? And I’m suspicious that Kent and Cynthia are closer than some other co-authors – on page 104 there is a reference to Beth Andres-Beck.

So we used to have four values – communication, simplicity, feedback and courage. SE adds Respect. The First Edition (FE) chapter on principles is 6 pages long, the SE chapter is 12 pages, and there’s almost no common ground between the two.

The shock is that the twelve practices have gone, at least as a tightly defined list. I miss them so much I put together http://www.bitwix.com/xpdiagram.htm to remind me what they are. Instead of the excellent diagram on FE page 70, we have spidery maps.

And so it goes on. Do you want to read about Frederick Taylor, the industrial engineer who used systematic methods to improve factory production? In FE, he is in the bibliography but dismissed with “as strategies for software development [his principles make] no business sense and no human sense”. In SE, he gets a whole chapter.

My disappointment is that Kent’s first edition was so practical and so readable, it was inspiring. The second edition is neither. It loses the simple, countable sets of values, principles and practices in a mess of new ideas. And the ideas are communicated in such a way that I find myself skipping to the end of the chapter.

Thankfully, there are secondhand copies of the first edition available. Embrace change? Not in this case.

On Rounding

2006-03-19T18:09:00.001Z

This is just a wee bitch about Microsoft's permanent need to improve our programming lives. In this case, it's about rounding numbers to two decimal places.

In the UK, Value Added Tax (VAT) is 17.5%. If something costs £2.00 then £0.35 is added in VAT making a total paid of £2.35. If something costs £2.20 then 17.5% is £0.385 which either £0.38 or £0.39 depending on whether you round up or round down.

At school, I was taught to round up if the number ended in 5. And that's what the Excel rounding routines (see above) do. It's also what the SQL Server ROUND function does - see below.

It's not what the .Net Framework rounding does - they have decided to use Bankers Rounding, where you round towards an even number. So 0.385 is rounded to 0.38. Bankers Rounding must be cockney rhyming slang for Astounding.

At least .Net looks consistent. Imagine my surprise when I checked this in Visual Basic 6.0 to find that some roundings go one way, some go another. How else to explain that the VAT on 0.20 is 0.03, but the VAT on 4.20 is 0.74? It is pretty stink, as they say in New Zealand.

Wheel Spire Dome Office Flat

2006-01-27T07:15:00.000Z

These five buildings and structures rise above the South London streets. Each has its own story. Some have stayed the same, others have moved from one use to another.

First we have the "London Eye" also known as the Millennium Wheel. It is now iconic, but I remember sitting on the Embankment in September 1999 watching them fail to hoist it from its horizontal position, making it another national embarrassment.

Next is the spire of Christ Church and Upton Chapel, physical home of www.church.co.uk (now that's what I call a website address). There is the suggestion that the stars and stripes on its spire link to Abraham Lincoln's family who contributed to the original building.

Third is the dome of the Imperial War Museum, a radical transformation of a mental asylum. As a kid I just loved going there to see tanks and fighter planes up close. Now it's the human stories I go for, and I never come out laughing.

The Shell Centre comes next. This is the Upstream building and is still used as offices, unlike other parts of the complex which have become flats. The architects wanted a building nearly twice as high; I'm glad they weren't allowed. Its best moment is as a projection screen for events such as the poppy drop in November.

Last we have a block of flats, which got in the paper when someone asked £4,500,000 for a one bedroom flat. For me it isimportant to note that it used to be the headquarters of MI6, the British spies now relocated to a landmark building. This block was never interesting enough to feature in a James Bond movie.

A Random Number Web Service - Keeping It Honest

2006-01-21T23:05:00.000Z

Two things Microsoft have made easy for us these days. Writing a web service and producing random numbers. But do they work together?

Web services are new(ish) so it's no surprise that the authoring tools are getting easy to use. Visual Studio 2005 does get you from zero to hero in minutes. If you skip documentation paragraphs (as I do), then the only gotcha is that yes, you have to run WSDL from the VS2005 command line prompt.

Random number generators have been around for years. We've all used them for silly programs. Most of us have then noticed that to start with they actually gave us the same stream of "random" numbers, so we read up about seeding and then found a way that was random enough to seed the generator so that we never saw the same sequence twice.

We were therefore pleased that in the .Net Framework

Random r = new Random();

used a seed generated from the time. So we could just use that and *bingo* our numbers were never the same twice.

Put these two technologies together, and you have a random number generating web service.

Except you don't. Use the service twice on a page, and you get the same number.

The problem is that each call to the web service creates a new Random() class object, seeded with the current time. Call it quickly enough, and the next one will be seeded with the same time, and it's no longer random.

My solution was to pause for a tick before creating the Random object. I did this by holding the DateTime.Now.Ticks and then sleeping the thread for 1 millisecond.

using System.Threading;

public class RandomData 
    : System.Web.Services.WebService
{
    Random m_r;
    public RandomData () 
    {
        long tc = DateTime.Now.Ticks;
        do
        {
            Thread.Sleep(1);
        } while (tc == DateTime.Now.Ticks);
        m_r = new Random();
    }

You can then use m_r.Next() without fear.

Why do you want a random number web service? So that it can become a full random data web service, applying algorithms or reading databases of potential values. See www.bitwix.com/NorMad for more.

New / Change / Nouvel : Pun your own headline

2006-01-21T16:20:00.000Z

Just East of St Paul's Cathedral is a red brick building, shortly to become a building site, then to become Britain's first building by Jean Nouvel.

It's an interesting test case of what constitutes a building worth keeping, and when the combination of a "starchitect" and a commercial property developer is likely to do the city any good.

My bias is that in 2002 I schlepped over to Switzerland for Expo.02. In the town of Morat, in the middle of the lake, was a massive iron cube. You queued to get on the boat out to this cube, and then had three panoramic experiences on three different levels. Stunning, and a credit to Monsieur Nouvel.

The red-brick New Change Buildings (built 1953-1960) by Victor Heal have their detractors. "Regrettable ... silly little semi-period balconies ... sculpture as retardataire as the architecture" says Nikolaus Pevsner in the 1962 edition of The Buildings of England : London.

Instead we get 220,000 sqft of "retail destination" which Land Securities promises us will "create a vibrant commercial hub for this important City community". The buildings are not high - six floors - but they are designed to get plenty of floorspace for shops and offices.

On balance, I'm content that the Heal building will go. I've watched the City being filled in with so many really bad blocks, this one might be a little better. We are told that there will be rooftop public space - I would appreciate that if it is more public than, say, the garden on Stirling's One Poultry.

I just don't expect a building of real quality. We won't get an Institut Monde Arabe.

Links
Land Securities press release
Jean Nouvel and the Morat Monolith

The largest hidden gem in London

2006-01-14T18:03:00.000Z

Of course you know it's there, it's just that you've never seen it. A stadium sized concrete structure hidden away in a back street, magnificently doing the job is was built to do.

Stockwell Bus Garage is a landmark building in London. Archictecturally perfect and completely unaffected by the heritage industry. A fair sprinkling of graffiti but that's no more offensive than the plethora of official signs forbidding unauthorised access.

It was a mediocre grey day when I walked over to the garage, stopping to photograph the blue plaque for Dan Leno. So the photo does not do it justice. If you want to see it, turn left out of Stockwell tube and take the second left turn. Better would be to use the 196 or P5 bus.

Links
Wikipedia article
Photos on LondonBusGarages.co.uk showing that it is always a grey day in Stockwell
Onionbagblog pictures - still no blue sky

Do all programmers speak Sanskrit?

2006-01-10T23:58:00.000Z

The most commented-on post in 2005 on Scot Adams's blog was Do all programmers speak english?. I read this while setting up a Wiki for my company, thinking that Wiki was the first word of Hawaiian I had learned.

Which got me to thinking about the derivation of words we programmers use. They mostly fall into two groups - classic adaptations and clever neologisms. Where, I thought, are the words borrowed from other languages, adapted for use in computing?

By classic adaptations, I mean someone has gone for a Latin or Greek root and used it for a new purpose. Computer, to take an obvious one, comes from the Latin computare, to reckon. Program from the Greek programma a proclamation.

Some words have a root in other languages. Window is recorded in English in the early thirteenth century. Its first use in the sense of overlapping rectangles on a screen was in 1974. Whereas Menu as a computing term was used in 1967, a mere 130 years after its first recorded use in English (from the French).

The neologisms are where the fun starts. Bit as a contraction of Binary Digit, then Byte for eight bits, and so Nybble for half a Byte. My favourites are copyleft (as opposed to copyright), marketecture (design elements for marketing it, not for using it) and outernet (a.k.a. the real world).

But these words are inventions. Where are the borrowings? Where are the computing equivalents of boss (Dutch), tycoon (Japanese), guru (Sanskrit) or coach (Hungarian), all words we use but in the same sense as everyone else?

You could claim Algorithm, which traces back to al-Khowarazmi, Arabic for the man from Khwarazm, meaning one Abu Ja'far Mohammed Ben Musa, a mathematician whose work on Algebra influenced the use of the Arabic number system in Europe. Or Bot, a contraction of Robot, from a Czech word for forced labour, used by Karel Capek in his play R.U.R. (1920). But both of these had a life in English before computing adopted them.

One I can find is Kludge, which was first used in 1962 as "an ill-assorted collection of poorly-matching parts, forming a distressing whole", yet comes from the German word Kluge, originally meaning smart or witty, according to the Oxford English Dictionary (CD-Rom, 1992, still runs on my wife's computer, can't install it on my computer as I have no 3.5" floppy drive). Or, from the Scots kludge or kludgie for a common toilet, according to the Jargon Wiki.

The second, to go with boss, tycoon etc, is Kahuna, which is Hawaiian for shaman, and shows that Wiki was actually my second word in that language.

Any one got any more?

Meanwhile, I've found a word for the naming of classes by joining nouns together, such as TextBox or ToolBarButtonCollection. Henceforth, this is to be known as the Tatpurusha Class Naming Convention, borrowing the word Tatpurusha which comes from the Sanskrit for his servant and is therefore itself a tatpurusha word. Currently Googling for "tatpurusha class" returns no hits, but it is only a matter of time.

That's it. Forgive me for being such a geek (U.S Slang from 1916), an anorak (Greenland Eskimo, 1934) and a nerd (made up by Dr Seuss, 1950, probably).