Carlos Ble

Carlos Ble

I am a professional software developer, I solve problems.

I also teach and mentor developers to build better software.

Working as an independent professional since 2009.

Can I help you?

  • Do you need high quality tailor-made software?
  • Need training on TDD, clean code or refactoring?
  • Is it risky? do you need advise?
  • May I pair with you to write better code?

Events

Upcoming public training courses:

  1. [in English] May 5, 6 & 7
    TDD - Train the Trainers (iSQI)
    Potsdam, Berlin
  2. [en Español] 23, 24 y 25 de Abril.
    Curso de TDD con examen de certificacion iSQI
    Madrid
  3. [en Español] 29, 30 y 31 de Octubre.
    Curso de TDD con examen de certificacion iSQI
    Madrid

Conferences:

  1. I'll be at SocratesUK 2014
  2. I'll be at the London Test Gathering Workshops.

Last week was awesome, I went to Barcelona to run two training courses. Well, one of them was my yearly session at the Postgraduate on Agile Methods at La Salle (Universitat Ramon Llull). The first postgraduate in the world on Agile Methods. I explain eXtreme Programming, together with my good friend Rubern Bernardez,  during 6 days (3 weekends).

PMA 2013/2014

PMA 2013/2014

 

This has been my third year at the PMA and it's been really nice. The selection process for participants went very well thanks to Xavier Albaladejo and so the group was excellent. People have made an endeavor to understand the XP practices and the values behind. Even project managers, people that have been away from code for years, were test-driving the exercises in pairs.  The fact that decision makers come to the class and get to appreciate the benefits of clean code and XP is very important in my opinion.  Because they can encourage and tell developers later. In the group there were testers and developers too. The different mindsets together were very interesting when facing code. Enriching experience for everybody. Thank you all for this great PMA edition. Special thanks to Xavi and to Quim Ibañez for his kindness and support.

 

During the week, I gave one of my TDD training courses, this time open to the public. In general, public courses are more energizing than in-house, because people are willing to learn and participate. They have to pay for their ticket or ask their companies and that makes a difference. This time I got to know several members from the Barcelona Software Craftsmanship Community. The level in the training was very high, in fact, it was more an exchange than a teaching session. There were many interesting discussions and retrospectives whilst looking at the code in the projector.  It's been also very nice to meet old friends and observe how they have progressed over the last couple of years. Specially Manuel Rivero who has made an outstanding progress in his career and now let me learn from him.

 

TDD Training in Barcelona

TDD Training in Barcelona (open to the public)

This experience reminds me my first open course in Madrid in 2010, when I got to know people that are now good friends and that today, run their own training courses on TDD and clean code or lead teams. So I believe that we have started here a wonderful relationship and that we will cross roads soon again. There was magic in the air.

I have to say thank you to my good friend Javier Gomez for all the support and the hosting,  as the event happened in Ricoh Spain. In this kind of courses I get to know great programmers that usually end up being colleagues or collaborators at some point ;-)

Coding dojo - Barcelona Software Craftsmanship

Coding dojo - Barcelona Software Craftsmanship

 

Thank you very much also to all the folks that came to the coding dojo that we had on Monday evening, hosted by Barcelona Software Craftsmanship, thanks to Manuel Rivero, Beatriz Martin and Jaume Jornet. In my opinion the community is very healthy in Barcelona, congratulations.

Teaching TDD

TDD class at the IronHack 2nd edition (picture by @JackLondon84)

Last week I was the teacher in the second edition of the IronHack, well for the last two days of the week. This time I've joined the group on their second week rather than the fifth. So I've been the one introducing unit tests. It's been quite challenging as it had to be using JavaScript. Many new concepts at the same time. Really hard for the participants but eventually absolutely all of them understood the benefits of unit tests and even the TDD cycle. They got the point with TDD. Fortunately,  my friend Fernando Moreno (who was a participant in the previous edition), was helping me out with the class. He was solving doubts and helping with technical problems and that made a huge difference. Being two people answering questions, was the key for the group to progress with steady pace. I am so grateful to Fernando, a great teacher assistant.

