Calendar

This is my current calendar of speaking events. More details on the talks are listed below the calendar.

2021-05-11T09:00:00

  days

  hours  minutes  seconds

until

DeveloperWeek Global: Management

Techorama – May 18, 2021 @ 05:45 PT

Port that .NET Framework application to .NET 5
.NET 5 represents a new era within the .NET ecosystem. New development on the .NET Framework has ended, and while it is still a viable application framework, the writing is definitely on the wall as there is no reason that any new development projects would use the v4.x .NET Framework. Instead, they would most likely be on .NET 5 or .NET Core 3.1. This could end up with projects within a company being scattered across various development frameworks as your team manages both current applications and new systems. In this session we will look at how to port your .NET Framework application. We will use the Porting Assistant for .NET (an open source AWS-created application” to evaluate the level of effort needed to convert the applications as well as work through several of the most common porting issues and concerns.

DeveloperWeek Global: Management – May 11, 2021 @09:00 PT

Are we done yet?
The definition of “done” is a historic problem in software development. Developers and their product stakeholders tend to look at this problem as “how well the delivered product matches the requirements.” However, there is another problem with “done”, and that is the evaluation as to when a release is ready to be set free to run amok in the wild. This becomes even more complicated when we look at things like working in the cloud where your release may include new system resources – are those “done” at a different time? In a period of continuous release cycles – are things ever done?

This session is based on stories around determining done-ness. We will look at test-cases and test-paths as an evaluation criteria. We will talk about how UI interactions affect the ability to determine “done.” We will also look at risk enhancers, such as configurable business logic, CI/CD, and Infrastructure as Code, and how those enhancers affect our ability to understand “done.” Lastly, we will discuss some real-world stories about the QA of complicated systems.

NDC Workshops – May 4 & 5 – full day

Converting a Monolithic App to a more Domain-Driven Design
Implementing a system using domain-driven design seems “straight-forward” when looking at a brand new system. Changing an existing enterprise system, especially one built in the monolithic approach that was common a few years ago, can be daunting. In this workshop we will take a hands-on approach to working through the steps necessary to refactor a non-DDD monolithic application using “traditional” DDD approaches.

As part of this workshop you will convert a simplified monolithic web application to a system running in a more domain-driven approach. Generally, in each section we will talk about various patterns and implementation strategies, you will have some time to do some implementation yourself in code, and then we will review an example where the conversion has already been completed. As we go through each area there will be some discussion of tips and tricks and perhaps some horror stories about where it has gone completely wrong.

The various areas we will cover:
1) Strategies for getting started
2) Defining domains when working within a monolithic system
3) Evaluating current unit and integration tests for ability to support refactoring efforts
4) Implementing micro-services over a monolothic back-end
5) Converting historical-data access patterns to CQRS
6) Splitting, segmenting, and changing the business layer to stay within the domain
7) Communicating between domains with events and messaging
8) Dev-Ops considerations in a DDD world

Salt Lake City .NET User Group – March 11, 2021 @ 4:30 pm PT

Modernizing an Existing System to Take a More Domain-Driven Approach
Distributed computing and the cloud go hand-in-hand. However, there are a lot of applications that are built in a more classic way that does not take into account the cloud and what it offers. In this discussion we will talk about modernizing an application or system. We’ll talk a bit about domain-driven design and several of the more common design patterns used during a refactor. After the theory, we will step into the realm of the practical and walk through the process of performing changes on a large application.

Confoo.ca – February 24, 2021 @ 11:15 am PT

