Scott Sauber
Director of Engineering at Lean TECHniques Inc
Des Moines, Iowa, United States
Actions
Scott is a software consultant and primarily does web development using ASP.NET Core and JavaScript. His second passion behind web development is helping teams realize their potential through technical practices (such as CI/CD, IAC, TDD, etc.) and working more effectively (such as limiting WIP, visualizing work, etc).
He’s a Microsoft MVP, Friend of Redgate and co-organizes the Iowa .NET User Group. You can find Scott on Twitter @scottsauber or on his blog at scottsauber.com.
Links
Awards
Area of Expertise
Topics
The Most Important Thing You'll Ever Learn - The Responsibility Process
The Responsibility Process is the most important thing I've ever learned in my entire life, and it's not even close. I use it every single day, both at work and in my personal life. What is the Responsibility Process? It's a process, discovered by Christopher Avery, that identifies the traps that people fall into when dealing with challenges that stand in our way. To avoid falling into the same traps yourself, you'll have to attend the talk. It'd be irresponsible not to.
The Background on Background Tasks in .NET 8
Need to run a task in the background in .NET 8? There are lots of scenarios for background tasks ranging from a task that runs for a long time, or perhaps an operation that needs to be retried multiple times if it fails, and many other scenarios in between. While there are lots of scenarios for background tasks, there are also lots of solutions to this problem that can leave a .NET developer unsure of which to choose from. Solutions such as IHostedServices, BackgroundServices, Worker Services, Hangfire, and more. In this talk, we'll break down all of these solutions with their pro's and con's and when to choose one over the other, as well as a deep dive on how these all work under the hood.
The 12 Factor .NET App
The 12 Factor App was a set of 12 principles that help create modern, maintainable codebases. But what are they? Why do they matter? And how do I apply this to my .NET app?
In this session, we'll answer all of those questions in 60 minutes. You'll be able to walk out with not only ideas on how to improve your codebase immediately when you get back to work, but also you'll walk out with real world tested implementations for your .NET application.
Test Driven Development with C# - from Padawan to Jedi
In this session, we will discuss how to do Test Driven Development (TDD). We will start our Jedi training from the basics of what TDD is, why you should be doing it, and how it improves the quality of your software. We will also talk about what TDD is not and where developers often go wrong with TDD and succumb to the dark side. All along the way, we will do live coding demos so that you can see TDD in action. Demos will be in C#, but the TDD concepts apply to any language.
Test Driven Development for the Frontend
In this session, we will discuss how to do Test Driven Development (TDD). We will start with the basics of what TDD is, why you should be doing it, and how it improves the quality of your software. We'll also talk about how you can TDD the frontend, despite many saying it's hard or even impossible. All along the way, we will do live coding demos so that you can see TDD in action. Demos will be using React, but the TDD concepts apply to any language or framework.
Logging Best Practices in .NET
If you're building a .NET app today, logging is a crucial tool to have in your toolbelt to troubleshoot what is going on in your application. In this talk we will review logging best practices so you don't get caught debugging through a forest without the proper log.
First off, we'll discuss what logging should be used for and what it shouldn't. We'll talk about what the different log levels mean, and why you're probably abusing the Information log level. We'll discuss why structured logs are useful and how to properly use a log context to attach useful properties to every log. Of course, there'll be demos all throughout using Serilog in conjuction with the ILogger.
Safely Evolving Legacy Code
A new ticket comes in. It's for "that app." You know the one. The one nobody wants to touch, because the code is a mess and yet the application is business critical. In this talk, the fancy technologies will be put to the side, and instead the the reality most people live in will be acknowledged. You'll learn how we can evolve legacy code from the state it's in today to the value we need to get from it tomorrow
Learning Blazor on .NET 8 From Scratch
If you're like many C# developers, you've already seen some Blazor demos. Maybe you've even played with a little bit, but you really haven't really gotten to dive as deep as you'd like.
In this workshop, we'll start at the beginning and build you up with a foundation of what Blazor is, how it works, and everything you need to know to be productive with Blazor. We'll cover topics like components, routing, authentication, forms, validation, automated testing, and more! We'll also be using some of the latest Blazor features released in .NET 8.
Attendees can expect a balanced mix of learning concepts, and applying those concepts with hands on labs as we build out a project from scratch.
HTTP Security Headers You Need To Have On Your Web Apps
In this session, we'll explain a handful of HTTP Security Headers (including HSTS, CSP, XFO, and more) from the bottom up. We'll explain what they are, what they do, and how you can implement them to secure your sites. On each of these, we'll demo a before and after so you can see first hand what each of these security headers do.
Everything you wanted to know about running a User Group
So you think running a user group is easy? You think to yourself, how hard can it be? I was once like you, and then I joined the leadership board for a 850+ member .NET user group and got a reality check. In this session, I'll pull behind the curtain and give you a glimpse of what goes on behind the scenes of running a user group. Topics will include finding speakers, acquiring sponsors, dealing with finances, choosing venues, promoting events, dealing with politics, and more.
Docker for Databases
By now you've probably heard something about Docker. Maybe you've even used it. But did you know Docker can be a revolutionary tool not just for your applications, but also for your databases? In this session, we'll review where Docker fits into databases, and also where it doesn't. By leveraging Docker for your databases you can create a powerful development environment for developers and DBA's alike.
Decoding OAuth From Scratch
OAuth is a topic where it’s easy to get overwhelmed. It’s a complicated process involving lots of jargon including JSON Web Tokens, Scopes, Flows, and more. In this talk, we’ll start breaking OAuth into its individual pieces.
We’ll start by talking about what problem OAuth solves before diving into how it solves that problem. We’ll talk about JSON Web Tokens and how they work. We’ll also do live demos with different OAuth flows such as Authorization Code Flow with PKCE and Client Credentials Flow to talk through how they work.
If you’ve never peeked under the covers of how OAuth works - you won’t want to miss this talk.
DevOps for Databases
In this session, we'll start from the beginning and discuss the decisions you need to make when deciding how you want to build and deploy database schema changes. We'll talk about Migration vs Model based approaches and the pros and cons of both. We'll discuss common gotcha's and review the workflows I've gone through to get to a successful build and deploy pipeline up and running in no time (including a SQL Server database that got its start over 25 years ago).
Creating a Healthy, High Performing Engineering Organization
Everyone wants a top notch software engineering organization, but how do you make that happen? During my time as a software consultant, I've worked with over a dozen companies ranging from Fortune 100 companies down to startups, and the same themes keep coming up over and over again. I've boiled my experience down to a series of over 20 questions to ask your organization in order to create a great engineering organization. Don't worry, I won't just leave you with the questions, I'll also tell you why those questions matter, and how I would answer every single one of them. If you feel like your engineering organization could be performing better, you won't want to miss this talk.
Building and Deploying a .NET 8 App Using Azure, Bicep, and GitHub Actions
In this workshop, we'll cover the soup to nuts on deploying an ASP.NET Core 8 API to Azure App Service using Bicep and GitHub Actions.
Lots of times this kind of stuff gets set up once and then you never touch it for awhile. This usually leads to one (or all) of these outcomes:
- you weren't the one to set it up so you have no clue how it works
- this knowledge gets forgotten
- it isn't done often so you don't know the best way to do it
In this session, we'll start from the beginning sprinkling in some .NET concepts, Azure concepts, and GitHub Actions concepts. We'll cover all of these topics:
- Using Bicep to provision the infrastructure
- Using GitHub Actions to deploy the app
- Learning how App Service works
- Configuring Zero Downtime Deployments with Deployment Slots
- Setting up Health Checks in ASP.NET Core
- Setting up Logging and Instrumentation
- Integration with Azure Key Vault for secret management
We'll mix in presentation with hands-on labs to get you up and productive with the full stack of building and maintaining an ASP.NET Core API.
If you're interested in learning how any of these technologies work, you don't want to miss this workshop.
10 Vulnerabilities Your Web Application Probably Has Right Now
In this session, we'll discuss 10 unique vulnerabilities that are likely impacting your web application at this very moment. For all 10, we'll do a live demo with the vulnerability in place as well as show how to eliminate the vulnerability to properly secure your web applications. If you have a web application that you care about securing, you don't want to miss this talk.
10 Opinions For Creating More Maintainable .NET Apps
As an application adds more and more features, if you're not careful, it can quickly spiral into becoming the application no one on the team enjoys working on. This session is structured as a series of lightning talks on various topics to help you improve the maintainability of your .NET applications. We'll discuss libraries and best practices to help with folder structure, validation, ORM's, automated testing, code flow, DevOps, microservices, and more. By the end, you should be able to take a few ideas away that you can start implementing immediately when you get back to the office.
Scott Sauber
Director of Engineering at Lean TECHniques Inc
Des Moines, Iowa, United States
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top