Interesting Interview: The State of Software Engineering

I've just watched this great interview with Kent Beck on RefactoringClub channel

• The State of Software Engineering

Interesting Talk: "TDD Discipline - Thinking Ahead Without Coding Ahead"

I've just watched this great talk by Jason Gorman

• TDD Discipline - Thinking Ahead Without Coding Ahead

Interesting Talk: "Defining Object-Oriented Design"

I've just watched this great talk by Sandi Metz

• Defining Object-Oriented Design

Interesting Talk: "Test Driven Development: That’s Not What We Meant"

I've just watched this great talk by Steve Freeman

• Test Driven Development: That’s Not What We Meant

Interesting Talk: "Uptime 15,364 days - The Computers of Voyager"

I've just watched this wonderful talk by Aaron Cummings

• Uptime 15,364 days - The Computers of Voyager

Podcasts sobre caring tasks en The Big Branch Theory

Hace un tiempo me invitaron al podcast de The Big Branch Theory para hablar sobre la narrativa de trabajo de cuidados que hemos aplicado en los últimos años en algunos equipos de Lifull Connect.

Estos son los dos episodios en los que participé:

• Caring Tasks 1
• Caring Tasks 2

Si la idea les resulta curiosa en el post The value of caring profundizo en esta narrativa y cuento cómo se originó y en qué contexto.

Interesting Talk: "Tidy First?"

I've just watched this interesting talk by Kent Beck

• Tidy First?

Interesting Talk: "Software Art Thou: Real Software Engineering"

I've just watched this wonderful talk by Glenn Vanderburg

• Software Art Thou: Real Software Engineering

Native/Browser SPA versions using ClojureScript and re-frame talk at SCBCN17

Last month I had the pleasure of giving a talk at the Software Craftsmanship Barcelona 2017 conference about what my colleague Francesc and I have been learning lately while working on the mobile and browser versions of a SPA using ClojureScript and re-frame.

I talked mainly about how re-frame's effects and coeffects, re-frame's subscriptions and modelling a UI as FSMs place you in a pit of success, i. e., a design that, according to Jeff Atwood, "makes it easy to do the right things and annoying (but not impossible) to do the wrong things".

It was my first talk in a big conference and I had some technical problems, so I was very nervous at the beginning. After a while I relaxed and felt better. In the end I received more questions than I expected and very nice feedback.

I'd like to thank Modesto for lending me his computer when mine crashed just before the talk and helping me relax.

This is the video of the talk, (thanks Autentia for recording all the talks and for being so kind to me when I was having technical difficulties). I hope you'll find it interesting:



and these are the slides that I've improved after the talk using Modesto's feedback (thanks!!): .

Thanks to Francesc and all the people in Clojure Developers Barcelona Group, Green Power Monitor and Codesai that contributed to improve the talk with their feedback. Also thanks to my colleague Antonio for "persuading" me to give a talk in a conference.

Finally, I'd also like to thank Software Craftsmanship Barcelona 2017 conference organizers for giving me the opportunity to talk at such a great conference and for all the effort they put to make this conference better, edition after edition.

Kata: Varint in Clojure using Midje and test.check

In last week's Barcelona Software Craftsmanship Dojo we did the Varint kata created by Eric Le Merdy.

Since I was facilitating it, I couldn't code during the event.

Once I got home, I did it using Clojure.

These are the tests using Midje and Clojure test.check libraries:

and this is the resulting code:

I used a mix of a bit of TDD, a lot of REPL-driven development (RDD) and some property-based testing.

Basically, the cycle I followed was like this:

1. Write a failing test (using more complicated examples than the typical ones you use when doing only TDD).
2. Explore and triangulate on the REPL until I made the test pass with some ugly complete solution.
3. Refactor the code to make it more readable.

I've noticed that when I mix TDD and RDD, I end up doing bigger steps and keeping less tests than when doing only TDD. I think this is because most of the baby steps and "triangulation tests" are done on the REPL which gives you a much faster feedback cycle.

This way I wrote both encode and decode functions.

Once I had then working with a few examples, I added property-based tests using Clojure test.check library (a QuickCheck like library for Clojure) to automatically explore more examples by checking that the property of "decoding and encoded number returns the number" held for 1000 randomly generated examples.