The group has a great potential, this training course is going to be a remarkable milestone in the life of many participants. It's been a pleasure meeting the folks.

And... you know what? pretty much all the participants from the first edition have a job already. And I know that some of them are really interesting positions. This is great news, I had the chance to talk with four of them and they are very enthusiastic about their new careers. This fact says a lot about the IronHack project and I am glad for being part of it. The more I know the project and the people behind it, the more I like it.

On Thursday evening Marta Fonda (from edition one) came up to give a talk on personal branding after my class, it was a nice surprise and we had a great time with beers afterwards.

On Friday I organized a small coding dojo in the same venue and I had the chance to pair with Sergio Revilla and Vishal  Shahdadpuri, from the first and second editions. We had a great time, I could appreciate Sergio's evolution which is impressive and we learned from each other. Pasku came out with a nice solution in Ruby. We ended up with a nice solution in JavaScript, also using a functional style.

I will back in the IronHack this summer in Barcelona. Check out their new courses on iOS development, in Madrid & Barcelona (summer and autumn).

With good names for packages, classes, methods, variables,... code should be self-explanatory.  Long method names are not a problem if they really make code read better and don't reveal too much implementation details. Names are more powerful than most developers usually think, they have a profound impact on our designs. In general names should be pronounceable but there are always exceptions.

  • In a small loop, it's OK to name the index i, j, k or something like that you don't have to say theLoopIndexWhatever. In fact, "i" reads better in a short loop.
  • Methods should not contain concrete details, those should be parameters instead:     

            assertThatThereAreTwoResults(results)

          Should better be written like:

                      assertThatThereAre(2, results)

  • Method names should say what they do, but not how:

            addWordIfIsValidAndHasCorrectLength(word,  results)

          Should may be:

                     addValid(word, toResults);

  • The name of the class should be considered when naming methods. The name of the methods should be considered when naming its arguments. Given that methods should not have more than 3 parameters (the less the better), the names of the arguments may be combined with the name of the method, specially if there is a single parameter. Good names care about their context.

            result = expressionResolver.resolveExpression(expression)

          Reads better like this:

                     result = resolver.process(expression)

  • In the case of test methods, the name should describe the behavior without concrete details. The details are inside method body. The test method name is the description and the body is the example:

            one_plus_two_returns_three()
          Should be:

                     sums_two_single_digit_numbers()

  • Names should not contain technical details, like the types , because they are an excuse not to search for proper domain names. Modern IDEs provide enough help for the programmer to find out types, code should be business domain oriented.

            parseString(expression)
          Should be:

                     parse(expression)

Avoid prefixes and suffixes like "Abstract*", "I*" (ISomething), "*Impl"...

Don't let the syntactic noise bother you when choosing your names, the fact that there is a brace in the middle should not impede you from writing a line of code that reads like well-written prose ;-)

I'll probably will go on updating this post with more examples.

 

I am using LeanPub to create some manuals and it's a very nice service.  You just have to use Markdown to write your document and it generates a good looking pdf document from it. Well, as far as I've read today it's actually kramdown a superset written in Ruby. Everything was fine but that my partners wanted to add a custom header image in the manual. This is not supported by Leanpub, in fact it's not supported by Markdown as far as I know. So I decided to manipulate the pdf using my preferred OS (linux). It's not easy!

Pdftk (the pdf toolkit) is great!

pdftk  it's a powerful command line tool to manipulate pdfs. The tool that has saved me eventually. Thanks Sid Steward! What I've done is:

  1. Use LibreOffice to insert the header image into an empty document and then save it as pdf (header.pdf)
  2. Use LibreOffice to create a cover for the book (cover.pdf)
  3. Remove the first two pages from my_book.pdf,  generated by Leanpub:
    pdftk my_book.pdf cat 3-end output tmp.pdf
  4. Add the cover:
    pdftk cover.pdf tmp.pdf cat output tmp2.pdf
  5. Add the background:
    pdftk tmp2.pdf background header.pdf output my_final_book.pdf