Software Refactor Patterns
The only thing constant about software is that it changes. Whether you need to remove technical debt, move to the cloud, or add new functionality – changing software seems to be a constant part of being a software developer. In this session, we will go over the primary refactor design patterns, look at how they can be implemented (in C#\.NET), and tell some stories about them being used in real-life.

DeveloperWeek Virtual 2021 – February 18, 2021 @ 1:00 pm PT

Up-skilling while still checking in
How do you switch design paradigms, or shift technologies or architectures – especially when not all of your team has the requisite knowledge? Many times this means that either some of your team will be left behind or you have to stop\slow development. Who likes those choices? We will go over a couple of up-skilling strategies that will keep a developer team productive while updating their skills and knowledge as part of their job. Download the deck from here.

NDC London 2021 – January 28, 2021 @ 07:00 am PT

Software and Database Refactor Patterns
Many of us are working on enhancing and maintaining systems that have some longevity. Changing these systems in any meaningful manner is dangerous. I learned during my years as a consultant that one of the most common problems that companies have when trying to revitalize applications is understanding where to start. In this session we will talk about various software and database refactor patterns that are designed to limit that danger, ensure forethought and planning around any major refactoring efforts, and give confidence around the likelihood of success for a refactoring. We will talk about various reasons for refactoring an application and discuss those patterns commonly used to support that refactor. As part of this discussion we will also talk about external factors, such as team size and experience, can affect the success around various pattern implementations. You can download the deck here.

DeveloperWeek New York 2020 December 9, 2020 @ 10:00 am PDT

Designing a microservice
In this session we will walk through the nuts and bolts of designing a microservice for a complex business need. We will go over some conceptual considerations such as eventual consistency through messaging and data ownership. We will also go over the implementation of event sourcing and command-query responsibility segregation (CQRS), what that would look like within a single microservice, and how they relate to an entire system. You can download the deck from here.

O’Reilly – About the Software Architecture Superstream Series November 11, 2020 @ 12:00 pm PDT

Modernizing an Existing System to Take a Domain-Driven Approach
Domain-driven design seems straightforward when looking at greenfield development. Implementing DDD in an existing enterprise system, however, is daunting. Here’s something to make the process easier. We will walk through a step-by-step refactoring of a non-DDD SOA-based system using DDD approaches, especially command-query responsibility segregation (CQRS) and event sourcing patterns.

DeveloperWeek Global: Enterprise 2020 November 10, 2020 @ 11:00 PST

Microservices + purpose built databases
When building applications in a pure microservices architecture you have the luxury of flexibility around how you persist the data. Rather than being forced into a database system that tries to support all of your cross-domain use cases, you can choose a data persistence strategy that makes the most sense for that microservice. The full-deck is available here.

{API: World} 2020 October 29, 2020 @ 10:00 am PDT

Software Refactoring Patterns for Moving to Microservices
Dependence on APIs and microservices will continue to grow as development teams gain experience in this approach. New development is pretty straightforward around this approach. Refactoring existing systems, however, is not. In this session, we will go over the primary refactor design patterns, look at how they can be implemented, and tell some stories (some funny, some scary) about their usage in real-life. You can get the deck here.

.NET Developer Days 2020 October 21, 2020 @ 05:45 am PDT

Modernizing an existing system to take a more domain-driven approach
Domain-driven design seems “straight-forward” when looking at green field development. Implementing that in an existing enterprise system, however, is daunting. In this session we will go over some of the refactoring patterns that support this change and we will demonstrate the steps necessary to refactor a non-DDD SOA-based system using DDD approaches. We will talk about the kinds of decisions that have to be made, when they need to be made, and what those decisions look like in the grand scheme of your refactor. You can download the deck here.

NDC Sydney 2020 October 14, 2020 @ 4:20 pm PDT

Modernizing an existing system to take a more domain-driven approach
Domain-driven design seems ‘straight-forward’ when looking at green field development. Implementing that in an existing enterprise system, however, is daunting. In this workshop we will demonstrate the steps necessary in refactoring a non-DDD SOA-based system using DDD approaches, especially Command-Query Responsibility Segregation (CQRS) and Event Sourcing patterns. We will talk about the kinds of decisions that have to be made, when they need to be made, and how to recover from bad decisions. The use of a service-oriented architecture is not new. There are thousands of existing enterprise systems that are built using SOA. This would typically look like a set of ‘client applications’ that talk to a set of ‘back-end services’ that were designed using a one-size-fits-all approach, where the representation of a persisted object is a union of all the business needs. The growth in domain-driven design shows how that may not be the best approach. You can download the deck from here. Video for the talk has been posted onto YouTube by NDC, and is available here.

TDevConf 2020 October 3, 2020 @ 11:40 am PDT

Modernizing an existing system to take a more domain-driven approach
Domain-driven design seems ‘straight-forward’ when looking at green field development. Implementing that in an existing enterprise system, however, is daunting. In this workshop we will demonstrate the steps necessary in refactoring a non-DDD SOA-based system using DDD approaches, especially Command-Query Responsibility Segregation (CQRS) and Event Sourcing patterns. We will talk about the kinds of decisions that have to be made, when they need to be made, and how to recover from bad decisions. The use of a service-oriented architecture is not new. There are thousands of existing enterprise systems that are built using SOA. This would typically look like a set of ‘client applications’ that talk to a set of ‘back-end services’ that were designed using a one-size-fits-all approach, where the representation of a persisted object is a union of all the business needs. The growth in domain-driven design shows how that may not be the best approach.

DeveloperWeek Global: Cloud 2020 September 30, 2020 @ 10:30 am PDT

Refactor or Replace: Evolving a Software System
Software systems age just like living entities; they have a period of robust life and then start to get slower and more fragile over time. At some point you have to take an objective look at your system and determine whether you can refactor it back into robustness, or whether your best option is to simply replace it. In this session we will go over the factors that play into this determination, including current architectural design and code smells, development team experience, SDLC processes, risk tolerance, and leadership. We will also work through several high-level approaches to managing both refactoring and replacement efforts. Download the deck from here.