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.

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:

  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. }
  28. //------ THE TEST
  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();
  41. // exercising the SUT
  42. service.add(new User({email: ''}));
  44. // verifying configured expectations
  45. mock.verify();
  46. });

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.

Isolation with jMockit: Stub out System from Java JRE

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.

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

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 😉

Do not create unnecessary methods

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:

  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. }

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

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

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:

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

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:

  2. result = someVar.toUpperCase(); // is good/clear enough
  4. // Whilst this method does not make sense:
  5. public String convertToUpper(String input){
  6. return input.toUpperCase();
  7. }
  9. // And this method does not bring value:
  10. private void addWordToList(List<String> palindromes, String word) {
  11. palindromes.add(wordToBeChecked);
  12. }
  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. }

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:

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

Return: get out as soon as possible

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:

  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. }

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

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

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