KitKats, satellites, and the modular monolith

You're probably here because of the unusual title, but I assure you this isn't clickbait!

Modular Monoliths are becoming more popular since people realised how very hard microservices are to manage, maintain, develop, and debug.

But how do you create a modular monolith that solves the problems a microservice creates but doesn't just revert to type?

This is where KitKats, satellites, and the modular monolith really do have something in common.

Join me in this session as we explore the modular monolith, touching on architecture, design, implementation, and everything in between.

Quit while your ahead

From an early age, we've been taught the value of perseverance, to never give up, and to hang on in there, and never quit. I'm sure many of you will recall motivational pictures on office walls and the funny memes on the internet – but what if that kitten hanging in there just let go? What if it landed in a better place?

From your career to relationships, choosing when to quit a situation gives you the power and control over your life and work to make way for better things.

This doesn't mean rage quitting or simply giving up. As developers, we are analytical by nature and can apply critical analysis to ourselves and our surroundings.

I've quit many a time and I'll share my reasoning behind my various decisions and the outcomes that came from them.

You'll leave the session armed with the knowledge that quitting doesn't have to be negative, that you can review situations and make well-considered decisions, and that letting go can lead to something truly spectacular.

[WORKSHOP] Building cloud-ready, resilient systems in .NET

You may think that your application is already cloud-ready, it's deployed in the cloud, isn't it?!
But in truth, if your application is hard to monitor/scale/release/maintain, lacks resiliency, and is poorly structured, then it's not "cloud-ready".

So what does "cloud-ready" actually mean?

A “cloud ready” application is a legacy software application that has been modified to run on cloud computing infrastructure.

Whether you are looking at a modular monolith or a full-blown distributed system, building a cloud-ready, resilient application is a must.

In this workshop, we will look at the requirements for Tacky Tacos. A fictional taco business that's thriving and wishes to expand.
We'll look at all the different requirements that need to be met, starting with a code kata and how we can apply various design patterns to our way of thinking.
We'll then move on to building out a functioning, all-be-it, contrived modular monolith using .NET 8 and C#, learning as we go.

Topics we'll cover:
- Architecture and Methodology
- Modular monolith vs microservices vs SOA
- Distribution and Modularisation
- Common design patterns
- Modelling requirements
- .NET 8 application development recap
- Data
- Synchronous communication
- Asynchronous communication
- .NET Aspire
- And more!

Who is this workshop aimed at

This workshop is aimed at backend developers with some experience writing web applications using C# and .NET.

The workshop will not cover .NET Framework.

Equipment and software
- A computer - either Windows PC or macOS
- Visual Studio 2022 or JetBrains Rider
- VS Code
- .NET 8 or higher
- Docker Desktop
- Postman or similar
- Azurite

======================================

For the organiser:

## Some of the topics we'll cover:

- Architecture and Methodology
- Modular monolith vs microservices vs SOA
- The "12 Factors" and what they are
- Distribution and Modularisation
- Common design patterns
- Modelling requirements
- Practical: Code kata for tacky tacos

## Implementations

### .NET 7 application development recap
- Dependency Injection
- HttpClientFactory
- Good practices

### External Configuration
- What it is and why it is useful
- Practical: implement external configuration with

### Databases
- Why separate DBs may be required
- Eventual Consistency
- DB options - SQL, Document, Table, Blob, Serverless
- Practical: Create two distinct databases - later these will employ "eventual consistency"

### Synchronous communication
- Introduction to synchronous communication and when to use it
- Synchronous options
- Practical: build an HTTP endpoint for a web client
- Practical: implement gRPC to communicate with a non .NET application
- Practical: implement a hub with SignalR to broadcast real-time information

### Asynchronous communication
- Introduction to asynchronous communication and when to use it
- Message brokers
- Implementation considerations
- Error handling
- Choosing a message broker
- Practical: Implement a pub/sub with RabbitMQ

### API gateways and BFF
- Introduction to the use cases and considerations
- When to use BFF
- Practical: API Gateway with YARP

### Load balancing
- What it is and why we need it
- Practical: Add load balancing to YARP

### Service discovery
- What it is and why we need it
- Practical: set up Service Discovery using Steeltoe and Eureka
- Practical: Integrate Service Discovery with YARP API gateway

### Resiliency
- What makes an application resilient?
- policies, circuit breakers, fallbacks and retries
- Practical: implement policies with Polly

### M2M Authentication
- Why it's needed
- Practical: Implement M2M authorization with Auth0

### Monitoring, tracing, observability
- What is it and why do we need it
- What is the OpenTelemetry project
- What tools are available
- Practical: Implement various endpoints and actuators with Steeltoe

### Serverless
- When to use a serverless function and why
- Practical: create an Azure Function service

## Who is this workshop aimed at

This workshop is aimed at backend developers with some experience writing web applications using C# and .NET.
The workshop will not cover .NET Framework.

## Equipment and software
- A computer - either Windows PC or macOS (I have no experience with Linux so if you bring a Linux machine my problem-solving will be limited)
- Visual Studio 2022 or JetBrains Rider or VS Code
- .NET 7
- Docker Desktop

ASP.NET Basics for Experts

People love to stay in their comfort zone and do what they've always done. But what if you could take your web applications to the next level just by getting the fundamentals right?

In this .NET 8 demo-rich session, I will show you how to make your applications more testable, maintainable and resilient.
Whether you are working with a monolith or a vast distributed application, the areas we'll cover will be applicable.
Join me and learn about the following topics and more!

- Minimal APIs, top-level statements and good design practise
- Dependency injection and inversion of control
- HTTP clients and policies
- Resiliency and circuit breakers with Polly
- Discovery clients with Steeltoe OSS

Bridging The Gap

