A hammer builds, or not?

Last night, while i was browsing the latest tweets, i noticed there was a discussion going on about the difference in compilers and debuggers. Two of the comments made by Michael Bolton (@michaelbolton) were:

@testalways Debuggers don’t debug any more than compilers write programs, any more than hammers build houses.
@QualityFrog @testalways @AGareev A thing doesn’t act like a tool until an actor, a person, puts it into action.

I continued reading the tweets on this topic, until I read the following tweet by James Bach (@jamesmarcusbach):

@michaelbolton debuggers don’t ever perform any debugging. But hammers and compilers really do build and build, respectively.

After reading this, I thought: “Well, James, a hammer is a tool. It’s a dead object. It can do anything. So it can’t build”. Now, I could have held my mouth shut. But when I disagree with a comment, there is an incredible urge inside me which says: “mingle, mingle, mingle!”. So I did. I mingled, without asking (which some might consider as rude. But I like discussions. They help me learn. They help me understand. They educate me. A good discussion helps me to see things from different perspectives. At least, I hope so).

It’s the person handling the hammer that creates the pattern of a house. A hammer is not required to build a house. There are many types of houses which are entirely made by hand. Just imagine the clay houses in some 3rd world countries. So I replied to James:

@jamesmarcusbach How does a hammer build? It’s not the hammer that creates the pattern of a house. /cc @michaelbolton

It’s the person handling the hammer that creates the pattern of a house. A hammer is not required to build a house. There are many types of houses which are entirely made by hand. Just imagine the clay houses in some 3rd world countries. And then I received James reaction:

@MichelKraaij don’t ask silly questions.

What, whut? Silly? My question wasn’t intended silly. It was a dead serious question. I was asking how a hammer builds. In my perception the hammer doesn’t build. It’s a tool. It is the person handling the hammer that builds. But did I really ask a silly question? Or did James interpret my question as silly? Maybe I was asking something obvious, because to him a hammer actually builds? Then indeed, it might have looked like a silly question. Maybe I’m just misinterpreting something. Or he is. Words can get misinterpreted very easily. Let’s continue. There is only one way to clarify all of this. Respond:

@jamesmarcusbach It might have sound silly, indeed. Maybe just as silly as saying that hammers do build.

Yes, my question had a little sarcastic undertone. And I chose to answer using his own words. What I didn’t expect was James’s response:

@MichelKraaij instead of insulting me, use your brain. Come on, man. Don’t play dumb.
@MichelKraaij I could answer your question, but you already know the answer. Don’t waste my time, please.

Huh? What happened here? My tweet wasn’t meant insulting?! To me, the word silly means “funny” or “humorous” in a bit of sarcastic way. Did I make a bad translation here? Let’s look it up. Oh wait, the word “silly” has several meanings in English. And some of them can be interpreted as insulting indeed! Damnit, that’s why I prefer to speak face-to-face instead of *just* chatting. So many emotions don’t get transferred when sending a tweet. Something went terrible awry here. Why would I waste the time of someone whose opinion I value? Let’s ask for some clarification, because he really lost me here…

@jamesmarcusbach Then pls help me understand “But hammers & compilers rlly do build & build, respectively”, b/c clearly i’m not getting it.

A short 15 minutes later, James responds:

@MichelKraaij I’ve taken you close enough to the solution. Get up and think, now.

This one sounds a bit more challenging. After all, I consider James (and Michael) to be my mentors. So I value their responses. Especially when they sound challenging. Now, where was I. Did I really miss something?

In the meantime, I see a tweet from Peter Houghton (@petehoughton) pass by:

@MichelKraaij I think it’s along the lines of debugging is a cognitive (exploratory) activity. Building is more mechanical, formulaic.

Yes, this is true. Debugging is about exploring and about revealing, which can be done either manually or with support of tools. So this is a cognitive activity, indeed. In addition, a potential bug has to be interpreted by a person, again, a cognitive activity. So I respond to Pete:

@pete_houghton I think of building like testing. A set of activities, some of these activities supported by tools, with a purpose.

Okay, back on topic of the misinterpreted sentence. Have I misinterpreted it? Wait, is he actually talking about a “hammer”. Like, the tool which I use to hit my thumb? Or is he referring to something else? Am I missing something? MC Hammer? Nah! A different tool, called “Hammer”? Let’s Google. Well, yeah, there actually is one! It’s a mapping tool by Valve. No, I don’t see James as the type who fiddles around with maps for online gaming (actually, I used to do that a few years back, when I played CounterStrike. So I actually knew the program!). I continue to ponder… In the meantime, I receive a reaction from James:

@MichelKraaij have you figured it out yet?

No, actually I don’t. I start questioning my own judgment. Am I actually dumb? Is he right? Am I missing something that obvious? Or…. am I misinterpreting words in the sentence? Let’s ask:

@jamesmarcusbach No, not yet. But i do want to ask a question (yes, it might sound silly). Are we talking about this?: http://bit.ly/hv9mCH

Oh, drat, I used “silly” again. Well, message has been sent. Nothing I can do about it anymore. And then it remains silent for a while… Maybe this was really too insulting?

Suddenly Stephen J. Hill (@stephen_J_Hill) responds:

@MichelKraaij @jamesmarcusbach Hammers & compilers are both _tools_ used directly in building. Debuggers highlight pattern for others to id.

Well yes! I totally agree. Nevertheless, you’re saying what I was thinking…it’s a tool! (And my brain fills in: “It doesn’t build on its own!”). After a while, James responds:

@Stephen_J_Hill It’s true that the hammer and compiler are tools used in building, however, they are also themselves actually building.
@Stephen_J_Hill You have to ask yourself: what does it mean to build something?

Okay, he addresses the question to Stephen, but I take on the challenge to answer the question, since I has on my mind for quite a few hours now. I answer:

@jamesmarcusbach @Stephen_J_Hill I suppose it means to structure/merge parts (e.g. materials/pieces of code) in a certain way.

Within a few minutes James responds:

@MichelKraaij To connect parts together into a greater whole is a kind of building. Hammers and compilers both do that.

Yes, hammers do connect parts together into a greater whole. But if I place a hammer on the floor, nothing gets connected. Michael mentioned this in his tweet, stated in the beginning of this blog post. Nevertheless, a car also drives. My eyes also see. But, they all need additional components. They need components, like my brain, to be able to understand the convert light. Only then, it sees. (There are people can look, but do not see anything. The light doesn’t get interpreted, either by the eye or by the brain. These people don’t see). I consider building as a system. It needs certain components to function. Yes, you can take away components. But that destroys the system. So I answer:

@jamesmarcusbach Nevertheless, neither are mandatory for building. Also, they will not build by themselves.

James responds:

@MichelKraaij Neither of those elements are required to make what I said true and relevant.
@MichelKraaij A debugger is not a debugger, but a hammer and compiler both build.

I agree with the first part. A debugger doesn’t do any debugging. All the bugs remain, until they get fixed. This isn’t something a debugger (tool) does. But to me, building is an activity. And a hammer is a tool. So, a hammer can become a building tool. It’s still a tool, but now used in the activity of building. So I respond:

@jamesmarcusbach I think of building as an activity. Yes, a tool can become a building tool. But it’s the combination that builds.

Even my hands are tools. They can be put to use to help me, my consciousness, to build things. They can be put to use for a lot of things. Like transferring my thoughts into movement, which in turn makes letters appear in this blog post (thanks for technology!). James responds:

@MichelKraaij Building is an activity. It’s an activity that is performed by hammers and compilers.