See more powerful examples of pdftk.

Things that didn't work so well:

  • Xournal: this tool is great when it comes to adding some text to a pdf document among other things. Probably the best pdf tool with GUI I've tried. However, it doesn't support adding images or headers. There is a patch to insert images but I didn't spend the time trying to compile it.
  • PDFedit: looks powerful but I didn't know how to use it. I could remove text from the document easily but nothing more.
  • uPDF: looks interesting but it's buggy,  like experimental. It didn't work for me, freezes when saving the document and the GUI is quite hard.
  • PDF Mod: this one is looking very good! but I knew about it when I already solved the problem and didn't try it out.  The doc says it modifies pdf but I don't know whether it supports headers/backgrounds and things like that.
  • LibreOffice-pdfimport: Right, it opens up the pdf document but it looses its format and images at least for my pdf book.
  • Pandoc: In desperation I tried to generate the pdf myself skipping Leanpub, from the markdown text. Pandoc is brilliant and very powerful converter. Together with latex-beamer it has generated a pdf for me:
    pandoc -t beamer -o my_book.pdf -i my_book.txt
    The problem was that I don't have a nice latex template to use so I just loose all the nice formatting provided by Leanpub.

I also tried two commercial tools for Windows but none of them were very good either.  The prices were reasonable so I though I would just buy them but the trial version was good enough to realize the software wasn't good.

This story has taken me way much time I thought,  I hope you save some time reading this if you face the same problem :-)

 

iSQI logo

I am happy to announce that the work  I've been doing in the last quarter in collaboration with iSQI is now official. We have prepared a new TDD training based on the successful course that I've been running in Spain for about 3 years. The new training is now part of iSQI's Certified Agile program, so those who want to take the exam after the course will become certified (if they pass it).

iSQI is a well-known organization in Europe specially among testers. Their CAT (Certified Agile Tester) is quite popular and I can tell is a good training because I participated in one edition just to see how they work. Now iSQI also wants to provide more training options for developers.

I've created a hand book for the participants and a guide for trainers, updating my original course with an additional day and new exercises.  In January I'll be in Berlin running the first Train the Trainers (TTT) where developers passing the exam will become trainers entitled to run official courses and certify other developers.

I do know this training provides great value to developers. I encourage people new to TDD to participate in the training because I know they will learn. I would discourage those who want just the certification because this one is not easy to get.  The exam is mostly coding to demonstrate that candidates really understand TDD. Last month we had the first pilot training in Potsdam (Berlin) and only half the participants passed the exam.  Fortunately all of them learned something new and I can tell that if they keep practicing, they will pass the exam in a few months. But at the same time I am satisfied that not everybody passed the exam because we had some people that haven't been coding in the recent years and I felt they were not ready yet.

I don't know about other certifications because I don't have any, and the value of this training is not in the certification either but in the important lessons participants learn. However I can confirm that the people passing this exam will know what TDD is, and what it's not and that provides value too. We are doing a good job there.

My challenge now is to train other trainers so that we preserve the essence of the course adding even more value and quality.  If you are a seasoned test-driven developer please join us as a trainer :-)

We know TDD is not mainstream and will probably never be, but I see in this a great opportunity for TDD to reach more developers. An opportunity for developers to feel comfortable asking their managers for three days to come and practice and then keep on practicing on a regular basis.

Even though the title of the training is TDD, we cover some basics on clean code and SOLID design principles to make sure we triangulate towards well-designed code. The emphasis is on good naming and removing duplication. The first day is all about refactoring, unit tests, and design principles.

