News for hackers. Stuff that matters.
Re:Hexagonal Architecture and Domain Driven Design by shoo on Tuesday April 12, 2022 @04:44AM (#31000105)
> Keep your domain models separate from infra implementation stuff

this is a corollary of the S in SOLID -- domain models and infra implementations will have different reasons to change at different times, so they should be decoupled

> Architect your applications in sensible layers > Decouple stuff that doesn't strictly belong together

Agreed, but this isn't prescriptive enough, if you put 5 opinionated stakeholders in a room, they may argue over 25 different incompatible ideas of "sensible". Parnas suggests arranging things into modules so that changes or difficult decisions are isolated to single modules. Basically the same idea as S in SOLID. The D in SOLID suggests a concrete way to decouple things (interfaces!).

> This stuff should not need lists of XML config to get right

agreed. the key idea is to think about the dependency graph between modules. XML config & dependency injection & so on are some techniques for managing dependencies, but it is less important that figuring out a clean module design and module dependency structure that decouples the application.

Many possible candidate dependencies between pairs of modules should be banned as they would erode the architecture and add unnecessary coupling between things that need to change in response to different forces. With some extra knowledge about the purpose of each module, it should be possible to write a small validation tool that can inspect module dependencies and automatically fail the build if someone proposes to add a bad dependency.

https://en.wikipedia.org/wiki/SOLID

http://sunnyday.mit.edu/16.355/parnas-criteria.html

Re:Hexagonal Architecture and Domain Driven Design by berkes on Tuesday April 12, 2022 @04:49AM (#31000133)
> This stuff should not need lists of XML config to get right

I'm "doing" DDD in "hexagonal monoliths" for years now. And have never touched a line of XML.

The XML is caused by Java (more specific its Maven build system). You'll hardly touch any XML when you build your projects in Go, Ruby (not rails!), Rust or many other languages or platforms.

Re:Hexagonal Architecture and Domain Driven Design by Tainnor on Tuesday April 12, 2022 @07:22AM (#31001082)
You can use gradle with Java (no XML), and even if you use maven, your pom.xml won't have much to do with your application logic, so I'm not exactly sure where this idea comes from that you need XML to do DDD in Java.
Re:Hexagonal Architecture and Domain Driven Design by regularfry on Tuesday April 12, 2022 @05:01AM (#31000206)
For the record you won't touch XML in Rails either!
Re:Hexagonal Architecture and Domain Driven Design by berkes on Tuesday April 12, 2022 @06:58AM (#31000950)
Correct!

Why I emphasized the not rails! part was to avoid confusion about DDD, Hexagonal and Rails. I'm convinced Rails cannot and will not be usable in a DDD setup, or Hexagonal architecture. Well, maybe if Rails is the "HTTP interface", but you'll be fighting tooth and nails to make it not use a database.

Re:Hexagonal Architecture and Domain Driven Design by Tabular-Iceberg on Tuesday April 12, 2022 @08:02AM (#31001417)
I haven't used Rails before, so I may be missing something, but is this necessarily the case?

If I remember correctly the blue book isn't too keen on modelling your domain in your database, but rather build it out of POJOs and then build a separate layer. But at the same time it's open to using DDD with a logic paradigm, which is eerily similar to a relational database. If, after you've done the necessary work with the domain experts, you have determined that Rails is the right tool for a job, I think you can safely call it a paradigm and carry on.

Re:Hexagonal Architecture and Domain Driven Design by berkes on Tuesday April 12, 2022 @01:38PM (#31005861)
I'm quite certain that with some effort, and possibly some stretching of definitions, one can "do DDD with Rails".

But at that point you are going against the grain. You are both missing out on some good parts of Rails and spending a lot of time to work around or against what Rails wants and needs: Rails is very opinionated, don't forget that.

From https://en.wikipedia.org/wiki/Active_record_pattern#Criticis... > Another critique of the active record pattern is that, also due to the strong coupling of database interaction and application logic, an active record object does not follow the single responsibility principle and separation of concerns as opposed to multitier architecture which properly addresses these practices.[citation needed][clarification needed] Because of this, the active record pattern is best and most often employed in simple applications that are all forms-over-data with CRUD functionality, or only as one part of an architecture.[citation needed] Typically that part is data access and why several ORMs implement the active record pattern.

And a Rails without ActiveRecord, while technically possible, leaves you with a Rails that is hardly workable -if at all- and brings a lot of pain. Your application will live in ActiveRecord models, spread all over:

> ActiveRecord is meant to become the central part of your domain logic. -- https://solnic.codes/2016/05/22/my-time-with-rails-is-up/

So the answer would be: yes, this is necessarily the case. In practice and even in theory.

Re:Hexagonal Architecture and Domain Driven Design by Tabular-Iceberg on Wednesday April 13, 2022 @03:42AM (#31012120)
I can’t speak from experience, but the article you linked seems to make sense.

Rails appears to have very little to do with object oriented programming, except as an implementation detail. My point is that although Evans strongly recommends OOP for DDD in the blue book, it’s not a requirement.

If the first design phase of DDD, where you sit down with the domain experts, you might discover that what you are building is really just a CRUD app. Then it’s probably wise to actually use a CRUD framework, Rails or otherwise. You’re still using DDD, and you’re not even going against the grain or missing out on framework features.

When you make your database your model you delegate “decoupling from persistence” to the authors of your RDBMS. They have already decoupled it for you in that you’re not opening files and writing data, your INSERT statement is just stating facts about your domain.

I’ve explored the pattern of putting the entire domain model in the database in the form of constraints, triggers and queries that return JSON. The controllers just map URLs to queries, validate the input and just pass the result of the query to the client without looking at it.

It’s extremely powerful and productive. You never have to think about N+1. It’s more like logic programming than anything else. The downside is that SQL and associated tools aren’t terribly ergonomic, and it’s hard to find developers who are comfortable working like that.

Re:Hexagonal Architecture and Domain Driven Design by regularfry on Wednesday April 13, 2022 @07:25AM (#31013387)
I think part of the point is that if you are a Rails shop first, then trying to strap DDD on is only rarely going to work. If you are a "right tools for the job" shop who decide to do DDD as a primary tool, then there might be cases where it is what you choose.
Re:Hexagonal Architecture and Domain Driven Design by Tabular-Iceberg on Wednesday April 13, 2022 @09:12AM (#31014192)
Even if you are a Rails shop first, you can use DDD to determine if it's wise to take on the project in the first place. If it turns out that the domain cannot be expressed as a CRUD app, maybe refer the client to someone else. Then you will officially have used Rails with DDD, even if you haven't written a single line of Rails code for the project.

Much of DDD is really tech independent, and takes place before a single line of code is written. This is probably also where it's the most important. You're going to have to learn the domain first or the project will be a world of pain regardless of what architecture you choose.