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 Asynchronous Methods 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 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.

Using Channels in C# to Enhance Concurrent Code

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 Is Probably Wrong

C# 8 brought new features to interfaces, including default implementation, access modifiers, and static members. We'll look at these new 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 .NET

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 types, 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 the time we're done, we'll see how delegates can add elegance, extensibility, and safety to our programming. And as a bonus, you'll have a few functional programming concepts to take with you.

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.

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.

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 for Absolute Beginners: 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.

Catching Up With C#: What You May Have Missed

C# has been changing rapidly over the last several years. You may have heard of some of the items like tuples, string interpolation, and nullable reference types. But how may of the 50 changes (starting with C# 6) do you actually know? We'll take a closer look at 10 of the changes that are most important to your code, including nameof, discards, pattern matching, expression-bodied members, various null operators, and auto-property updates. And of course, there will be resources to see the rest of the updates.

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 principles and techniques that will keep our code manageable and understandable. Think about the developer who will come after you. Now, imagine that he's a homicidal maniac who knows where you live.

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.

Get Comfortable with .NET Core and the CLI

.NET Core is the future of .NET. So let's get comfortable with the 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 Core or have been using .NET Core with Visual Studio, this session will help you get up-to-speed in this powerful environment.

Get Func-y: Understanding Delegates in .NET

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 types, 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 the time we're done, we'll see how delegates can add elegance, extensibility, and safety to our programming. And as a bonus, you'll have a few functional programming concepts to take with you.

Getting Started with .NET Core on macOS

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 C# Interfaces

We all want code that is easy to maintain, extend, and test. 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.

I'll Get Back to You: Task, Await, and Asynchronous Methods 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 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.

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

Leggo My Ego

As developers it's really easy for us to let our egos get in the way. And that's understandable. What we do is a creative process: we're problem solving and coming up with new and creative ways of doing things on a regular basis. We need to take pride in our work, but there are serious consequences when we let too much ego get involved: we can become defensive, isolated, and stubborn. Our teams can fall apart due to lack of sharing, mentoring, and communication. Let's figure out how to keep things in balance so that we are open to other ideas, helpful to other developers, and also able to take the appropriate amount of pride in the work that we do. Together, we can make the world a better place.

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.

Run Faster: Parallel Programming in C#

Want to see code run 6 times faster? Join me as we use parallel programming to make full use of our multi-core systems. We'll use techniques such as the .NET Parallel.ForEach, and we'll also spin up Tasks manually to take more control over the process. Along the way, we'll see how to write code that is easy to run in parallel (warning: it may start you down the path of functional programming). Use the hardware you have to run faster.

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.

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

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.

What's New in C# 8 Interfaces (and how to use them effectively)

C# 8 brings new features to interfaces, including default implementation, access modifiers, and static members. We'll look at these new 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.