TCA showcase

[shahzadmajeed]

Hello,

One of the data point we are missing during TCA evaluation is existing apps that are built with TCA so we can try them out and see their complexity and user experience. This will make us more confident about using TCA for our future and current (long term large scale) apps.

TCA Authors: Do we have such a list?
Developers: If you have built apps with TCA and can include the name and link to App Store in the discussion below that would be greatly appreciated

Thank you

[saroar]

here is my own two app you can
https://github.com/AddaMeSPB/AddaMeIOS -> https://apps.apple.com/app/id1538487173
https://apps.apple.com/us/app/word300/id1619504857

[shahzadmajeed]

Thank you for sharing these

[josephktcheung]

I've scanned through Github and here's a list of open sourced apps that uses TCA:

Puffery App store: https://apps.apple.com/de/app/puffery/id1508776889
reminders-app
Marconio
Prose macOS
DroidKaigi 2021 iOS Application
weg-li
Seed
runitz
Critical Maps iOS App iTunes: https://itunes.apple.com/app/critical-maps/id918669647
GuitarTuner
Tube service App store: https://apps.apple.com/app/id1540626286#?platform=iphone

[shahzadmajeed]

Thank you for this list ❤️

[pacu]

Our App is still in the making but it's SwiftUI + TCA.

https://github.com/zcash/secant-ios-wallet

I've developed one of the first SwiftUI apps in the crypto space back in 2019 when SwiftUI was a mere beta. I can tell you that Vanilla Swift UI doesn't work for not even for "the Fruta App" applications. You need more tools. TCA is not a silver bullet but a very flexible tool that provides a framework that a team can use to build an application that uses unidirectional data driven flow to drive SwiftUI's DSL.

My main concern when evaluating TCA for building secant, was the learning curve. If your project is a fully open, everyone can contribute freely kind of project, TCA could be either: 1) a very attractive honey pot to get developers the TCA crave they were seeking, or 2) a contributor barrier. Only time will tell, currently is a coin-toss. If your project is closed-source and 9-to-5 coding. Your team will be very happy of learning new stuff. Every new hire of the future will benefit of having a clear onboarding route already created for you by the pointfree dudes.

What I can say about my experience so far:

The CONs:

• TCA has a learning curve proper of using a new paradigm with familiar tools. Takeaway: you will have this learning curve whatever your choice is if you are not familiar with it.
• You will have to create wrappers for dependencies you once used innocently "out-of-the-box". Takeaway: this was probably an illusion. You are paying the cost up front and before you were deferring it until it blew up on your face.
• Not the Drag and Drop solution you dreamed of.

The PROs:

• it's is very well documented. But, you have to make the time for reading it and sink it in. Unless you already know the functional paradigm, there are things than won't be easy so figure out just by cmd+click and reading the code.
• it provides a very opinionated way of handling state and data flow on your app. This reduces SwiftUI's bugs significantly. SwiftUI makes it easy to couple screens to one another. Combine observers can drag down your app's performance due to unexpected re-renders and hierarchy recreations that will make your app flicker, reset at best if not crash.
• it makes you have testable code by default. Having to wrap your dependencies in witnesses or wrappers lets you mock them you will have .live and .demo implementations of every dependency you once used to struggle with. Your app is far closer to 100% test coverage than ever before.
• it makes you a better developer. There's no way you go though the docs without learning something new.
• using Store and Reducer make your business logic fully unit-testable.

other comments:
You will compensate the learning curve with time saved by not having to deal with bugs caused by mishandled bindings, random re-renders, etc.

How I approached it:

The way I found to approaching TCA is actually subscribing to pointfree.co content and study it. Try to rely on people that has experience on it to help your team gain traction and experience. If not, create study groups and dedicate time of your day into absorbing the content generated by the authors. You won't be able to absorbe more than 45 minutes of content a day. Since there are many concepts that are covered throughout the episodes and in the end the only way to learn them fully is to apply them. If you have an urge, try to find contractors that are very familiar with it and let them help you ease the curve.

[jshier]

• TCA has a learning curve proper of using a new paradigm with familiar tools. Takeaway: you will have this learning curve whatever your choice is if you are not familiar with it.

I've found this learning curve always exists, even if you write your own app architecture from scratch. It's just that, by writing the architecture from scratch, you're learning the architecture while writing it, which will likely take more time overall than simply learning an architecture. If you take external contributions, contributors always have to ramp up on the architecture. At least with TCA there's extensive documentation, videos, and others using it, rather than none of those things for a bespoke solution.

[pacu]

Plus, there's a big chance that writing your own architecture goes wrong and you end up (luckily) re-inventing the wheel. If you have good fortune our wheel will turn without squiggling much.

[stephencelis]

