Jeremy Bytes

byte-sized chunks of .NET

For a link to past presentations, please see: Presentations

Featured Topics

I'll Get Back to You: Task, Await, and Async in C#

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 call 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.

Better Parallel Code with C# Channels

Producer/consumer problems show up in a lot of programming scenarios, including data processing and machine learning. Channels give us a thread-safe way to communicate between producers and consumers, and we can run them all concurrently. In this presentation, we will explore channels by comparing parallel tasks with continuations to using a producer/consumer model. In the end, we'll have another tool in our toolbox to help us with concurrent programming.

Catching Up With C# Interfaces: What You Know May Be Wrong

C# 8 & C# 11 brought new features to interfaces, including default implementation, access modifiers, and static members. We'll look at these features, and see where they are useful and where they should be avoided. The world of interfaces has changed; the line between interfaces and abstract classes has blurred; and C# now has multiple inheritance (sort of). With some practical tips, "gotchas", and plenty of examples, we'll see how to use these features effectively (and safely) in our code.

A Tour of Go for the C# Developer

Learning other programming languages enhances our work in our primary language. From the perspective of a C# developer, the Go language (golang) has many interesting ideas. Go is opinionated on some things (such as where curly braces go and what items are capitalized). Declaring an unused variable causes a compile failure; the use of "blank identifiers" (or "discards" in C#) are common. Concurrency is baked right in to the language through goroutines and channels. Programming by exception is discouraged; it's actually called a "panic" in Go. Instead, errors are treated as states to be handled like any other data state. We'll explore these features (and others) by building an application that uses concurrent operations to get data from a service. These ideas make us think about the way we program and how we can improve our day-to-day work (in C# or elsewhere).

Get Func-y: Understanding Delegates in C#

Delegates are the gateway to functional programming. So let's understand delegates and how we can change the way we program by using functions as parameters, return values, variables, and properties. In addition, we'll see how the built-in delegate types (Func and Action) are waiting to make our lives easier. By looking at code, we'll see how delegates can add elegance, extensibility, and safety to our programming.

LINQ - It's Not Just for Databases

LINQ (Language Integrated Query) is mostly associated with Entity Framework and database access. But it can be used for much more. LINQ lets us sort, filter, and aggregate data all in memory without needing to make another database call. In this session, we will build up an application that manages my book collection, including filtering, grouping, sorting, and even controlling how items are sorted. We will use the LINQ fluent syntax to combine functions and make a great user experience.

All Topics

A Banjo Made Me a Better Developer

What does a banjo have to do with software development? They both require learning. And picking up a banjo later in life showed me 3 things that I've brought into my developer life. (1) You can learn; a growth mindset removes blockages. (2) You don't have to be afraid to ask for help; experienced banjoists/developers can point you in the right direction. (3) You don't have to be perfect before you share what you've learned; it's okay to show what you have "in progress". In combination, these have made me a better banjo player and a better developer.

A Tour of Go for the C# Developer

Learning other programming languages enhances our work in our primary language. From the perspective of a C# developer, the Go language (golang) has many interesting ideas. Go is opinionated on some things (such as where curly braces go and what items are capitalized). Declaring an unused variable causes a compile failure; the use of "blank identifiers" (or "discards" in C#) are common. Concurrency is baked right in to the language through goroutines and channels. Programming by exception is discouraged; it's actually called a "panic" in Go. Instead, errors are treated as states to be handled like any other data state. We'll explore these features (and others) by building an application that uses concurrent operations to get data from a service. These ideas make us think about the way we program and how we can improve our day-to-day work (in C# or elsewhere).

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 to dial in the level of abstraction that is "just right" for our applications.

ASP.NET MVC Conventions: Your Secret Decoder Ring

ASP.NET MVC is filled with hidden conventions: put a controller or view in a certain place and give it a special name, and it magically works. If you know the conventions, you can quickly get an application up and running. But if you don't know the secret codes, all is lost. In this session, you will learn the conventions of ASP.NET MVC around controllers, views, parameters, layouts, and routing. Once you have the decoder ring, you can focus on the parts of your web application that make it unique.

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.

Better Parallel Code with C# Channels

Producer/consumer problems show up in a lot of programming scenarios, including data processing and machine learning. Channels give us a thread-safe way to communicate between producers and consumers, and we can run them all concurrently. In this presentation, we will explore channels by comparing parallel tasks with continuations to using a producer/consumer model. In the end, we'll have another tool in our toolbox to help us with concurrent programming.

Catching Up With C# Interfaces: What You Know May Be Wrong

