Calendar

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

2021-01-28T07:00:00

  days

  hours  minutes  seconds

until

NDC London 2021

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.

UK .NET Virtual Meetup – February 17, 2021 @ 11:00 am 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.

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.

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.