🛑 ADIÓS A LA OBSESIÓN PRIMITIVA 📱 Conoce todo mi contenido y sígueme → linktr.ee/soydianapinto #DomainDrivenDesign #SoftwareArchitecture #CleanCode #ValueObjects #TechInterview #Programadores #TechLife #SoyDianaPinto

Organizing your domain into ValueObjects/, Aggregates/, Repositories/ is like organizing your house by material. "Where's the fork?" "Metal/. Obviously." This is of course joke, but the same principle applies. If we want have business domain that speaks business language, we need to focus on business terms - rather than technical patterns. So "Wallet/", "Product/", "Promotion/", rather than "Aggregate/", "Repository", "Service/"

📢[New Article] The Power of Value Objects sivalabs.in/blog/the-power-o… 👉 Benefits of using Value Objects 👉 Using Value Objects with JPA 👉 Binding Request Parameter/Body to ValueObjects in Spring Boot applications #Java #SpringBoot

The Domain layer folder structure should express intent. I didn't understand this until a few years ago. The Domain sits at the core of Clean Architecture. It's where you define your entities and the most important business logic. So, I want to share a situation I ran into recently. I was looking at a project I built many years ago. The folder structure in the Domain layer bothered me. I was focusing on technical concerns instead of features. The symptoms of this are folders with names like: - Entities - Enumerations - Exceptions - Repositories - ValueObjects I'm sure you've done (or seen) this at some point. What's the problem with grouping by type? This folder structure doesn't tell you anything about the Domain. It also has low cohesion. The types inside a folder aren't related. So what did I do? I reorganized the folders so that related concepts are in the same folder. The benefits of this approach are: - Improved cohesion - High coupling within one folder - Low coupling between unrelated folders When you apply this on an application level, you end up with Vertical Slice Architecture. Here's why this is so valuable: milanjovanovic.tech/blog/ver… What do you think about this approach? --- Sign up for the .NET Weekly with 75K other engineers, and get a free Clean Architecture template: milanjovanovic.tech/template…

Funky idea for Laravel projects: What if DTOs directly went into the app/Models folder? Because objectively, they also are models. I really really really hate seeing "DTOs" or "ValueObjects" folders. But they are necessary in some occasions.

🚀 EF Core: GroupBy sobre Complex Types Durante años, hacer GroupBy sobre objetos complejos en EF terminaba ejecutándose en memoria 😓 Desde EF Core 9, esto cambió. Hoy puedes agrupar por Value Objects (ej: Precio = Monto Moneda) y EF Core: ✅ lo traduce a SQL ✅ genera GROUP BY por propiedad ✅ ejecuta todo en DB Resultado: LINQ más limpio, modelos DDD reales y mejor performance 🚀 🎓 Aprende EF Core moderno en 👉 netuniversity.org #dotnet #efcore #efcore9 #ddd #valueobjects

🚀 New blog dropping 21.10.2025: “Advanced Value Object Patterns in .NET” by @PawelGerr! Discover advanced topics: Open-ended Date, Composite File Identifier, Recurring Dates, Jurisdiction & more. Stay sharp, stay tuned! #dotnet #csharp #valueobjects #softwarearchitecture #devcommunity

#100diasdecodigo #100DaysOfCode [dia 729] adicionado valueobjects , testes de unidade e camada de serviço github.com/waltereidi/unimar…

