Generic Math in dotnet7

New additions in dotnet 7 allow you to add static methods and operators to interfaces. While the merits of this is another discussion, it did bring the concept of generic math, a set of new math-related generic interfaces, to the base class library. Using these sets of interfaces in the System.Numerics namespace, you can add simple math operators to your classes that tie into other places within the ecosystem.

This session will introduce you to the concept of Generic Math in dotnet. We'll look at these new interfaces, explain how they work, and give you examples for how to both implement and consume them. By the end of this session, you'll have an understanding and appreciation for these new tools.

Neural Networks In Under An Hour

As Artificial Intelligence and Machine Learning continue to evolve, the things they can do are becoming breathtaking. None of these tools capture the imagination more than Neural Networks. However, as our libraries become more robust, few people really understand what's going on behind the scenes.

The inner workings of Neural Networks are surprisingly simple. While there may be a lot of math, it's not really hard math. To prove this, we're going in write and train a Neural Network, from scratch, live, in the session. Of course, I'll explain everything along the way.

Understanding How Your CPU Thinks

You know all those algorithms you take for granted? I'm not talking about those boring algorithms you learned in school. I mean things like adding two numbers or converting a number to to text. Have you ever wondered how the computer really does that?

I recently embarked on a journey to create a math library that would efficiently handle large numbers. Along the way, I had to figure out how some of these algorithms really worked, and was completely surprised by their ingenuity. The end result was a better appreciation for all those library methods that are "just there" and a new approach for solving problems in my own code.

I this session, I will share all these findings with you. From the surprisingly mundane to the completely insane, I invite you join me beyond the operators and into the algorithms. You will leave this session with a better understanding of low level code that will help you write better code.

Demystifying the .NET Runtime

While most .NET developers know that .NET is an interpreted language, have you ever thought about what that really means? If the language is compiled to an intermediate language (literally called "Microsoft Intermediate Language" or MSIL) and run on a VM, how have they added more features to the language without updating the interpreter?

This talks answers all these questions and more. We'll take a deep dive into the differences between the .NET Compiler and .NET Runtime. We'll see what's possible in the compiler, what the runtime can do, and how you can know what's happening where. You'll leave this session with a deeper appreciation of the .NET languages and a clearer sense of how your code really runs.

Internal Development Platforms: Are IDPs Right For Me?

When developers are working locally, they act with impunity, allocating new resources at a whim. However, what happens when they must approach the ops team, bowls extended, asking "please, sir. May I have so'more?" Wouldn't it be easier if there was a system set up to allow development to allocate any necessary resources from a pre-approved list?

Internal Development Platforms (IDP) entered the chat. IDPs give ops teams the ability to create a catalog of approved resource types. This allows dev teams to specify required resources from the catalog during development. During your CI/CD pipeline, the IDP looks at the list of required resources, matches them with rules provided by the ops team, and either creates new or reuses existing resources to stand up the environment. This allows dev teams to worry about development while ops teams worry about allocating resources, securing resources, and, hopefully, keeping costs down.

During this talk, we'll talk about IDPs and how they work, show where they are appropriate to use, and give an example of an IDP in action. By the end of this session, you'll have all the information you need to decide if IDPs are right for your organization.

This talk required internet access.

Introduction to Game Design

Every developer secretly (or not so secretly) wants to develop games. However, most developers think there just is not enough time to learn the tricks needed to makes games. This session will show the you how to leverage your existing development knowledge to create games.

Rethinking Architecture: A Look at Macroservices

In the beginning, all software was a single, monolithic executable. However, large scale executables quickly became unwieldy, cumbersome, and a nightmare to update and maintain. We took a step back and addressed the problems. As such, Service Oriented Architecture was born, and we all rejoiced. However, these large scale services quickly became unwieldy, cumbersome, and a nightmare to update and maintain. We took a step back and addressed the problems. As such, Microservices were born, and we all rejoiced.

Unfortunately, the honeymoon with Microservices is now over, as we start to see problems with this style. In this talk, we'll take a step back, and look at the pros and cons of both SOA and Microservices. From there, we can weigh these concerns and try to find a happy middle ground, which I affectionately refer to as Macroservices. By the end, we'll have an appreciation for the concerns we must weigh as we decide how to build or refactor our next application.

A Journey through Creating and Consuming Custom NuGet Package

It's time to start a new project. I import that library of shared functions I always seem to need. Then, I go to NuGet and grab any necessary packages. Until recently, I never thought about how I could combine these steps. However, this brave new world of DevOps forced me to address this concept, and I was amazed at the ease of creating NuGet packages and the power of the NuGet platform.

In this talk, I'll guide you through my journey into creating and hosting custom NuGet packages. I'll start with the basics of NuGet package creation and hosting by turning a simple DLL into a NuGet package. From there, I'll talk about how you can make your package fit into your target project with configuration transforms, source code transforms, and specifying development dependencies. Finally, we'll discuss some of the advanced options that are available, such as wiring custom build steps into your project. You'll leave this session empowered to create your own amazing packages into your development environment.

Education vs. Certification

Everyone wants to know how to move ahead in their job. Whether we wish to move to a better project, better position, or better pay, we need to consider what roads in our professional development will yield the highest results. In this open discussion, we will discuss the various ways to make you stand out from your peers. We will discuss the virtues and pitfalls of education, certification, experience, and community involvement. The audience will be fully encouraged to share their own stories.