I think that these three techniques are complementary and its combination makes me more productive.

To document the development process I commit after each TDD green step and after each refactoring. I also committed the REPL history.

See all the commits here if you want to follow the process.

You can find all the code on GitHub.

Kata: Ohce in Java

Yesterday I facilitated the Ohce kata in a Barcelona Software Craftsmanship event.

Since I was facilitating, I didn't have the opportunity to write any code.

So, when I got home, I did the kata in Java using outside-in TDD and jMock.

I committed after each passing test and each tiny refactoring, so that you can follow the process if you feel like. You can check the commits step by step here.

You can find the resulting code in this GitHub repository.

Thanks to all the attendees and to Magento Barcelona for kindly having us once more.

Update:

I improved the design in this new version of the code:

• Revisited Kata: Listening to the tests to improve the design of Ohce

Software Craftsmanship Barcelona 2015

Last weekend I attended the Software Craftsmanship Barcelona 2015. This was the first time I participate as an attendee (I had worked in the organization of the first two editions).

It was a great event. I attended very interesting talks and had amazing conversations with many people. Some of them I already knew from the Barcelona, Zaragoza, Bilbao, Canarias and Valencia community or from abroad but many of them I just met there.

If I had to highlight my favorite talk, I'd choose Accesibilidad en el software. ¿Qué es? ¿Por qué es importante? (Software Accessibility. What is it? Why is it important?) by Juanjo

Juanjo is a great developer and an accessibility specialist. He also happens to be blind.

He showed us how he programs with Visual Studio using a screen reader and knowing nearly every keyword shortcut. It was very impressive.

Personally, I found it amazing how the human brain adapts to different situations. He has developed a great memory and is able to mentally "visualize" the code with just hearing it once (at a really fast speed).

He also told us about several applications he'd made in his spare time to improve his and another blind people's daily life.

I also enjoyed very much Vicenç García-Altés' talk about Mutation Testing, Álvaro García's talk Tu carrera como una marathon (Your career as a marathon) and the Yatzy refactoring kata also facilitated by Álvaro.
 
We (the No Flop Squad) also participated in the SCBCN15.

The afternoon before the SCBCN15 we facilitated a Pre-SCBCN15 coding dojo.

We practiced doing the Business Rules kata but with the constraint of having to develop an internal DSL that make the tests read nearly as the business rules it was testing. The constraint was based on an exercise Xavi Gost and I did to practice together in one of my last visits to Valencia. This constraint forces you to stay more time on the problem space before passing to the solution space.
We received a lot of positive feedback.

On Saturday morning we gave a talk in which we spoke about an ongoing experiment that we've been developing during the last month: Hybrid Persistence.

In this experiment, we are exploring the idea of persisting different parts of the state of an aggregate on different data storage technologies depending on the kind of state. The idea is similar to Polyglot Persistence but it works at a finer grain persisting separately the identity and mutable state of each member of the aggregate. The relationships among members of the aggregate can also be persisted independently.

The experiment is still in an initial phase, so we haven't yet reached to any sound conclusions. In the talk, we explained the ideas behind this exploration, what we have seen so far (including dead-ends, mistakes and successes) and the things we'd like to try next.

On Sunday afternoon there was an Open Space .

A session that I really enjoyed and took a lot of ideas from, was Dinamizando las comunidades locales (Energizing local communities)

in which organizers and members of several communities across Spain, shared our experiments, successes and failures in trying to improve and sustain our communities.

Also while we were selecting the open space grid, someone nominated a session asking me to give a short introduction to Clojure. Surprisingly it received enough votes to be selected so I had to improvise it.

I showed some code examples and used LightTable to write and evaluate expressions on the fly while I was explaining some language features. Álvaro helped me (thanks!) writing on Juanjo's laptop the code I was writing on my laptop and showing on the screen so that he could also follow the talk using his screen reader.

I tried to demystify parentheses and prefix notation, and explain some of the simplest goodies of the language. Even though it wasn't a good talk, I think I managed to at least arise the curiosity of some of the attendees. I also invited all to come to the Clojure Developers Barcelona's Introduction to Clojure event on next October 27th.