🔵 𝐇𝐨𝐰 𝐈 𝐒𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞 𝐌𝐲 𝐂𝐥𝐞𝐚𝐧 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐏𝐫𝐨𝐣𝐞𝐜𝐭𝐬 (𝐅𝐨𝐥𝐝𝐞𝐫 𝐛𝐲 𝐅𝐨𝐥𝐝𝐞𝐫) Clean Architecture isn’t just about principles, it’s about clarity. A well-structured folder setup keeps your code scalable, testable, and easy to navigate. 𝟏. 𝐃𝐨𝐦𝐚𝐢𝐧 𝐋𝐚𝐲𝐞𝐫 This is the core of the system, 100% pure C#. 📁 Domain ├── 📁 DomainEvents ├── 📁 Entities ├── 📁 Enumerators ├── 📁 Constants ├── 📁 Exceptions ├── 📁 Repositories ├── 📁 Shared └── 📁 ValueObjects 𝟐. 𝐀𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧 𝐋𝐚𝐲𝐞𝐫 This layer defines what your system should do. 📁 Application ├── 📁 Abstractions │   ├── 📁 Data │   ├── 📁 Email │   └── 📁 Messaging ├── 📁 Behaviors ├── 📁 Contracts ├── 📁 User │   ├── 📁 Commands │   └── 📁 Queries ├── 📁 Order │   ├── 📁 Commands │   └── 📁 Queries └── 📁 UseCases # (Optional) 𝟑. 𝐈𝐧𝐟𝐫𝐚𝐬𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞 𝐋𝐚𝐲𝐞𝐫 This is where tech details live. It implements all the abstractions. 📁 Infrastructure ├── 📁 Data │   ├── 📁 Repositories │   ├── 📁 Migrations │   └── 📁 DataContext │     └── ApplicationDbContext.cs ├── 📁 Messagin ├── 📁 Services └── 📁 Jobs 𝟒. 𝐏𝐫𝐞𝐬𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 𝐋𝐚𝐲𝐞𝐫 This is the entry point: Controllers, Endpoints. 📁 Presentation ├── 📁 Controllers ├── 📁 Middleware ├── 📁 Extensions ├── 📁 Endpoints   # For Minimal APIs (optional) └── 📁 ViewModels  # For frontend or UI rendering (optional) 💬 How do you structure your .NET projects? ❤️ Like if this helped bring some structure to your project 🔄 Share with someone struggling with a messy codebase! #CleanArchitecture #DotNet #BackendTips #SoftwareDesign #FolderStructure #PedroConstantino #CQRS #CSharp

Folder/ ├── Domain/ │ ├─ Entities/ │ | │ ├─Enums/ │ │ │ └ValueObjects/ │ ├── Application/ │ ├──Services/ │ └── DTOs/ ├── Infrastructure/ │ ├── Persistence/ │ └── Repositories/ └── Program.cs

