Monday, January 2, 2012

2011's mindfucks

Do you know what mindfuck is? Quoting the urban dictionary:
An idea or concept that shakes one's previously held beliefs or assumptions about the nature of reality.
I like this definition, but I would widen it a bit. This idea or concept doesn't have to be based on held beliefs nor assumptions. It can also broaden the horizon by introducing something completely new. However this has to really change one's perceiving of the reality. Once you see it, you will not be able to miss it again.


The 2011 has gone and it is a part of the past right now. It is a good moment to stop for a while and look backwards to see what has happened during the last twelve months.

There were two people who messed up in my head in the previous year. I met both on conferences in my home city, Kraków (Cracow).

The first person was Linda Rising. I haven't heard about her before, but she gave such a great prelection on the 33rd Degree, that I decided to dig deeper with her work and I don't regret it.

The second person was Greg Young. I knew him from many publications, videos and podcasts. I was hoping to learn something new and exciting, and I wasn't dissapointed. His workshops during JDD11 were really mindblowing.

The Power of Retrospection

Linda Rising is a world wide known consultant on Agile, Patterns, Retrospectives and others. During the 33rd Degree conference she was talking about Retrospectives. She was speaking very precisely and with great passion. I really enjoyed her lecture.

I never liked Retrospective meetings, since they were boring and I thought that they don't add any value to the process. I guess I've never been on a good one before.

After the Linda's lecture, I realized that each iteration should be an experiment. Each one should be a little different than the previous one. We always have to try to change something, measure it and in the end (during the Retrospective meeting) make the summary and new plans for next experiments.

I remember very clearly when this nice, probably twice older than me, lady was talking about the people who do the best retrospectives in the world... The elder people! Yes, our grandparents! They always tend to look into the past and consider what would they do differently if they were young again, and what they would not change at all. We should learn to look in this same way as they do.

The real mindfuck for me, on the Retrospective topic, was the possibility to adapt those techniques to the personal life - not only at work. Just like our grandparents do...

The Power of toString()

Greg Young is a world wide known IT specialist with many years of experience. During the JDD 11 conference he was leading the workshops about... testing. During three hours we have created our own testing framework based on the top of JUnit, which was doing much more than validating the code.

Let's look at the Smalltalk for a moment. In this language each method invocation is actually a message being sent to the object. And this message is actually a regular object too.

On those messages we can invoke an old and almost forgotten method - toString(). Usually we use it during debugging, or to log something. We don't tend to find it valuable for the business problems. But if we stop for a moment and think how this method can be written in Commands and Domain Objects, we will get a whole new bunch of possibilities. Especially when using Event Sourcing as a storage mechanism.

I won't get into much details about this idea, because I suppose we can read it in Greg's upcoming book "Event Centric".

In general the idea is to bring the toString() method back to business through the tests. We should write our business tests scenarios in a Given-When-Then pattern and then apply this method in an appropriate context.

As Given we can provide collection of Events that were applied earlier, or the Tested Object itself prepared for this particular scenario. We can call toString() on those Events, or directly on the Tested Object and write the output in a file with scenario description. Later we can call toString() on the Command, treated as When, that is beeing sent and append the output to the file. In the end we can call toString() on the Tested Object or on the collection of Events, that were raised during the Command invocation and append the output to the file as Then.

In this way we can easily generate business documentation based on the test scenarios. We can go to our clients and give them the output of our tests - they will be able to actually understand them! After all we are writing test, aren't we? And if we are, then why do not use them for more than quality checks?

The next year...

I expect, that the new 2012 year will bring me much more mindfucks, than previous one. I am looking forward to face that, since there are not so many things comparable to a good blown mind. ;)

And did you experience any mindfucks during the past year?


1 comment:

  1. Great post. Thank you for sharing your knowladge. Inspired me to dig even, when the ground is pretty solid.

    ReplyDelete