Presentation Topics

I'd love to come speak at your developer conference, user group, or corporate event. To see what some folks have said about my presentations, visit my Feedback page. To make a request, simply drop me a note.

In addition, I offer full-day workshops on several topics. Take a look at those here: Workshops.

Here's a list of topics that I specialize in:

C# Language Features

IEnumerable, ISaveable, IDontGetIt: Understanding .NET Interfaces
Do you want code that's maintainable, extensible, and easily testable? If so, then C# interfaces are here to help. We’ll take a look at how we can use interfaces effectively in our code -- starting at the beginning ("What are interfaces?") and then exploring why we want to use them. Along the way we'll use existing interfaces, implement own interfaces, and take a look at dynamic loading, unit testing, and dependency injection. All of which is made easier with interfaces.

Materials: Slides & Code Samples
Pluralsight Course: C# Interfaces
Learn to Love Lambdas (and LINQ, Too)
Lambda expressions can be confusing the first time you walk up to them. But once you get to know them, you’ll see that they are a great addition to your toolbox. Used properly, they can add elegance and simplicity to your code. And some .NET constructs (such as LINQ) lend themselves to lambda expressions. We’ll take a look at how lambda expressions work and see them in action.

Materials: Slides & Code Samples
Video Series: Lambdas & LINQ in C#
Get Func<>-y: Delegates in .NET
Do you use delegates in .NET?  If so, then Func<T> and Action<T> are just waiting to make your life easier.  Not using delegates?  Maybe you should.  We'll take a look at what delegates are, why you would want to use them, and how to use Func<T> and Action<T> to tie things all together (with a few Lambdas thrown in just for fun).

Materials: Slides & Code Samples
Video Series: C# Delegates
T, Earl Grey, Hot: Generics in .NET
Let the compiler work for you. Generics shift the burden of type-safety from the developer to the compiler. To understand Generics, we'll take a look at some .NET classes from the BCL (such as List), comparing the generic and non-generic versions. Then we'll add Generics to our own methods to add flexibility and type-safety.

Materials: Slides & Code Samples
Video Series: C# Generics
Practical Reflection in .NET
Reflection is an extremely powerful feature of .NET. But there is a big difference between what we can do and what we should do. Several of these features are useful to the everyday developer. We'll take a quick look at what reflection is capable of and then narrow our focus to practical uses -- balancing flexibility, safety, and performance.

Materials: Slides & Code Samples
Pluralsight Course: Practical Reflection in .NET
I'll Get Back to You: Task, Await, and Asynchronous Methods
There's a lot of confusion about async/await, Task/TPL, and asynchronous and parallel programming in general. So let's start with the basics and look at how we can consume asynchronous methods using Task and then see how the "await" operator can makes things easier for us. Along the way, we’ll look at continuations, cancellation, and exception handling.

Materials: Slides & Code Samples
Video Series: Task and Await in C#
Recorded Presentation: NDC London - January 2016
Keep Your UI Responsive with the BackgroundWorker Component
Keep your UI responsive. If we're not careful, a long-running process will cause our application to "lock up". The BackgroundWorker component gives us an easy-to-use solution by moving that long-running process off of our UI thread and also gives us features such as progress reporting, cancellation, and error handling. We'll see how easily the BackgroundWorker component fits in with an application using the Model-View-ViewModel (MVVM) pattern. And we'll compare the BackgroundWorker component to the Task Parallel Library to make sure we're using the right tool for the job.

Materials: Slides & Code Samples
Pluralsight Course: Introduction to the .NET BackgroundWorker Component

Software Practices

DI Why? Getting a Grip on Dependency Injection
What is Dependency Injection? And why would we want to use it? That's what we're here to answer. We'll start by looking at the problems caused by tight coupling. Then we'll use some DI patterns such as constructor injection and property injection to break that tight coupling. We'll see how loosely-coupled applications are easier to extend and test. With a better understanding of the basic patterns, we'll remove the magic behind DI containers so that we can use the tools appropriately in our code.

Materials: Slides & Code Samples
Pluralsight Course: Dependency Injection On-Ramp
Design Patterns: Not Just for Architects
Design patterns are not just for architects. In fact, you already use Design Patterns but probably don’t know it. Observer, Facade, Iterator, Proxy - these are all patterns that allow us to better communicate our ideas with other developers. And once we understand the patterns, we can use solutions that people way smarter than us have already implemented. In this session, we’ll take a look at several Gang of Four patterns that we regularly use without realizing it. Don’t know who the Gang of Four is? Join us to find out.

Materials: Slides & Code Samples
Pluralsight Course: Design Patterns On-Ramp
Recorded Presentation: Silicon Valley Code Camp - October 2015
Abstract Art: Getting Abstraction "Just Right"
Abstraction is awesome. And abstraction is awful. Too little, and our applications are difficult to extend and maintain. Too much, and our applications are difficult to extend and maintain. Finding the balance is the key to success. The first step is to identify your natural tendency as an under-abstractor or an over-abstractor. Once we know that, we can work on real-world techniques (including DRY, SOC, KISS and YAGNI) to dial in the level of abstraction that is "just right" for our applications.

Materials: Slides & Code Samples
Pluralsight Course: Abstract Art: Getting Things "Just Right"
Clean Code: Homicidal Maniacs Read Code, Too!
There's no such thing as a write-once application. The world is constantly changing, and our code needs to change with it. To keep code readable and maintainable, we'll use techniques such as intentional naming and method trees. Think about the next developer to maintain the code. Now, imagine he's a homicidal maniac who knows where you live.

