Sander Hoogendoorn is an independent dad, avid traveler, and lifelong software developer. With over 40 years of hands-on coding experience under his belt, he still ships code every day — because once a developer, always a developer.
Currently the CTO at iBOOD, Sander has led technology at companies such as ANVA, Quby, and Klaverblad, and was once Capgemini’s global agile thought leader. But don’t expect corporate buzzwords—Sander’s known for cutting through the fluff with a post-agile mindset and a healthy disregard for outdated best practices.
He helps teams and organizations break rules that need breaking — replacing heavyweight processes with lightweight thinking, and agile dogma with actual flow. If something’s slowing your team down, chances are he’s already ranted about it in a keynote.
Onstage, Sander brings code, stories, and sharp insights—whether he’s talking disruption, continuous delivery, microservices, monads (yes, really), software architecture, or the lost art of elegant code. His talks are fast-paced, thought-provoking, and never just theory.
Sander believes in small steps, critical thinking, and building stuff that works. No silver bullets. Just better software, made by better teams.
After five years of building, breaking, and learning at iBOOD, we’ve discovered what makes a development team truly successful. No frameworks, no dogma—just seven practical habits that help teams ship great software, stay motivated, and keep improving.
This talk is based on real experiences, not theory, nor agile BS. We’ll dive into:
- Prioritizing Pragmatically Balancing business needs, technical debt, and innovation.
- Killing Complexity Keeping architecture, code, and processes simple, even as you scale.
- Owning the Work Why autonomy beats process, and how teams can take real ownership.
- Communicating Relentlessly Why constant, transparent communication makes everything smoother.
- Building Microteams Why smaller, focused teams move faster and collaborate better.
- Delivering Continuously Making small, frequent releases a habit (without the chaos).
- Having Fun Because happy teams build better software. An afterthought about purpose, mastery, and autonomy.
I’ll share stories from the trenches—what worked, what failed, and what we’d never do again. If you’ve ever wondered how to build a team that doesn’t just survive but thrives, this talk will give you concrete ideas to take back to your team.
Even after decades of programming, I’m still surprised at how some ideas can fundamentally reshape how we write code. For the past ten years, monads have done precisely that—for me, and many developers I work with.
It started with a small experiment: porting Scala’s Try monad to Java to clean up messy error handling. This quickly became a habit. Monadic code—built around chaining, pure functions, and predictable behavior—proved easier to reason about, more robust, and far simpler to test.
Since then, we’ve built and open-sourced a range of monads, and we now approach most of our logic functionally. It’s become a sport to start methods with a return, avoid nulls, eliminate ifs, and skip try-catch blocks altogether.
This talk is a practical, hands-on introduction to monads—not in theoretical Haskell terms, but in everyday Java, C#, and TypeScript. You’ll see real code and tangible benefits and leave with techniques you can apply immediately—even if you’re still suspicious of the M-word.
You’ll Learn:
- Why functional thinking leads to more predictable code
- What pure functions are, and why they matter
- What monads are (really), and how to recognize them in your code
- How to use monads like
Try,Option,Maybe, andChooseto write cleaner, safer logic - How to apply these ideas across languages and platforms, with live examples
If you’re tired of nulls, nested ifs, and repetitive error handling, this talk will change your thoughts about flow, failure, and functional design.
Searching for speaker images...