Jeremy Clark

Information & Communications Technology

Sedro-Woolley, Washington, United States

Jeremy Clark

Developer Betterer

Jeremy Clark makes developers better. By drawing on over 15 years of experience in application development, he helps developers take a step up in their skill set with a focus on making complex topics approachable regardless of skill level. He is a Microsoft MVP for .NET, and he has authored seven courses for Pluralsight, including "C# Interfaces", a course aimed at giving developers a clear understanding of abstraction. He loves speaking and has delivered over 300 technical presentations in the last 10 years in the United States and Europe. Jeremy lives in northern Washington with his lovely wife, 3 cats, 2 dogs, and a banjo.

Current sessions

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 lets understand delegates and how we can change the way we program by using functions as parameters, variables, and properties. In addition, we'll see how the built in delegate types, Func and Action, are waiting to make our lives easier. We'll see how delegates can add elegance, extensibility, and safety to our programming.


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.


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. With some practical tips, "gotchas", and plenty of examples, we'll see how to use these features effectively in our code.


WORKSHOP Leveling Up: Asynchronous Programming in C#

Asynchronous programming is a critical skill to take full advantage of today's multi-core systems. But async programming brings its own set of issues. In this workshop, we'll work through some of those issues and get comfortable using parts of the .NET Task Parallel Library (TPL).

We'll start by consuming asynchronous methods using the Task Asynchronous Pattern (TAP), including how to handle exceptions and cancellation. With this in hand, we'll look at creating our own asynchronous methods and methods that use asynchronous libraries. Along the way, we'll see how to avoid deadlocks, how to isolate our code for easier async, and why it's important to stay away from "asyc void".

Throughout the day, we'll go hands-on with lab exercises to put these skills into practice.

Objectives
o Use asynchronous methods with Task and await
o Create asynchronous methods and libraries
o Handle exceptions and cancellation
o Prepare code for asynchronous operations

Pre-Requisites
Basic understanding of C# and object-oriented programming (classes, inheritance, methods, and properties). No prior experience with asynchronous programming is necessary; we'll take care of that as we go.


WORKSHOP Leveling Up: Dependency Injection in C#

Loosely coupled code is easier to maintain, extend, and test. Dependency Injection (DI) help us get there. In this workshop, we'll see how interfaces can add "seams" to our code that makes it more flexible and maintainable. From there, we'll dig into loose coupling with Dependency Injection. DI doesn't have to be complicated. With just a few simple changes to our constructors or properties, we can have code that is easy to extend and test.

After laying a good foundation, we'll take a closer look by diving into various DI patterns (such as constructor injection and property injection) as well as other patterns that help us handle interception and optional dependencies. Along the way, we'll see how DI helps us adhere to the SOLID principles in our code. We'll also we'll look at common stumbling blocks like dealing with constructor over-injection, managing static dependencies, and handling disposable dependencies.

Throughout the day, we'll go hands-on with labs to give you a chance to put the concepts into action.

If you're a C# developer who wants to get better with concepts like abstraction, loose coupling, extensibility, and unit testing, then this is the workshop for you.


WORKSHOP Leveling Up: Unit Testing with C#

Unit testing can make you a faster developer. Good tests let us move forward more confidently, give us instant feedback when checking regression, and help us pinpoint bugs when things go wrong. In this workshop, we'll look at the qualities of good tests, including isolation, repeatability, runnability, and more. And we'll look at specific techniques that make our tests easy to ready, easy to write, and easy to run.

We'll go hands-on with TDD (Test-Driven Development) to see the red-green-refactor cycle in action. Some code is tricky to test: we'll look at how to test for exceptions and error states, and we'll use a mocking framework to create mocks and stubs. Tools include MSTest and NUnit (for testing) and Moq (for mocking), but the skills easily translate to other frameworks.

Objectives
o Why Unit Test? Getting the actual benefits
o Characteristics of a good unit test and how to implement them (including isolation, repeatability, runnability, and more)
o Basics of TDD
o Parameterizing tests
o Techniques for testing exceptions
o Using a mocking framework to isolate dependencies

Pre-Requisites
Basic understanding of C# and object-oriented programming (classes, inheritance, methods, and properties). In addition, experience with interfaces and other forms of abstraction is very helpful. No prior experience with unit testing is necessary; we'll take care of that as we go.