C# 8 & C# 11 brought new features to interfaces, including default implementation, access modifiers, and static members. We'll look at these features, and see where they are useful and where they should be avoided. The world of interfaces has changed; the line between interfaces and abstract classes has blurred; and C# now has multiple inheritance (sort of). With some practical tips, "gotchas", and plenty of examples, we'll see how to use these features effectively (and safely) in our code.

Code is for Humans

The computer understands your code just fine. But what about humans? The world is constantly changing, and your applications need to change with it. Humans make those changes; sometimes it's you, sometimes it's someone else. So let's look at some practical techniques to keep code readable, such as working in small pieces, coming up with good names for methods and objects, and avoiding "clever" code. Think about the next developer who needs to change this code. Often that developer is you from six months in the future.

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.

DI Why? Getting a Grip on Dependency Injection

Many of our modern frameworks have Dependency Injection (DI) built in. But how do you use that effectively? We need to look at what DI is and why we want to use it. We'll look 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.

Diving Deeper into Dependency Injection

You know the basics of dependency injection (DI). Now it's time to take a closer look at how DI patterns and other design patterns can help us use DI effectively. We'll look at implementations and uses for DI patterns including constructor injection, method injection, and property injection. In addition, we'll use other design patterns to add functionality to existing objects and to manage disposable dependencies. We'll leave with several practical ways to improve the functionality and testing of our code.

Focus on the User: Make 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.

Get Comfortable with .NET and the CLI

Command-line interfaces (CLI) can be very powerful. The same is true in the .NET world. So let's get comfortable with creating, running, and testing applications using the command-line interface. We'll create a self-hosted web service and then write an application to use that service. Unit tests will make sure things work along the way. Whether you're new to .NET or have been using .NET with Visual Studio, this session will help you get up-to-speed in this powerful environment.

Get Func-y: Understanding Delegates in C#

Delegates are the gateway to functional programming. So let's understand delegates and how we can change the way we program by using functions as parameters, return values, variables, and properties. In addition, we'll see how the built-in delegate types (Func and Action) are waiting to make our lives easier. By looking at code, we'll see how delegates can add elegance, extensibility, and safety to our programming.

IEnumerable, ISaveable, IDontGetIt: Understanding C# Interfaces

You want code that is easy to maintain, extend, and test. C# interfaces are here to help. In this session, you will learn we to use interfaces effectively in your code, starting at the beginning ("What are interfaces?") and then exploring why and when to use them. Along the way you'll learn how to use existing interfaces, implement your own interfaces, and also use interfaces for unit testing and dependency injection. The result is code that is easier to maintain, extend, and test.

I'll Get Back to You: Task, Await, and Async in C#

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 call 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.

Learn to Love Lambdas in C# (and LINQ, Too!)

Lambda expressions in C# 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. In addition, lambdas let us scope our variables more appropriately with captured variables. We’ll take a look at how lambda expressions work and see them in action. We’ll also see how LINQ can help us move from imperative programming to declarative programming (a gateway to functional-style programming).

LINQ - It's Not Just for Databases

LINQ (Language Integrated Query) is mostly associated with Entity Framework and database access. But it can be used for much more. LINQ lets us sort, filter, and aggregate data all in memory without needing to make another database call. In this session, we will build up an application that manages my book collection, including filtering, grouping, sorting, and even controlling how items are sorted. We will use the LINQ fluent syntax to combine functions and make a great user experience.

Practical Reflection in C#

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, such as making runtime decisions for features and functionality -- all while balancing flexibility, safety, and performance.

Safer Code: Nullabilty and Null Operators in C#

New projects in C# have nullable reference types enabled by default. This helps make the intent of our code more clear, and we can catch potential null references before they happen. But things can get confusing, particularly when migrating existing projects. In this session, you will learn about the safeguards that nullability provides as well as the problems you still need to watch out for yourself. In addition, you will learn the various null operators in C# (including null conditional, null coalescing, and null forgiving operators). These can make your code more expressive and safe.

Test-Driven Development in the Real World

Are you tired of trivial TDD examples like FizzBuzz? I am. So let's look at a real-world problem to see how Test-Driven Development (TDD) helps us think is small pieces, build provable code, and reduce the amount of unneeded code that creeps into our applications. In the real world, 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 learn how to break down complexity, isolate dependencies with mocking, and capture expected exceptions.

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. And maybe you see testing that way, too. 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 by letting us code more confidently, catch bugs earlier, and minimize manual testing. With this in hand, we can show our boss (and ourselves) how unit testing makes us faster.