There were so many other interesting talks I couldn't see. I can't wait for the videos to be published.

All in all, it was a wonderful event.

I'd like to thank from here all the attendees and the organization for making it possible. I'd also like to thank Netmind for letting us use their facilities for free one more time.

Kata: "Sieve of Eratosthenes" test-driven and explained step by step

Yesterday we practiced doing the Sieve of Eratosthenes kata at a Barcelona Software Craftsmanship event.

My partner Fernando Mora and I used TDD in Scala to write the code.

Today I did it once again in Clojure.

I'd like to explain here how I did it step by step in order to share it with the Barcelona Software Craftsmanship members.

I started by writing this test:

which I quickly got to green by just hard-coding the response:

In this first test I used wishful thinking to get the function and signature I wished.

Then I wrote the following test:

which drove me to generalize the code substituting the hard-coded list by a code that generated a list that was valid for both the first and the second test:

The next test was the first one that drove me to start eliminating multiples of a number, in this case the multiples of 2:

I made it quickly pass by using filter to only keep those that are not multiples of 2 and 2 itself:

Alternatively, I could have taken a smaller step by just eliminating 4, then go on triangulating to also eliminate 6 and finally refactor out the duplication by eliminating all the multiples of 2 that are different from 2.

Since the implementation was obvious and I could rely on filter, I decided not to follow that path and took a larger step.

I've noticed that my TDD baby steps tend to be larger in functional languages. I think the reason is, on one hand, the REPL which complements TDD by providing a faster feedback loop for triangulation and trying things out and, on the other hand, the power of sequence functions in those languages (in the case of this kata the Scala and Clojure ones).

Once the test was passing I started to refactor that ugly one-liner and got to this more readable version:

in which I extracted two helpers and used remove instead of filter to better express the idea of sieving.

My next goal was to write a test to drive me to generalize the code a bit more by eliminating the hard-coded number 2 in line 10 of the code.

To do it I just needed a test that forced the code to also eliminate just the multiples of 3:

Again I could have triangulated to first eliminate 9 and then 12 before refactoring but there was an easier way at this point: to introduce recursion.

But before doing that, I quickly went to green by calling the sieve function twice to eliminate the multiples of 2 and 3:

With this tiny step I both highlighted the recursive pattern and provided a safe place from which to start using refactoring to introduce recursion.

In this case I think that having tried to directly introduce recursion to make the test pass would have been too large a step to take, so I played safe.

Once in green again I safely refactored the code to introduce recursion:

Notice that this version of the code is the first one that solves the kata.

From this point on I just refactored the code trying to make it a bit more readable until I got to this version:

Finally, I wrote a more thorough test that made the stepping-stone tests that helped me drive the solution redundant, so I deleted them:

If you want to have a closer look at the process I followed, please check the commits list where I've also included the REPL history. You can also see all the code in this GitHub repository.

That's all.

I'd like to thank Barcelona Software Craftsmanship members for practicing together every two weeks, especially Álvaro García for facilitating this last kata, and eBay España for kindly having us yesterday (and on many previous events) in their Barcelona office.

Kata: Studious Student in Clojure

Last week Leo Antoli facilitated a kata for Software Craftsmanship Barcelona.

We had to solve the Studious Student exercise.

Leo wanted us to experiment how useful testing is in an exercise like this one, so we divided the group in some pairs using TDD, some pairs testing after writing the code and some pairs not testing at all.

The exercise is a bit tricky as pairs that were not testing discovered at the end, whereas the ones doing TDD or testing after coding discovered early during the process.

After an iteration of one hour, we had a very interesting debate about automatic testing.

This is my solution of the exercise in Clojure:

and these are the tests using Midje:


You can see all the code in this GitHub repository.

I'd like to thank Leo for being so kind and sharing his knowledge with us.

Introduction to TDD with Barcelona JUG and SCBCN

Yesterday Álvaro (@alvarobiz) and I facilitated the Fractions Arithmetic kata. It was an activity organized by the Barcelona Java Users Group and the Barcelona Software Craftsmanship Community. Thanks to Ignacio Cougil and Jonathan Vila for having the idea and making this event possible.

