Thoughts about Absurdism, essence, and software design. | Continue reading
DTOs help you create a more stable RESTful API; they protect your API clients from changes made on the server. | Continue reading
Determining if the complexity of a problem is related to the nature of the problem or related to the way that we approach solving it. | Continue reading
Two approaches to implementing separation of concerns and better cohesion of operations in your GraphQL schema. | Continue reading
There's a lot of advantages to using GraphQL instead of REST on your server, and there's a lot of advantages to using Apollo Client instead of writing your own data-fetching logic. In this article, we talk about some of GraphQL's greatest architectural advantages. | Continue reading
The single biggest thing that improved the quality of my designs was understanding how dependencies influence my ability to write tests. In this article, I'll show you how I write testable code. | Continue reading
There are so many reasons why event-based systems are the standard for large-scale enterprise applications like GitHub, Facebook, Google, etc. In this article, I list a few reasons why I believe in 'em. | Continue reading
Apollo's REST Data Source does a lot more than you'd think behind the scenes, and that's why it's recommended instead of using a wrapped HTTP library like Axios or Fetch in order to hook up data to your resolvers. | Continue reading
In this blog post, I explain how using a private constructor helps to force a single way to create an object, and why it's most commonly used with the Factory Pattern. | Continue reading
GraphQL is the latest API style on the block. It's a modern way for us to pull data out of your system (queries) and make changes to your system (mutations). I'm finally committing to learning everything GraphQL in 2020. In this article, I'll break down my personal learning roadm … | Continue reading
Software Design and Architecture is pretty much it's own field of study within the realm of computing, like DevOps or UX Design. Here's a map describing the breadth of software design and architecture, from clean code to microkernels. | Continue reading
Software Design and Architecture is pretty much it's own field of study within the realm of computing, like DevOps or UX Design. Here's a map describing the breadth of software design and architecture, from clean code to microkernels. | Continue reading
In this article, we'll walk through the process of using Domain Events to clean up how we decouple complex domain logic across the subdomains of our application. | Continue reading
Should we utilize Domain-Driven Design principles and patterns in front-end applications? How far does domain modeling reach from back-end into front-end? | Continue reading
Should we utilize Domain-Driven Design principles and patterns in front-end applications? How far does domain modeling reach from back-end into front-end? | Continue reading
Instead of a DI Container, I just package features by component and use logical naming conventions. | Continue reading
In this article, you'll learn about the Clean Architecture, why we should separate the concerns of large applications into layers, the 6 most common types of application logic, and which layer they belong to. | Continue reading
In this article, you'll learn about the Clean Architecture, why we should separate the concerns of large applications into layers, the 6 most common types of application logic, and which layer they belong to. | Continue reading
Dependency Injection and Depdency Inversion are two related but commonly misused terms in software development. In this article, we explore both types of DI and how you can use it to write testable code. | Continue reading
The term brutalism is often associated with Brutalist Architecture, however it can apply to other forms of construction and art, such as web design and music. | Continue reading
CQS (Command-Query Segregation) is a design principle that states that a method is either a COMMAND that performs an action OR a QUERY that returns data to the caller, but never both. | Continue reading
CQS (Command-Query Segregation) is a design principle that states that a method is either a COMMAND that performs an action OR a QUERY that returns data to the caller, but never both. | Continue reading
In this guide, we walk through the process of creating a TypeScript project from scratch with hot-reloading, and scripts for building, development, and production environments. | Continue reading
How to expressively represent (database, validation and unexpected) errors as domain concepts using functional programming concepts and how to hook those errors up to our Express.js base controller. | Continue reading
In this article, we discuss how we can use a few CQS principles to handle unbounded 0-to-many or many-to-many collections in aggregates when designing web applications for performance. | Continue reading
In this article, you'll learn how identify the aggregate root and encapsulate a boundary around related entities. You'll also learn how to structure and persist aggregates using the Sequelize ORM on White Label, the open-source Vinyl Trading app. | Continue reading
Functional programming is not the end to all of our problems. Quality software is all three paradigms. | Continue reading
An intention revealing interface is a standard for writing code that is expressive enough to adequately explain it's purpose without needing to explain implementation details. In this article, we look at how to use intention revealing interfaces to write code that is well-underst … | Continue reading
In this post, I explain how good ol' fashioned encapsulation + TypeScript getters and setters enable us to effectively create Domain Events directly from the aggregate roots in our domain-driven design projects. | Continue reading
In this blog post, we talk about the utility of getters and setters in modern web development. Are they useless? When does it make sense to use them? | Continue reading
Originally published here June 2019, with discussions on Hackernews and Reddit. Melvin Conway is credited with that quote back in 1967.In simple terms, Conway… | Continue reading
In this article, we explore how organizing application logic as Use Cases in the application layer helps to make large typescript projects easier to reason about. | Continue reading
There are several patterns that we can utilize in order to handle data access concerns in Domain-Driven Design. In this article, we talk about the role of DTOs, repositories & data mappers in DDD. | Continue reading
Naming files & folders well, using well-understood technical constructs and strategically organizing files well are three ways to improve our ability to change code quickly. | Continue reading
The Single Responsibility Principle specifies that a class or function should only have one reason to change. Admittedly, that's not very clear. This article describes why understanding the domain is important to know how SRP can be implemented. | Continue reading
More and more money is being spent by companies on maintaining bad JavaScript code. Here's where I think our industry needs to change. | Continue reading
In this article, we'll look at the various different versions of the "clean architecture", simplify it, and understand how we can use it to write more flexible Node.js code with TypeScript. | Continue reading
Entities are the first natural place we should aim to place business logic in domain-driven applications. In this article, we talk about the roles and lifecycle of an entity in Domain-Driven Design. | Continue reading
MVC the granddaddy of application architectures. In this article, we explore common MVC patterns, the responsibilities of the "M"- model, and when it makes sense to look to other architectures. | Continue reading
The SOLID principles are a set of software design principles that teach us how we can structure our functions and classes to be as robust, maintainable and flexible as possible. | Continue reading
Recycled from the 'When to Use TypeScript' [Guide] article posted April 6th, 2019The Performant System Problem, the Embedded System Problem, and the Complex… | Continue reading
A comparison between designing Node.js applications using REST-first design and Domain-Driven Design. | Continue reading
Purposefully throwing errors can have several negative side effects to the readability and traceability of your code. In this article, we take a look at an alternative to how to handle errors within your Node.js + TypeScript applications. | Continue reading
In this article, we explore how to structure a clean and consistent Express.js controller by using abstraction and encapsulation with TypeScript. | Continue reading
Domain-Driven Design is the approach to software development which enables us to translate complex problem domains into rich, expressive and evolving software. It's the way we design applications when the needs of our users are complex. | Continue reading
Value Objects are one of the primary components of Domain-Driven Design. Here's a simple Value Object class in TypeScript. | Continue reading
Strap yourself in. In this guide, we compare when it's absolutely vital to be using TypeScript, the strictly-typed programming language, and when it makes sense to stick to vanilla JavaScript. | Continue reading
Sequelize is a great ORM for NodeJS applications that are built on relational backends. Inevitably, you'll need to update your models as the database requirements change.. or if you did something silly. Here's a real life approach to using Sequelize to doing database migrations. | Continue reading