For my friends in Spain I have to say that we would like to translate the materials to Spanish and run a TTT somewhere in Spain and also in Latinamerica. Probably in Mexico and Colombia. But we don't know when is this going to happen or whether it will happen eventually. For now, all is in English and the first editions will happen in Berlin. But if I can give the course with my bad English, you can for sure participate ;-)

All the information and contents about this training is here.

 

 

My experience at the IronHack

 

I am one of the lecturers/mentors of the first IronHack edition, a training program for people who want to become professional developers. My part takes only three days and it's been this week. Three full-day hands-on sessions on JavaScript, TDD and testing techniques. The experience has been fantastic for me.

ironHack

During the class at IronHack

When I knew about this idea of training people with any background so that they become developers in only 8 weeks, I thought... shit man, how the hell are people going to learn and assimilate all the contents and concepts in such a short period of time? That's impossible! But I was invited as a mentor by Mauricio Morales and his energizing message made think that I wanted to know how this accelerated training academies works. So I accepted the invite to experience something new, to experiment and learn. And it's been totally worth joining the teachers team :-)

The best thing it's been getting to know the people. IronHack staff are great guys and the participants/students are brilliant. They are doing their best to understand all these new techniques and tools despite of their different backgrounds. People that progress faster take their time to pair up with the people that are struggling, helping them speed up the pace and learn. The people with less programming background are very patient and motivated. Well, all of them are very motivated, this is what is exciting in there.

For me it's been a challenge because I am used to train developers but not beginners. Some of the folks were developers but some of them were pretty new to software development.  And difficulties is what make me learn the most, so I've learnt important lessons that will help me out in the near future. Anyway I am quite satisfied with my work and specially with their effort.

Now, as you may imagine, this training does not entitle all the students to consider themselves senior software developers right after the end of it, it's just too short! But I don't think that is the objective. They are learning from passionate professionals that work every day in "the real world". One or two different guys like me every week. They are getting to know the best techniques we know, how we think and work so that they are learning from our mistakes. What has taken years for some of us is summarized in hours during the training. Internalizing them is going to take sometime to students but it's still faster than some traditional training methods.

I believe this concept is good even if it only serves to add some pressure on other training methods. We need better developers and providing different training alternatives sounds right to me.

If in the future I meet a single person from this fantastic group and she tells me that what we practiced in the class was  useful in her career, then my objective will be accomplished. If they write code with care from now, I'll be totally satisfied. Code for other human beings, not for machines which is what some people believe after other training programs.

I want to say  THANK YOU to the guys behind IronHach: Ariel Quinones, Gonzalo Manrique, Israel Guitierrez, Xavi Leal, Mauricio Morales and company.

And of course THANK YOU to the intrepid participants: Sergio Revilla, Daniel Bardaji, Daniel Castillo, Agustin de la Villa, Alejandro Dominguez, Daniel Cusan, Marta Fonda, Fernando Moreno, Ruben Kanna, Imanol Yañez y Jaime Muñoz.

 

 

2013-11-27 17.58.59

Tuenti office with my friends: Miguel Angel Garcia, Joaquin Engelmo, David Santiago, Imanol Yañez and Marta Fonda

And I visited Tuenti for my first time, finally!

Yesterday was a very intense day because right after the full-day session at the IronHack, I went to Tuenti offices (Madrid) to give a talk to software engineers.  Last week my good friend Kini and Jose Lorenzo sent my an email inviting me to do so. I didn't prepare slides because I didn't feel like giving another talk with slides I felt more like having a discussion. I just prepared a few ideas based on my experience and my point of view to start up the discussion. It was along the lines of professionalism, XP and specially practices like TDD and BDD. Fortunately people were participating in the discussion with a lot of interest. I am not very good at counting but I guess there were more than 50 people. Tuenti gathers some of the most talented developers in the country, not only Spanish developer but also from other countries.  It's a very nice place, looks  very cool as a place to work. I've been listening how good people are in Tuenti for a long time so I am glad I got to know people in person that I only knew from twitter and really enjoyed sharing experiences with them. I hope to meet this group more times in the future.

