Manage Cloud Infrastructure With C# Using Pulumi

It's fairly common now for teams to be in charge of deploying their own architecture using infrastructure as code (IaC). While this is a good practice, it also adds another knowledge requirements to teams to learn the IaC language and ecosystem.

What if teams could write IaC in a language they already excel in and use everyday?

This session will introduce Pulumi, a library enabling exactly that. Attendees will be given an overview of Pulumi and its benefits, as well as comparisons to existing choices. Using C#, there will be a live demo using Pulumi to deploy resources to Azure. Those resources will be then used to run a C# app, showing how teams can stay entirely within one language to deploy their apps.

Presentation outline:
- Infrastructure as Code
- Typical Options
- Pulumi
- Benefits to Teams and Organizations
- Coding demo (this will be the bulk of the presentation)
- Recap, closing thoughts, questions

How to Test Between Microservices Using Contract Testing

A test suite you have confidence in is essential to producing high quality software. In particular, end-to-end tests provide significant confidence per test in the system, but are also prone to environment changes, third-party failures, and wait times on other teams. These issues frequently prevent teams from shipping features as planned and rely on systems outside of the team's control, ultimately impacting business outcomes.

What if teams could gain the confidence that end-to-end tests bring, but without the inherent fragility?

Contract testing offers a solution to this problem. This session will go over what contract testing is, as well as the benefits it can bring to you and your team. It will also go through a practical demonstration of how to use Pact, an open source library for writing contract tests. The demo will use C#, though Pact is offered in a variety of languages, so the knowledge will be transferable.

No More SQLite - How to Write Tests With EF Core Using TestContainers

Integration tests are crucial to ensuring your app's reliability. However, traditional options for writing these with EF Core, such as using SQLite or a real dev database, often introduce challenges both with maintainability and confidence - sometimes even secretly making tests pass with false positives.

This session will offer an alternative, a library called TestContainers, that addresses these challenges. After going through the more common options and the pitfalls of them, I'll introduce the TestContainers library, the benefits it offers, and demonstrate with a coding demo how to implement it in some real integration tests using EF Core.

While this talk will be made with .NET in mind and use examples in C#, the TestContainers library is offered in 10+ languages, and the knowledge can be transferred to other ecosystems. Attendees will be assumed to have basic knowledge of unit and integration testing.

Presentation outline:
- The problem
- Traditional solutions
- 1. In-memory provider
- 2. SQLite provider
- 3. Real dev database
- 4. Containerized database with a Dockerfile
- Introducing TestContainers
- Why TestContainers?
- Coding demo (this will be the bulk of the presentation)
- Recap, closing thoughts, questions

xUnit Expanded - Better Testing With xUnit

xUnit is one of the most used testing tools for C#, yet its full capability often goes underutilized.

Unfortunately, there isn't much guidance or documentation for developers in terms of what libraries to use with xUnit or some of the more uncommon functionality of xUnit itself, keeping much of its use to the realm of learned experience.

This talk will cover some xUnit tips and tricks that come from just that. Through a coding demo, you'll learn how to make tests easier to write and more robust, as well as other lesser-known libraries and patterns that can be used in tandem with it to fully unlock its potential.

This session is tailored both to those with many years of testing, as well as those new to it. The advice in it is intended to be a set of practical patterns and libraries that any skill level can take advantage of.

Presentation outline:
- Motivation
- Libraries used
- Parallelism in xUnit
- FluentAssertions
- Coding demo (this will be the bulk of the presentation)
- Recap, closing thoughts, questions

Hearing and Being Heard - Getting the Entire Team to Speak

Many of us have been on teams where the same few people speak every meeting, and likewise, the same few people very rarely ever speak. Often, we also fall into one of those categories ourselves. Learn why this happens, why it's beneficial for everybody if the whole team participates, what happens when participation isn't equal, and practical actions to take to encourage all individuals to share their opinions and concerns.

At first glance, it can be confusing to navigate this issue. Should team members be required to say something, or called on directly? What if they truly have nothing to say? Are there any benefits from addressing this? How do we get all people to participate and share knowledge, and more than that, do so comfortably?

Regardless of your role on the team, this talk will address these questions and give you practical actions to take to help your team feel safe and get the feedback, opinions, and concerns of all of its members.