Timo Rößner

Life-long student, part-time failure, avid creator, hopeless humanist, softcore objectivist, amateur scientist. And professional rocketeer.
Director of Platform Engineering (Berlin) at Planet and maintaining the awesome Reek gem.

Read this first

Why does the universe favour the creation of life?

Pulling together a couple of more or less sound assumptions I had this slightly odd thought that the universe is trying to come to an end as fast as possible by creating life as the ultimate means to this end in order to return the energy that was borrowed in the course of the big bang.

I am taking the following for granted:

  • As the second law of thermodynamics states, entropy is and will always be increasing (for a beautiful explanation for the layman check out this video from Steve Mould)
  • This will ultimately result in the heat death of the universe, which means that everything is at (roughtly) the same temperature. This is the ultimate level of disorder; if everything is at the same temperature, no work can be done, and all the energy will end up as the random motion of atoms and molecules.

Now let’s look at a couple of wilder claims:

  • Living matter will increase entropy faster...

Continue reading →

So what’s the whole point of everything?

“What is the purpose of life?” is a question that probably keeps every human busy that has even a minimum amount of self-reflection.

A lot of people choose religion to answer this question. To each his own - I’m an atheist so that wasn’t an option for me. My idea of the purpose of life is quite simple: It’s life itself. There is no deeper meaning. Life - and that means all forms of life - is the most important thing in this universe.

But it’s not just life alone. A life alone is kind of pointless. There are countless studies that show that people are social beings and you can even die from loneliness. This did surprise me and to this day I can’t understand how it ever could surprise me. Werner Heisenberg theorized that maybe quantum particles are only observable when they interact with each other, so in a certain sense, they only exist when they interact, and I like to think that it’s...

Continue reading →

The Rockstar-Ninja-Coder and you. A layman’s guide how to not hire them


Image source

I have been doing tech recruiting for start-ups over the last 10 years and oh boy, did I fuck up a lot. On the plus side of things, I did also learn a lot about human behaviour, hiring bias and common misconceptions about what constitutes a “good” team member.

I have seen the biggest douche bags called the “top performers” and the actual performers “constant underachievers”. Actually that’s a pretty common topic I have seen across many organisations. Human perception is pretty freakin’ bad. We overvalue merits that are tangible and undervalue merits that are kind of fuzzy. Take the “rockstar developer” for instance (sometimes also called a ninja). People refer to a “rockstar developer” as to somebody that is exceptionally skilled and that literally carries the whole company on his back. Unfortunately that’s not all: A “rockstar” is a rockstar for a reason and only rarely...

Continue reading →

Kill all the mutants - a deep dive into mutation testing and how the Mutant gem works

As part of a presentation I’m hoping to give at the end of this year about abstract syntax trees and how you can leverage them I started to look into how the Mutant gem works. Mutant is the by far most advanced gem for doing mutation testing in Ruby. I was (and still am) amazed how incredibly well built it is on all levels, ranging from the “big picture” architecture down to the “nuts and bolts” source code.

When it comes to mutation testing I learned one thing. It’s complex. Really complex. And as a consequence, Mutant is complex.

I did learn a lot from reading its source and I’d like to share this with you.

Beware though, this is going to be a long ride.

This article will probably take you at least half an hour to an hour. But at the end, it’ll hopefully be worth your while.

 Mutation testing in a nutshell

Let’s quickly talk about what mutation testing is first.

Quoting from...

Continue reading →

You are what you read, watch and listen to

My scratchpad to keep track of my biggest inspirations in terms of books, newsletters, articles and videos.

 Books about science

  • Superintelligence. Mindblowing.
  • Seven Brief Lessons on Physics. A truly wonderful book.
  • We Have No Idea: A Guide to the Unknown Universe - Popular science has never been better.
  • Riemann’s Zeta Function. I’m still at chapter 2 after 2 years, but whatever.
  • Reality Is Not What It Seems: The Journey to Quantum Gravity. Same author as “Seven Brief Lessons on Physics”. Brilliant.
  • Seven Brief Lessons on Physics
  • The Millenium Problems
  • Fermats Last Theorem

 Books about computer science

  • Building Microservices- There are quite a few good books out there about Microservices, but I consider this to be the bible of microservices.
  • Practical Object Oriented Design - probably the best book I ever read about OOP.
  • Clean Code - I don’t agree with quite a few chapters...

