Discover how composable architectures transform software development for enhanced flexibility, scalability, and innovation.

hantian pang

GitHub

Community Picks is a section on daily.dev where our community members share the most interesting and valuable content they've discovered online. From insightful articles to handy tools, every post is a gem curated by our dedicated coomunity. To contribute to Community Picks, you need to have at least 250 reputation points, ensuring that only active and trusted members can share their finds.

Community Picks

Composable software architectures are redefining software development standards, offering enhanced flexibility, scalability, maintainability, innovation, and better dependency management. They differ from monolithic architectures by utilizing independent, reusable components. Advanced tools like Bit can support the implementation of a composable architecture.

Composable Software Architectures are Trending: Here’s Why

I am wondering if you can ever truly reuse components in different apps…. I think you will end up with a if-ology for small nitty gritty details jere and there.
Its similar to Shared Libraries in monoliths, Shared Packages in Microservices, Shared Models etc. Only a very few are truly reusable.
As an example, you could have an application that deals with Books, and the search capability of the Books. For the App used in the Printing Facility you will be interested in different aspect of a book that wont be relevant for a Book Store.
I feel DDD Bounded Contexts are kind off stoping the Composable Architecture described here. Unless you let app to inject nearly everything to Composable module, but whats the point then?

Sound interesting but everything tends to go back to monolithic after trends fail

This sounds like a maintenance hell. Microservice itself is already hell when introducing large features across many components, you want to split it down even more?

All I see is reinventing libraries and introducing complexity and dependency hell.
It seems like author never worked on enterprise class software if by any chance this seems viable.

At first glance this sounds interesting, but then you dive deeper and it becomes clear that - like so many modern frameworks - the idea is fully built around Javascript/Typescript.
I think there is no true composability if you cannot choose different languages. Whatever happened to using the right tool for the job?
Also, what is the difference between “composable architectuure” and just having shared packages/libraries?