less code, more software

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.

is an excellent book by Tim Lister and Tom DeMarco (isbn 0-932633-43-9). 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.

Development is inherently different from production.

Most organizations don't set out consciously to kill teams. They just act that way.

The trade-off between price and quality does not exist in Japan. Rather, the idea that high quality brings on cost reduction is widely accepted. [Tajima and Matsubara]

The manager's function is not to make people work, but to make it possible for people to work.

The trick isn't in the technology; it's in the changing of habits.

An age-old pattern of interior space is one that has a smooth "intimacy gradient" as you move toward the interior.

Employee turnover costs about twenty percent of all manpower expense. But that's only the visible cost of turnover. There's an ugly invisible cost that can be far worse.

It's only the right to be wrong that makes you free.

The structure of a team is a network, not a hierarchy.

Everyone quickly understands that the presence of the posters is a sure sign of the absence of hard work and talent.

The more you improve the way you go about your work, the harder the work will be.

The manager of a large project in Minneapolis has refused to move his people to the new quarters. ("New in this case just meant smaller and noisier.) Administrators were simply stunned at his refusal; they had never considered the possibility.

is an excellent book by Peter Falk (isbn 978-0-099-50955-4). As usual I'm going to quote from a few pages

My object is to keep you awake.

I didn't stay in college the full four years. I quit after three months and joined the Merchant Marines. Men with one eye were not drafted and in the Merchant Marines they were not allowed to work on deck or below deck, but they could work in the kitchen. I sailed out as third cook. My specialty was pork chops.

About the third time I was late, even before I hit my seat, LaGallienne froze me with a question: "Why are you always late?" I said I had to drive down from Hartford. She asked coldly, "What do you do there? There are no theatres in Hartford. How do you make a living?" I told the truth. "I'm not an actor." She snapped back "Well you should be, now sit down."

I remember vividly that particular performance when for the first time I was suddenly startled by a new totally unexpected sound - a rich, deep authentic snore. Holy jamolies. There is someone on this stage that is sleeping - really sleeping.

I have never been arrested in the United States but I have been arrested in Paris, Moscow, Havana, Genoa, Belgrade, and Trieste.

Did he want to be buried or cremated? His answer to them was brief - "Surprise me."

"Here and there you'll find a raisin."

I was struck very early by the dramatic possibilities of playing a man who housed within himself two opposite traits.

For me The Princess Bride was a movie without a blemish, perfect for both kids and adults.

is an excellent book by Jerry Weinberg (isbn 0-932633-49-8). 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.

The average scientist is good for at most one revolution.

"Proof" in its original sense was a test applied to substances to determine if they are of satisfactory quality... Over the centuries, the meaning of the word "prove" began to shift, eliminating the negative possibilities...

They know "better" - which is to say that their illusion is stronger.

We drive more slowly at night to give us more time to observe potentially dangerous situations.

More probable states are more likely to be observed than less probable states, unless specific constraints exist to keep them from occurring.

Things we see more frequently are more frequent: 1. because there is some physical reason to favor certain states, or 2. because there is some mental reason.

The Axiom of Experience can, like all of our principles, be turned around, to become a definition of what we mean by the word "like": Two things are alike if one in the present can be substituted for one in the past.

a "boundary" may not be infinitely thin, precisely so it can partake of both system and environment. Rather than separating, such a boundary connects.

We can learn, if nothing else, proper caution in our speech, which will inevitably lead to proper caution in our thought...

is the title of an excellent book by James Grenning (isbn 978-1-93435-662-3). As usual I'm going to quote from a few pages:

A good design is a testable design.

TDD helps you go faster... Slowing down is exactly what is needed to go fast!

Like TDD, if testing is hard, do it all the time - it gets easier.

Test automation is the gift that keeps on giving.

One test result is worth 1,000 expert opinions [Wernher von Braun]

You get a shot of testability with a portability chaser.

If we can identify a particular code smell, we have a better chance of eliminating the bad smell.

Shifting levels of abstraction should happen for a purpose.

Refactoring should be part of everyday development. It's not on the schedule, and you don't ask for permission to refactor.

The industry norm is for code to incrementally worsen with each change. We need to reverse that.

Dual-targetting, like TDD, has another benefit: it influences your design. Paying attention to the boundaries between software and hardware produces more modular designs.

I don't remember where I was when Kevlin Henney asked me:

Why do cars have brakes?

but I do remember his answer as a definite light-bulb moment. What's your answer?

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
A very common answer is

to stop

or some variation thereof. In other words, to brake. It reminds me of the noun-verb thing again. Lights light. Irons iron. Compilers compile. Brakes brake. But that was not Kevlin's answer. Kevlin's answer was:

So you can drive faster.

His answer feels paradoxical which usually means there's a deep truth. Brakes allow you to stop when you want. Brakes allow you to stop where you want. Software tests are like brakes. They help you drive faster.

I'm also reminded of the P.W.Bridgman quote at start of chapter 6 of Jerry Weinberg's Introduction to General Systems Thinking:

...it is better to analyze in terms of doings or happenings than in terms of objects or static abstractions.

Thinking about brakes allowing you to stop is thinking statically. Thinking about braking allowing you to drive faster is thinking dynamically.

If you liked this post you might like the follow up Why do car drivers brake?.

Here's a refactoring I often teach. It's particularly applicable if you're wanting to refactor legacy code. I'll show it in C++ in honour of the excellent developers at Promethean.

I'll start with a typical Singleton:

class singleton
{
public:
 static singleton & instance();
 void f(int value);
 int g(const std::string & path);
private:
 singleton();
 ~singleton();
};

Together with typical piece of client client code that I'm wanting to unit-test:

int client::eg1()
{
 stuff();
 more_stuff();
 int r = singleton::instance().g("Hello world");
 return yet_more_stuff(r);
}

My problem is that singleton leads to one or more external dependencies I'd like my unit-tests to bypass. My first step is to create an interface for the singleton:

class singleton_interface
{
public:
 virtual void f(int value) = 0;
 virtual int g(const std::string & path) = 0;
 ...
};

And then make singleton implement the interface. (The saving grace of singleton is that its methods are at least instance methods.)

class singleton : public singleton_interface
{
public:
 static singleton & instance();
 void f(int value);
 int g(const std::string & path);
private:
 singleton();
 ~singleton();
};

Now I can overload eg1 as follows:

int client::eg1(singleton_interface & instance)
{
 stuff();
 more_stuff();
 int r = instance.g("Hello world");
 return yet_more_stuff(r);
}
int client::eg1()
{
 return eg1(singleton::instance());
}

And finally, I can create singleton_interface sub-classes and use them in my unit-tests:

struct my_mock_singleton : singleton_interface
{
 explicit my_mock_singleton(int g_result) 
 : g_result(g_result) 
 {
 }
 void f(int value) 
 {
 }
 int g(const std::string & s) 
 { 
 return g_result; 
 }
 int g_result;
};
void test_client_eg1_hitch_hiker_is_42()
{
 assert(42 == client().eg1(my_mock_singleton(6*9)));
}

One of my Mastery book snippets from a few days ago reads:

Masters ... are zealots of practice, connoisseurs of the small, incremental step.

I was doing the roman numerals kata in ruby and something related to small incremental steps occurred to me. Here's three tests:

def test_to_roman
 assert_equal "I", to_roman(1)
 assert_equal "II", to_roman(2)
 assert_equal "III", to_roman(3)
end

and here's the first code snippet:

def to_roman(n) 
 roman = ''
 if n == 3
 roman = 'III' 
 end
 if n == 2
 roman = 'II'
 end
 if n == 1
 roman = 'I'
 end
 roman
end

I can refactor these three if statements into a single while statement, in very small steps, as follows:

def to_roman(n) 
 roman = ''
 if n>= 3
 roman += 'I'
 n -= 1
 end
 if n>= 2
 roman += 'I'
 n -= 1
 end
 if n>= 1
 roman += 'I'
 n -= 1 
 end
 roman
end

and then:

def to_roman(n) 
 roman = ''
 if n>= 1
 roman += 'I'
 n -= 1
 end
 if n>= 1
 roman += 'I'
 n -= 1
 end
 if n>= 1
 roman += 'I'
 n -= 1 
 end
 roman
end

and then:

def to_roman(n) 
 roman = ''
 while n>= 1
 roman += 'I'
 n -= 1
 end
 roman
end

Ok. Now here's the original again:

def to_roman(n) 
 roman = ''
 if n == 3
 roman = 'III'
 end
 if n == 2
 roman = 'II'
 end
 if n == 1
 roman = 'I'
 end
 roman
end

And this time I refactor in a different direction, towards an array lookup:

def to_roman(n) 
 units = [ '', 'I', 'II', 'III' ]
 roman = ''
 if n == 3
 roman = units[3]
 end
 if n == 2
 roman = units[2]
 end
 if n == 1
 roman = units[1]
 end
 roman
end

And then:

def to_roman(n) 
 units = [ '', 'I', 'II', 'III' ]
 roman = ''
 if n == 3
 roman = units[n]
 end
 if n == 2
 roman = units[n]
 end
 if n == 1
 roman = units[n]
 end
 roman
end

And then:

def to_roman(n) 
 units = [ '', 'I', 'II', 'III' ]
 roman = ''
 if n == 3
 roman = units[n]
 end
 if n == 2
 roman = units[n]
 end
 if n == 1
 roman = units[n]
 end
 roman
 units[n]
end

And then:

def to_roman(n) 
 units = [ '', 'I', 'II', 'III' ]
 units[n]
end

In this case I can refactor from a sequence of if statements in two directions equally easy - towards a while or towards an array lookup. Ok. Now consider the situation if I was starting from a switch instead of a sequence of ifs:

def to_roman(n) 
 case n
 when 3 then 'III'
 when 2 then 'II'
 when 1 then 'I'
 end
end

From this I can easily refactor towards an array lookup but refactoring towards a while is perhaps not quite so straightforward.

I'm suggesting that a construct is useful not just in it's own right but also in relation to all the other constructs it might get refactored to or from. How easily can I move from one construct to another? Do some constructs live only on one-way roads? Do some lead you down more dead-ends than others?

I'm reminded of the family on holiday in the West Country who got thoroughly lost. Spotting a farmer leaning on a gate they stop the car, wind down the window and ask

Excuse me. Can you tell me how to get to Nempnett Thrubwell?

The old farmer looks at them and says

Well.... you don't want to start from here.

I was rereading chapter 3, Systems and Illusion in Jerry Weinberg's excellent An Introduction to General Systems Thinking yesterday. On page 56-57 Jerry writes:

If I say: "The exception proves the rule" in front of a large class, there will be a division in understanding... Some will believe I have uttered nonsense, while others will understand "The exception puts the rule to the test"

I've read the book four times. I'm a slow learner but this time something clicked and I immediately understood the earlier passage:

...the exception does not prove the rule, it teaches it.

Jerry goes on:

"Proof" in its original sense was "a test applied to substances to determine if they are of satisfactory quality."

I was struck by two thoughts when I read this. One was the parallel with testing. Of a test as a "proof". The other was the word original. I realized that when I hear the word "proof" I have a strong association with its noun meaning rather than its verb meaning. I tend to think of a proof as a finished proof that completely proves something. It's the noun-verb thing I've blogged about before. I wondered if there were any old dictionaries online so I could get a feel for how the generally accepted meaning of the word proof might have changed over time. There is. http://machaut.uchicago.edu/websters has two Webster's dictionaries. The 1828 dictionary came back with:

Proof [noun] 1. Trial; essay; experiment; any effort, process or operation that ascertains truth or fact. Thus the quality of spirit is ascertained by proof; the strength of gun-powder, ...

The 1913 one came back with:

Proof [noun] 1. Any effort, process, or operation designed to establish or discover a fact or truth; an act of testing; a test; a trial.

and a modern dictionary http://www.thefreedictionary.com/proof said:

Proof [noun]. 1. The evidence or argument that compels the mind to accept an assertion as true.

I find the difference fascinating. The 1828 and the 1913 definitions define the noun as the process whereas the modern one defines the noun as the evidence resulting from the process.

Jerry continues:

We retain this meaning in the "proofs" of printing and photography, in the "proof" of whiskey, and in "the proof of the pudding." Over the centuries, the meaning of the word "prove" began to shift, eliminating the negative possibilities to take on an additional sense: "To establish, to demonstrate, or to show truth or genuineness."

At first I didn't understand the bit about "eliminating the negative possibilities". I think it's partly to do with my ITA spelling at school. But I am persistant. Slowly it came to me. The word that did it for me in...

"Proof" in its original sense was "a test applied to substances to determine if they are of satisfactory quality."

...was the word if. To determine if they are of satisfactory quality. The proof was an act. There was the possibility of failure.

I started thinking about the word proof a bit more. I googled the phrase "the proof of the pudding". If you think this phrase is pretty meaningless then you're right - it's a shortened version of:

The proof of the pudding is in the eating.

Again it's about the possibility of failure. It reminds me of the scene in the film The Cat in the Hat (another film Patrick and I love watching) where the Cat has just made some cupcakes (with the amazing kupcake-inator). He tries one and says:

"Yeuch. They're horrible. Who want's some?"

I love that line. I also googled the word proof as related to alcohol content. The history behind the phrase is just wonderful. In the 18th century spirits were graded with gunpowder. Imagine you're buying some spirits. How would you know if an unscrupulous merchant had watered it down? You couldn't tell just by looking. What they did was pour a sample of the solution onto a pinch of gunpowder. If the wet gunpowder could still be ignited then the solution had proved itself. Don't you just love that?

So let's hear it for pudding and for spirits and for gunpowder and for tests. And for the possibility of failure.

is an excellent book by Christopher Alexander (isbn 0-19-502402-8). As usual I'm going to quote from a few pages:

A thing which has the quality without a name never fit any image exactly. What is exact is its adaptation to the forces which are in it.

The fact is that the elements themselves are patterns of relationships.

Any thing which lives can only be achieved as the end product of a process, whose force takes over and replaces the willful act of creation.

The mastery of what is made does not lie in the depths of some impenetrable ego; it lies, instead, in the simple mastery of the steps in the process, and in the definition of those steps.

How does the pattern language, which exists behind this flux, steer it, and enter into it? It hinges on the close relationship between the process of creation and the process of repair.

As in the organism, there is no sharp difference between the process of construction and the process of repair. Each process of construction helps repair some larger whole, of which it is merely a part. No thing is whole unto itself.

Within this process, every individual act of building is a process in which space gets differentiated. It is not a process of addition, in which pre-formed parts are combined to create a whole: but a process of unfolding, like the evolution of an embryo, in which the whole precedes its parts, and actually gives birth to them, by splitting.

The form of the whole, and the parts, come into being simultaneously.

This can only happen if the design is represented in an utterly fluid medium; it cannot happen in any medium where there is even the slightest resistance to change.

No building is ever perfect.

I've been doing the Yahtzee kata in cyber-dojo to improve my Ruby. During the 247 increments I learned about...

• any?
• send
• [lo...hi]
• reduce
• :+
• module names start with a capital

It's also on pastie if you like a black background. You can use Cyber-Dojo to step through the diffs of every single increment!

module Yahtzee
 def self.score dice, category, n=nil
 return -1 if invalid(dice, category)
 if category == :value
 value(dice, n)
 else
 send(category, dice)
 end
 end
 def self.chance dice
 dice.reduce(:+)
 end
 def self.yahtzee dice
 dice.uniq.length == 1 ? 50 : 0
 end
 def self.value dice, n
 dice.count{|die| die == n } * n
 end
 def self.one_pair dice
 die(tally(dice).find{|n| pair?n }) * 2
 end
 def self.two_pair dice
 score_tally dice, [2,2]
 end
 def self.three_of_a_kind dice
 score_tally dice, [3]
 end
 def self.four_of_a_kind dice
 score_tally dice, [4]
 end
 def self.full_house dice
 score_tally dice, [3,2]
 end
 
 def self.small_straight dice
 dice.sort == [1,2,3,4,5] ? 15 : 0
 end
 def self.large_straight dice
 dice.sort == [2,3,4,5,6] ? 20 : 0
 end
 #- - - - - - - - - - - - - - - - - - - - - - - 
 def self.categories
 [:value, :chance, :yahtzee, :one_pair, :two_pair,
 :three_of_a_kind, :four_of_a_kind, :full_house,
 :small_straight, :large_straight
 ]
 end
 def self.invalid dice, category
 dice == nil \
 or dice.length != 5 \
 or dice.any?{|die| die < 1 or die> 6 } \
 or !categories.include? category
 end
 def self.score_tally dice, pattern
 starts?(pattern, tallies(dice)) \
 ? sum(dice, pattern.length) \
 : 0
 end
 def self.starts? short, long
 long[0...short.length] == short
 end
 def self.tallies dice
 tally(dice).map{|n| count(n) }
 end
 def self.rolls dice
 tally(dice).map{|n| die(n) }
 end
 def self.tally dice
 dice.uniq.map {|die| [dice.count(die),die] }.sort.reverse 
 end
 def self.sum dice, n
 sum2(rolls(dice)[0...n], dice)
 end
 def self.sum2 scorers, dice
 dice.select {|die| scorers.include?die }.reduce(:+)
 end
 def self.pair? n
 count(n) == 2
 end
 def self.count n
 n[0]
 end
 def self.die n
 n ? n[1] : 0
 end
end

I challenged myself to write the code in a functional style with no local variables - it's a bit 'dense' in places as a result.

is an excellent book by Ivan Illich et al (isbn 0-7145-2510-3). As usual I'm going to quote from a few pages:

Finally there is is the American valuation on instrumentalism - an emphasis on doing - on doing something, almost anything when confronted with a problem. "Doing nothing in a difficult situation" was interestingly enough an item diagnostic of neuroticism on a popular American psychological test. Sometimes the emphasis on movement became so great that speed itself was emphasised - sometimes for no logical reason.

It does not strike me as inconsistent, that religion and notions of the hereafter are especially relevant when "the here" is so lousy and so short.

Man has no nature, only a history [Ortega Y Gassett]

there seems to be an absence of informal and comfortable places to gather and talk and thus a further reduction in "informal networks of help".

The business of modern society is service… Thus, service is to care which is to love and love is the universal apolitical value.

The tool defines the problem rather than the problem defining the tool.

There is no greater power than the right to define the question.

The easiest way to create a monopoly is to invent a language and procedure which will be unintelligible to the layman.

When we talk about skilled work it is not the nature of the craft, but the social relation of the worker to management that is under discussion. The full expression of the worker's skill conflicts directly with the needs of management.

One of the real satisfactions of skilled work is that, like an artist, your hands produce what your mind conceives.

The frustration of not being able to apply his skills on the job is often the motivation for doing it at home.

is an excellent book by Michael Feathers (isbn 0-13-117705-2). As usual I'm going to quote from a few pages:

A few years ago, I gave my friend Erik Meade a call after I'd finished work one night. I knew Erik had just started a consulting gig with a new team, so I asked him, "How are they doing?" He said, "They're writing legacy code, man."

To me, legacy code is simply code without tests. I've gotten some grief for this definition… I have no problem defining legacy code as code without tests. It is a good working definition, and it points to a solution.

In nearly every legacy system, what the system does is more important than what it is supposed to do… Frankly, it's very important to have that knowledge of what the system actually does someplace.

When teams aren't aware of their architecture, it tends to degrade. What gets in the way of this awareness? … The brutal truth is that architecture is too important to be left exclusively to a few people.

When you have tests around the areas in which you are going to make changes, they act as a software vise [vice]. You can keep most of the behaviour fixed and know that you are changing only what you intended to.

The most subtle bugs that we can inject are bugs related to inheritance. … The language feature that gives us the most possibility for error when we lean is inheritance.

Orthogonality is a fancy word for independence… One of the startling things that you discover when you start removing duplication zealously is that designs emerge.

Sometimes it makes sense to add a variable to a class and use it to sense conditions in the method that we want to refactor.

…not all behaviours are equal in an application.

Code is pretty fragile material.

At this point in my career, I think I'm a much better programmer than I used to be, even though I know less about the details of each language I work in.

The primary purpose of a compiler is to translate source code into some other form, but in statically typed languages, you can do much more with a compiler.

is an excellent book by George Leonard (isbn 0-452-26756-0). As usual I'm going to quote from a few pages:

You have to be willing to spend most of your time on a plateau, to keep practising even when you seem to be getting nowhere.

Our hyped-up consumerist society is engaged, in fact, in an all-out war on mastery.

Sometimes, when the moment came to go to class, I would be feeling particularly lazy. On those occasions I would be tempted to do almost anything rather than face myself once again on the mat.

Practice, the path of mastery, exists only in the present.

To see the teacher clearly, look at the students… The best teacher generally strives to point out what the student is doing right at least as frequently as what she or he is doing wrong.

A doctor practises medicine and an attorney practises law, each each of them also has a practice.

The master of any game is generally a master of practice.

The courage of a master is measured by his or her willingness to surrender. This means surrendering to your teacher and to the demands of your discipline. It also means surrendering your own hard-won proficiency from time to time in order to reach a higher or different level of proficiency.

The essence of boredom is to be found in the obsessive search for novelty. Satisfaction lies in mindful repetition, the discovery of endless richness in subtle variations on familiar themes.

For the master, surrender means there are no experts. There are only learners.

It can be argued that what is most abstract is most fundamental and often most persistent over time.

Those we know as masters are dedicated to the fundamentals of their calling. They are zealots of practice, connoisseurs of the small, incremental step. At the same time - and here's the paradox - these people, these masters, are precisely the ones who are likely to challenge previous limits.

Last week Olve Maudal and I ran two cyber-dojos at the NDC conference in Oslo. The first one attracted only a few people, partly due to some confusion about where it was being held. But what it lacked in quantity it more than made up for in quality. Uncle Bob and Corey Haines seemed to invent a new style of pair programming where Uncle Bob used his left hand and Corey used his right hand! Several people posted encouraging tweets:

• @KevlinHenney: If you are at #ndc2011 today, I strongly recommend the cyber-dojo with @JonJagger and @olvemaudal this afternoon.
• @UncleBobMartin: #ndc2011 cyber-dojo was very cool. Too bad you missed it. Must not be very many programmers here
• @CoreyHaines: Terrific fun at #cyber-dojo at #ndc2010 Only 4 of us there today, you should come to the repeat on Friday after lunch!
• @occulto: Best thing today: doing a kata in #cyber-dojo with @sondreb, @unclebobmartin and @coreyhaines #ndc2011 try it on Friday!

More people attended the second one. Corey was there again, along with Michael Feathers and Jon Skeet. Once again the tweets were very encouraging.





In the evening Olve created a TurnKey Linux VirtualBox server image to make it super-easy to run your own cyber-dojo. It's less than 500MB and downloadable from http://dl.dropbox.com/u/22404698/TurnKey-CyberDojo-20110610.ova.

Mike Long has written a pdf on how to set it up.

Thankyou to Olve and Mike and to everyone who attended.

My Lean on the Java Compiler by Hiding post has proved quite popular so I've been thinking about if it could also work for C++... It can. I'll use Singleton as a example again. Suppose you have a C++ class like this:

class legacy
{
public:
 legacy();
 void eg1();
 void eg2();
 ...
};

#include "legacy.hpp"
#include "singleton.hpp"
void legacy::eg1()
{
 singleton::instance()->call();
}
void legacy::eg2()
{
 singleton::instance()->call();
}

Again, you want to create a seam for singleton access. The first step is to introduce the hiding identifier in the header file:

class legacy
{
public:
 legacy();
 void eg1();
 void eg2();
 ...
private:
 class singleton; // <----- }; 

Now Lean on the Compiler. All the calls to singleton::instance() no longer compile because the global singleton class is now hidden by the local singleton class just introduced. Next, in the source file add a global variable called instance of type singleton* and refactor all occurrences of singleton::instance() to instance.

#include "legacy.hpp"
#include "singleton.hpp"
singleton * instance;
void legacy::eg1()
{
 instance->call();
}
void legacy::eg2()
{
 instance->call();
}

Then Lean on the Compiler again to make sure there are no typos. Next remove the global variable called instance from the source file and refactor the header file to this:

class singleton; // <----- class legacy { public: legacy(); void eg1(); void eg2(); ... private: singleton * instance; // <----- }; 

Finally, initialize the instance member in the constructor definition.

legacy::legacy()
 : instance(singleton::instance())
{
}

I haven't tried this on real legacy code either. Caveat emptor!

Here's a small trick which might not be out of place in Michael Feather's excellent book. I'll use Singleton as a example. Suppose you have a class like this (Java):

public class Legacy
{
 public void eg1()
 {
 stuff(Singleton.getInstance().call());
 }
 public void eg2()
 {
 more_stuff(Singleton.getInstance().call());
 }
}

And you want to create a seam for the singleton access. The first step is to introduce two public fields:

public class Legacy
{
 public int Singleton;
 public Singleton instance;
 public void eg1()
 {
 stuff(Singleton.getInstance().call());
 }
 public void eg2()
 {
 more_stuff(Singleton.getInstance().call());
 }
}

Now Lean on the Compiler. All the calls to Singleton.getInstance() no longer compile because the Singleton class is now hidden by the int Singleton just introduced. Next refactor all occurences of Singleton.getInstance() to instance (the other identifier just introduced, you can pick any name for this one but it's type must be Singleton).

public class Legacy
{
 public int Singleton;
 public Singleton instance;
 public void eg1()
 {
 stuff(instance.call());
 }
 public void eg2()
 {
 more_stuff(instance.call());
 }
}

Then Lean on the Compiler again to make sure there's no typos. Finally refactor to this:

public class Legacy
{
 public Singleton instance = Singleton.getInstance();
 public void eg1()
 {
 stuff(instance.call());
 }
 public void eg2()
 {
 more_stuff(instance.call());
 }
}

The name lookup rules for Java allow this to work but I don't think this idea will work in C++ (for example). I haven't got time to try it now as I'm heading off to the NDC conference in Oslo. I only thought of it yesterday. I haven't tried this on real legacy code. Caveat emptor!

Update. I have a C++ version aswell.

Working Effectively With Legacy Code by Michael Feathers (isbn 0-13-117705-2) is a great book. The very first dependency breaking technique (p326) is called Adapt Parameter. It uses this Java example:

public class ARMDispatcher
{
 public void populate(ParameterSource request) {
 String[] values
 = request.getParameters(pageStateName);
 if (values != null && values.length> 0)
 {
 marketBindings.put( 
 pageStateName + getDateStamp(),
 values[0]);
 }
 ... 
 }
 ...
}

Michael writes:

In this class, the populate method accepts an HttpServletRequest as a parameter. ... It would be great to use Extract Interface (362) to make a narrower interface that supplies only the methods we need, but we can't extract an interface from another interface. ...

and a bit later...

Adapt Parameter is one case in which we don't Preserve Signatures (312). Use extra care.

Well, here's a variation on Adapt Parameter where we do Preserve Signatures. I'll stick with the Java example, but the idea is broadly applicable...

First we create our ParameterSource interface and fill it with the signatures of the methods in HttpServletRequest that our populate method calls:

public interface ParameterSource
{
 String[] getParameters(String name);
}

then we implement the adapter for HttpServletRequest:

public class HttpServletRequestParameterSource 
 implements ParameterSource
{
 public HttpServletRequestParameterSource(HttpServletRequest request) {
 this.request = request;
 }
 public String[] getParameters(String name) {
 return request.getParameters(name);
 }
 private HttpServletRequest request;
}

Next we add an overload of populate taking a ParameterSource and implement it with an exact copy-paste:

public class ARMDispatcher
{
 public void populate(ParameterSource request) {
 String[] values
 = request.getParameters(pageStateName);
 if (values != null && values.length> 0)
 {
 marketBindings.put(
 pageStateName + getDateStamp(),
 values[0]);
 }
 ... 
 }
 public void populate(HttpServletRequest request) {
 String[] values
 = request.getParameters(pageStateName);
 if (values != null && values.length> 0)
 {
 marketBindings.put(
 pageStateName + getDateStamp(),
 values[0]);
 }
 ... 
 }
 ...
}

Now we Lean on the Compiler (315) to make sure we haven't missed any methods in HttpServletRequest that our populate method calls. Add any we missed to the ParameterSource interface. Implement them in HttpServletRequestParameterSource as one liners. When it compiles we can refactor to this:

public class ARMDispatcher
{
 public void populate(ParameterSource request) {
 String[] values
 = request.getParameters(pageStateName);
 if (values != null && values.length> 0)
 {
 marketBindings.put(
 pageStateName + getDateStamp(),
 values[0]);
 }
 ... 
 }
 public void populate(HttpServletRequest request) {
 populate(new HttpServletRequestParameterSource(request));
 }
 ...
}

And now we have a seam we can pick it at...

public class FakeParameterSource 
 implements ParameterSource
{
 public String[] values;
 public String[] getParameters(String name) {
 return values;
 }
}

is an excellent book translated by R.L.Wing (isbn 0-7225-3491-4). As usual I'm going to quote from a few pages

In trying to understand a work like the Tao Te Ching, it is important to keep in mind that Chinese characters are not so much representations of words as they are symbols of ideas.

Because of its idea-embedded nature, the Tao Te Ching is a work that brings truth to the adage: It is better to read one book one-hundred times than one-hundred books one time.

True power is the ability to influence and change the world while living a simple, intelligent, and experientially rich existence.

Simplicity in conduct, in beliefs, and in environment brings an individual very close to the truth of reality.

When expectations are dropped, the mind expands, and reality expands along with the mind.

Nothing exists without the presence of its opposite.

Practice non-interference.

A house filled with riches cannot be defended.

Individuals who master themselves become less egocentric

Evolved Individuals strive to be intuitive, spontaneous, and simple.

Never fall completely into step with current society.