Mastering .NET 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. .NET 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 .NET 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 .NET Aspire.

After introduction to .NET 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 .NET Aspire
- register and discover services within the .NET 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 .NET 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.
- .NET 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.

Task. Async. Await. What it is and how it works?

In this talk, we'll delve into the world of asynchronous programming in C#.NET. You'll learn about the Task class, its role in asynchronous operations, and how it simplifies the process of writing non-blocking code. We'll explore the async and await keywords, understanding their purpose and how they interact with Task to create more responsive and efficient applications.

Key takeaways:
- The fundamental concepts of asynchronous programming
- The role of the Task class in C#.NET
- How to use async and await to write asynchronous code
- Best practices for asynchronous programming

Prerequisites: Basic understanding of C# and object-oriented programming

Target audience: C# developers of all levels

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.

Hackers vs. APIs: The Hidden Weaknesses in Your Code

APIs are the backbone of modern software, enabling seamless communication between applications. While their importance is undeniable, APIs can be susceptible to security breaches if not properly secured. This talk dives into the OWASP and CWE top security vulnerabilities, established frameworks that identifies the most critical API security vulnerabilities.

We'll explore real-world examples of these vulnerabilities, along with corresponding code samples, to illustrate the potential threats and their impact. Through this exploration, you'll gain a deeper understanding of how to fortify your APIs against malicious actors, ensuring the safety and reliability of your software ecosystem.

Preferred session duration: one slot, 30-60 minutes

Target audience:
Software Developers - this includes backend developers responsible for building and maintaining APIs, as well as frontend developers who integrate with APIs
API Designers - those involved in designing and documenting APIs will benefit from understanding common vulnerabilities
Security Professionals - anyone involved in application security will find this talk valuable for identifying and mitigating API-specific risks
Architects and Team Leads - those responsible for the overall security posture of applications will benefit from understanding API security best practices

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.

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

Breaking the Chains: API Versioning Strategies for a Changing World

In the dynamic world of software, APIs are the lifeblood of modern applications. But how do you evolve your API while ensuring compatibility and avoiding breaking changes for your clients? This talk will explore effective API versioning strategies, from simple semantic versioning to more advanced techniques. We'll discuss the trade-offs of each approach, best practices for managing version transitions, and how to gracefully deprecate old versions. By the end of this session, you'll have a solid understanding of how to version your APIs effectively, ensuring a smooth and sustainable development lifecycle for your clients and your own team.