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.

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

C# Language Features

Getting Started with .NET Core on macOS (works on Windows 10, Too!)
Microsoft .NET Core lets us quickly spin up services, websites, and create applications that run on a variety of platforms. In this session, we'll see how to create a self-hosted service and then consume that service in a simple application. We'll use Visual Studio Code and the command-line interface (CLI) to do all of this on macOS (and these exact same projects run on Windows, too).
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.
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.
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).
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.
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.
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.
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.

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.
Learn the Lingo: Design Patterns
You already use Design Patterns but probably don't know it. Observer, Facade, Iterator, Proxy - Learning the lingo allows us to better communicate your ideas with other developers. 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.
Abstract Art: Getting Things "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 to dial in the level of abstraction that is "just right" for our applications.
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. We'll think in small pieces and take a look at some techniques to keep our code manageable and understandable. Think about the next developer to maintain the code. Now, imagine he's a homicidal maniac who knows where you live.
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.
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.


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.

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.


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 Windows 8 application that covers these fundamentals. Although you will probably end up doing most of your UI design with a drag-and-drop tool such as Expression Blend, knowing the internals gives you a leg up in making the final tweaks to ensure an excellent user experience.
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.


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.
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.
More to come...

No comments:

Post a Comment