Speaker

Dennis van der Stelt

Dennis van der Stelt

Distributed Systems addict

Rotterdam, The Netherlands

Dennis is a Software Architect who loves building distributed systems and the challenges they bring. To always be better than the day before, he continuously searches for new ways to improve his knowledge on architecture and software development. He shares what he learns in numerous articles, presentations, and blog posts.

If you want to chat, feel free to ping Dennis on Twitter at @dvdstelt

Area of Expertise

  • Information & Communications Technology

Topics

  • Architecture
  • Domain Driven Design
  • Event Driven Architecture
  • Messaging
  • SOA
  • DDD
  • Distributed Systems
  • microservices
  • Cloud Computing

Autonomous microservices don't share data. Period.

Are you building a monolith using microservices? If a small change in business logic or in data requires you to modify code in more than one service, you probably are. Isn't it unbelievable that even using the latest technologies like .NET Core, containers, serverless and more doesn't help? In this session we'll discuss why technology doesn't change coupling. We'll have a different look at microservices. One where they'll truly be autonomous and not share data at all.

Unique session of 350 slides that I go through in 40 minutes and then possibly present demos. It was build using the Lessig Method Presentation Style. It teaches a different style of modeling your architecture.

Microservices done right

Go beyond the hype and build a solid foundation of theory and practice with this workshop on SOA and microservices development.

Join for a deep dive covering architectural topics like:
- UI decomposition
- Vertical slices & bounded contexts in practice
- Data ownership across the enterprise

You’ll also learn the nitty-gritty details of building production-ready systems including:
- Fault tolerance
– HTTP and queues
- Scalability, high availability & monitoring

Finally, get some hands-on experience in SOA development by building:
- Scalable command-processing endpoints
- Publish/subscribe event-processing interactions
- Long-running multi-stage business processes and policies

We’ll understand service oriented architecture concepts, and DDD concepts such as bounded contexts and data ownership.
We’ll apply those concepts to build a simple, yet fully functional, order management system sample with a microservices architecture, using patterns such as command processing, pub/sub, and long-running sagas.

Dealing with eventual consistency

As software architects we want to make our systems more performant, maintainable, understandable, or any other thing-able. We use infrastructure like Azure Service Bus or Service Fabric. Maybe we’ll introduce patterns like CQRS and Event Sourcing. Many of these choices introduce eventual consistency, but users expect immediate consistency. They don’t want to wait for eventually. They expect feedback now. There are, however, ways to work around this.

So what exactly is eventual consistency and how can we make it work? In this session, we’ll have a look at different patterns, both in the user interface and the back end, that give our users immediate feedback even though the back-end system is not. We’ll discuss how to solve the complexity of dealing with eventual consistency, without sacrificing decomposability or performance.

Coding event driven microservices

It's been 10 years since microservices were introduced and by now we've all tried to build them, making them as small and autonomous as possible. But more and more it seems like we're building a distributed monolith. In this session we'll take a business process and starting from scratch, develop our microservices to turn it into a working solution. The end result will demonstrate how we will be able to create loosely coupled microservices that are maintainable, testable and easily deployable.

Change your architecture during deployment

Many systems start with diagrams of boxes and arrows and the promise of high consistency and low coupling. The boxes are supposed to be loosely coupled components, but each arrow often results in a highly coupled dependency at runtime. What if we can do something about it… during deployment?

In this webinar, we’ll identify design decisions that influence your system’s behavior both at design-time and run-time. We’ll observe how changing your design during deployment gives you many opportunities for making trade-offs to improve function and performance and gives you the information you need to shape your system architecture.

Event Driven microservices in vertical slices

Did you build your system using microservices but ended up with a distributed monolith?

In this workshop, we'll go beyond the hype and build a solid foundation of theory and practice on architectural styles like:

- Vertical Slices Architecture
- Event Driven Architecture
- Microservices Architecture
- Service Oriented Architecture

Without making your system even more complex and unmaintainable, actually look at how we can solve those problems, covering topics like:

- Data ownership across the enterprise
- Fault tolerance of our processes, transactions, and data
- Scalable event-processing endpoints
- Long-running multi-stage business processes and policies

You’ll better understand architectural concepts and DDD concepts such as bounded contexts and data ownership.

We’ll apply those concepts to build a simple, yet fully functional, order management system sample with a microservices architecture, using patterns such as command processing, pub/sub, and long-running sagas.

Some reviews when I gave this workshop before:

- A dedicated trainer, able to explain architecture topics at the level of the listeners. Each time he explained it from a development perspective with code and correlating it with diragrams for the architectural perspective.
- Amazing job, thanks for taking the time to explain these topics to us. Can't wait to apply this knowledge.
- Fun trainer, has a lot of knowledge and lots of experience. It shows.
- Information was interesting and presented clearly. Trainer's enthusiasm and passion was clearly visible.

NDC Porto 2023

October 2023 Porto, Portugal

Techorama Netherlands 2023

October 2023 Utrecht, The Netherlands

KCDC 2023

June 2023 Kansas City, Missouri, United States

Techorama Netherlands 2022

October 2022 Utrecht, The Netherlands

NDC Oslo 2022

September 2022 Oslo, Norway

Developer Week '22

July 2022 Nürnberg, Germany

Future Tech 2022

June 2022 Utrecht, The Netherlands

DOTNED SATURDAY 2022

May 2022 Hilversum, The Netherlands

.NET Developer Conference '21

November 2021 Köln, Germany

Dennis van der Stelt

Distributed Systems addict

Rotterdam, The Netherlands