Reddit Programming
212 subscribers
1.22K photos
125K links
I will send you newest post from subreddit /r/programming
Download Telegram
Domain-Composed Models (DCM): a pragmatic middle ground between Active Record and Clean DDD
https://www.reddit.com/r/programming/comments/1qast8w/domaincomposed_models_dcm_a_pragmatic_middle/

<!-- SC_OFF -->I wrote an article exploring a pattern we converged on in practice when Active Record became too coupled, but repository-heavy Clean DDD felt like unnecessary ceremony for the problem at hand. The idea is to keep domain behavior close to ORM-backed models, while expressing business rules in infra-agnostic mixins that depend on explicit behavioral contracts (hooks). The concrete model implements those hooks using persistence concerns. It’s not a replacement for DDD, and not a defense of Active Record either — more an attempt to formalize a pragmatic middle ground that many teams seem to arrive at organically. The article uses a simple hotel booking example (Python / SQLAlchemy), discusses trade-offs limits of the pattern, and explains where other approaches fit better. Article: https://medium.com/@hamza-senhajirhazi/domain-composed-models-dcm-a-pragmatic-middle-ground-between-active-record-and-clean-ddd-e44172a58246 I’d be genuinely interested in counter-examples or critiques—especially from people who’ve applied DDD in production systems. <!-- SC_ON --> submitted by /u/senhaj_h (https://www.reddit.com/user/senhaj_h)
[link] (https://medium.com/@hamza-senhajirhazi/domain-composed-models-dcm-a-pragmatic-middle-ground-between-active-record-and-clean-ddd-e44172a58246) [comments] (https://www.reddit.com/r/programming/comments/1qast8w/domaincomposed_models_dcm_a_pragmatic_middle/)
Bring back opinionated architecture
https://www.reddit.com/r/programming/comments/1qayazp/bring_back_opinionated_architecture/

<!-- SC_OFF -->Enterprise architecture claims to bring clarity, but often hides behind ambiguity. And maybe that’s something we need to confront. When I was a developer, I was always attracted to highly opinionated libraries and frameworks. I always preferred a single way of doing things, over three different ways to do it, and they all have their pros and cons. This is something Enterprise Architecture really struggles with I feel. We tend to overengineer things. We would rather build a tool with 3 different data interfaces, than commit to 1 well thought out interface. Don’t get me wrong, I’m not advocating here for abandoning backup plans and putting all your eggs in one basket. What I am advocating for is architectural courage. Are all these “it depends” and “future-proofing” mantras there to get to a more correct solution, or just there to minimize your personal responsibility if it all goes haywire? You also have to calculate the cost of it all. In the above scenario where you cover all your bases and build a REST API and an sFTP connection because “you might need it in the future”, you will have to maintain, secure, document, train and test both. For years to come. Just another think that can break. That would be ok if that scenario actually plays out. If the company strategy changes, and the company never connects the two applications, all of that has been for nothing. Then there is the conversation of the easy-off ramp in implementing new software. It’s cool that you can hot swap your incoming data from one service to a different one in less than a week! Now we just need six months of new training, new processes, new KPIs, new goal setting and hiring to use said new data source. I’m not suggesting we should all become architectural “dictators” who refuse to listen to edge cases. But I am suggesting that we stop being so deep into “what-if” and start focusing more on “what-is.” Being opinionated doesn’t mean being rigid, it’s more about actually having a plan. It means having the courage to say, “This is the path we are taking because it is the most efficient one for today.” If the strategy changes in two years, you deal with it then, with the benefit of two years of lower maintenance costs and a leaner system. <!-- SC_ON --> submitted by /u/GeneralZiltoid (https://www.reddit.com/user/GeneralZiltoid)
[link] (https://frederickvanbrabant.com/blog/2026-01-09-bring-back-opinionated-architecture/) [comments] (https://www.reddit.com/r/programming/comments/1qayazp/bring_back_opinionated_architecture/)
Quotes from "A Pattern Language" (Origin of Design Patterns)
https://www.reddit.com/r/programming/comments/1qb6czi/quotes_from_a_pattern_language_origin_of_design/

<!-- SC_OFF -->"Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice." "The patterns are still hypotheses, all 253 of them - and are therefore all tentative, all free to evolve under the impact of new experience and observation." "Every society which is alive and whole, will have its own unique and distinct pattern language ... every individual in such a society will have a unique language, shared in part, but which as a totality is unique to the mind of the person who has it." "In what frame of mind, and with what intention, are we publishing this language here? The fact that it is published as a book means that many thousands of people can use it. Is it not true that there is a danger that people might come to rely on this one printed language, instead of developing their own languages, in their own minds?" "The fact is, that we have written this book as a first step in the society-wide process by which people will gradually become conscious of their own pattern languages, and work to improve them." "When in doubt about a pattern, don't include it." "There are often cases where you may have a personal version version of a pattern, which is more true, or more relevant for you." <!-- SC_ON --> submitted by /u/SpeedyPuzzlement (https://www.reddit.com/user/SpeedyPuzzlement)
[link] (https://arl.human.cornell.edu/linked%20docs/Alexander_A_Pattern_Language.pdf) [comments] (https://www.reddit.com/r/programming/comments/1qb6czi/quotes_from_a_pattern_language_origin_of_design/)
While everyone Is Talking About AI, GAC Is Coming for Your Job
https://www.reddit.com/r/programming/comments/1qb71ay/while_everyone_is_talking_about_ai_gac_is_coming/

<!-- SC_OFF -->There has been a lot of industry is dead and other doomsayer type opinions in regards to. This post represents my 2c. <!-- SC_ON --> submitted by /u/myFullNameWasTaken (https://www.reddit.com/user/myFullNameWasTaken)
[link] (https://blog.cvetic.in.rs/philosophy/while-everyone-is-talking-about-ai-gac-is-coming-for-your-job/) [comments] (https://www.reddit.com/r/programming/comments/1qb71ay/while_everyone_is_talking_about_ai_gac_is_coming/)
timelang - Natural Language Time Parser
https://www.reddit.com/r/programming/comments/1qbiky2/timelang_natural_language_time_parser/

<!-- SC_OFF -->I built this for a product planning tool I have been working on where I wanted users to define timelines using fuzzy language. My initial instinct was to integrate an LLM and call it a day, but I ended up building a library instead. Existing date parsers are great at extracting dates from text, but I needed something that could also understand context and business time (EOD, COB, business days), parse durations, and handle fuzzy periods like “Q1”, “early January”, or “Jan to Mar”. It returns typed results (date, duration, span, or fuzzy period) and has an extract() function for pulling multiple time expressions from a single string - useful for parsing meeting notes or project plans. Sharing it here, in case it helps someone. <!-- SC_ON --> submitted by /u/kamranahmed_se (https://www.reddit.com/user/kamranahmed_se)
[link] (https://timelang.dev/) [comments] (https://www.reddit.com/r/programming/comments/1qbiky2/timelang_natural_language_time_parser/)
Visualizing Recursive Language Models
https://www.reddit.com/r/programming/comments/1qbn7sc/visualizing_recursive_language_models/

<!-- SC_OFF -->I’ve been experimenting with Recursive Language Models (RLMs), an approach where an LLM writes and executes code to decide how to explore structured context instead of consuming everything in a single prompt. The core RLM idea was originally described in Python focused work. I recently ported it to TypeScript and added a small visualization that shows how the model traverses node_modules, inspects packages, and chooses its next actions step by step. The goal of the example isn’t to analyze an entire codebase, but to make the recursive execution loop visible and easier to reason about. TypeScript RLM implementation:
https://github.com/code-rabi/rllm Visualization example:
https://github.com/code-rabi/rllm/tree/master/examples/node-modules-viz Background article with more details:
https://medium.com/ai-in-plain-english/bringing-rlm-to-typescript-building-rllm-990f9979d89b Happy to hear thoughts from anyone experimenting with long context handling, agent style systems, or LLMs that write code. <!-- SC_ON --> submitted by /u/nitayrabi (https://www.reddit.com/user/nitayrabi)
[link] (https://github.com/code-rabi/rllm) [comments] (https://www.reddit.com/r/programming/comments/1qbn7sc/visualizing_recursive_language_models/)
Why I Don’t Trust Software I Didn’t Suffer For
https://www.reddit.com/r/programming/comments/1qbrz59/why_i_dont_trust_software_i_didnt_suffer_for/

<!-- SC_OFF -->I’ve been thinking a lot about why AI-generated software makes me uneasy, and it’s not about quality or correctness. I realized the discomfort comes from a deeper place: when humans write software, trust flows through the human. When machines write it, trust collapses into reliability metrics. And from experience, I know a system can be reliable and still not trustworthy. I wrote an essay exploring that tension: effort, judgment, ownership, and what happens when software exists before we’ve built any real intimacy with it. Not arguing that one is better than the other. Mostly trying to understand why I react the way I do and whether that reaction still makes sense. Curious how others here think about trust vs reliability in this new context. <!-- SC_ON --> submitted by /u/noscreenname (https://www.reddit.com/user/noscreenname)
[link] (https://medium.com/@a.mandyev/why-i-dont-trust-software-i-didn-t-suffer-for-bbf62ca3c832) [comments] (https://www.reddit.com/r/programming/comments/1qbrz59/why_i_dont_trust_software_i_didnt_suffer_for/)