Yesterday I had a very interesting conversation with Keir (one of my students at MakersAcademy) during our lunch break.
We talked about the relationship between cooking and software development, specifically how you learn these skills.
When you cook, if you have eaten before, you base your cooking on your experience mixing up the ingredients and how they will taste once they are combined in the dish. Similarly, when you are coding you apply your experience creating structures and combining them together.
If you are new to software development this reaches a whole new level. You suddenly are cooking, but you have never eaten before. You have to taste every ingredient and food you want to mix before you can even think about combining them together into a dish.
Guiding a group of six people that want to become software developers is a big challenge. As the master chef I have to give them little taste of ingredients and letting them savour them, play with them. Slowly, while getting used to the structures (Strings, Numbers, Hashes, Arrays, etc) they will see how they can combine them into a cohesive self.
Even if you are an experienced developer, it helps a lot if you spend some time now and then playing with your ingredients (the data structures of your language). This way you will find new ways you can incorporate them into your applications.
This weekend I was working on a product idea we have been toying around (I wanted to have a little break from writing) and a thought occurred to me…
Suppose you are like me sitting in your home office some weekend (or late night) and you are coding on some project you want your colleagues/friends to see when they come back from the weekend or the next day. “Well”, you say, “you push it on github and they will get it…”
Right, all true, but What if I want them to see my thought process?
So here is the idea:
- You write a test
- You write sufficient code to make it pass the simplest way you can imagine
- You commit that code
- You refactor that code (micro refactoring)
- You commit that code
- You look if there is some other code that can be refactored that’s related (macro refactoring)
- You commit that code
- You push to github
I am going to experiment with this a little and see if there is any benefit at all in this approach and if people actually like reading the commits in chronological order to understand the thought process of a person.
Note: I usually commit many times (almost every 5 minutes), but not following a particular criteria (as long as the tests pass that is), that’s why I thought that this would be a good approach to keep my commits at bay and to have an order of commits.
"I’ll be happy about it", I said yesterday morning jokingly in our campfire’s main chat room at patheleven.
This was actually the answer I said to Sebastian when he said that if I sold 10 copies of the book it would be awesome for a first day.
So guess what happens next, You guys bought a total of 13 copies!
I am flabbergasted, I really am. I did not expect to sell any copy of my book the day I was going to let it out on it’s journey. Specially if you consider that it still needs some serious reviewing and I still have to write a lot of the material.
I will be updating the book every week (possibly on Fridays so that you can read the new material over the weekend). Currently I want to focus in finishing the recipes for the activities of an Inception Workshop first. This will possibly be accompanied by some of the appendices where I dig deeper into some of the things described in the activities.
This project is really a great experience in many levels, so I am going to keep on updating you on it and some day post some of my thoughts and advices on self publishing a book, but for that I need to finish this one first!
Let’s get back to writing now…
I remember a conversation I had with Dave Hoover a few years ago. We were talking about his recently published book Apprenticeship Patterns. I was telling him that I wanted to write something about the craft of writing software myself, but that I wanted to write a book aimed more to the Journeymen out there.
This holiday season I was struggling with my writing. I somehow could not get myself into writing more in my blog; I was suffering the known writers block. Something changed though and I decided to give Leanpub a try and get myself to write a book.
Well, actually I thought about a series of books which I will publish under the series Software Craftsmanship - The Hidden Toolbox.
The first one in the series (and hopefully not the last one) will be Inceptions - Starting a Software Project. In this book I give a recipe book as how you can run an Inception Workshop successfully and the tools you need.
Currently I am writing the activities chapter in which I describe how to run each activity you can do during an Inception Workshop.
If you are interested in the book please go to the leanpub page of the book and register your interest! It will be interesting to know for how much you’d buy it for (I have a price range in mind, but I will adapt it if there is sufficient feedback).
Some pieces of software (programs and libraries) can be considered the particular masterpiece a craftsman has done. Those are those projects they did in their non-paying, non-working time (I use these terms as I don’t believe there is such a thing as free time), maybe with special care or love, but for sure trying to solve a problem or scratch an itch.
Usually I learn quite a bit when I look at the code of people who’s work I admire. This takes some time though, as I spend a lot of time then looking into open repositories looking out for these pieces of workmanship.
I would love to have a place where, known to be good, craftsmen would place their masterpieces. I am not talking about a repository for these. I am talking about a place where you will find some guidance of particular interesting parts of the code. A place where you can comment on the code and see the comments of others.
The software development community, specially the one we belong to (the software craftsmanship community) is a very small community of professionals.
We embrace perpetual learning and a community of professionals that pushes each other to the limits; where we learn from each other.
Sometimes we don’t exactly remember from whom we learned which technique or way of working and the roots of that knowledge, of that discovery, get lost in time.
I would love to have a place where, like in a family tree I could see who has learned what from whom. This way, for instance if I pair with Corey Haines and I realize that J.B. Rainsberger has had a great influence in his style for naming and refactoring I can try and contact Joe to see if there is a chance that I can learn that skill from him.
This place (or app) would not give any clue on how good you learned what you did, but only a way to see from whom you learned.
It should also offer the possibility of (at least) two ways of relations; direct (you actually paired with that person and she agrees that that is true) or indirect (you have read a book, article, etc that influenced your style).