Introvert and extrovert, frontend and backend, this language or that one, with children or without. There are so many gaps in our industry that can have consequences if not bridged - will you get the promotion? Will you get the new job? Will your voice be heard? There are many ways to bridge a gap, and often the best way isn’t obvious. Layla and Alyssa hope, that through their stories and experiences, they can bring mindfulness and compassion to the forefront of your thoughts and help you bridge the gaps in your career and life.

Understanding Microservices: a guide for the monolithic developer

Microservice Architecture and the reasons why you should move to it, and the reasons you shouldn't, have been well discussed.
If you have already decided to move over to microservices from monolithic development, then you may be finding the whole process a bit daunting.
What aspects should you, a developer be concerned with?
What does all the terminology mean?
How do the services talk to each other?
In this session, I will show you how to get started with microservices architecture, answering these questions and many more.
We'll look at The Tacky Tacos project, built with ASP.NET 6, and explore how the whole process fits together from a development point of view.
Hopefully, you'll leave the session with the confidence to start your own microservices application development straight away!

TDD and the Terminator - An introduction to Test Driven Development

Getting started with Test Driven Development (TDD) can be very challenging. It requires a different mindset and approach to writing and developing code. However, once in that mindset, it is very difficult not to write tests first.

But why bother writing tests first?

In this session, we will go through the reasons for writing tests before coding, look at architecture and design principles, such as SOLID and see how it all comes together to create a more testable and maintainable application.

I will show you how to get started writing tests first with practical examples on how to reprogram a T800 series Terminator so you can start using TDD in your own applications (or killer robots from the future).

Hasta La Vista badly-written code!

Building cloud-ready applications in .NET

Applications are growing increasingly complex, and harder to manage and monitor. Throw in globally distributed microservices and distributed teams; things only get more challenging.

Yet there are tools and libraries out there that can empower you the developer to make considered decisions that make everyone's lives easier, from architects to SREs.

Libraries such as Steeltoe (based on the ever-popular Spring Boot for Java), YARP and Polly are just a few and in this session, I will show you how, with just a few lines of code, you can greatly improve the cloud-readiness of your application.

Join me as we cover

- Configuration
- Messaging
- Circuit Breakers and HTTP resiliency
- and more.

Distribu-ready with the Modular Monolith

The past few years have seen huge hype around distributed systems and microservices.

Pre-emptive implementation of a distributed architecture has led to many engineering teams struggling with vast complexity and sadly for many, the dreaded "Distributed Monolith".

Some teams are in such a pickle that they are even reverting their distributed applications back to a monolith.

I'm all for designing and developing for future growth, but there is a better way than diving straight into distributed architecture.

Behold, the Modular Monolith.

By design, the modular monolith is "distribu-ready" and in this session, we'll cover the design principles and implementations that make the modular monolith one of the best options for future-proofing your application whilst minimising complexity.

Building the modular monolith

In the world of software development, finding the right balance between monolithic and microservices architectures is crucial to creating maintainable and scalable applications. However, the journey to microservices is not without its challenges, and teams often find themselves grappling with the repercussions of premature migration.

Introducing the modular monolith; all the benefits of a monolith such as reduced complexity, ease of deployment, easier debugging, and so on, but ready to be easily decomposed into services as required.

Join us as we explore the principles, patterns, and practices that empower developers to build robust, flexible, and extensible applications without prematurely diving into the complexities of microservices.

In this hands-on, practical workshop we will build a modular monolith and learn the following as we go:

Modular Design Principles: Learn how to break down your application into cohesive modules that encapsulate distinct functionalities, promoting code reuse and easier maintenance.

Dependency Management: Discover techniques for managing dependencies between modules, ensuring clear boundaries and minimising tight coupling.

Scalable Architecture: Explore strategies for designing monoliths that can scale vertically and horizontally to accommodate growing demands.

Architecture enforcement: Dive into architecture testing and other approaches that help with maintaining the architecture and design.

Performance Optimization: Gain insights into optimizing module communication and data flow to enhance the overall performance of your application.

Future Migration Considerations: Explore how modular monoliths can serve as a stepping stone towards a microservices architecture, and the factors to consider when planning a future migration.

Reverse migration: Understand the considerations and techniques for reverse migration from distributed system back to a monolithic architecture.

This workshop is aimed at backend developers with some experience writing web applications using C# and .NET.
The workshop will not cover .NET Framework.

This is a hands-on practical workshop where you will be writing a lot of code. You will need to have the following to effectively participate:

- A computer - either Windows PC or macOS
- Visual Studio 2022 or JetBrains Rider or VS Code
- .NET 6 or higher
- Docker Desktop

The Forgotten AI of Video Games

The focus upon AI continues to be the predominant technology subject of the day; it’s the must-have feature of any new product or service; it’s at the forefront of many discussions about ethics, attribution and indeed our own future employment prospects.

But increasingly, the term “AI” has become synonymous with only one flavour of artificial intelligence - that being “machine learning” (ML) - e.g. generative AI, applied AI, large language models (LLMs) and the such.

However, there are many other types of AI, which until recently, were the mainstay algorithms found behind automated decision making solutions.

Many of these concepts can be found in the video games we know and love.

Are these other types of AI still relevant? Do they risk being drowned out, or forgotten, in the rush to embrace machine learning solutions?

In this session, intended for the enterprise/business application developer, we’ll open a window into the world of the video game development.

We’ll explore the type of algorithms that are a staple of game development: pathfinding, state machines, decision trees, and goal-oriented action planning.

We’ll delve into some of the performance considerations necessary to keep these algorithms running efficiently.

We’ll circle back to how the business application developer can use this type of AI in applications, and how the lessons learnt making video games can help us write better software.