Argument’s names may improve the method’s signature expressivity

In a previous post I wrote some examples of method names that use their arguments' names to form an expressive expression:

  • Users findBy(String name){...}

It reads well when looking at the method definition but it may not read well when used:

  • users = findBy(someReallyBadVariableName);
  • users = findBy("bob");

In this case I can prevent consumers from writing unexpressive code with some redundancy:

  • Users findByName(String name){...}

But the redundancy may be annoying in some cases, so when may I avoid the redundancy?

I believe it depends on:

  • If the method has more than one argument, I can't count on the argument's names - still they have to be good names.
  • The level of abstraction of the method:
    If the method or function is a low level one, like in a general purpose library, then I prefer to have some redundancy because it's hard to tell how is it going to be invoked. On the other hand if it's closer to the domain then the usage gets narrower and I feel better counting on the argument's name.
  • The type of the argument - are they primitives or objects?
    If the argument is a primitive like a string, someone may pass a literal into the function thus making the readability bad. However if it's a domain object, literals are not possible and variable names use to be more precise:

What others heuristics do you usually consider?

No, it’s not the money

I totally disagree with the idea that ultimately we write software for money, for someone to make money -- or more money. I can't bear with sad statements like "well, eventually we get paid to produce revenue" or "at the end of the day what counts is the money", "we do agile to make more money" or just "show me the money!". Bullshit.

If money is the only purpose, agile methods are not going to help you!

During my years as independent developer and consultant, I've observed two primary reasons for agile methods to fail. One resides in the top management (not every manager!) whilst the other is in the technical side - the developers (not every developer!).

Top management's problem

When top managers care more about money than they do about people, sooner or later employees  feel that they are just numbers, resources and agile methods can't help. There is no point in trying to talk about Scrum or XP to those top guys, because what they really have is a crisis of values. A big problem of perception. What they really need is executive coaching, not agile practices. I don't think we should encourage them to attend agile conferences, we should rather recommend them a really good life coach, psychotherapy, meditation, yoga, sport...

Important: I am not talking about all the managers, just about some people.

Money should never be a goal in itself. We write software to solve people's problems, because we care about others and want to improve their circumstances. Or perhaps just because we enjoy doing so. Money should be just one consequence of doing our job right. The disease  that is killing our planet is cancer. When the goal of a company is just to make more money every year,  to increment the "growth", that's a cancer. Unlimited growth is cancer. It kills the human body and at a large scale it's killing the planet. Agile values and principles do not scale up in economic terms, like many other things - Jorge Uriarte talks about it in his brilliant talk in Spanish. 
Money does not buy happiness because money can't buy an eternal life and health. Rich people are never satisfied because money is not fulfilling so they become gollums - let me refer to another brilliant talk in Spanish this time by Joan Antoni Mele.

If you happen to be an employee in one of these companies don't be confused, the problem is deeper at the basis of the system, it's not your fault. There are actual reasons for you to feel the lack of purpose and hence motivation. You can try to change things within your team or area, do your best for them, learn and share in that circle but it will stop in there. It could be a good time to reflect on where and how you want to spend your energy, your life.

Developers' problem

On the other hand the reason why agile methods fail sometimes has to do with some developers. We ruin the code, remember?We must learn to say NO, to have the courage to face the truth even when it's not nice and talk about it. Of course we must deliver excellent quality software and accomplish our commitments. The XP practices are intended to promote the principles and values that help developers behave like professionals. I travel often to mentor developers in many cities and what I always find is a dramatic lack of knowledge, technical skills.  Really smart people but missing basic knowledge. Because the majority of us haven't been taught by professionals. Fortunately we can work around that, I think conferences and other events are great tools along these lines -- apart from training and mentoring. Deliberate practice is very important and communities help a lot with this. We practice together to improve our skills. The more I read about Software Craftsmanship, the more I feel on the same page. I highly recommend the book by Sandro Mancuso on the subject, I am not gonna try to repeat his inspiring words. This is why I believe less in "agile events" and "agile communities" and more in communities of practice.

If it's not money, then what is it?

You have to find it by yourself. I can tell you that I don't work for money, it just comes in as a matter of doing what I like, the best I can do it. It's not always easy, sometimes it's actually scary but it works. I like to think I wasn't born to be a money machine. The desire of being helpful to others is my driving force. I know I won't be effective if I can't get that feeling.

Daniel Pink says that our motivation comes from autonomy, mastery and purpose. These are good goals in themselves rather than means to produce money. Nice example, isn't it?

To close this post, I leave you with this powerful keynote by Martin Fowler about the role of the programmer:


Watching Kent Beck test-drive

I've been watching and studying K. Beck's video series on TDD this week. These screencasts are really good in my opinion, I am glad that Kent made them. I would like to see more of them.

According to Amazon, I bought Kent's book on TDD in January 2008. At that time I was working on a kind of experimental project at the University of La Laguna so I had plenty of time to practice TDD all day long. The software had to work but there was no deadline, it was a kind of grant, perfect for me to learn and practice. And we delivered clean code that worked finally. Well, today for sure I wouldn't like that code.

With Kent's book and the help of the TDD mailing list (Yahoo), I embraced the technique soon and stuck with it since then. So my style is quite "classic", although I believe I use more test doubles than Kent (looks like he doesn't use doubles at all, but I'd like to see that). However as I've gained experience and learned from others and from my own mistakes, my style has been evolving over time. Moreover teaching TDD to lots of  people during these years has have a huge positive impact on the way I test-drive my code.

