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