@pacu Thanks for the feedback! We hope that some of the updates we have planned will help with some of the learning curve. We should probably get a proper "beta" channel for TCA going so folks can play with some of these planned features a bit earlier so that they can provide feedback. We do a lot of prolonged testing and refinement before releasing new features to TCA, but the more folks that have hands on it the better. Would you be interested in such a channel?

[shahzadmajeed]

Hi,

Thank you for sharing your input. I love this discussion. I cannot share exact details of our assessment right now but here are some points:

TCA

• ~30-40% of TCA code was needed to build features (local store, state and environment). We didn't want to use it for everything i.e., single store and pullback etc..
• Explicit thread safety is needed to avoid dirty reads & crashes i.e., all store.send calls should be on same thread (main)
• Learning curve was higher but I 💯 agree that learning curve is involved with every new architecture/pattern
• Testability is amazing with TCA, specially being able to test your logic with just a mock function (effect) was mind blowing
• There were lot of other factors considered which I'm skipping

Conclusion:
We will write our own lightweight (~200 LOC) state machine with some Combine extensions and use that within a home-written VIPER stack. This will allow us to extend our architecture to meet our uses cases/needs.

[gonzalonunez]

We're big fans of TCA at @withprimer :)

There is definitely a learning curve for new engineers, but the pros far outshine the cons:

• Testability is unlike any other iOS app architecture I've ever seen, the cost of writing and maintaining good tests is extremely low
• It increases the ease with which you can interop between SwiftUI and UIKit (passing Stores around is simple) which has been really nice for us
• It's fun to use and write code with! There is a fair amount of boilerplate for new features but these are solvable problems with increasingly mature tooling

