The Eric Normand Podcast

What is a mutation function? 12.12.2022 6:07 ↓

Mutation functions let you represent changing state over time. They are easily reified, used as reducing functions, and can operate on nested data.

What is Signature-Driven Development? 06.12.2022 11:14 ↓

Signature-Driven Development means starting with function signatures before you implement them. I also discuss why we implement the hardest function first.

Is deferring decisions about our domain a good idea? 21.11.2022 5:38 ↓

I wonder when to deal with business rules. Do they belong in the domain layer?

Can domain modeling be taught? 14.11.2022 9:01 ↓

I answer a listener's questions about whether domain modeling is a skill that can be taught.

Why domain modeling? 07.11.2022 5:59 ↓

We explore why focusing on the domain model can improve your software quality.

How do we evaluate a data model? 31.10.2022 31:04 ↓

We talk about how you can evaluate the two parts of a domain model.

What is a domain model and how do we think about them? 24.10.2022 24:37 ↓

In this episode, I talk about the three-part model of domain modeling and what it means about how they are used.

When do we want to refer to things by name? 17.10.2022 11:50 ↓

In a domain model, when should we refer to things by name, and when should we nest a subcomponent?

Collections in domain models 10.10.2022 17:59 ↓

When do we use collections in domain models, and how do we think about the states they represent?

Layout of Domain Modeling book 03.10.2022 25:07 ↓

In this episode, I talk about the three parts of my book, which mirror the three levels of domain modeling.

The power of runnable specifications 29.08.2022 14:39 ↓

I talk about the advantages of writing a spec directly in your production language.

What is a domain model? 22.08.2022 10:08 ↓

In this episode, I continue the exploration of the definition of domain model to serve as a base layer of understanding to write my next book.

What is a high-level language? 15.08.2022 6:53 ↓

We've all heard the term _high-level language_. Initially, it referred to the step from assembly languages to compiled languages. But it has another definition, which has to do with how well the language lets you think.

Rewrites 08.08.2022 9:34 ↓

How is Smalltalk so small? Four rewrites.

Is the abstract stuff at the top or the bottom? 24.04.2022 14:26 ↓

I explore a new perspective about what abstraction means and how it can cause problems.

The Christopher Alexander Effect 07.02.2022 13:34 ↓

Why does some design advice work for some people, but not for others? And why do some agile practices work for some people, but not for others? I call that The Christopher Alexander Effect and explain how it works.

My feelings about static vs dynamic typing 31.01.2022 35:37 ↓

Can't we all just get along?

Computer Science as Empirical Inquiry: Symbols and Search 10.01.2022 2:04:33 ↓

In this episode, I excerpt from and comment on Allen Newell's and Herbert Simon's 1975 ACM Turing Award Lecture.

How far can we stretch technical debt? 15.11.2021 24:52 ↓

Technical debt is a metaphor used to explain the tradeoff we all face when we have a deadline. How much is it worth to rush the code out the door? It's a good metaphor, but the term is often used these days to mean 'code I don't like'. In this episode, I examine the parts of the metaphor and ways in which technical debt differs from financial debt.

How to avoid premature optimization? 08.11.2021 32:10 ↓

I explore why clean code is a lagging indicator and how the domain model is a leading indicator of maintenance cost.

What is domain modeling? 01.11.2021 21:46 ↓

I begin exploring the process of domain modeling with a definition.

Computer Programming as an Art 27.09.2021 1:21:01 ↓

I read from the 1974 Turing Award Lecture by Don Knuth.

Programmer as Navigator 30.08.2021 1:11:29 ↓

We read and discuss the 1973 ACM Turing Award Lecture by Charles W. Bachman.

The Humble Programmer 02.08.2021 2:16:14 ↓

We read from and comment on Edsger Dijkstra's 1972 Turing Award Lecture called The Humble Programmer. Is the problem with programming that we don't recognize our own limitations? We'll explore that and more.