Mock objects on JavaScript

Many frameworks use the word "mock" for what in reality are "spies". But that's OK, the work "mock" in English covers actually all the possible test double types...

However according to G. Meszaros, a mock object is a specific type of test double that is configured with expectations before exercising the system under test. During the execution the mock compares the calls being made, to its expectations failing if they don't match.

The two frameworks I use for test doubles in JavaScript are Jasmine and Sinon.js. And I also use some helpers of my own. None of these two frameworks provide actual mock objects. Sinon has a "mock" function that let us configure expectations before exercising the system under test. It behaves like a mock if we are working with functions only. Nonetheless if we are working with objects (OOP), then what Sinon provides is not a mock object because a call to any other method in the object other than the expected, will not fail the test. And it should as unexpected calls should make the test fail.

The solution to have real mock objects with Sinon is just a little helper:

  1.  
  2. //------ HELPER FUNCTIONS
  3. function unexpectedCall(functName)
  4. {
  5. return function(){
  6. throw new Error('Function ' + functName + ' was not expected but invoked');
  7. };
  8. }
  9. function inocuousCall(){
  10. return function(){};
  11. }
  12. function replaceAll(obj){
  13. return {
  14. methodsWith: function(fn){
  15. for (var propName in obj)
  16. if (typeof(obj[propName]) == 'function')
  17. obj[propName] = fn(propName);
  18. }
  19. }
  20. }
  21. function stubThe(obj){
  22. replaceAll(obj).methodsWith(inocuousCall);
  23. }
  24. function mockThe(obj){
  25. replaceAll(obj).methodsWith(unexpectedCall);
  26. }
  27.  
  28. //------ THE TEST
  29.  
  30. it("stores the user when adding a new one", function(){
  31. // the DOC (depended-on component)
  32. var repo = userRepository();
  33. // the SUT (system under test) and dependency injection
  34. var service = userService(repo);
  35. // patching the DOC, making it a mock
  36. mockThe(repo);
  37. var mock = sinon.mock(repo);
  38. // configuring expectation:
  39. mock.expects("store").once();
  40.  
  41. // exercising the SUT
  42. service.add(new User({email: 'test@test.com'}));
  43.  
  44. // verifying configured expectations
  45. mock.verify();
  46. });
  47.  

In languages like Java or C#, test doubles frameworks create a replacement for all the methods in the target class/interface. In JavaScript however, frameworks replace single functions. For this reason it's possible to have the same object acting as the SUT and the double in a single test. But the fact it's possible doesn't mean it's right. Whenever you find yourself in a test using a double for some method and then invoking another method in the same object, think carefully whether the design is appropriate. That smell is usually pointing out that you should extract a new class and create a dependency between the old and the new, so that one acts as the double and the other as the SUT.

In general I prefer to wrap up system functions so that I can inject test doubles and test drive my designs easily. In general is not a good idea to mock objects you don't own. But this time I was doing some research, preparing one edition of my Online Training Class on Test Doubles and came across jMockit as a way to stub out System artifacts. jMockit is an isolation framework that I haven't tried before.

The idea is to stub the System.currentTimeMillis built-in function. I tried PowerMock but it didn't work for this particular case. PowerMock is brilliant for stubbing static methods and constructors as long as they are not part of the system. Very handy for legacy code.

  1.  
  2. // import mockit.*;
  3. public void simulateCurrentTime() {
  4. new Expectations() {
  5. @Mocked("currentTimeMillis") System mockedSystem;
  6. {
  7. System.currentTimeMillis();
  8. result = 123456L;
  9. }};
  10. }
  11.  

