Technical Coaching

I am available for technical coaching. Contact me for setting up an initial workshop.

I use a combination of teaching specific techniques and then pairing/ensembling with the client to apply the learned techniques in their production code. For more on the general setup, see the Samman Technical Coaching website.1

My coaching is specialized around

  • reducing complexity by using functional programming principles, and
  • writing better tests and managing tests effectively.

Functional programming and effective testing go hand in hand. Functional programming tends to reduce the complexity in the code base, resulting in simpler and less brittle tests. At the same time, testable code drives the code base to use more pure functions.

Writing better tests

I help developers learn how to effectively manage tests. There’s an art to writing tests that don’t end up feeling like they work against you instead of for you, and it involves some key skills:

  • How to write tests, and which tests to write, for new code.
  • Managing tests while refactoring. (Yes, it’s a thing.)
  • Implementing changes in requirements without breaking existing tests.

The last skill is the hardest, and requires the other two skills plus a highly decoupled design. Functional programming removes several (but not all) mechanisms that introduce coupling compared to imperative paradigms, which is why I do functional programming whenever feasible.

Functional design/programming principles

The transition from thinking imperatively to thinking like a functional programmer is quite a challenging one if done alone. There is a multitude of tutorials on how to replace for loops with the higher-order functions map, filter, and reduce, but much fewer about how to deal with side effects and model state at application scale; and that is where reduction of complexity/coupling matters the most.

I have three tiers of FP training:

  1. Introduction to FP: understanding immutable data, pure functions, and composition.
  2. Beyond map, filter, and reduce: how to scale up immutability and purity to application level.
  3. Abstraction and interpretation: how to deal with side effects, and express domain operations at the appropriate level; “inverted dependency inversion”.

Together with good tests you end up with a system where changes are fun rather than frustrating.


  1. I am a board member of the Samman Technical Coaching Society. ↩︎