Since the kata was meant to be an introducction to TDD, we had first a short talk explaining a bit what TDD is about.

The talk took longer than I expected because we discussed about topics, such as, TDD, object-oriented design or refactoring. Thanks for the questions and comments, I think they lead to interesting discussions.

Then we started the kata working in pairs.

In the Fractions Arithmetic kata you have to develop the arithmetic of rational numbers but, in this occasion, we limited ourselves to just developing the addition of rational numbers. We modeled the rational numbers as value objects and the fractions had to be reduced.

Álvaro and I went from pair to pair commenting with them their approaches, helping when some pair was stuck, talking about some possible refactorings, etc.

I enjoyed the experience a lot and I hope all participants took something useful home.

We talked about some books and talks that might be interesting to learn more about TDD.

These are the links:

• TDD books.
  • Test Driven Development: By Example by Kent Beck. Read it to know first-hand the original TDD source
  • Diseño Ágil con TDD by Carlos Blé. A very interesting explanation of TDD in Spanish which has a Creative Commons license
  • Growing Object-Oriented Software Guided by Tests by Steve Freeman and Nat Pryce. A wonderful advanced TDD and OO book which illustrates the london School of TDD.
  • Test Driven, Practical TDD and Acceptance TDD for Java Developers by Lasse Koskela. A really great TDD book. Its second part is specially dedicated to apply TDD to specific Java technologies
  • Modern C++ Programming with Test-Driven Development by Jeff Langr. Another great book on TDD which, due to its more recent publication, also contains explanations and worked examples on the Transformation Priority Premise and the Mikado method.
• Refactoring books.
  • Refactoring, Improving the Design of Existing Code by Martin Fowler. A must-read.
  • Refactoring to Patterns by Joshua Kerievsky. Another great book which reconciled two worlds.
• Some more advanced talks we mentioned (and an extra one I forgot to mention):
  • Listening to Test Smells by Steve Freeman
  • Design How Your Objects Talk Through Mocking by Konstantin Kudryashov
  • Fractal TDD: Using tests to drive system design by Steve Freeman

Thanks to all for coming. We'll see each other in the next one.

Craft Conference 2014

Last month @pclavijo and I went to the Craft Conference in Budapest.

It was my first international conference and it was a great experience.

This were my favorite talks in no particular order:

• Conway's Law and you: How to organize your organization for optimal development, Michael Feathers
• Polyglot Data, Greg Young
• Responsibly maximizing craftsmanship in software engineering, Theo Schlossnagle
• Acknowledging CAP at the Root - in the Domain Model, Eric Evans
• Find the right abstraction level for your tests, Gerard Meszaros
• Going reactive: event driven, scalable, resilient and responsive systems, Jonas Bonér
• Coaching teams through change, Rachel Davies
• Building on SOLID Foundations, Nat Pryce and Steve Freeman
• Jackstones: the journey to mastery, Dan North

This other one I couldn't go but @pclavijo said it was great, so it's in my talks queue:

• How I learned to stop worrying and love flexible scope, Gojko Adzic

Kata: UglyTrivia legacy code refactoring kata in Java

I've just solved the UglyTrivia legacy code refactoring kata in Java which was the kata we did in the last Barcelona Software Craftsmanship event.

This is the initial version of the Game class:


And this is the code after my refactoring:

Update:
And this is the code after I revisited it again (Feb. 27th 2016):


Check my solution in GitHub with commits after each refactoring step.

Birthday greetings refactoring kata at Barcelona Software Craftsmanship: step by step commits and screencasts

Last Monday I hosted an event for Barcelona Software Craftsmanship community.

We practiced refactoring and learned about ports and adapters using Matteo Vaccari's Birthday Greetings kata in refactoring mode. This is the initial code in Java that we tried to refactor.

I prepared several slides to introduce what we were going to do. I thought that we could just start refactoring for two hours right after this explanation, but, thanks to the suggestions of some attendees, we changed the plan and did two iterations (extracting the employees repository in the first one and extracting the greetings sender in the second one) with a retrospective in the middle.

