From the Ground Up: Stories and Lessons from a Major Rewrite

They told us "make it do what it always did, but better." They told us to use the newest processes, a new build setup, a new design, a new architecture. It seemed impossible, and for quite a while, we didn't think we would get it done. And then, we did.

My team recently completed a massive rewrite of a project that was more than 10 years old. In just over a year, we changed almost everything: the architecture, the logging process, the design, even the build and deployment setup. About the only thing that remained the same was our development framework. But now twenty thousand people use our rewritten app every day. Was this our best idea? Maybe not! But it is running in prod right now, and running well.

Rewrites are a huge undertaking, one that comes with distinct and potentially expensive tradeoffs. We ran into many of these issues, and I believe that our stories from how we dealt with them can server as an example for other teams. Come along as I present some of the data, successes, failures, and lessons learned by me and my team when we rebuilt a massive project from the ground up.

Time Management for the Distracted Developer

I am a distracted developer. I've had Attention-Deficit Hyperactivity Disorder (ADHD) my entire life. I've also been a programmer professionally for 10+ years and I've always been... was that a butterfly? It sure was pretty. I wonder what species it is? I should go find out... but I also needed to submit those change requests and oh wait here's that TODO list I misplaced yesterday, need to investigate that...

Wait, what was I doing again?

Programming being a mentally-intensive occupation, it's quite easy to get distracted and lose the focus that is so critical to good development. This session will cover a bunch of tips, trials, failures, and successes I've picked up during my career as a distracted developer, including different focus techniques, structures which can improve time-management skills and an overview of the various methods used to redirect distracted individuals and help them focus. If you find yourself easily distracted, even if you don't have a medical condition like I do, you'll find something to use in this session.

Distraction is the enemy. You can't beat it forever, but you can ward it off. This session will show you how.

Making Design Patterns Fun with C# and Food!

Design Patterns are one of those things developers really should know, but often don't take the time to learn about. There's a simple reason: they're boring!

This dynamic, funny session take nine of the most popular design patterns from the seminal Gang of Four book and use food and jokes to make them interesting. From why Adapter can be used to find optimum cooking temperatures, to how Factory Method is perfectly suited for making sandwiches, to modeling a veggie stock market using the Observer pattern, this session takes design patterns and makes them fun again.

Plus, there'll be working code samples for each of the nine patterns, all hosted on GitHub so you can play with them as you like as soon as the session is over. Come to this session, and let's make design patterns fun again!

This session is targeted at beginner to intermediate developers, though even advanced developers will find something useful here.

The Fundamental Laws of Software Development

There exists a set of fundamental adages, quotes, and philosophical "laws" which govern how software is developed in our modern age. They affect code, designs, life in general; yet many aren't aware they are working at all. This session will shine a light on what these laws are, who created them and why, as well as discussing how developers and other technology professionals can use them to their advantage.

Hear how The Legend of Zelda and a five-year-old clearly revealed the usefulness of pair programming; how land ownership in Italy gave rise to an astoundingly common ratio (and how this helps us fix bugs); even how designing a nuclear power plant can make everyone in the room suddenly become an expert on bike sheds.

Come with an open mind, stay for the stories, and you will learn something you can take back to your job with you!

The Software Anti-Pattern Extravaganza!

Anti-patterns are ideas, methodologies, strategies and constructs that supposedly help solve problems, but in reality make newer, more sinister issues. They are everywhere, in every organization to some extent. The problem is: what should be done about them?

In this fast-paced session, we'll take a humorous look at some of the most common anti-patterns. From accidentally developing a relational database inside a relational database (The Inner-Platform Effect), to what happens when everything looks like a nail (Golden Hammer), to organizations which cannot really talk to each other (Stovepipe Enterprise), these anti-patterns are insidious and very, very common. This session presents stories and potential strategies to work with, prevent, and mitigate common software anti-patterns.

Oh, and there will also be alien abductions, smiting, mud, and lots of jokes and stories. Don't miss it!

Hold Up, Wait a Minute, Let Me Put Some Async In It

The introduction of async/await to C# has irrevocably changed how .NET developers created their applications. But what about older applications? How can they get the async goodness?

In this code-heavy session, we'll take a "older" .NET web app which has no asynchronous code and slowly refactor it into a modern async app. Along the way, there'll be discussions what practices we need to be aware of, such as "async all the way down". This session also demonstrates when async/await is NOT needed, as well as when it is.

Async/await is wonderful, but it's not a cure-all. Let's take an old app, put some async in it, and see how it all comes together.

Let's Learn Blazor by Building Connect Four

Blazor is the new hotness in the ASP.NET Core world. But exactly what IS it, and how does it work?

This code-heavy session will explore how to create a new server-side Blazor project from File -> New Project. We'll see how Blazor works under the covers, and how we can use ASP.NET Core and Razor Pages to build new performant sites very quickly. In the process, we'll build the classic board game Connect Four, and maybe even play a few rounds.

Let's learn how Blazor works by building Connect Four!