You can download the Primer app here. We also have a second smaller app, Zines, that is also built with TCA (and free to use, so it's probably more useful to check out).

[shahzadmajeed]

Interop is an interesting point and I didn't think if it before. I can definitely see how TCA can help with that. Did you face any issue with thread safety?

[gonzalonunez]

No! At least none that I'm aware of and we monitor our errors well. For what it's worth, we do very basic multithreading, nothing crazy.

[ZevEisenberg]

We're using TCA in the new how-to app for kids at The New York Times. We're loving the increased testability it affords.

[shahzadmajeed]

Thank you for your input. Which architecture do you use for main apps at NYTimes?

[shahzadmajeed]

Did you face any issue with thread safety?

[ZevEisenberg]

The main news app uses flow controllers and UIKit. Haven't had many thread safety issues that I can recall, but our threading needs are pretty simple, and I imagine they'll get simpler with new concurrency things.

[krzysztofzablocki]

main apps were MVVM+C, TCA made development really fast

[simme]

I'm using TCA for my two apps Handla and Plantry. The latter is only partly converted thus far. The former was built from the ground up using TCA.

Converting an old codebase has been pretty straightforward, started at the leaf nodes and new features. Working my way inwards.

Building a new app from scratch with TCA was a total joy! Even when building with UIKit I was able to get up and running quickly because it makes mocking data and functionality so easy!

Every time I work on an app that doesn't use TCA I miss it!

[erikolsson]

I’ve used TCA for a bunch of different apps. My latest one is called Effekt, built on TCA + UIKit + Metal:
https://apps.apple.com/us/app/effect-live-wallpaper/id1616146386

[rcarver]

The upcoming 2.0 release of my app Series is TCA + SwiftUI. It's in TestFlight now, happy to add you.

I've been using TCA for just about a year now, I converted a client's app from vanilla SwiftUI and then decided to use it for my own app rewrite. Overall it's saved me way more headaches than its created. When I follow the patterns things tend to go very well.

In that spirit, my 2c on making TCA more accessible is to define and document common patterns for using it. For me, the hardest part is designing for composition and composing state (sharing state, delegating effects to parent). There's so much knowledge in the Point Free videos, isowords and the case studies but it's hard to get a quick tip when you're up against a new problem.

[ghost]

In that spirit, my 2c on making TCA more accessible is to define and document common patterns for using it. For me, the hardest part is designing for composition and composing state (sharing state, delegating effects to parent). There's so much knowledge in the Point Free videos, isowords and the case studies but it's hard to get a quick tip when you're up against a new problem.

I wish I could upvote this comment a million times.

[jdowd7]

We are using TCA @ Exer Labs- its the basis of our 2.0 Gait Application.
We focus on providing solutions in the Physical Therapy and Elder Care space with machine learning and augmented reality all on iOS.

[romero-ios]

My budgeting app, Money Flow, was re-written from MVVM to TCA for iOS 15 - https://www.moneyflow.app

[junjielu]

Our app PDB is building entirely on TCA + UIKit.
Thank you so much for this extraordinary framework!

[zboralski]

We just got approval for our new app that uses TCA + SwiftUI. It is really a personal data management app (starting with the Contacts domain). The user interface is completely content-agnostic and everything from the user interface perspective is a graph of propositions you can interact with based on each proposition's type.

https://apps.apple.com/app/id1638189843

Manage and present your contacts with the Belua app.

Features:

Organise

• Display generative art for contacts without photo.
• Use tags to categorise your contacts.
• Use the touch action to surface contacts in recent.
• Sort by recent, by recently added, by tag or by country.
• Privacy Built-In from the start.
• Actions such as favourite, tag and hide work across devices if you are using iCloud.
• Works in Airplane mode

Search

• Search text in contacts
• Diacritic insensitive [a diacritic is a glyph added to a letter or to a basic glyph].
• Works with natural language text to ensure correct behaviour in multiple scripts and languages such as Chinese or Japanese.

The app also features privacy built-in from the start, so you can feel confident that your information is safe.

[mluisbrown]

The Trading.com app (https://apps.apple.com/app/id1576478434 - US only) is built entirely using TCA and UIKit. Initially it was developed using the ReactiveSwift fork of TCA as we were targeting iOS 12 as a minimum. However that changed during development and the code was re-factored to use the "real" TCA and Combine.

An interesting point is that the Android version of the app was also developed using an in-house Kotlin port of TCA.

It's a pretty complex app with a lot of real time information streams and continuous UI updates. If you have access to the US App Store you can try it out without having do any real trading by using a demo account with fake money.

Since then I moved on to work at Argent and the iOS app is mostly TCA, although there is some older code using an in-house redux style architecture.

Right now I can't imagine myself working on any iOS app not using TCA. The difference it makes is really immense.

[FredericRuaudel]

I've rebuild the app I'm in charge at Ver de Terre Digital using TCA and I'm really happy with the result. The development is more flexible, I can easily add new features, tests them, create preview apps to live test them, and simulate screen state to generate my AppStore screenshots using fastlane snapshot ! I highly recommend it ! 💚

Soildiag on the AppStore

[jeffersonsetiawan]

Tokopedia: Indonesia Ecommerce app
It's using RxSwift version of TCA because we still support iOS < 13 and still using cocoapods.

Really enjoy using the TCA, highly recommended!

[saroar]

wow I am ready for work your company let me know if you need any dev :)

[andreweades]

Readable is a small app built with TCA. I've just updated it for iOS16.

https://apps.apple.com/us/app/readable/id1474243671?platform=iphone

[kuglee]

Here's mine:
Swift Formatter: Xcode extension for Apple's swift-format code formatter
https://github.com/kuglee/SwiftFormatter

[krzysztofzablocki]

SourceryPro uses TCA too, most powerful Xcode extension that enables live AST based templates

[byMohamedali]

Hello,

Hope you're doing well, here is my app it's a BIG project, on 3 differents platform (macOS, tvOS and iOS) using the same core code, with TCA and packaging feature like you did on isoword project, it's making my life so easier to maintain the 3 platforms :)

I'm currently starting to migrating to reducer protocol.

Thank you again,

[birnimal]

I have built a music player app Music Rover with TCA.
SwiftUI and MusicKit.

Like many music player apps, it requires complex navigation back and forth between albums, playlists, and artists, so I used TCACoordinators.

I usually use Next.js and Redux for web development, and TCA + SwiftUI is great because it is easy to learn and develop in a similar way to them.

One thing I could not figure out how to do is to send actions from multiple functions to a specific function.
For example, since song playback is performed by various functions, I wanted to send an action from each function to the function that manages playback. However, it seems that in order to send actions across functions, it is necessary to make the reducer a parent-child relationship, and I gave up on this idea because I thought it would complicate the structure. Instead, I now create a Client and make a request to it with a PassthroughSubject.

[barksten]

We have an app that's been built with TCA, SwiftUI and MapKit since the beginning. Unfortunately it's only usable in Sweden.
Min Karta@appstore

[Bartozo]

Hello 👋

I have created a Life Progress app with help of The Composable Architecture (TCA). It uses the latest ReducerProtocol and many other cool things 🙌 Feel free to check out the repository and let me know what do you think about it 🙂

🔗 Here's the link:
https://github.com/Bartozo/Life-Progress-iOS

[emrdgrmnci]

Hi all 👋🏼

I have created a NBA teams and players list app with The Composable Architecture (TCA).

🔗 Here's the link:
https://github.com/emrdgrmnci/MatchScoresTCA

[Sajjon]

Radix DLT's wallet app uses TCA

[akashsoni01]

Currency exchange app written in TCA. https://github.com/akashsoni01/currency_exchange_app

[Echim2016]

Hi all,

I'm currently launching an engaging icebreaker game app called "Check-in Box" using TCA and currently supports Traditional Chinese only. This app sparks conversations through specific topics and fosters closer connections between you and your friends. 🧋

https://github.com/Echim2016/check-in-box-ios
https://apps.apple.com/us/app/id6474719999

[rokon-uddin]

Hi,
At Monstarlab we maintain a TCA-based iOS project starter template. Feel free to have a look and share your feedback:
https://github.com/monstar-lab-oss/swiftui-template-tca