This was a really good idea because it gave us the opportunity to debate about different approaches to this refactoring and about ports and adapters. Some very interesting points were raised during those conversations and we could exchange personal experiences and views about this architecture and refactoring. This kind of conversations are a very important part of practicing together and they enrich the kata experience.

I think I have a lot to improve as an event host. Next time I'll make explicit that attendees need to bring their laptop and I'll try to help more the beginners.

I had published a possible solution to the kata, but it was just the final solution not the intermediate steps. Some attendees said that they would like to see how this refactoring could be done in small steps. For that reason, I redid the kata again at home committing after every refactoring step and recording the process:

• Step by step kata commits
• Screencasts of most of the process: Extracting the employees repository and Extracting the greetings sender

Take this recordings with a grain of salt because I'm still working hard to improve my refactoring skills.

Well I hope this might be useful to someone.

Just to finish, I'd like to thank all the attendees for coming, I had a great time. I'll try to do it better the next time.

I'd also like to thank netmind for their support to our community giving us a place and the means to hold Barcelona Software Craftsmanship events. Having a regular place for our events makes everything much easier.

So far the events have had much more attendees than we had expected. In fact, this last Monday we nearly run out of space. If this trend continues, we'll probably need to ask for a bigger room to hold future events.

-----------------------------------------------------------------------------

PS: Christian Soronellas shared a version of the initial code in PHP.
Thank you very much Christian!

Some resources for Specification By Example and Behavior-Driven Development

Last Monday I attended the second event of Barcelona Software Craftsmanship.

Viktor Farcic and Jordi Falguera gave a talk about Specification By Example (SBE) and Behavior-Driven Development (BDD).

I really did like the talk, especially because it was enriched with their own experiences applying SBE in different projects.

For some people in the audience SBE was not a completely new concept, for some others it was. In either case, the topic generated a lot of interest and many questions.
Those who were already using it wanted to hear about a different approach to it (there are probably as many approaches as teams and projects).
Those who were just starting or planning to use it in their projects, were more interested in practical how-tos, ways to overcome possible obstacles and other stories from the trenches. The same goes for the people (like me) that knew about SBE through Godjko Adzic's great book or have heard or read about it in talks or posts.
Finally, I could imagine the brains of the people hearing about it for the first time, churning wildly, like mine was when I started to read Godjko Adzic's book, imagining how SBE could impact their projects, thinking in all the possibilities opening before them and in how they could get there.

To sum up when the talk ended, we were left wanting for more.

For that reason I'd like to share in this post several interesting links that I have come across while learning about SBE, so that, they can help other people interested in it to learn more and to compare some of the different approaches and tools that exist for SBE.

Dan North's original BDD post: Introducing BDD
and its great What’s in a Story? post.

Books:

• Bridging the Communication Gap: Specification by Example and Agile Acceptance Testing by Gojko Adzic.
• Specification by Example by Godko Adzic.
• The Cucumber Book: Behaviour-Driven Development for Testers and Developers by Matt Wynne.

Talks:

• On Behavior-Driven Development Dan North and Liz Keogh.
• Behavior-driven Development by Liz Keogh.
• BDD: Step Away from the Tools by Liz Keogh.
• BDD: Busting the myths by Gojko Adzic.
• Growing software from examples by Seb Rose.
• Especificaciones ejecutables, acercando negocio y desarrollo Vicenç García Altés.
• Behaviour Driven Development and Cynefin by Liz Keogh.
• On BDD, Cucumber, Hexagonal Architecture by Matt Wynne.
• Reinventing software quality by Gojko Adzic.
• Using Cucumber for BDD and Agile Acceptance Testing by Gojko Adzic.

----------------------------------------

PS: The great thing it's that Viktor and Jordi have proposed a BDD Workshop on March 3, 2014, so that we can practice how to write specifications.

Interesting Talk: "OOP básico, lo que crees saber II"

I've just watched this interesting talk by Xavi Gost:

• OOP básico, lo que crees saber II 

It's the second part of a talk that took place during the Software Craftsmanship Barcelona 2013.
It talks mostly about the SOLID principles and Xavi's code hygiene rules.