Learning and groking recursion

I’ve started learning functional programming in July 2016. Actually I wanted to learn Elm because it looked to me like a powerful web development language (and I’d head some good things about Elm from very experiences Haskell programmers. One word that drew my attention was : the code written in Elm is very elegant.

I “practice” Elm only when I am at home, in my free time (which basically means, when the 3 young kids are asleep, at night).

I soon discovered the Functional Programming world, which was not really my first intention. But I thought, well, let’s go for it, let’s be “mainstream” J

That’s where things got a little more complicated than I had expected. As many will say, it is a change of paradigm, for people like me, who did some PHP, SQL, ASP 3.0 or a little “copy/paste JavaScript” before.

When this change of paradigm was done in my head, things became really smooth and fun.  But then I decided to dive into recursion (I had not really notice that a List.map IS actually a recursion).

Things again became complicated. I was told to read some books to grasp the “recursion” thing, but it was hard. I started reading “The little schemer”, I understood this very simple and fun book, so I thought it was ok.

Then I decided to actually write a recursive function of my own, and I fell lost. I didn’t understand what I was not doing that was in the book. I decided to stop looking at the book, and to try, and try and try, again and again, with very different exercises that I invented. It was hard, the solution was never easy to find, sometimes I felt like I was an expert in recursion, and sometimes I felt like I would never be able to do it. I thought it was a good thing that I was not paid to program.

Guess what? Yesterday I began reading Evan Czaplicki’s book Functional Programming in Elm. And he describes, not exactly in the same way, the pain that he had when he was a student, learning and practicing recursion. Wow, how good it felt to hear that.

Especially when he compares it to leaning the For loop, and it reminded me that, yes, at the beginning it was hard for me to grasp the For loop. But I had forgotten that I had to learn it long ago. Now it is feels so obvious.

In this book, Evan also gives some advice about how to understand recursion when you try to apply it. It looks like some “dumb” advice, coming from an expert in this field. But guess what? That was the same tricks that I had found myself. Which means that what we think is just something that we use because we are not experts, is also used by experts! How good it is to hear that also!

One last thing. Evan says that we the existing functions of Elm, we don’t really have, most of the time, to invent our own recursive functions in Elm. Was I wasting my time trying to learn that? Trying to re-do the functions of the Elm List library? Was I the only one on earth trying to do that?

Guess what… Later in the book, Evan writes that it is a very good thing to learn recursion, and the best way to do it is, for instance, trying to write the recursive functions from the Elm List library.

What I learned :

  • Don’t be afraid of what you try.
  • Prefer practicing again and again than reading books.
  • Consider you learned something not when you understood what was written in a book, but when you can actually do it.
  • Invent your own exercices.
  • Try to dig deeper than the surface.
  • Be your own master.

Rétrospective fun : “Like to Like”

Pour briser un peu la cadre habituel des rétrospective, un format assez original, vise à mettre en avant autant les choses positives que les choses négatives, et se veut plutôt fun, ce qui est toujours utile !

Avant la rétro :
Le Scrum Master prépare à l’avance des “cartes de facilitation” avec un mot sur chacun. Il retourne ces cartes face masquée et en fait une pile qu’il pose sur la table. Il faut mettre des mots sérieux, des mots positifs, des mots négatifs et des mots fun. Par exemple, la liste suivante :

  • Fun
  • Les 12 Travaux d’Hercule
  • Dans les délais
  • Un jour sans fin
  • Clair
  • Higway to hell
  • Réussi
  • Accessible
  • Freddy
  • Intégré
  • Eureka !
  • Dangereux
  • Talentueux
  • La vie est un long fleuve tranquille
  • Propre
  • Rapide
  • Collaboratif
  • Génial
  • Fiable

Pendant la rétro
Brainstorming individuel
Chaque participant prépare plusieurs post-its (le maximum possible) :
des choses à continuer à faire, des choses à arrêter de faire, des choses à commencer à faire (il faut que chacun ait des items dans chacune de ces 3 catégories).

1er tour de jeu
Une personne de l’équipe est désignée comme juge.
Le juge retourne une des cartes de la pile de cartes de facilitation préparées par le Scrum Master et chaque participant pose sa carte qui se rapproche le plus de cette carte (face cachée). Le dernier qui donne sa carte a perdu : il reprend sa carte.

Seul le juge regarde les cartes posées par les joueurs et sélectionne la carte qui se rapproche le plus, selon lui, de la carte de facilitation.
C’est cette carte qui est gardée, et les autres sont écartées du jeu.

Tours suivants
Le même process reprend, mais on désigne à chaque tour un nouveau juge (lorsqu’elle la personne est juge, elle se contente de jouer le rôle de juge et pas le rôle de joueur).
Le jeu s’arrête lorsque chaque joueur a donné toutes ses cartes.
En fonction du nombre de post-its que chacun aura rédigé, il est possible que ce ne soit pas nécessaire de tirer les 20 cartes de facilitation.

Générer un plan d’action
Pour ce faire, il faut décider comment faire pour que les choses négatives passent dans une catégorie positive, comment reproduire les choses positives, et comment commencer les choses qu’on ne fait pas encore. Cela peut être fait en discussion collective ou en brainstorming individuel.

Remarques

  • Je vous invite à faire une petite répétition avant avec 3-4 personnes pour être sûr de bien le faire le jour J.
  • Comme vous l’aurez remarqué, le facilitateur s’efface au profit du groupe.

Lean Coffee

Chacun réfléchit à des sujets dont il aimerait qu’on parle. Ce peut être des choses positives (“on a bien géré ça, il faut continuer à le faire”, “telle personne m’a bien aidé, je voulais lui dire”,….)

On les affiche silencieusement.

On élimine les doublons.

On vote pour 5 ou 6 sujets (dot-voting)

On dispose de 10 mns pour parler de chaque sujet (il faut un timer visible de tous) en commençant par le sujet qui a obtenu le plus de vote.

Au bout des 10 mns, on décide si le sujet est clos, ou si on rajoute 5 mns pour continuer la discussion (au détriment des autres sujets).