This is the method I had to invoke from within my JUnit test in order to stub out the function. It works! I have to say that it took me more than one hour to make it work because I couldn't find this in the documentation. I found several blog posts but they are old, the framework has changed since then. Eventually, a combination of information gathered from several posts yielded this working method.

Kids, don't do this at home!

If you want to know more, join the next edition of my training class ;-)

Methods should be short, from 1 to 7 lines of code, maximum 10 in some cases (with the exception of some algorithms). Because a method does just one thing its name should describe it precisely. But it should not contain implementation details (like data types). The name of the method is the "what" and the implementation is the "how". Try to avoid implementation details in the name.
When you find yourself using the words "and/or" in your methods names, consider that you might be exposing too many implementation details and try to search for a better name.

Sometimes, people new to this kind of modularity end up creating methods that are not necessary:

  1.  
  2. private boolean checkIfCharsAreEqual(char[] wordArray,int first_char, int second_char) {
  3. if (wordArray[first_char] != wordArray[second_char]){
  4. return false;
  5. }else{
  6. return true;
  7. }
  8. }
  9.  

This method does not add any clarity to the code. Moreover boolean methods can just return the condition:

  1.  
  2. private boolean checkIfCharsAreEqual(char[] wordArray,int first_char, int second_char) {
  3. return (wordArray[first_char] != wordArray[second_char]);
  4. }
  5.  

There is no need for the "if-else" block when the result of the condition is the return value of the function/method. Even after this change, the method does not make sense. Try to "inline" the method to see whether the code invoking it reads equally good.

When conditionals contains more than one boolean expression (using logic operators AND/OR) then I usually prefer to extract a method so that the reader doesn't have to think, just read and understand:

  1.  
  2. // before:
  3. if (someCondition(arg1) && !someOtherCondition(arg2))
  4.  
  5. // after:
  6. if (isSomeCaseWithProperName(arg1, arg2))
  7.  

When methods are boolean, try to name them so that they read well preceded by the "if" keyword. I like using the prefixes "is" and "are" or "areThere" for boolean methods operating on single variables and collections respectively.

When the new method is just an alias of another method, consider whether adding it adds any value in terms of readability:

  1.  
  2. result = someVar.toUpperCase(); // is good/clear enough
  3.  
  4. // Whilst this method does not make sense:
  5. public String convertToUpper(String input){
  6. return input.toUpperCase();
  7. }
  8.  
  9. // And this method does not bring value:
  10. private void addWordToList(List<String> palindromes, String word) {
  11. palindromes.add(wordToBeChecked);
  12. }
  13.  
  14. // And this method does not bring any value:
  15. public boolean stringContainsAtLeastOneSpace(String input) {
  16. if (input.contains(" ")){
  17. return true;
  18. }
  19. return false;
  20. }
  21.  

Also notice that the prefix "string" in the method name is redundant because the parameter is a string. In the case of methods with one or two arguments, consider using names for the arguments that read well together with the method name:

  1.  
  2. public User findBy(int phoneNumber){
  3. ...
  4. };
  5.  

I believe the idea of a single exit point for functions comes from the 70's. A function used to have only one exit point, a single return statement. I still see some developers doing this but it's not a good idea. As soon as you have found what you were looking for, just get out the function.

The old style:

  1.  
  2. public int someMethod(String input) {
  3. int code = 0;
  4. if (someCondition(input))
  5. code = 1;
  6. else if (someOtherCondition(input))
  7. code = 2
  8. return code;
  9. }
  10.  

Improved: returning the value as soon as it's found:

  1.  
  2. public int someMethod(String input) {
  3. if (someCondition(input))
  4. return 1;
  5. if (someOtherCondition(input))
  6. return 2;
  7. return 0;
  8. }
  9.  

The second example is not only shorter but also less exposed to defects. In the first example, if for some reason I forgot the "else" and the second condition applies, I'd be returning the wrong value.

The reasons to return as soon as possible are:

  • Code is usually more simple
  • The likelihood of future defects is lower