swift-composable-architecture VS Recombine

TCA for short. Very scalable, quite promising, quite popular. A decent alternative for MVVM enhanced by the Clean Architecture. You can learn more about it in a Point-Free tutorial and on GitHub.

🙏 Built with SwiftUI and The Composable Architecture (TCA): This isn’t a feature, but I just want to express my gratitude to the creators and maintainers of these two frameworks, which have played a huge part in making me fall in love with iOS development.

Razliciti alternativni frameworci i arhitekture - Recimo, na pamet mi padaju Composable Architecture (https://github.com/pointfreeco/swift-composable-architecture) i RIBs arhitektura (https://github.com/uber/RIBs). Ok, ove arhitekture resavaju neke probleme. Ali da li problemi koje te arhitekture resavaju solidan developer ne moze sam da resi bez vendor locka za kreatore tih arhitektura. Jesu one open-source, ali meni je rizik da se vezujem za bilo sta sto sutra moze da prestane da se odrzava.

I came across this post discussing MVM, MVVM, MVP, and composable architecture.

At a minimum, Composable Architecture, and now Dependencies from Point-Free.

I’ve built a couple of apps with this framework: https://github.com/pointfreeco/swift-composable-architecture

While there are apps that use a Redux-style architecture, the arch is still in its infancy in the community. There are a number of implementations each with their own take on Redux. TCA is probably the one with the most name recognition and documentation.

Learn it if the project at hand requires it. A lot of older, more mature apps will still use UIKit, so it’s likely if you plan to work an iOS developer job that you will need it. But it’s getting to the point where a lot of the forward thinking shops are already starting to integrate SwiftUI. (Me being one of them) which, btw, a lot of people will say SwiftUI isn’t quite there yet, and I mostly disagree. SwiftUI is good for a great many use cases. Yes, there are still pain points, but you can write most of the apps you’d need to write in SwiftUI. And there are great architectural frameworks out there that actually give SwiftUI an opinionated way to structure apps that is testable and maintainable. Check out pointfreeco’s The Composable Architecture (https://github.com/pointfreeco/swift-composable-architecture)

Although I used MVVM-style architectures before, I’m now preferring the centralised store Redux-like architectures. However, The Composable Architecture feels too overbearing for me, and feels more like a framework than a library. I’d advise using more lightweight libraries like Recombine which are easily extensible if you need any additional functionality, or even making your very own store architecture to perfectly fit your needs.

Yeah, app architecture in SwiftUI can be really difficult. I’d advise you check out this library - Recombine. It provides a really elegant and lightweight solution to app architecture which I really really enjoy.

Nice article! I love MVVM, but I find it really hard to auto-discipline with it. In a larger app, I tend to get lost with it quite easily, resulting in spaghetti code where I don’t know what’s modifying what and why such thing isn’t working as it’s supposed to be. Recently, I’ve really been enjoying lightweight Redux-like libraries like Recombine (or direct implementations of it like in Swift with Majid’s articles - they incentivise (not force, unlike something like Swift Composable Architecture which can feel a little overbearing) well-structured and clear code. I’d love to hear your thoughts on it in a blog post!

How is Swift Composable Architecture in terms of performance with bigger apps - on the Swift forums I’m always seeing posts about bad performance. Also, with The Composable Architecture, you have side effects in the reducer, which seems counterintuitive. What do you think of a library like ReCombine, which seems a bit cleaner and simpler? I’m interested in these Elm-inspired Redux architectures, but don’t want to jeopardise the user experience. And I still haven’t found one which cleanly integrates with SwiftUI’s Core Data.

I agree, I think lensing is a super cool feature – it also makes us want to structure our app state and actions even more (who would want to write @EnvironmentObject var lensedStore: SubStore, when you could write @EnvironmentObject var lensedStore: SubStore?). Lensed states are also required to be equatable in Recombine and discard unnecessary UI updates, so you alleviate SwiftUI's diffing and get those sweet performance benefits.