Continue reading →

Lessons learned from some of the best Ruby codebases out there (part 3)

(Important note: This was originally published on the Blacklane dev blog - I’m just putting this up here as kind of mirror)

Welcome to the third part of the series - you can find the first part here and the second part here.

In this part I will again focus on some other highly interesting gems Mutant uses, in particular the Abstract Type gem and the Adamantium gem.

 Abstract Type

The Abstract Type gem allows you to declare abstract type classes and modules in an unobstrusive way:

In programming languages, an abstract type is a type in a nominative type system that cannot be instantiated directly. Abstract types are also known as existential types.An abstract type may provide no implementation, or an incomplete implementation. Often, abstract types will have one or more implementations provided separately, for example, in the form of concrete subclasses that can be instantiated. It...

Continue reading →

Lessons learned from some of the best Ruby codebases out there (part 2)

(Important note: This was originally published on the Blacklane dev blog - I’m just putting this up here as kind of mirror)

Welcome to the second part of the series (you can find the first part here).

We’ll continue to look at some other highly interesting gems Mutant uses.

Initially I had planned to cover multiple gems again, but after starting to look into the IceNine gem I realized that this was big enough for its own blog post.


IceNine is a library for deep freezing objects:

hash_1 = { 'key' => 'foo' }

hash_1.frozen? # => false
hash_1['key'] = 'bar' # => "bar"

# Let's freeze it

hash_2 = { 'key' => 'foo' }

hash_2.frozen? # => true
hash_2['key'][0..2] = 'bar' # This works, so the hash is not deep frozen

# IceNine deep freezes in contrast

require 'ice_nine'

hash_3 = { 'key' => 'foo' }

IceNine.deep_freeze hash_3
hash_3.frozen? # => true

Continue reading →

Lessons learned from some of the best Ruby codebases out there (part 1)

(Important note: This was originally published on the Blacklane dev blog - I’m just putting this up here as kind of mirror)

I recently started looking into Mutant and related gems for an upcoming presentation about abstract syntax trees I am working on at the moment.

While browsing the source code of Mutant and of the gems that Mutant uses I realized that those codebases are among the cleanest code bases I have ever seen in Ruby land with an amazing overall architecture and I’d love to share what I’ve seen and learned reading their code.

I intend to make this a series with the first part of this series not covering Mutant itself but the gems it uses.

Let’s get started with *Mutant*s gem dependencies.


Concord is a nice little library that helps you turning this:

class ComposedObject
  attr_reader :foo, :bar
  protected :foo; :bar

  def initialize(foo, bar)
    @foo = foo

Continue reading →

How to use github to evaluate developers

A couple of days ago I gave a presentation titled “How to use github to evaluate developers” for HR guys / girls and recruiters at the HR in tech event at Zalando organised by honeypot.

It was overall a pretty awesome event and it was fun for me to be part of this.

You can find my slides on slideshare.

Zalando also published the talk on their youtube channel.

View →

The latest and greatest additions to Reek

2015 has been an awesome year for Reek. With the release of Reek 3 we reached a level where I’d call Reek a stable, mature and - if used right - an incredibly useful library.

We have been quite busy since the Reek 3 release - here are my favourite features we have added to Reek since then:

 Unused private methods

Reek now detects unused private methods and warns you.
Code like this:

class Car
  def start


  def hyper_drive; end

would cause Reek to emit:

1 warning:
  [8]:UnusedPrivateMethod: Car has the unused private instance method `hyper_drive` [https://github.com/troessner/reek/blob/master/docs/Unused-Private-Method.md]

Right now this smell detector can only recognise unused private instance methods - we plan to expand it to class methods as well in the future.

 Deactivate UtilityFunction for private methods

Quite some users complained about the...

Continue reading →