All I need to know about manufacturing I learned in Joe's garage

is an excellent book by William B. Miller and Vicki L. Schenk (isbn 0-9630439-3-5). As usual I'm going to quote from a few pages:

I mumbled back something equally unintelligible, the traditional response to somebody whom you aren't sure you've met and whose name you aren't certain of.

"Why is there such a conflict?" he asked. "Both departments are striving for the same thing, the good of the company. Why should they not work together?"

With all that volume flowing through his "factory," even the slightest unplanned act will ripple through everything else with a domino effect.

Fanatic: A person who redoubles his effort after having lost his direction.

If you double the amount of equipment and tools in use, you must halve the failure rate simply to stay even.

Planning can be perfect - it's all theoretical. Execution can never be perfect - it involves real people using real tools on real material.

People are expected to inspect their own work, both for function and to specification… Statistical and analytical charts are maintained on the production floor by workers, not by Quality Assurance people in a remote office.

Like most computer people would have, he had stayed close to his electronic toy rather than come to the garage to watch the production operation.

The finest carver does the least cutting.

Nobody ever tried harder under pressure.

"know'why" in addition to "know-how"

Long test method names

Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch

Writing good code is hard. For lots of reasons. One reason is the tension you try to balance when choosing identifiers. On the one hand you want your identifiers to be longer to give you enough space to make them expressive. But on the other hand you want your identifiers to be shorter so they don't balloon into monsters when combined into expressions. For example:

// too short
bool is_leap_year(int y)
{
    return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
}

// too long
bool is_leap_year(int intYearValue)
{
    return intYearValue % 4 == 0 && intYearValue % 100 != 0 || intYearValue % 400 == 0;
}

// just right, said Goldilocks
bool is_leap_year(int year)
{
    return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}

However, the names of your test methods are not subject to this design tension. The names of your test methods should never be part of a larger expression. So loosen up! Feel free to use long test method names. Names that reflect the specification not the implementation.

// not like this
static void test_leap_year()
{
    assert(!is_leap_year(1999));
}

// like this
static void years_not_divisible_by_4_are_not_leap_years()
{
    assert(!is_leap_year(1999));
    assert(!is_leap_year(2001));
}

THE Secret of Scrum

This is another fragment of the ALE conference lightning talk I did. It again follows on from Jerry Weinberg's quote:

No other observation skill may be more important to software engineering than precision listening.

I've tried to become a much better listener in recent years. An active listener. One of the things I've noticed is that software developers are somewhat prone to treat things as being black and white. True or false. Right or wrong. This is perhaps not so surprising for several reasons. Anyway, the point of the clip is not really to poke fun at Scrum, but to highlight the use of the word THE.

Precision Listening

At the ALE conference I did a lightning talk. On my first slide I quoted this from Jerry Weinberg's Quality Software Management Volume 1: Systems Thinking:

As consultants, we've found that the quickest and surest way to classify organizations into similar patterns is by the way people think and communicate.

On the second slide I quoted Jerry again (from the same book):

No other observation skill may be more important to software engineering than precision listening.

I was reminded of this a moment ago when someone cold-called me. I honestly don't remember what the person's name was or what they were selling. What I do remember is how the conversation started:

Hello, Jon Jagger speaking.

Hello, can I speak to Jon Jagger please.

Do you recognise this pattern? This response is pure waste. It does nothing but waste my time. After this response the one thing I know for sure is that they're not listening to me. And if they're not listening to me why should I listen to them?

flow = speed x density

I attended the ALE conference in Berlin last week. It was excellent in many many ways. Lots of participants have written blog entries and I thought I would write a short one about just one of the many things I thought was really great. It was the above graph which Karl Scotland drew in his talk, The Science of Kanban.

Karl used this graph in the context of traffic.

• The green line is traffic Speed and it rises (to the right) from zero at the bottom left.
• The red line is traffic Density and it rises (to the left) from zero at the bottom right.
• The black line is traffic Flow and equals Speed x Density.

