Handling conflict in your team

When you're From the moment you’re not working alone on something, you’re bound to have some conflicts. This is normal and healthy!

As technical (and maybe more introverted) people, we might tend to avoid these conflicts. But we shouldn’t shy away from them. Take it from someone who is conflict averse.

We should have more conflicts in our life and work, not less. This might sound strange but conflicts themselves are not the problem, it’s how we deal with (or avoid) them that makes things better or worse.

We’ll be exploring some ideas to stop hiding from conflicts and techniques to handle them better. The goal is to improve team collaboration and trust in each other.

Will the real CQRS please stand up: Separating Fact from Fiction

CQRS is one of those patterns/architectures/designs that is easily misunderstood. The basic idea of "separate your reads from your writes" is simple. But it's too simple, it allows for too many misconceptions: the use of separate data stores, caching, eventsourcing, eventual consistency...

Let's take a step back and start from the essence of CQRS; what you should do; what you can do but be aware of trade-offs.

We'll also have a look at different implementation possibilities in .net.

Let's get back to the basics and see which CQRS is the real one.

How to Give a Talk Without Losing Your Cool

Ever felt like the idea of giving a talk sends you into full-on freakout mode? You’re not alone! Join us for a light-hearted yet practical session where we bust the myths that keep you off the stage and share the secret sauce to delivering a killer presentation.

We’ll cover everything from choosing a topic that makes you say, "Heck yes!" to mastering the art of not just speaking, but storytelling. Learn how to keep calm and carry on with breathing techniques that would make a yoga instructor proud, how to use visuals that actually help (and not just fill up slides), and how to prepare like a pro (spoiler: it’s more than just hitting ‘next slide’).

By the end of this session, you'll be ready to step up to the mic with confidence, a story to tell, and maybe even a laugh or two. Because let’s face it—public speaking doesn’t have to be a nightmare. It can be your next big win!

By the way, introverts give the best talks. I know because I'm one myself.

Log It Like It's Hot: Unleashing the Superpowers of Logging

Dive into the underestimated world of application logging. This talk sheds light on how logging, often less appreciated than unit testing, can be transformed into a powerful tool in your development arsenal.

Discover practical tips and tricks to elevate your logging from mere text files to a proactive, insightful resource. Learn how to automate logging to simplify troubleshooting and predict issues before they escalate. We’ll discuss how to make your logs not just informative but actionable, turning them into a first line of defense when production environments go awry. We'll also dive in logging and tracing for your microservices and other distributed systems.

I’ll guide you through the nuances of modern logging practices, from implementing structured logging for better data analysis to smartly handling sensitive information. This session is ideal for developers and IT professionals seeking to enhance their logging strategy with efficiency and foresight.

Join me for a concise, insightful exploration into making logging an integral, dynamic part of your development process. Leave equipped with the knowledge to transform your logs into a valuable asset, ready to tackle any challenge that comes your way.

Death to the repository

A highly opiniated talk about the non-existant purpose of the repository in an age of Entity Framework. How it just complicates and adds useless code that has no added value for our users. Although there might be one valid use-case...

Selling your ideas

Have you ever tried to convince others, colleagues or managers, of your great idea? Everyone must see that your this is a great idea, it will improve the current way of working 10x. You used passion, logic reasons, numbers, success stories. But they weren't interested?

Convincing people of your idea can take more than numbers and logical reasons.

Let's explore some easy to use tips and tricks to improve your chances to sell your ideas and get them implemented. Whether you're in a leadership role to convince your team or selling it to higher management.

How to outsmart the Great Chinese Firewall with just your browser

The developer tools of the browser can do much more than just show errors in the console, see network traffic or debug an application.

This session shows how I managed to get a half working website usable from behind the Great Chinese Firewall using just the developer tools. No VPN, proxies or any other advanced developer tools.

This is a short talk, 15 minutes, 30min max.

The Estimation Paradox: Why They're Always Wrong but Still Matter

"When will it be done?" Probably the most dreaded questions a developer can receive.

Whether it’s for a task we’re currently working on or an estimate for a client project, we hate this question. Why can’t they just let us do the work? It’ll be done when it’s done.

Unfortunately, it doesn’t work like this in the real world. Nobody wants to write a blank cheque. When we’re building a house, we also want to have an estimate of the budget and when it will be done.

Estimates are, by definition, always wrong, but they do serve a purpose. At least when used wisely.

In this talk we'll discover:
- Why estimates fail
- How to confront our fears and how to overcome them
- How to use them correctly and make them more accurate
- How to make them less painful and use them for improving our work

Whether you’re estimating a detailed user story or a flimsy two-page project brief, this session will give you tips, tricks and skills to face the estimation paradox.

Enforcing decisions and guidelines in code

Any software project needs some standards and guidelines. These "conventions" can cover code style, architecture, best practices and common mistakes or issues.

All of these could be found in code reviews. but could also be easily missed. These are also the "easiest" to spot and real issues (business, logic, performance...) might go unnoticed.

In this talk we'll cover how we can automate detecting the easy stuff so we can focus on the hard parts. We'll be covering and automating the following items:
- enforce code styling
- verify architecturel conventions
- check best practices
- avoid mistakes

To do this we'll be implementing tips and tricks using:
- standard .NET tools
- architecture (unit) tests
- code analyzers and fixers
- build pipeline checks

All these enforcements are not to limit creativity but to remove wasted time and have more time for the creative or hard work.

This is suited for developers and architects who want to have more time for the creative part of our work.