Florian Winkelbauer

Conference Talks

Pilot Decision Management (Clifford Agius)

The TDODAR framework:



What do we think happened?


What should we do?

Decide - What are we going to do?


Assign tasks to the members of the team


Sharpening the Tools (Dan North)

Become a Software Craftsman:

Novice Programmer

Need rules (not patterns) to guide their way: Don’t ask. Follow this advice and you will be fine.

Advanced Beginner

Do not follow the rules! Find out why the rules are the rules. We are starting to get context - we experience how stuff works.


You become goal oriented. This is a time based thing. Most people become competent if they keep doing something.


This is a deliberate step. Things start to become intuition. Patterns start to become useful. “How can I make this better?”


You are operating of instinct. You don’t think about rules, you “just know”. This is critical: You don’t know how you come up with your decision.

Learn to love meetings (Dr. Neil Roodyn)

Preventing the Collapse of Civilization (Jonathan Blow)

Don’t Walk Away from Complexity, Run (Venkat Subramaniam)

Transactions - Myths, Suprises and Opportunities (Martin Kleppmann)

ACID is more or less a marketing term, it isn’t too precise.


Used to mean that your database is written to an archive tape. When tape bands fell out of fashion, durability was redefined as “fsync to disk”. With the rise of distributed system, durability was redefined once more to mean replication.




Serializable isolation means that the effects of concurrent transactions is as though all transactions were performed in a serial (one after the other) fashion. Each transaction feels as if it had the whole database for itself.

Databases have different default and maximum isolation levels. These levels are:

Race conditions:

How did we end up here (Todd Montgomery & Martin Thompson)

It’s about time (Christin Gorman)

The basic time library in your favorite programming language might be horrible. Why? Because they tend to mix two very different concepts:

What time is it? 1532428776. No, I mean what time is it? Well, that depends. Which epoch do you mean?

.NET1 Jan 0001
Windows1 Jan 1601
Unix1 Jan 1970
GPS5 Jan 1980

A timestamp on Windows means something completely different than a timestamp on Unix!

Time synchronization (clock drift correction) is the reason why Windows does not guarantee, that the system time increases monotonically. So you shouldn’t use it. Instead, use something different like the current tick count, or use your own sequence number.

UTC (which stands for Coordinated Universal Time) is an effort to create a system on which we can all agree.

Coding advice:

PID Loops and the Art of Keeping Systems Stable (Colm MacCárthaigh)

Control theory:

Present -> Observe -> Feedback -> React -> (Present)

A furnace is a classical example of applied control theory: you want to keep water at a specific temperature. So what do you do? You measure the error (e.g. the water has 20°C, it should be 100°C, so the error is 80°C) and react with correcting actions based on the error. To do this, we distinguish three types of controllers:

P Controller

PI Controller

PID Controller

Anti Patterns

Using open loops is scary. The system cannot detect a problem. Chaos engineering and observability are fine practices to find open loops. Open loop systems tend to be imperative (do this, do that), while closed loop system tend to be declarative (please get the system into my defined desired state).

Power laws are out to get you. A system failure can spread in an exponential way. These failures can be kept in their cages by building smaller systems (which decrease the overall “blasting radius”). Other techniques include:

Sudden load spikes can bring down a system. In general: keep your queues short. LIFO queues might be a good idea, as they will prioritize new information.

Implementing edge triggered systems imply, that you have solved the “deliver just once” problem. Level triggered (and idempotent) systems seem to be a simpler solution.

Big Numbers and the 1Hz CPU (Tom Hudson)

We do not have a good intuition for how fast different parts of a computer are.

Let’s have a look at a 3ghz CPU and different access times:

All these values seem “low enough”, but let’s but them into perspective using a 1 Hertz CPU:

Design, Composition, and Performance (Rich Hickey)

Thinking Fast and Slow (Linda Rising)

System 1:

System 2:

We identify with System 2 and we believe, that System 2 is in charge.

System 1 gains its speed by using heuristics. It is also in charge of “telling our story” in which we are identified as the hero. System 1 is prone to biases such as:

We overestimate our own understanding and underestimate the role of randomness in our world. We seek for patterns and explanations, even if there aren’t any.

System 2 can only focus for about 50 minutes (max) before taking a break.

We use System 2 to learn something new. Over time, a certain skill moves to System 1 (e.g. walking, driving, or playing an instrument). After is has moved to System 1, interference from System 2 can hurt our performance by “overthinking”.

System 2 takes a lot of energy. Self control causes a drop in your blood glucose. We have a limited pool of “mental energy”. This is why we tend to make worse decisions when tired or hungry.

System 2 believes that it runs the show, but System 1 is in charge! And that’s good. You don’t want to trust a system which lets you forget your keys to care about essential tasks such as breathing.

Better Meetings:

Mistakes and Discoveries While Cultivating Ownership (Aaron Blohowiak)

Netflix Culture:

Levels of Ownership:

  1. Demonstration: No ownership
  2. Oversight: You do it, but we will pre-approve it
  3. Observation: You do it and we will review it after it is done
  4. Execution: Here’s where we want to go and we know that you will pull it off. We might check just so that we know what’s going on
  5. Vision: You understand your responsibilities and your shareholder’s needs


Changing your Habits & Environment to get more Professional Productivity (Linda Rising)

Functional data that adapts to change (Don Syme)

A Cheap Effective Method for Dealing with Stressful Situations (Linda Rising)

If (domain logic) then CQRS, or Saga (Udi Dahan)

Cultivating Architecture (Martin Fowler, Birgitta Böckeler)

What I learned from three years of sciencing the crap out of DevOps (Jez Humble)

Files (Dan Luu)

Optimize For Time (Andy Walker)

Conversational Transformation (Jeffrey Fredrick, Douglas Squirrel)

Conversational Analysis with The 4 Rs

Continuous Retrospectives (Linda Rising)

Solving Problems the Clojure Way (Rafal Dittwald)

Persistent Data Structures and Managed References (Rich Hickey)

End to end functional tests that can run in milliseconds (Nat Pryce)

Design Microservice Architectures the Right Way (Michael Bryzek)

Key points:

Entity Component Systems and You: They’re Not Just For Game Developers (Paris Buttfield-Addison, Mars Geldard, Tim Nugent)

Programming Is The Easy Part (J. B. Rainsberger)

A lot of high level software design principles boil down to a linear combination of “remove duplication” and “improve names”.

Modern SQL A lot has changed since SQL 92 (Markus Winand)

SQL has changed a lot, though most developers only know the 1992 standard

Testing as an equal 1st class citizen to coding (Jon Jagger)

Technical Leadership and Glue Work (Tanya Reilly)

The Only Unbreakable Law (Casey Muratori)

Improving eBay’s Development Velocity (Randy Shoup and Mark Weinberg)

Uncoupling (Michael Nygard)


Kinds of Coupling


Make Impacts Not Software (Gojko Adzic)

Protect Yourself Against Supply Chain Attacks (Rob Bos)

Monitoring Is Not Observability (Baron Schwartz)

Working at the Center of the Cyclone (Dr. Richard Cook)

Resilience In Complex Adaptive Systems (Dr. Richard Cook)

How Complex Systems Fail (Dr. Richard Cook)

Sleeping with the enemy (Gojko Adzic)

Some quotes:

Diagrams as Code 2.0 (Simon Brown)

Software Architecture, Team Topologies and Complexity Science (James Lewis)

More Speakers