Hi @filamentphp devs! Guava Calendar now has a stable v2 release for Filament v4 with a bunch of improvements! We now support all the good stuff in Filament v4: Schemas you can now defines schemas for your modals, allowing you to combine forms and infolists as you want. On top of that, we improved how schemas are defined. By default, we automatically discover the correct schema based on filament conventions (we look for your resource's form / infolist), so any model will work out of the box as long as you have a resource for it. But you can now also define a Schema per model as a new method in your widget. Value Objects & Enums We make extensive use of Value objects and enums within the calendar, making working with it a breeze. Methods now receive ValueObjects from us as parameters, helping you better understand the data you are working with. Context Menu & Actions The context menu feature has been improved and now dynamically loads the actions. This means you can now finally conditionally hide / disable actions based on the context of the calendar. To help with this, we inject various Value Objects depending on the context the action was used in - for example, you can access `EventClickInfo` in almost any Closure used in an action to access information about the clicked event. We also support policy responses, so your actions can react better and provide feedback as to why an action was not authorized. Theme & Accessibility We themed the calendar to better fit into your filament app. Text colors change dynamically based on the contrast ratio, just like the rest of filament v4. There's too much to fit inside a single tweet, so feel free to check out our completely rewritten documentation with detailed explanation and code examples for each feature to better understand how everything works.

The Domain layer should express business intent, not technical concerns. A few years ago, I didn’t get this. My old projects had Domain folders like: - Entities - Repositories - ValueObjects - Enumerations - Exceptions Looks clean, but it hides the Domain. You lose cohesion. You jump across folders to understand a single use case. Today, I group related concepts by feature, not by type. The result? - Higher cohesion - Easier navigation - Faster onboarding - More maintainable code Want to see how to apply this in practice? I'll share all the secrets here: milanjovanovic.tech/ddd-refa…

PHP: v8.4.2 Pest: 3.8 Error: Termwind\ValueObjects\Node::__construct(): Argument #1 ($node) must be of type DOMNode, null given, called in /vendor/nunomaduro/termwind/src/HtmlRenderer.php on line 43 at vendor/nunomaduro/termwind/src/ValueObjects/Node.php:17 @enunomaduro #Pest

Finally got around to reading Domain Modeling Made Functional, Tackle Software Complexity with Domain-Driven Design and F#, by Scott Wlaschin. Book basically covers: 1. Domain Driven Design 2. How to design with types 3. How to implement 1 and 2 in code & refactor it. There's other good content leveraging the above like balancing both exceptions vs. Result (e.g errors as values) & Persistence concerns (e.g. database). My favorite, though, are his translations of OOP concepts to FP ones. This is a huge deal because most DDD (Domain Driven Design) content is heavily biased towards OOP, design patterns, and mutation, none of which is in the FP world. Additionally, despite Java's & C#'s massive improvements, OOP devs don't worship types like the FP community does, and sum types & records are perfect for modelling things in DDD style, with the compiler's help. So having his translations from the OOP world to the FP one helped a lot. He even included Onion/Hexagonal architecture which I loved, omitting the parts that FP devs don't need. I've been meaning to read "The Blue Book" and "The Red Book", famous DDD books, for a long time, but my patience of translating OOP things to my world is basically spent, so it was dope to get Scott's explanation. The topics are vast so everything had external links if you wanted to learn more. The biggest thing I took away was I am 90% on track. That was a HUGE sigh of relief; 90% of the book I'm either like "Yeah, I know this" or "whoa, cool, so I was doing it like you're supposed too, rad". That made me feel good; I don't use F#, I use TypeScript, but it's basically the same, just more verbose for unions, and doesn't have those dope Monad helpers. The other crazy thing was it was released in 2018. Excluding Continuous Delivery/TDD, everything in the book is just as relevant in today's world in how I build software, and done the same way, so that was another self-esteem boost knowing the core techniques continue to be evergreen, and language agnostic (well... they _do_ assume your types don't suck and even in 2025, there are popular languages who's type systems aren't that great). One minor thing, it was hilarious to see DTO's, Data Transfer Objects, embraced and encouraged. I haven't used DTO's or VO's, ValueObjects, since my OOP days back in like 2011. I get why, and agree, no doubt, but... just funny in that: 1. most FP devs I work with have no idea what those are 2. most OOP devs under 32 have zero idea what those are, either Really loved how both relational and NoSQL persistence were covered with raw SQL. Really helped solidify some feelings I've had and concerns, and squashed all anxiety after reading. I only have about 2 years of real Postegres and DynamoDB experience, but based on what I read, I was on the right track "thinking with an FP mindset" around persistence, and was missing a major core piece around how to save Unions/Sum Types/Variants, so the examples provided were awesome. If you don't know DDD and want to learn it, buy this book. If you want to learn how to "design with types, first, not tests first", buy this book. If you know TypeScript, but aren't really sure if the types are giving you value in your work, buy this book and see if it doesn't give you a fresh perspective on how to approach your work. pragprog.com/titles/swdddf/d…

The Domain layer folder structure should express intent. I didn't understand this until a few years ago. The Domain sits at the core of Clean Architecture. It's where you define your entities and the most important business logic. So, I want to share a situation I ran into recently. I was looking at a project I built many years ago. The folder structure in the Domain layer bothered me. I was focusing on technical concerns instead of features. The symptoms of this are folders with names like: - Entities - Enumerations - Exceptions - Repositories - ValueObjects I'm sure you've done (or seen) this at some point. What's the problem with grouping by type? This folder structure doesn't tell you anything about the Domain. It also has low cohesion. The types inside a folder aren't related. So what did I do? I reorganized the folders so that related concepts are in the same folder. The benefits of this approach are: - Improved cohesion - High coupling within one folder - Low coupling between unrelated folders When you apply this on an application level, you end up with Vertical Slice Architecture. Here's why this is so valuable: milanjovanovic.tech/blog/ver… What do you think about this approach?

🚀 Just released a new version of Thinktecture.Runtime.Extensions, an open-source library for #dotnet developers! 🎉 The latest update lets you easily create #SmartEnums, #ValueObjects, and #DiscriminatedUnions—available in two flavors: ad hoc and regular. github.com/PawelGerr/Thinkte…

The Domain layer folder structure should express intent. I didn't understand this a few years ago. The Domain sits at the core of Clean Architecture. It's where you define your entities and the most important business logic. Recently, I was looking at a project I built many years ago. The folder structure in the Domain layer almost made me cry. I was focusing on technical concerns instead of features (use cases). The symptoms of this are folders with names like: - Entities - Enumerations - Exceptions - Repositories - ValueObjects I'm sure you've done (or seen) this at some point. What's the problem with grouping by technical concerns? This folder structure doesn't tell you anything about the Domain. It also has low cohesion. The types inside a folder aren't related. You have to jump between many unrelated folders to find what you need. So what did I do? I reorganized the folders so that related concepts are in the same folder. The benefits of this approach are: - Improved cohesion - High coupling within one folder - Easier navigation through the solution - Better maintainability and adding new features "Package by feature" is an excellent approach for many applications. Read this to learn how to implement it: milanjovanovic.tech/blog/ver… What do you think about this approach? --- Do you want to simplify your development process? Grab my free Clean Architecture template here: bit.ly/3UKv8pl

Hey! thanks for spending some time on this. A few thoughts: > PS: Any project becomes a mess over time, no matter which architecture you use. Anyone thinking otherwise is delusional. I don't think this has to be true (and IME, this is not true). Keeping a codebase maintainable is an exercise of constantly rethinking your models. Smaller, independent contexts massively help with this. > There's a lot of turnover [...] I don't think this has to be true either, and has also not been my experience. Maybe depends on the company? >Common sense would be to make sure muscle memory acquired by using Laravel is still applicable. This ensures anyone can be productive as fast as possible with the least amount of business-specific knowledge. This touches directly on my point. It is devastatingly hard to understand a large-enough codebase where everything is global and just stuffed into `app`. If you hire someone and they can dive into a context and work on that feature alone without having to think of everything else, that helps, don't you think? Everything one learned about Laravel is still applicable. >If you are using a framework [...] You *can and should* still use the framework. I still rely deeply on the framework, use all of its features, and am coupled to it. The default structure is a sensible suggestion and I don't disagree with it — proposing a default contextualized structure would be impossible because... it is contextualized (x.com/nicolaibaaring/status/…) I'm more than happy to keep discussing this. I don't think "people will not understand this" is a good argument though. Why exactly do you think someone wouldn't understand it? What is the difficulty exactly? I find it much harder to jump into a project and have dozens of files into each directory, all unrelated to one another. In fact, I think that's one of the things that hurt maintainability the most — if everything is global, it's much harder to understand a specific concern of the codebase or writing/modifying code without affecting other places. Here's a practical example: you join a new job, and you need to understand how checking out a cart works. Now you need to look into `Models`, `Enums`, `Services`, `ValueObjects`, `DTOs`, `Mail`, `Contracts`, etc (and you still might miss things)., instead of looking into `Checkout` and `PaymentProcessing` (or something like that). If you want to understand and/or work on the queue on Laravel, you can simply dive into the "Queue" component within the framework codebase. It's a joy to work on — if you want to PR something to the event bus, you look into `Events`. Everyone understands it just fine, why would it be different in an application? What problem is being solved in grouping unrelated things together?

𝗧𝗵𝗲 𝗗𝗼𝗺𝗮𝗶𝗻 𝗹𝗮𝘆𝗲𝗿 𝗳𝗼𝗹𝗱𝗲𝗿 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝘀𝗵𝗼𝘂𝗹𝗱 𝗲𝘅𝗽𝗿𝗲𝘀𝘀 𝗶𝗻𝘁𝗲𝗻𝘁. I didn't understand this a few years ago. The Domain sits at the core of Clean Architecture. It's where you define your entities and the most important business logic. So, I want to share a situation I ran into recently. I was looking at a project I built many years ago. The folder structure in the Domain layer bothered me. I was focusing on technical concerns instead of features. The symptoms of this are folders with names like: - Entities - Enumerations - Exceptions - Repositories - ValueObjects I'm sure you've done (or seen) this at some point. What's the problem with grouping by type? This folder structure doesn't tell you anything about the Domain. It also has low cohesion. The types inside a folder aren't related. So what did I do? I reorganized the folders so that related concepts are in the same folder. The benefits of this approach are: - Improved cohesion - High coupling within one folder - Low coupling between unrelated folders When you apply this on an application level, you end up with Vertical Slice Architecture. Here's why this is so valuable: milanjovanovic.tech/blog/ver… What do you think about this approach? --- Simplify your development process – download your free Clean Architecture template today: milanjovanovic.tech/template…

Los que hacéis DDD o similar, hemos llegado a una conclusión (que otros también hacen). Entre Bounded Context y dominios trabajamos con DTOs "vitaminados". Tienen ValueObjects, enums y puede que algún método. Cuando pasamos info a API, devolvemos "resources" con tipos básicos.