But now watching Kent coding has been a bit surprising to me. Notes to myself about the episodes:

Episode 1:

Kent writes the first test from the outside-in, but makes it pass bottom-up. Using a single test as a means to constantly validate the code he is writing works. He moves code from the test to production and back to the test, always moving in safe steps. My surprise he is that all the triangulation is performed with a single test, an evolving end-to-end test. I think I'd probably have written several tests, leaving the first one red for a while (he does that in an upcoming episode). From this very first episode I can notice that Kent uses the tests to maximize feedback, focusing on getting things done. Very pragmatic, I like that.

Episode 2:

Kent uses the "fake it until you make it" trick, returning a hardcoded zero value, but then rather than writing another test to triangulate, he uses the same one to make the production code more generic. Again very pragmatic. I only use "fake it until you make it" when I don't have a clear vision of how to make it pass. That keeps my flow and gives me some inspiration. So in this case I would just write something more than "return 0".
The surprise in this episode is that Kent prefers to leave some duplication in the code in favor of symmetry. Duplication makes me feel unconfortable so I would rather remove it. Now I value symmetry a bit more, I got his point.

Episode 3:

Kent removes several tests. In order to split a problem into smaller pieces, he leaves a failing test and moves on to test-drive those small pieces (methods) that are needed. When the big method works and the big test passes, he realizes the small methods should be private and so changes their visibility. Then the small tests don't even compile and Kent just deletes them. He calls these "scafolding tests", needed to flow with safe small steps but not necessary in the end.
To me this is a bit surprising, it's definitely not my style but I see the benefit - flow and fast feedback again. I rarely delete tests, only when they are proven redundant (and I loose the 10$ as Kent says). When I find myself testing a method that should be private I question my design. It usually tells me that the method probably belongs in a different object where it's public. If writing a specification (what tests really are from my point of view) turns out to be difficult, that gives me a hint about my design. However it's true that sometimes premature design decisions may get you stuck, loose the flow.

Episode 4:

I really like the idea of test-driving the same problem from scratch several times to find out which order is the best. Choosing the tests appropriately is very important for TDD to be productive. To success with triangulation the order in which we choose tests is fundamental. This exercise is excellent, I will practice it more often with code katas.

Some conclusions:

I can see that Kent uses the tests to progress with steady pace in safe small steps, maximizing fast feedback loops. I see that the primary focus of his tests is not on documenting the behavior of the  system, Kent just wants to get code working soon. The names of the tests are readable and tell a story but I like them to be more expressive. Sometimes Kent reflects only the input in the name, whilst I prefer to describe the behavior. As an example I would type  "it_is_not_possible_to_remove_a_null" whilst he typed "removeNull". I continously refactor my tests to improve their names, making sure I could copy and paste those names (together with the class name), paste them into a text document and deliver it as human readable documentation source.

I tend to use tests more as specifications than tests so I probably spend more time thinking of the tests and ordering them for the sake of an effective flow aftewards. The truth is that sometimes it's hard to approach the problem from the outside-in and the pragmatism demonstrated by Kent helps with that. I'll take advantage of these lessons to keep on evolving my style


Thank you Kent Beck for your book and your videos!

And thanks to my friend @pasku1 because I believe he told me about these videos. 

Code symmetry

Today, Peter Kofler and I have been pairing over the Internet to do deliberate practice. To improve our coding skills. We have been working on the word wrap kata, to practise the Transformation Priority Premise, this time using JavaScript. We've checked-in the code after every little change so the evolution can be seen in the "commits" in the repo.

What I have learned in this session:

  • I will always use curly braces in "if" statements even when they only contain a "return" statement: I used to think that, even without the braces,  developers would notice the "return" and thus avoid the mistake of adding lines afterwards. But Peter suggested that some developers might add lines before the "return" statement. This is something I didn't think of before!
  • Code symmetry helps to explain the intention of the code.

Code symmetry started to grab my attention when I saw Kent Beck in his TDD screencasts. In the second episode he prefers to leave some duplication in favor of symmetry.

Peter and I were working on a simple function to find out the position where we had to wrap the line. We had a green test with this implementation:

  1. function wrapPosition(paragraph, maxLineLen){
  2. if (paragraph.indexOf(" ") > -1){
  3. return paragraph.indexOf(" ");
  4. } else {
  5. return maxLineLen;
  6. }
  7. }

Then I noticed that the "else" was not necessary so I removed it:

  1. function wrapPosition(paragraph, maxLineLen){
  2. if (paragraph.indexOf(" ") > -1){
  3. return paragraph.indexOf(" ");
  4. }
  5. return maxLineLen;
  6. }

The Peter said, "now the 'if' statement looks like a guard clause, but in reality we don't have such a guard clause".
This is true, the reader may wonder why is that guard clause in there. Actually we know that any of
the two paths is possible, so the "else" expresses the intent of the code better.

But we still thought that the "else" was not necessary, so Peter came up with the idea of inverting the condition:

  1. var lineBreak = "\n";
  2. var notFound = -1;
  3. function wrapPosition(paragraph, maxLineLen){
  4. var hasNoBlank = paragraph.indexOf(" ") == notFound;
  5. if (hasNoBlank){
  6. return maxLineLen;
  7. }
  8. return paragraph.indexOf(" ");
  9. }

Now it does not look that much like a guard clause. What do you think?

Some related talks and posts that Peter has sent to me, related to our discussion today:

It's been a very interesting discussion, I want to say thank you to Peter for arranging this session. There will be more soon 🙂