Why you should start practicing DDD tomorrow?

In a world of ever-increasing software complexity, Domain-Driven Design (DDD) offers a pragmatic approach to building software that aligns closely with the business domain.

This talk will delve into the core concepts of DDD, explaining how it can help you:
- Improve code maintainability: By modeling your software around the business domain, you'll create code that's easier to understand and modify.
- Enhance collaboration: DDD fosters effective communication between developers and domain experts, leading to better software solutions.
- Accelerate development: By focusing on the most critical parts of your domain, you can deliver value faster.

This talk will provide practical examples and insights, empowering you to start applying DDD principles in your projects tomorrow.

Prerequisites: Basic understanding of object-oriented
programming and software design patterns.

Target audience: Software developers, domain experts, architects, and technical leaders.

Key takeaways: Core concepts of DDD, benefits of adopting DDD, and practical tips for implementation.

Geographically Distributed Engineer: Challenges, Culture, and the Architecture Trap

Throughout my career, I have served on numerous globally distributed software engineering projects. This talk draws directly from those experiences, offering a candid look at recurring and often surprising challenges that arise when development efforts are separated by distance and disparate cultures.

We will analyze real-world friction points I encountered in communication, cross-site synchronization, and maintaining team cohesion. Crucially, I will share specific lessons learned regarding profound truth of Conway's Law, illustrating how my teams' geographical boundaries frequently and unforgivingly dictated module dependencies and complexity of resulting software architecture.

I will present a practical, experience-tested playbook for mitigating "distributed decay" that results, covering:
- Strategies to optimize communication tools for asynchronous global work
- Techniques for intentionally defining architectural boundaries to align with—and benefit from—team separation
- best practices for fostering a unified culture learned through direct trial and error.

Join this session for an honest and tactical breakdown of how to transform geographical separation from a crippling constraint into your team's most powerful organizational asset.

Distributed Systems Engineering: Gap Between Textbook Theory and On-Call Reality

The theoretical foundations of distributed systems provide crucial intellectual scaffolding, but they often paint a deceptively clean picture of system behavior and failure.

In production, the challenges engineers encounter are fundamentally different from the idealized textbook scenarios. We struggle not with elegant theoretical dilemmas, but with the subtle, messy, and often unexpected operational realities.

This session dives deep into the unwritten realities of distributed systems engineering, comparing the clean, predictable problems we study with the complex, real-world issues.

Attendees will leave with practical war stories, debugging strategies, and a clearer understanding of what it takes to build and operate resilient systems at scale.

Target audience: Software Engineers
Preferred session duration: 45 - 60 minutes

Get Smart, Avoid the Sting: Mastering OWASP Top Security Vulnerabilities

Don't let security vulnerabilities leave your web applications exposed! This hands-on workshop dives deep into the OWASP Top security vulnerabilities, equipping you with the knowledge and skills to identify, understand, and mitigate the most critical web security risks. Learn practical techniques and best practices to fortify your applications and prevent costly attacks. Get smart about security – before you feel the sting.

PREFERRED SESSION DURATION: full-day / half-day

TARGET AUDIENCE:
- Software Engineers
- QA Engineers

TECHNICAL REQUIREMENTS:
- Laptop with your favorite IDE

Build Better Software with Domain-Driven Design

Building complex software systems often leads to challenges like miscommunication between developers and business stakeholders, inconsistent implementation of business rules, and difficulty in adapting to changing requirements.

Domain-Driven Design (DDD) provides a powerful set of principles and patterns for tackling these challenges by focusing on the core business domain and aligning software design with the business needs.

This workshop will delve into the core concepts of DDD, including:
- Ubiquitous language
- Bounded Contexts
- Rich Domain Model
- Aggregates, Entities, Value objects
- Domain events
- Domain services

Through a combination of lectures, discussions, and hands-on exercises, you will learn how to apply DDD principles to design and implement robust and maintainable software systems. You will gain practical experience in:
- Identifying and defining Bounded Contexts within a given domain.
- Modeling domain entities, value objects, and aggregates.
- Implementing domain services and handling domain events.
- Applying DDD patterns to real-world scenarios and use cases.

PREFERRED SESSION DURATION: full-day, half-day, 2 hours

TARGET AUDIENCE:
- Software Developers: Experienced .NET developers who are interested in building cloud-native applications.
- Architects: Software architects and solution architects who are responsible for designing and implementing cloud-native solutions.
- DevOps Engineers: DevOps engineers who are involved in the deployment and management of cloud-native applications.

TECHNICAL REQUIREMENTS:
- Laptop with your favorite IDE

Aspire: Getting Started

This session will provide an introduction to the Aspire framework, a powerful tool for building modern, cloud-native applications. You'll learn about its core principles, including service registration, dependency injection, and distributed tracing. We'll explore how Aspire simplifies development by addressing common challenges like microservice orchestration, data integration, and cloud deployment.

Conquering the Chaos: Mastering Flaky Tests

Flaky tests are the bane of every developer's existence. They can slow down development cycles, erode confidence in test suites, and make debugging a nightmare. In this talk, we'll dive deep into the root causes of flaky tests, from timing issues and race conditions to environmental factors and test design flaws. We'll explore practical strategies to identify, diagnose, and eliminate these elusive bugs. Learn how to write robust, reliable tests that consistently deliver accurate results, saving you time and frustration in the long run.

TARGET AUDIENCE:
- Software engineers at all levels, from junior to senior.
- QA engineers and test automation specialists
- DevOps engineers who are involved in CI/CD pipelines and test infrastructure
- Technical team leads and managers who are interested in improving software quality and delivery efficiency