By now it’s almost midnight. I head over to bed, confused about this conversation. In bed I ponder about “action causes reaction”. A hammer in motion has an effect on other objects, like nails. Is he thinking this? Well, in that case it’s the action from the hammer that builds, yes. In that context he might be right. But to me this isn’t the complete context. It’s “a” context. I’m thinking more in terms of the action from the person handling the hammer which in turn moves the hammer. Still confused, I fall asleep….

A rather long blog post this time. But I felt the need to put my thoughts on (digitized) “paper”. This is my opinion. It might not be yours. However, I do am interested in yours. Feel free to give your opinion about this discussion.

This entry was posted in Uncategorized. Bookmark the permalink.

6 Responses to A hammer builds, or not?

  1. morgsterious says:

    I followed your discussion yesterday and was itching to get in but I managed to control myself. As you, I did not see the distinction James was making yesterday. A hammer as well as a compiler is a tool that makes the work of building something a lot easier, but the job could be done without these tools as well. A debugger is, to me, also a tool that helps making the job of debugging a lot easier but the job could be done without this tool as well. But if we leave the tools out of the discussion and look at the two different activities performed; converting a plan into a construction or code into an executable vs interpreting code, then I guess we could se the first as something that can be fully automated whereas the latter needs intelligence.I'm not sure that this is what James was getting at and if it was I still think that the tool comparison was a bit off but this is my best guess for now.Cheers/Morgan

  2. This looks confusing indeed. It was started as a confused discussion. I think @AGareev wanted to point out that debugging is an exploratory (not exploratory testing) activity. Things got confused like I said and I gave the example with the debugger (as tool) from compiler. I mentioned though the impact of relative definition of debugger. And then it got to this…more confusing for me 🙂 I have the same sensation when the requirements are not clear enough for testing to be done.

  3. I too was following the discussion yesterday and avoided getting involved, too busy with the family.So I glad you wrote up your thoughts.I found the whole discussion interesting and it intrigued me.My take on this is too look at different context.What is meant by a hammer?A hammer can have different types, meanings. A pin hammer, claw hammer, sledge hammer, mallet, Mjolnir and clock hammer. So some of these hammers can be used to build but also they can be used to destroy. A complier will build but it will not un-build, that needs a decompiler.Some of these hammers neither build or destroy a clock hammer for example is used to make a sound.As I have already stated I am not 100% sure what James was/is getting at, but I would be trying to work out context – you appeared within your post to go along that line then stop – maybe you needed to ask more questions.Anyway great HONEST blog, loved the human approach in this.

  4. RayYho says:

    Hi Michel,I might be way off… but to me a hammer 'can' build: it drives a nail in to wood. Without it I would have a hard time doing that with bare hands (or I need a stone… well, don't want to make this more complicated). A compiler 'compiles': it translates the code I have written into machine language which the CPU understands. A debugger only helps to see me what is happening when code is executed. In that sense it is not actually debugging itself. Nothing has changed when the debugger is used.My 2 cnts ;-)Ray

  5. James Bach says:

    Hi Michel,

    This is a nice response. It shows that you are not paralyzed in your thinking, nor are you refusing the think. I appreciate that. Especially since I was pretty hard on you in that moment.

    [Michel Kraaij: Some lessons need to be learned the hard way. I’m glad you took the time to educate me and you didn’t stop when it seems i was failing certain expectations.]

    Now I will reveal my entire chain of reasoning and why I felt annoyed with your response.

    Context-analysis is a basic skill among context-driven testers. This is the ability to systematically and effectively consider different contexts and models; different possibilities and interpretations. Philosophers have a word for it: hermeneutics. It’s not a pretty word, but I love saying it, once in a while.

    I wasn’t seeing any context analysis in your first question to me. That meant that I would have to painstakingly explain my reasoning, instead of you discovering for yourself what my reasoning probably
    was. The real problem for me is that I felt that my reasoning was not particularly hard to see, if you just tried to see it. Hence it seemed to me that if I explained myself to you, I would have to lower my respect for you at the same time, and I didn’t want to do that.

    [Michel Kraaij: And i really appreciate it that you didn’t.]

    Had you shown me some of your thought process in your tweeting (your process of thinking through different ways I might have arrived at my statement), I would have responded differently.

    What I expected you to do was first to consider various meanings of the word “build”, not just your favorite one. (The inability to imagine different meaning for words is context-oblivious behavior; the inability to want to imagine them is context-imperial behavior)

    [Michel Kraaij: The funny thing in this is (which i forgot to mention in the blog), i DID consider the various meanings of the word “build”. I even looked it up. However, looking back, i also notice one of my fallacies: I ignored some of the contexts and chose to read “just” the perferred one. Even tho i know better. This is an important lesson I learned (again).]

    Here are some meanings, below, from the Oxford English Dictionary:

    – To construct for a dwelling; to erect (a house), make (a nest).
    Hence, To erect, construct (any work of masonry), and by extension, To construct by fitting together of separate parts; chiefly with reference to structures of considerable size, as a ship or boat, a carriage, an organ, a steam-engine (not, e.g. a watch or a piano).

    – To work up (material) into (a building); to join together so as to form a structure.

    – To construct by a process or with a result analogous to that of the builder. Said, e.g., of the Creator, or of natural forces, as when a crystal, an organic body, or the world, is compared to an edifice. Often said in passive of the human body, as ‘His frame was strongly built’ (cf. BUILD n.). Const. as in 1. built like a castle: said of a horse having a strong and sturdy frame.

    – To arise, form.

    So, that’s a start. Now let’s consider a hammer and a compiler. Both are mechanisms that physically transform matter (or information structured in matter) from one state to another. They are both in the
    chain of causation that you would put together upon being asked “How exactly was this house built?” or “How exactly was this software built?” (Compiler actually do write machine-language programs,
    according to the high level specification known as source code). I feel that being in the physical chain of causation can qualify, under some plausible definition of build, as building.

    It doesn’t matter that a human intelligence is needed to direct a high quality building process in most interesting cases. That doesn’t affect my point. You may disagree with me about my use of the word
    build, but could you argue that my point is incoherent with respect to the definitions above? I don’t think so.

    [Michel Kraaij: No, i don’t disagree. Actually, after i went to bed, i was pondering about this way of reasoning. I tried to find arguements to disagree with a with reason like this, and i couldn’t. However, it was reasoning that kept nagging my inner me. The voice inside me kept reminding me of “human intelligence” (actually, not just human intelligence. I also considered rigging a hammer. Ofcourse this rig somehow would also originate from human intelligence…).]

    Now let’s consider a debugger. That’s the weaker part of my argument. A debugger does not remove bugs, and it’s not even in the chain of causation to do so. Debuggers don’t change anything.

    You could argue that the debugger provides information that could help (and therefore “cause”) a programmer to recognize a problem that he then could proceed to remove. But that is not the physical causation sense I had been thinking about.

    Therefore it seemed reasonable to amplify Michael’s original statement: Debuggers debug even LESS than hammers build houses and compilers write programs.

    [Michel Kraaij: Thank you for your time to challenge me, even when i annoyed you, and for taking the time to write an extensive reaction.]

  6. I don’t quite buy it. I understand the reasoning; however, I find something fundamentally different about the compiler and the hammer that leads me to tolerate saying “a compiler builds software”, but does not let me tolerate saying “a hammer builds a house”. Instead, I think one needs to say that “one uses a hammer to build a house”.

    Sadly, I haven’t yet been able to pinpoint exactly what fundamental thing makes the difference, which interests me. I have some subconscious, perhaps cultural, reason not to say “a hammer builds a house”, and yet when I try to identify the essential difference between the compiler and the hammer, I can’t.

    I have decided one thing, however, from this exchange: I prefer to stop saying that “a compiler builds software”, and instead say that “one uses a compiler to generate machine code”. I don’t fully understand the impulse the anthropomorphise the compiler the way my use of English appears to encourage me to do.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s