Katana – Modern Swift framework for creating iOS apps, inspired by React/Redux

At the end of the day it was just a bad replacement for Core Data / Realm / whatever.

I wish I could tell you more but like yourself I really had absolutely no idea what the point was or what it was supposed to make easier.

MVC pattern in iOS usually creates Massive View Controllers that are really hard to maintain and test.

It's a similar problem that AsyncDisplayKit was trying to solve, who's ideas later moved into the react world in general.

Another general design problem in iOS land is the MVC (massive view controller). View controllers tend to get huge as time goes on and become large 5000 line god objects that do everything. A general structure that encourages you to separate things out helps in avoiding this.

There is also a general trend of dependency management being singleton sharedInstance objects everywhere, which can make unit testing a pain. Especially in swift land today with it's lack of dyanmic mocking with OCMock.

Also I notice a general lack of unit / integration testing in mobile apps.

Another one is autolayout being a layout system that crashes your app. It doesn't let you recover in a more elegant way.

---

Now it's totally possible to avoid these caveats with skill, but the architecture of things in iOS land tends to land you into these problems naturally as your team and code size grows bigger. I don't know if react's architecture solves some of this, but those are general problems with standard iOS conventions I've noticed over 7 years with iOS dev.

The benefits I've seen so far:

- Swift's type safety means you can validate at the type level that your app state is correct. As in, you could have an enum with separate cases for your authenticated and unauthenticated states, instead of optional values to indicate what state you're in. This makes your state stronger, in that the types hold only valid states rather than some possible states being invalid (e.g. unauthenticated with non-nil user info).

- State transitions -- reducer methods, (state,action) -> state -- are purely functional which makes (IMHO) feature work straightforward, testing trivial, and debugging fairly easy.

- Your view controllers become super dumb. All they have to do is render the data and relay input events. This is a nice clean separation of concerns.

- If your navigation route is managed in state, you get deep linking "for free". This is especially helpful in one of our apps for handling global errors that could occur on any network request (update state, route to error).

- Every bit of code has an easily identifiable home.

- Communicating between view controllers is simple. Rather than "passing the baton" as state is accumulated (say a multistep form), state accumulates naturally in the store.

I'm working on combining ReSwift with app coordinators here: https://github.com/willowtreeapps/cordux

I've written about it a little bit here: http://willowtreeapps.com/blog/app-coordinators-and-redux-on...

All that said, I still consider this an experiment. We've written about 40-50k lines of Swift across two apps with 8 developers so far, and opinions are mixed between considering it excellent and considering it burdensome.

Also, if I understand correctly, when you open an iOS app, it should always come back to where you left it, regardless of whether it was killed in the meantime (possibly by the OS).

I'm guessing these things are easier to deal with correctly if you use something like React+Redux or Katana.

this is definitely something interesting. We started looking into that at the beginning of the project but later we dropped it since we haven't found a use case when that was really needed, the performance are quite satisfying at the moment! Katana already has a diffing algorithm in place and some other optimizations.

If you have a project that could benefit from it, please open an issue so we can take a look at it!