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

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

Rockstars

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 →


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

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.freeze
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

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.

Continue reading →


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
    drive
  end

  private

  def hyper_drive; end
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 →


Reek 3 has been released!

My beloved Reek gem has come quite a long way. During the last months we refactored so much of the source code that it almost feels like a new and shiny gem.

Right after the release of Reek 2 we started to work on Reek 3 which we released a couple of days ago.

 A stable API

The changes that I’m most exited about is that we agreed on a public API and implemented it as well. For this API to use you’ll basically just do something like this:

require 'reek'

reporter = Reek::Report::TextReport.new
examiner = Reek::Examiner.new("class Klazz; def m(a,b,c); end; end")
reporter.add_examiner examiner
reporter.show

which would give you this

5 warnings:
Klazz has no descriptive comment (IrresponsibleModule)
Klazz#m has the name 'm' (UncommunicativeMethodName)
Klazz#m has unused parameter 'a' (UnusedParameters)
Klazz#m has unused parameter 'b' (UnusedParameters)
Klazz#m has unused parameter

Continue reading →


How to recruit great developers

I believe there are 3 ways of recruiting when it comes to technology and startups (ignoring agencies and freelancers):

 Nr 1 or the common way: Non-organic recruiting through cold calls and direct search

The “standard” way to do recruiting which probably never works out well for anybody.
Unless you are looking for interns, juniors or freelancers (no offense intended, that’s just the way it is).

There are many reasons why this approach does not work:

  • Developers prefer to be approached by technical guys and not by somebody who thinks that a “javascript” developer easily fits into a “java enterprise” environment I mean, why wouldn’t he, both positions have the word “java” in it ;)
  • Good developers often don’t respond to contact requests from xing and linkedin since their inboxes are already flooded with messages
  • It’s hard for a non-technical person to assess the quality of a developer

Continue reading →


You are what you read - my favorite books

There are a lot of inspirations in my life but books are certainly one of the most important one.

 Books about work and life and everything in between

  • Inventors Dilemma - quite repetitive but the key message was mind-blowing to me.
  • Getting things done - I have my own way of task management which doesn’t have to do much with GTD but I did learn a lot from it for sure.
  • The Lean Startup - my biggest influence waaaayyy back then. Still quoting from it on a regular base.
  • Rework - work less but smarter.
  • Mindset: The New Psychology of Success - after reading this I realized that I was of a “fixed mindset” in so many areas I’d always considered myself to be open-minded. Taught me that “talent” is an illusion and an excuse.
  • Delivering Happiness: A Path to Profits, Passion, and Purpose - funny, witty and honest. Taught me the value of team culture.
  • How Google Works - yes, there is some

Continue reading →

Subscribe to Timo Rößner

Don’t worry; we hate spam with a passion.
You can unsubscribe with one click.

GkrTewSNcmMiVEitLQOx