Speaking to Karl afterwards we discussed the analogy:

• Speed = cycle time. The time it takes from the moment a piece of work enters the system to the time it gets to Done.
• Density = work in progress. The amount of work that has entered the system but hasn't yet got to Done.

Karl also pointed out two feedback loops.

• Start on the density line (red) at zero (bottom right) and increase the density (move up and to the left). For a while increasing the density increases the flow. Increasing the flow causes the density to reduce. Thus you have a stabilizing feedback loop helping to increase the flow.
• As you continue to increase the density you drop over the top of the flow-curve.
• Now as the density increases the flow decreases. And decreasing the flow causes the density to further increase. Thus you have a different destabilizing feedback loop helping to decrease the flow.

Simple and effective. Thank you Karl.

The unknown craftsman

is an excellent book by Sōetsu Yanagi (isbn 0-87011-948-6). As usual I'm going to quote from a few pages:

The good artist or craftsman has no personal pride.

Seeing relates to the concrete, knowing to the abstract.

To divine the significance of pattern is the same as to understand beauty itself.

A pattern is both true to nature and artificial.

If the material is poor the pattern will suffer.

By and large, good pattern is of communal parentage.

Beauty must have some room, must be associated with freedom.

The Theologica Germanica, written in the fourteenth century, tells is: "He would know before he believeth cometh never to true knowledge". Applied to the perception of beauty, this means that if a man employs the function of knowing before seeing, his power is impaired.

Intuition is the power of seeing at this very moment.

The thing shines, not the maker.

They are made without obsessive consciousness of beauty; thus we catch a glimpse of what is meant by "no-mindedness", whereby all things become simplified, natural, and without contrivance.

Wye Barbel

Just back from two fantastic days fishing on the River Wye with my mate Brian on the Wye and Usk Foundation Wyebank and Courtfield beats. He caught this 11 lb'er - a new personal best. We can't wait to go back.

the alchemist

is an excellent book by Paulo Coelho (isbn 978-0-7225-3293-5). As usual I'm going to quote from a few pages:

"This is the first phase of the job," he said. "I have to separate out the sulphur. To do that successfully, I must have no fear of failure. It was my fear of failure that first kept me from attempting the Master Work.

"But arms cannot be drawn unless they also go into battle. Arms are as capricious as the desert, and, if they are not used, the next time they might not function."

"I had to test your courage," the stranger said. "Courage is the quality most essential to understanding the Language of the World."

"It is not what enters men's mouths that's evil," said the alchemist. "It is what comes out of their mouths that is."

"Tomorrow, sell your camel and buy a horse. Camels are traitorous: they walk thousands of paces and they never seem to tire. Then suddenly, they kneel and die. But horses tire bit by bit. You always know how much you can ask of them, and when it is that they are about to die."

"There is only one way to learn," the alchemist answered. "It is through action."

Quality Software ManagementVol 1. Systems Thinking