Materials: Slides & Code Samples
Recorded Presentation: Nebraska.Code() - March 2015
Choose Your Own Adventure: Refactoring to Human-Readable Code
Simple actions can drastically improve the readability of our code. This makes our code easier to maintain. In this live refactoring session, we'll take an existing class and make it easier to understand and navigate. We'll make sure the intent of our code is clear through well-named methods and properties. And we'll leave waypoints in our code for developers to follow. The result is a "choose your own adventure" approach to easily find the exact part of the code we need to work on.

Video: Clean Code: The Refactoring Bits
Shields Up! Defensive Coding in C#
Coding is easy. Making sure our code is robust and effective takes a bit of effort. By coding defensively, we prepare our applications to face the challenges of real users in the real world. We'll go through some best practices to handle errors and exceptions, validate user input, and head off the common causes of memory leaks. Our ultimate goal is to provide an excellent experience for our users regardless of the circumstances.

Materials: Slides & Code Samples

Testing

TDD / Unit Testing / Smart Unit Tests
How do you get started with Unit Testing? A quick way is to implement some simple business rules using Test-Driven Development (TDD). This gives us a chance to understand the tools, see the importance of testing, and write code that is easy to test. We'll use Conway's Game of Life to help us get there. Tools will include MSTest, NUnit, and we'll even take a quick look at Smart Unit Tests -- a feature coming with Visual Studio 2015.

Materials: Slides & Code Samples

Unit Testing Makes Me Faster: Convincing Your Boss, Your Co-Workers, and Yourself
Bosses hate unit testing. They see it as code that doesn't contribute to the final product. But here's the truth: unit testing makes us faster. We'll look at specific examples of how unit tests save time in the development process, whether we're creating UI-based applications or server-side libraries. With this in hand, we can show our boss how testing makes us faster and lets us move forward confidently and quickly.

Materials: Slides & Code Samples
Recorded Presentation: Visual Studio Live! Austin - May 2016

Test Driven Development in the Real World
Test-Driven Development (TDD) gives us a ton of advantages. It helps us think is small pieces. It helps us build provable code. And it helps reduce the amount of unneeded code that creeps into our applications. You've seen the simple examples of TDD such as building FizzBuzz or Conway's Game of Life. Those are great for getting started, but the real world is more complicated. We have to break down complex problems into workable solutions. We have to deal with services, libraries, and dependencies. And we have to deal with strange bugs that crop up. In this session, we'll go beyond the simple examples and see how we can use TDD effectively with real-world code. Along the way, we'll learn how to break down complexity, isolate dependencies with mocking, and capture expected exceptions.

Materials: Slides & Code Samples

XAML

Intro to XAML: Don't Fear the Markup
Understanding XAML (eXtensible Application Markup Language) is a key to creating the best user experiences in .NET -- whether for desktop, tablet, or phone. We will introduce the basic concepts around XAML and take a look at various features such as namespaces, elements, properties, events, attached properties and some basic layout. We’ll create a simple WPF application that covers these fundamentals. Although you will probably end up doing most of your UI design using the drag-and-drop designer, knowing the internals gives you a leg up in making the final tweaks to ensure an excellent user experience.

Materials: Slides & Code Samples
Data Templates and Value Converters in XAML
Business applications are all about data, and laying out that data is critical to creating a good user experience. XAML environments offer us several tools, including Data Templates and Value Converters, that make this easier for the business developer to manage. By the time we're done, you will have a good understanding of the basics of both of these valuable tools.

Materials: Slides & Code Samples

Other

Becoming a Social Developer: A Guide for Introverts
This is NOT a highly-interactive workshop. Now that you feel a bit safer, make the most of your time this week: talk to other developers. This is easy -- and incredibly terrifying. A few simple steps (and a bit of bravery) is all that it takes to get started. Building your developer network will boost your knowledge, your skills, and your career. Can an introvert become a social developer? YES! And we can do this while staying true to ourselves.

Web Site: Becoming A Social Developer
Video: Meet Someone New
Recorded Presentation (10 minutes): LIVE! 360 - November 2015
Recorded Presentation (60 minutes): NDC Oslo - June 2016
Focus on the User: Making the World a Better Place
Our job as developers is to make the world a better place, whether it's connecting people, providing entertainment, or making someone's job easier. We have to know who we're building software for: our users. Understanding my users has been a key to every successful project I've worked on. I'll share some of my successes and some of my failures, and show how that's led to the approach to software that I take today. Together, we can provide our users with just what they need to make their world a bit better.

Materials: Slides & Articles
Diagnostic Analyzers and Code Fixes
The .NET Compiler Platform ("Roslyn") allows us to easily create diagnostic analyzers that can alert us to issues in code as well as provide automated code fixes. We'll create a very simple analyzer and fix to show how easy this is to do.

Video: Building a Diagnostic Analyzer with Code Fix in Visual Studio 2015 (Preview)
Getting Started with Git
We all need source control, and you may already be using a centralized source control system. But let's take a look at Git -- a distributed source control system that has 100% functionality without needing a network connection. We'll take a look at how to get started using Git, some of the useful features like branching and rollbacks, and we'll also see the built-in support that is provided in Visual Studio. After seeing how easy it is, you'll wonder why you haven't been using it all along.

Materials: Slides & Code Samples
Video: Git Basics for Visual Studio Developers
More to come...

No comments:

Post a Comment