Name: Domain-Driven Design
ISBN: 9780321125217

What Hacker News says

wuschelAug 2026

Books that come into my mind that might be useful to you:

A Philosophy of Software Design — John Ousterhout

Designing Data-Intensive Applications — Martin Kleppmann

Domain-Driven Design — Eric Evans

There might be some courses as well, but I never looked into them.

This also works quite well:

Write down the problem. Think real hard. Write down the solution. (Thank you, Feynman).

thread

jdlshoreJul 2026

I’m not really a fan of the ideas. They’re not wrong, exactly, but I think they’re overstated. Instead, here’s some alternatives:

For design, Evans’ Domain-Driven Design does a good job of representing classic object-oriented design, and Fowler’s Patterns of Enterprise Application Architecture is good for expanding past business logic to larger systems.

For coding habits, “The Pragmatic Programmer” is a classic for a reason.

thread

JachMay 2026

I think learning Common Lisp and learning Coalton are best done separately. For CL the usual reference if you already know how to program is PCL: https://gigamonkeys.com/book/ But the cookbook is invaluable as well: https://lispcookbook.github.io/cl-cookbook/ When it comes to interactive development, looking up resources about SLIME should help since a lot is transferable to the mine environment (or as I prefer, a vim+slimv environment) by having the REPL right there as well as the "beam" metaphor.

For Coalton, I'm still casually exploring it myself. I'm less convinced by the main value propositions (I really like my dynamic typing and CLOS) but I still think it's an interesting language, and being on top of CL means I can mix using it where it makes more sense (even in the same file if I want) without having to abandon CL. I assume you've found the whirlwind tour/awesome-coalton examples for it.. I've seen some usage of it as a way to write "normal" mostly procedural-ish code but with declared types that you know will be checked and used for optimization, so it's sort of like writing PHP with types, or TypeScript, or even in some ways Java or C. e.g.:

    (declare add-two-ints (Integer * Integer -> Integer))
    (define (add-two-ints a b)
      (+ a b))

And (add-two-ints 3.5 5) will type-mismatch.

But I think Coalton's really meant to support writing programs in the style of statically typed languages like Haskell, Ocaml, and F#. Those languages are more than just the above add... style of declaring types, they're about using algebraic data types to model the problem and design your program in those terms. So I'd suggest finding a book or interesting tutorial or sample project in one of those languages, and seeing if you can figure out how to translate it into Coalton, because the Coalton material is still pretty sparse. I've had some success at this by reading "Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#". It really starts at the basics that I think Coalton sort of assumes you understand already. I'll share the main basic things I've taken from it, though I invite any correction.

First, while in many languages we love to pass variables as naked ints and other native types around, making more use of the type system means you can make explicit domain types for these things. You could write something like (define-type-alias CustomerID Integer), and use CustomerID as a type in other types and function definitions. The downside is you don't get a nice constructor for it, and you can accidentally pass CustomerIDs to functions written as only expecting Integers. You can instead write (define-type CustomerID (CustomerID Integer)) and now you'll get a nice little constructor and type errors trying to pass these objects to functions expecting Integers. The downside is you'll need to extract any underlying values with pattern matching/destructuring in match expressions, function arguments, or flattened let expressions.

define-type can be used to model a single thing (like an Integer) but it can also express an "or" relationship, or a "sum type", where a value can be one of several things. e.g.:

    (define-type PaymentMethod
      (CreditCard CreditCardInfo)
      (PayPal     Email)
      (Check      CheckNumber)
      StoreCredit
      Cash)

You might construct a value with something like (Paypal (Email "string@example")), and pass along this object (which is a PaymentMethod) to a function taking a PaymentMethod and doing something to it. You would use the (match ...) syntax to handle the various cases and extract out sub-data as needed. (Note there's none for StoreCredit, it by itself is all the info you need to make a match choice. You could just as well simplify the other two options and look up data elsewhere. In another language you might use enums for this. Having data directly there can be nifty though. e.g. in a state machine with an OrderStatus that's either Unpaid, Paid, Shipped, or Cancelled, you might carry along a Reason string (or richer type) for a Cancelled status...)

