Let's Build A Simple Web Server From Scratch

We take web servers for granted. They're a critical part of every single web infrastructure. Without a functioning web server, there is nothing for the browser to talk to and nothing to serve up your API.

While the concept of a web server might seem daunting, web servers are simple. Well-established RFC documents specify how a web server should respond to various requests.

This talk breaks down some essential RFC documents on how a web server should respond to HTTP requests. We'll build a new custom web server to serve files off the disk. We'll focus on HTTP/1.1 just for simplicity and time constraints.

All examples will be in C#, but the fundamentals are accessible to anyone of any level or from a different language background.

Learn about some of the critical parts of web infrastructure!

Crazy Web Performance with Azure Static Web Apps

One of the key processes for building a crazy performant web application is to use statically generated pages. A ton of systems exist for building these types of apps: like Jekyll, Gatsy, Gridsome, and more. Even your traditionally built Angular, React, and VueJS applications can be statically generated, as you don't need to rely on server-side processing.

If you're supporting the Microsoft ecosystem though, deploying these types of applications typically happen in two ways: Azure App Services or Azure Blob Storage. Both ways work but have drawbacks for serious production site.

In this session, you'll learn about the new Azure Static Web Apps platform and how you can get the best of all worlds in terms of performance and functionality. You'll see a site created and deployed within 5 minutes, the same site updated and revised with a complete CI/CD lifecycle, and server-side API functionality injected with Azure Functions.

Annihilating Workloads with Azure Functions

Are you looking to efficiently handle massive workloads in the cloud? Azure Functions, a form of serverless computing, can help. In this talk, we will explore the use of Azure Functions in a production environment, including the powerful producer-consumer design pattern and the highly scalable durable functions feature. Learn how Azure Functions can support scalability, allowing you to handle workloads ranging from 1 to 1 million entities with ease. Leave this talk with a solid foundation in Azure Functions and the tools to implement them in your own operations.

Real-Time Revolution: SignalR in Action

Does your application render a page and then just leave it?
Do you deal with issues of the local state being out of date?
Do you wish the server could just tell all the browsers that something has changed?

If you answered yes to any of those questions, it's time to join the real-time revolution! SignalR is a library designed to help .NET developers build performant, real-time cross-platform applications (not just web apps!).

In this demo-filled talk, you'll learn about what SignalR is, how it fits into a modern application ecosystem, and how you can take advantage of it in your current or future projects.

Job Freedom: Becoming an Independent Consultant

As developers, many of us have considered the benefits of working independently as a consultant. But what are the realities of this path?

In this presentation, we'll draw on over ten years of experience to explore the challenges and rewards of independent consulting.

We'll cover essential topics such as how to find your first clients, whether you should hire an accountant and/or lawyer, how to handle financials, and how to prepare for unexpected events.

Join us for an open discussion on the pros and cons of independent consulting.

Tactics for Building Background Services in .NET

Mature applications often find themselves in the predicament of having to do work "behind the scenes." Frequently, this could be simple tasks such as sending emails or updating statistics, or it could be something more complicated, like processing incoming files or building reports. These tasks should not impede the user experience because they can be done in the background.

But in modern .NET applications, what's the best way to implement background services? There isn't necessarily a right or wrong way, but there are ways that are "easy to write" and methods that are "easy to scale."

This talk aims to take you on a journey through several processes that allow you to work in the background. We'll cover the pros and cons of different approaches and leave you with actionable advice to apply to your projects. We'll even cover deployment strategies and how we do this with real projects today.

This talk has been updated for the 2024-2025 conference season. It will cover various ways to build background services, including IHostedService, HangFire, and Corvel.

Multithreaded Income: How Developers Can Achieve Parallel Success

In an unpredictable tech industry, job security is fragile. How can developers harness their unique skills to create a diversified, resilient professional life? This talk presents the concept of "Multithreaded Income," a strategic approach to building parallel income streams inspired by the principles of multithreading in software development.

What You'll Learn:

* Moonlighting & Side Gigs: Leverage your skills to create supplementary income streams without compromising your primary role.

* Course Building & Book Writing: Turn your expertise into educational content for additional revenue.

* Ethical Balancing & Time Management: Strategies for maintaining professional ethics and personal well-being across multiple commitments.

* Path to Financial Freedom: A roadmap for constructing a diverse income portfolio resilient to the tech industry's uncertainties.

Join us to explore a new paradigm for financial stability in your career, aligning technology's best practices with innovative career strategies.

Gauntlet: 30 Rapid Fire Tips and Tricks for .NET and C# Developers

Even for the most seasoned .NET professionals, the expansive ecosystem of C# and .NET can be a treasure trove of lesser-known gems and powerful intricacies. Whether it's the latest syntactic sugar in C# 10 or a high-performance feature introduced in .NET 8, the technology is constantly evolving, and so should our toolkits.

Join us for a rapid-fire exploration of 30 advanced tips and tricks curated explicitly for the seasoned .NET developer. From cutting-edge language features to proven best practices in performance optimization, this talk aims to enrich your .NET proficiency and elevate your software craftsmanship to the next level.

Come prepared to take notes, as we will navigate many topics at warp speed.

Dumb Mistakes I've Made with Relational Databases as a Developer

Maybe you're like me: you're a developer who has been working with relational databases most of your career, but you treat developing against the database the same way you would if you were slinging some code.

For small datasets, it's probably not a big deal. However, as my datasets have grown, I've learned that I need to change my thinking about the best approach to using a relational database. Example: MAYBE it's a poor idea to `foreach` over the 4 million rows in a table. It worked just fine when there were 4,000 rows.

My lessons were learned the hard way: doing something dumb, seeing it fail horribly in production, and then working backward for a better approach. In the end, we've been able to slice minutes (and sometimes hours) off of database interactions. We've lowered our compute, which has allowed us to use fewer resources.

Let's talk about a couple of the dumb mistakes I've made as a developer using relational databases, the impact it caused, and what the "better" way to approach the problem should've been. Feel free to come to share the lessons you learned, too!

My $8,000 Serverless Mistake

In the right circumstances, serverless technology can be a fantastic tool in your developer toolbox. There was a time when I went deep down the serverless rabbit hole with Azure Functions. It's solved many problems, and I still cannot recommend it enough. However, on my journey, I've also hit the limits of what it can do as a solution.

This talk discusses the timeline of migrating multiple services to Azure Functions and loving their flexibility. There were so many wins from making the move! But we'll also cover what went wrong, like an accidental $8,000 Azure bill because I loved them too much. What should I have done differently, and how can you protect yourself from accidentally trying to do too much with serverless?