conference, Development, Self-Improvement, Self-Learning

SocratesBE ’19 unconference diary

This weekend I had the opportunity to visit my favorite work event of the year: a socrates unconference. This is a quick brain dump of the things I learned in sessions, hallway discussions or over a drink. My goal is not to give a full overview of the topics covered during the sessions, but rather showcase what a typical day at a Socrates unconference could look like in case you are on the fence about attending one in the future.

Socrates unconferences use the open space format, this means that there is no predefined schedule. People just show up & share their own ideas for sessions in the morning. After some self-organization we end up with the schedule for the day. The next day this pattern repeats. It’s amazing to see how sessions and discussions during the first day often result in totally fresh session proposals the second day.

Day 0: meeting up

The unconference started on Thursday evening. We got to check into the hotel & met up in the bar for some drinks. Although not officially “started”, I already had enlightening discussions on:

  • Consulting & coaching experiences. E.g: “Is it worth paying a consultant 1000$ for a day of consulting, even if he’s just there to repeat the same exact message the employees have been giving management for years?”. Or: “When you are coaching a team on scrum practices, it might help to deliberately break eye contact as a scrum master during stand ups so team members learn to talk to the team instead of the scrum master”. You don’t learn this stuff from a book.
  • During dinner my table discussed how people learn & how coaches can leverage this. We discussed the Dreyfus model of skill acquisition, deliberate practice & Shu-Ha-Ri.
  • At night we had an interesting discussion on philosophy: Husserl, Effective Altriusm, …

Day 1

I was down with migraine for the first part of the day, but I managed to follow sessions in the afternoon. In that short timespan however, I was exposed to a ton of new ideas:

Lift pass kata
A hands-on session on the lift pass kata where all attendees got to wrap tests around & refactor a typical REST api.
Personal take-aways: Docker refresher, practice on writing tests against a real http endpoint & refactoring legacy code tips & tricks.

Wardley maps kata
Another hands-on kata session, but on a completely different topic: Wardley maps. Wardley maps are awesome. They are about building an intuitive and shareable understanding of your context to provide the situational awareness necessary for building a sound strategy. I read up on them but had never attempted to draw one myself. The session facilitators gradually eased us into creating our own map for a fictional business.

  • First, we were asked to think about the value chain. What capabilities are needed to satisfy our user needs? How are they related?
  • Next, they introduced the vertical axis: how visible is this capability to the end user?
  • Third, we got to think about the horizontal axis that represents the stages of evolution of a capability.

I thought I understood maps on a rational level, but drawing one myself really made it click. Recommended exercise to run for your own business!

Talk like Sandi Metz
Perhaps my favorite session of the day. We got together to watch one of Sandi Metz’ amazing talks. Do yourself a favor & go watch her stuff if you haven’t already. I’ll wait.

The point of this session wasn’t the talk’s content however. Instead we were observing what makes her talks so effective & fun to watch. Everyone took notes & we had a small group chat in the end sharing our observations. Some of the ones that stuck with me I will be copy-catting in future public speaking engagements:

  • She uses body language effectively. Not all over the place, but it adds to her story.
  • Her talks are very visual. She uses code diffs, arrows pointing to the relevant lines & color highlights to walk you through refactorings effectively.
  • She regularly shares personal experiences & stories. She also shares when she did something “frowned upon” or considered “bad practice”. This makes her instantly relatable & sincere.
  • She stimulates audience participation by asking several questions.
  • She often repeats her overview slides so you know “where we are” in the talk.

Evening activity: code smell quiz
In the evening, Matthew & Pedro hosted a code smell quiz. For more information, Matthew has written up a previous run on his blog. This is a great exercise to do with your own team!

Day 2

This image has an empty alt attribute; its file name is img_20191116_113226.jpg

Connascence kata
In this session we learned about connascence (i.e. a taxonomy for different kinds of coupling) through a fun kata. You can find a first draft of the kata description on Aki’s github.

Behavioral code analysis
In this session several people shared their experiences with codescene & behavioral code analysis techniques, i.e. techniques you can use to mine your git logs for interesting insights like “If X leaves the team tomorrow, which parts of the code present the biggest knowledge loss risks?” or “what parts of the code present a relevant risk to feature delivery?”. More info on Adam Tornhill’s blog.

Mob code review
During this session all attendees reviewed a piece of code together. It was really interesting to see how other people do reviews: Where do they start to look? What do they focus on? Do they list pure observations or make interpretations? Do they provide possible solutions? Do they provide links to further reading?

Personal take-aways: try to keep it as objective as possible. Instead of “this feels dirty”, try to describe in terms of naming issues, SOLID violations, connascence, code smells, etc.

Refactor some messy java mob session
In this session we grabbed a random piece of Java code and refactored it in group. Again, it was really interesting to see how others tackle these kinds of problems.

Design heuristics
In this session we were presented a design problem. Instead of only thinking about solutions, we were instead encouraged to think about what kinds of heuristics we use when solving problems. A lot of problem solving happens based on “intuition”. This session was an attempt to elucidate these implicit heuristics we use all the time. Most heated design disagreements are caused by people using different (implicit) heuristics. Once made explicit, you can constructively discuss the competing heuristics and even re-use them in new contexts. Some example heuristics we came up with:

  • Consider if it is easier to throw away irrelevant information than to reconstruct missing information.
  • Consider the reversibility of options when making a decision.
  • Consider picking the option that delays the choice.
  • If given a binary choice, consider if there are other options not presented.