define-struct can be used to model "and" relationships, or "product types", for bags of data where all fields are meant to exist at once. e.g.

    (define-struct Widget 
      (name  String)
      (sku   String)
      (price Cents))

Values are constructed like (Widget "Anvil" "1234" (Cents (* 50 100))) and individual data can be pulled out with accessors like (.name my-anvil).

Lastly you have type classes, which can be used for polymorphism in an interfaces sense. For a contrived example you might want to write a generic calculate-total-tax function that works for either Widgets (taxable) or GiftCards (not taxable). The type signature could be: (declare calculate-total-tax ((Taxable :a) => :a * Fraction -> Cents)). That is, it takes some taxable item, and a tax-rate (being lazy with a simple Fraction), and returns a Cents value. That Taxable is a type class constraint, which you define with define-class, along with any functions that make up the complete interface, such as: (get-taxable-amount (:a -> Cents)). You then use define-instance to write a get-taxable-amount function for Widgets (returning a full price), and another for GiftCards (returning 0), and so on if another type comes along. You can also extend built-in type classes this way to support your own new types.

thread

TheAlchemistJul 2025

The best way is to have a mentor. You can't beat that (in programming, as in life and any other discipline).

Second best, is looking at how the best people in the company I work for solve problems. Still takes a lot of time and effort, but I found it's well worth the effort.

As for books, A philosophy of Software Design by John Osterhout and Domain-Driven Design by Eric Evans are the ones I've found the best impactful for 'good taste'.

thread

swahJan 2025

Perplexity:

Based on the discussions from the provided Hacker News threads, here is a list of ten notable books recommended by users, particularly in the context of software engineering and programming:

## Top Ten Recommended Books

- *The Pragmatic Programmer* by Andrew Hunt and David Thomas A classic in software development, this book offers practical advice and principles for programmers.

- *Clean Code: A Handbook of Agile Software Craftsmanship* by Robert C. Martin This book emphasizes writing clean, maintainable code and has become a staple in programming literature.

- *A Philosophy of Software Design* by John Ousterhout This book provides insights into software design principles and the importance of simplicity in design.

- *Domain-Driven Design: Tackling Complexity in the Heart of Software* by Eric Evans A foundational text for understanding complex software systems and how to manage them effectively.

- *Designing Data-Intensive Applications* by Martin Kleppmann This book covers the principles of designing applications that handle large volumes of data efficiently.

- *Refactoring: Improving the Design of Existing Code* by Martin Fowler Focuses on the process of refactoring code to improve its structure without changing its functionality.

- *Code Complete: A Practical Handbook of Software Construction* by Steve McConnell This comprehensive guide covers best practices in software construction and coding techniques.

- *Effective Java* by Joshua Bloch A must-read for Java developers, this book provides best practices for writing robust Java code.

- *The Mythical Man-Month: Essays on Software Engineering* by Frederick P. Brooks Jr. A classic work discussing the complexities and challenges of managing software projects.

- *Programming Pearls* by Jon Bentley This book presents programming problems and solutions that enhance problem-solving skills and algorithmic thinking.

These books are highly regarded within the programming community and cover a range of topics from coding practices to software design philosophies, making them valuable resources for both new and experienced developers.

Citations: [1] https://news.ycombinator.com/item?id=41387062 [2] https://news.ycombinator.com/item?id=35929112 [3] https://news.ycombinator.com/item?id=32130578 [4] https://news.ycombinator.com/item?id=41387062 [5] https://news.ycombinator.com/item?id=35929112 [6] https://news.ycombinator.com/item?id=32130578 [7] https://news.ycombinator.com/item?id=29498220 [8] https://news.ycombinator.com/item?id=29306651

thread

hoerzuDec 2024

Here is a list so far: - Designing data intensive applications

- Just Enough Software Architecture

- Domain Driven Design - Tackling Complexity in the Heart of Software (Eric Evans) I recommend this one more than Vaughn Vernon's DDD.

- Clean Architecture (Robert Martin)

- Fundamentals of Software Architecture: an Engineering Approach

- Design Patterns (Gamma et al)

- Site Reliability Engineering: How Google Runs Production Systems

- Refactoring: Improving the Design of Existing Code (2nd Edition) (Addison-Wesley Signature Series (Fowler))

- Refactoring to Patterns