Mastering Aspire: From Fundamentals to Advanced Concepts

Building modern, cloud-native applications presents significant challenges for developers. Managing complex interdependencies between microservices, ensuring consistent performance under varying loads, and debugging issues in distributed systems can be overwhelming. Aspire provides a powerful framework that simplifies cloud-native development by offering a comprehensive set of tools and libraries for building resilient, scalable, and observable applications.

This workshop will guide you on a journey through the Aspire ecosystem, starting with fundamental concepts and progressing to advanced techniques. By the end of the workshop, you'll have the knowledge and skills to confidently design and implement robust cloud-native applications using Aspire.

After introduction to Aspire we will be working on a sample-app. You will gain hands-on experience learning how to:
- build a complete sample application from scratch using Aspire
- register and discover services within the Aspire ecosystem
- integrate database (e.g. MS-SQL, MongoDB) & messaging (e.g. RabbitMQ) & containers into your system
- integrate Azure services (CosmosDB, Storage) into your system
- implement logging, metrics collection, and distributed tracing using OpenTelemetry
- build automated tests of the system
- deploy and manage Aspire Applications

PREFERRED WORKSHOP DURATION: full-day, half-day, 2 hours

TARGET AUDIENCE:
- Software Developers: Experienced .NET developers who are interested in building cloud-native applications.
- Architects: Software architects and solution architects who are responsible for designing and implementing cloud-native solutions.
- DevOps Engineers: DevOps engineers who are involved in the deployment and management of cloud-native applications.

TECHNICAL REQUIREMENTS:
- .NET 8 SDK: Installed on the attendee's machine.
- Aspire Workload: Installed in Visual Studio 2022 (version 17.10 or higher) or via the .NET CLI.
- Docker Desktop or Podman: Installed and running on the attendee's machine.
- Visual Studio 2022 (recommended) or Visual Studio Code with the C# Dev Kit
- Basic understanding of C# and .NET development concepts.

GitHub Copilot: Unleashing AI Power Responsibly

Building high-quality software requires a multifaceted approach that extends beyond simply writing code. GitHub Copilot, an AI-powered coding assistant, empowers developers with a range of capabilities that can significantly enhance their daily workflow.

This workshop will explore the multifaceted role of GitHub Copilot in the modern development process. You'll learn how to leverage its capabilities not only for generating code suggestions but also for understanding and explaining code, deciphering complex algorithms, learning new programming concepts, debugging and troubleshooting code issues more efficiently, and seamlessly integrating Copilot into your existing development environment by optimizing your workflow with keybindings, autocompletion features, and other productivity-enhancing techniques.

The workshop will also emphasize the importance of maintaining software quality and code quality while utilizing AI assistance. You'll learn best practices for reviewing and validating AI-generated code, ensuring that it adheres to coding standards, and maintaining overall code maintainability.

The workshop will include a hands-on coding session where you'll experience firsthand how to integrate GitHub Copilot into your development process and unlock its full potential. By the end of this workshop, you'll be equipped to effectively utilize GitHub Copilot to:
- Accelerate your coding speed and efficiency
- Refactor your code easily
- Enhance code readability and maintainability
- Debug and troubleshoot code more effectively
- Streamline your development workflow
- Maintain high software and code quality while leveraging AI assistance.

PREFERRED SESSION DURATION: full-day, half-day, 2 hours

TARGET AUDIENCE:
- SW Engineers
- QA Engineers
- Students: To improve their coding skills and gain valuable experience with AI-powered development tools
- Anyone involved in software development: To learn how to effectively leverage AI to enhance their coding workflow

TECHNICAL REQUIREMENTS:
- IDE with GitHub Copilot Support
- Active GitHub Copilot Subscription
- Stable Internet Connection

The Power of Ubiquitous Language: Bridging the Communication Gap in Software Development

DDD emphasizes the importance of a shared language between developers and domain experts. This talk delves into the concept of Ubiquitous Language, exploring how it fosters better communication, reduces misunderstandings, and leads to better software that reflects the true needs of the domain. We'll discuss practical techniques for developing and maintaining a shared language within your team.

This talk targets software engineers, architects, and anyone seeking to master complex software domains.

Preferred session duration: one slot, 45-60 minutes.

"It Worked in Staging": Solving Performance Gaps in Distributed Systems

In my career building distributed systems, I’ve found that the deadliest performance killers are often invisible. They lurk in the cracks between services and in the treacherous drift between "clean" test environments and the chaotic reality of production.

In this session, I’ll pull back the curtain on the most complex performance puzzles I’ve solved. We’ll analyze the technical root causes, the observability tools used to unmask them, and why traditional testing often fails to catch them. You'll leave with a practical framework to bridge the gap between staging and reality.

TARGET AUDIENCE: Software Engineers
SESSION DURATION: ~60 minutes

Beyond Autocomplete: Mastering the Full Potential of GitHub Copilot

Are you using GitHub Copilot as a true pair programmer or just a glorified autocomplete? While AI tools are now standard in the dev stack, many engineers remain stuck in early-adoption habits, missing the advanced features that truly drive velocity.

This workshop moves beyond basic code completion to explore sophisticated workflows, including complex refactoring, unit test generation or debugging problems explanation. Through practical, real-world examples, you will learn how to integrate AI deeply into your development lifecycle to deliver high-quality results faster. Stop fighting the tool and start mastering your new digital partner.

TECHNICAL REQUIREMENTS
- IDE with GH Copilot
- GH Copilot subscription
TARGET AUDIENCE:
- Software Engineers
- QA Engineers
WORKSHOP DURATION
- 2-3 hours