is an excellent book by Jerry Weinberg (isbn 0-932633-22-6). This is the second snippet review for this book (here's the first). As usual I'm going to quote from a few pages:

A locked-on system tends to hold itself to an existing pattern, even against logical reasons to change. … Lock-ons occur in clusters.

We particularly look for the degree of congruence between what is said and what is done.

The quickest and surest way to classify organisations into similar patterns is by the way people think and communicate.

The feedback model says you can't successfully control anything for very long without information.

errors - deviations from requirements that give you information to control the system.

The treatment of error as a source of valuable information is precisely what distinguishes the feedback (error-controlled) system from its less capable predecessors and thus distinguishes Steering software cultures from Patterns 1 [Variable] and 2 [Routine].

If the technical reviews are not detecting a lot of mistakes it could mean that … the system is working very well.

Late modules tend to be fault prone modules.

The more modular you make the system, the fewer side effects you need to consider. You trade for this effect by creating modularity faults, or faults in the interaction between modules. You never get something for nothing.

Feedback must operate in small increments, at all levels - personal, product, process, and cultural.

In such a system it is meaningless to ask who is controlling whom?

It's not the event that counts...

In Quality Software Management volume 1 Systems Thinking, Jerry Weinberg writes (on page 111)

"It's not the event that counts, it's your reaction to the event".

A bit later, on page 124 Jerry writes something which I've read several times before but for some reason this morning it really spoke to me.

Tools do not determine how they will be used. Therefore it's not the tool that counts, it's your reaction to the tool. Programming tools can be used to program without understanding, or they can be used to free the programmer's mind and hands for tasks that can't be made routine.

Jerry finishes the paragraph with:

Pattern 2 (Routine) managers buy tools to force programmers to work in standard ways. Pattern 3 (Steering) managers manage tools to empower programmers to work in effective ways.

What Did You Say?

is an excellent book (subtitled The Art of Giving and Receiving Feedback) co-authored by Jerry Weinberg (isbn 0-924771-33-X). As usual I'm going to quote from a few pages. I know I've snippeted this book before, but I read it again and a really good book deserves a repeat snippet. For the past year or so I've deliberately been re-reading books I've already read rather than reading new ones.

Cybernetics tells us that feedback is a relationship between two systems. ... you're a system too.

A lot of our fear of telling them comes from inexperience, or rather experience at giving feedback poorly and then getting a poor result. But getting a poor result is is such a terrible experience only if we have a perfection rule.

Over time, the process of sorting creates an environment that will not provide feedback that leads to change.

In other words, it's not so much the feedback that counts, but the struggle to get it - not the feedback, but the feeding-back.

If you keep doing the same thing why do you expect them to change what they're doing?

Say what you saw and heard.

If mistakes are not acceptable, learning is not possible.

Learning is what feedback is all about.

QCon Deliberate Practice video

Videos are like buses. None for ages then two come along at once. I did this talk, on Deliberate Practice at the QCon conference in London earlier in the year (it's only just been put online). It's an extension of my 97 Things Every Programmer Should Know entry.

In the brain of me

Here's a video of the SkillsMatter talk I did on Thursday, titled "Stuff I'm starting to know now that I really wish I'd known 20 years ago". Its loosely based on the theme of Making The Invisible More Visible, one of my entries from the book, 97 Things Every Programmer Should Know. I completely botched what I was trying to say about courage. What I was trying to say was that courage is not the absence of fear.

My other SkillsMatter talk was based on Do More Deliberate Practice my other entry in the 97 Things Book.

This was the first run of quite a lot of new material so I was quite nervous, but I felt most of it went very well. Here's some of the feedback.

• Fun, informative, useful
• An interesting brain dump
• Entertaining and enlightening
• Very good. Thoughtful and interesting
• Great content - very interesting
• Great laid back presentation
• Interesting ideas and great presentation to go with it
• Well planned presentation, not just your standard powerpoint
• Very good talk. Inspiring
• Very interactive and well explained
• Clear explanations, good analogies, funny
• Fantastic
• Very good. Passionate speaker. Good insights

Becoming a Technical Leader

is an excellent book by Jerry Weinberg (isbn 0-932633-02-1). As usual I'm going to quote from a few pages. I know I've snippeted this book before, but I read it again and a really good book deserves a repeat snippet.

From working with systems, I have learned that the process of change is always organic.

Organic models may be characterized by "systems thinking": the belief that event X is the outcome of hundreds of other factors, including the passage of time.

People improve their performance not by amputating their old behaviors, but by adding new ones.

There are many technical workers who enjoy wandering so much that, like Alice in Wonderland, they don't much care where they go, so long as they get somewhere. Computer programmers call this process "hacking"

In front of each plateau is a ravine.

Probably the most widespread and pernicious myth about leadership is that only Leaders can lead, where the capital L indicates that someone has been appointed to the position of leadership. ... It's only in threat/reward models that leadership and management are synonymous.

You can develop your ability to see and hear more effectively.

People aren't used to thinking in terms of relationships.

I first look for personal power, which can be converted into almost anything.

Break down big learnings into a sequence of little ones, pay attention to the efficiency of your educational strategies, and become aware of your emotional reaction to learning.

CyberDojos

I've run a couple more CyberDojo's recently. The first was with Kevlin Henney during an onsite run of our Mastering Agile Practice course for commasoft in Bonn, Germany.

The second was for Mott MacDonald, in Croydon, England. Here's some feedback from the sessions:

• an awesome afternoon!
• It has been the single most useful training exercises I have attended at motts.
• it was an excellent team building exercise and a fun introduction to some development concepts we're not familiar with, in particular pair programming and test driven development, but also the concept of 'deliberate practice'.
• helped improve the cooperation within the team
• Great!
• I want more Dojos

Tests as specifications

The other day I was doing the yahtzee kata in C in CyberDojo and I got caught (not for the first time) by a classic gotcha...

I wrote my tests very very simply as follows:

...
static void two_pairs_scored_as_one_pair_is_spots_on_highest_pair(void)
{
    assert(...);
}

static void full_house_scored_as_one_pair_is_spots_on_the_pair(void)
{
    assert(...);
}
...

typedef void test(void);

static test * tests[] =
{
    two_pairs_scored_as_one_pair_is_spots_on_highest_pair,
    full_house_scored_as_one_pair_is_spots_on_the_pair,
    ...,
    NULL,
};

int main(void)
{
    for (int at = 0; tests[at] != NULL; at++)
        tests[at]();
    return 0;
}

I wrote another test and hit the Run-Tests button. But the new test didn't get run because I'd forgotten to add the name of the function to the tests array. Ooops. The new test compiled ok, and I'd tripped up thinking the test was passing when it wasn't even being run.

I've practised in CyberDojo enough that I don't get "sucked into the code" as much as I used to and when something like that happens there's now a fair chance I'll have enough awareness to notice it as it happens.

I stopped and thought about what had happened for a moment and I realized something. My problem was that I was writing the test function definition first. I should be writing the name of the test in the tests array first. And only once I've done that should I define it. There is a nice echo of the idea of Test First Design to this.

Of course in a language with reflection you only need to write the test function. Be that as it is, I like the the way the contents of the tests array lists the function names as specifications. In a language with reflection you don't get that.

The Secrets of Consulting

is an excellent book by Jerry Weinberg (isbn 0-0-932633-01-3). As usual I'm going to quote from a few pages. I know I've snippeted this book before, but I read it again and a really good book deserves a repeat snippet.

Consultants deal in change.

Consulting is the art of influencing people at their request.

..there is the problem of balancing certainty now versus uncertainty in the future.

Consultants are less adapted to the present situation, and therefore are potentially more adaptable.

The toughest problems don't come in neatly labelled packages. Or they come in packages with the wrong labels.

The bigness is not the horse.

The true expert can see multiple aspects of a situation, but the novice sees only... whatever is most conspicuous.

We all know that things tend to fall between cracks and that cracks occur at boundaries, where one system joins another.

For a trigger to be effective, the timing must be perfect: Too late means you're already committed to the troublesome action, while too early means you may forget again betwixt the cup and the lip.

There are always opportunities to jiggle.

Six memos for the next millenium

is an excellent book by Italo Calvino (isbn 0-099-73051-0). As usual I'm going to quote from a few pages:

Lightness for me goes with precision and determination, not with vagueness and the haphazard... (One should be light like a bird and not like a feather)...

... even correctness of style is a question of quick adjustment, of agility of both thought and expression.

... each value or virtue I chose as the subject for my lecture does not exclude its opposite.

Poetry is the great enemy of chance, in spite of also being a daughter of chance.

On folio 265 of the Codex Atlanticus, Leonardo begins to jot down evidence to prove a theory of the growth of the earth. After giving examples of buried cities swallowed up by the soil, he goes on to the marine fossils found in the mountains and in particular to certain bones that he supposes must have belonged to an antediluvian sea monster. At this moment his imagination must have been caught by a vision of the immense animal as it was swimming among the waves. At any rate, he turns the page upside down and tries to capture the image of the animal, three times attempting a sentence that will convey all the wonder of that evocation.

It is useless at every circle to invent a new form of metarepresentation.

What tends to emerge from the great novels of the twentieth century is the idea of an open encyclopedia, an adjective that certainly contradicts the noun encyclopedia, which etymologically implies an attempt to exhaust knowledge of the world by enclosing it in a circle.

There is a type of work that, in the attempt to contain everything possible, does not manage to take on a form, to create outlines for itself, and so remains incomplete by its very nature.

... the collection of objects of which only one specimen exists.

The classical author who wrote his tragedy observing a certain number of known rules is freer that the poet who writes down whatever comes into his head and is slave to other rules of which he knows nothing.

Synectics

is an excellent book by William J.J. Gordon (isbn 978-0060324308). As usual I'm going to quote from a few pages:

The word Synectics, from the Greek, means the joining together of different and apparently irrelevant elements.

Abstraction breeds more abstraction and more generality instead of leading to tough yes-no tests.

Words like intuition, empathy, and play are merely names put to complex activities in the hope that the naming of the activity will in fact describe it.

Human beings are heir to a legacy of frozen words and ways of perceiving which wrap their world in comfortable familiarity.

Synectics theory agrees with the conviction that a man does not know even his own science if he knows only it.

"All the crappy solutions in the world have been rationalized by deadlines."

He refused to recognize the fact that his search for the perfect problem was a way of avoiding failure in solving a less perfect one.

Invention is akin to painting for in practice, the element being constructed has the capacity to tell the builder what the next step should be. In invention this is much more critical than in engineering because the inventor is always attempting to do something new.

When this forgetfulness is formalized into a methodology, it reinforces the rejection of the commonplace.

Organic functions are unfinished, cylical, and self-reproductive... Synthetic functions are complete and more obviously subject to decay.

Conventions as abstractions from reality constitute a virtually complete and unassailable pattern, whereas the commonplace is infinitely repatternable.

The child who asks: "What's that funny noise?" is told the noise is thunder in such a way that speculation is supposed to stop... But naming the noise does not describe it. It does not answer the question, it kills it.

Why do car drivers brake?

Recently I wrote a small blog entry Why to cars have brakes? It's getting a lot of hits. Well, a lot for me. So naturally in my quest for even more hits here's a follow up...

Imagine you're in a car. Driving along. Why do you brake? I'm not asking what happens when you press the brake pedal? That's too easy (the car stops). I'm asking why…?


.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Here are two reasons:

Reason one: because there's danger ahead

This corresponds to a failing test. More specifically, it's when a test runs and asserts. A red. Perhaps there's a queue of traffic ahead (often a problem on the orbital car park known as the M25). Perhaps the road is closed off because workmen are working on it. Or maybe the local council has been meddling and the road is now a one-way-but-not-the-way-you-want-to-go road. Whatever the reason, something is not as expected.

Reason two: because you've arrived!

This corresponds to a passing test. A green. Wherever it is you're going, you've got there. Nothing unexpected happened. No traffic queues. No closed off roads. No meddling local council. Incredible!

In my entirely unscientific sampling almost everyone answers with the first reason. The second reason is not nearly as common. I find this interesting. I think maybe it's a reflection of the thinking statically vs thinking dynamically thing again. A perception that tests are most useful when they fire red. That tests which run to completion without incident are not so useful. But they are. Maybe more so.

Brakes help me stop. And stopping implies I'm already moving - I'm already going somewhere. But where? If I don't know where I'm going why am I moving at all? If I don't know where I'm going I'm just as lost as if I don't know where I am.

Tests are useful not just because of the I-didn't-arrive effect when they fail, they're also useful because of the I-did-arrive effect when they pass.

Another reason passing tests are really useful is the elves. But the elves will have to wait for another time.