This led to some really interesting discussions & a whole new set of heuristics I will be using in any future problem solving. More information on Rebecca Wirfs-Brock’s blog.

Impromptu Lightning talks
Lightning talks are my favorite part of the unconference. For 7 minutes, the floor is open to anyone that wants to share something. Topics range from a 7-minute introduction to system thinking, sharing an insight you had while working on some code during the day, to a a visual representation of the Dunning-Kruger effect. Or maybe even showing off your react app that simulates cellular automata or sharing a very personal story that managed to silence an entire room of people.

On the side
During the entire event there were a lot of other activities: attendees brought great aeropress coffee, we had an optional whisky & chocolate tasting, people played board games (playing Azul with people that do programming & maths for a living is hard!), we listened to live folk music. There might even have been some folk dancing 🙂

In summary
As always, I had an amazing time & hope to have helped in creating a welcoming environment for all the new faces. I have never encountered a group of people that are this passionate about what they do & want to share their insights, that are this considerate of other people.

To put it in the words of Jessica Kerr: I have found my camerata.

Standard
Development, Self-Improvement

Reclaiming Refactoring

We need to talk about refactoring. Or rather, about the frequent misuse of the word, the dangers this encompasses and what we can do about it. Time to reclaim what is an intrinsic part of software development!

As with many words in the English language, people use the word refactoring for different concepts. It’s a human thing to do, but it keeps surprising me how open for interpretation most terms are in a “scientific” field like computer science. Just try to Google an exact definition for the concept of a unit test: you’ll find about as many interpretations as there are people writing about it.

Continue reading

Standard
Development, Functional programming

Exploring data and API’s with F# type providers

This post highlights an F# feature called type providers that makes my life as a software developer easier. Ever had to parse some JSON? Explore a shiny new REST API? Maybe you’ve had to quickly try out an undocumented SOAP service?

Imagine you could talk to any kind of service or interact with any kind of data in your regular IDE, using the full capabilities of a static type system with minimal fuss. No need to generate proxy client code from .wsdl files, no need to reference any Nuget package. With some help from F#’s type providers, It just works™!

Introduction

I’ve been looking to introduce F# in my daily workflow. As a consultant, I often don’t get to pick the programming language I work in. As a result, my experiences with F# are limited to side-projects or throwaway code that doesn’t get committed to version control. One area where F# and its ecosystem are really practical and even outperform alternatives is in exploring data and services, both in the broad sense of the term. Say you have to integrate with a third party REST API that provides little-to-no documentation. F# provides a magical feature called type providers that allows you to explore this API with static types, minimal fuss, and all the features you’ve come to rely on of your trusty IDE. It’s the perfect way to get started with functional programming in a .NET environment.

Continue reading

Standard
Best practices, Self-Improvement, Self-Learning

Starting in an ongoing software project

Monday morning, 6 AM. You vault out of bed and into the shower, pick out your nicest outfit and leave for work. Finally, a new project. A breath of fresh air. The excitement of starting on a new team. The joys of digging into an unfamiliar codebase! 

In this post I provide some techniques I use to get a grasp on a new codebase fast. It’s always fun to start a new green-field project, but let’s be honest for a moment and acknowledge the fact that most projects you will work on as a software developer will start from an existing codebase. These tips and tricks will help you hit the ground running, even when you land in a muddy brown-field mess.

Continue reading

Standard
Best practices, Self-Improvement, Self-Learning, Testing

Legacy code retreat

Have you ever worked with code that literally brought tears to your eyes? Not in the good sense, mind you. I’m talking about code that is such a hassle to work with it makes you rethink some of your career choices. If that’s the case, a legacy code retreat might be just what you need to stop your fear of legacy code and instead start to appreciate the opportunities for improvement it provides. Legacy code can be a joy to work with, if you tackle it the right way.

Continue reading

Standard
Continuous Delivery, Security, Self-Improvement, Web Development

Techorama 2014 takeaways

Last week I attended the very first installment of Techorama, a new conference for developers hosted in Mechelen, Belgium. This post will walk you through my experiences of the conference and will highlight the most important takeaways from the various talks I attended.

General impressions

The conference had tracks on ALM, Mobile, Web, Cloud, Language & Tools, Sharepoint & SQL and best-of Build 2014. I mostly attended the Web and ALM tracks since they are most relevant for my current work, but I dabbled in the other tracks here and there. I expected this conference to be heavily Microsoft-oriented but it turned out that there were a lot of non-Microsoft specific talks. As a matter of fact, it would have been entirely possible to schedule your conference without attending a single Microsoft-specific talk.

Most of the talks I attended were high-quality presentations. The booth hall had some entertaining side tracks and there was a lot of swag up for grabs. The food was delicious (warm meals instead of the usual sandwiches!). Overall there was a very good vibe during these two days.

Continue reading

Standard