So I develop an app that is for both Android and iOS.
From time to time changes occur when working on one version that need to implemented on the other. I find it tedious to keep track of these changes so I don't forget them later.
I'm just curious as to what other workflows you guys use when managing a single feature set to be implemented in various projects.
Thanks
A few thoughts:
Have a Good Specification - I am not doctrinaire about specifications. I would probably not create a formal written specification when working on a one-person project that is not too big. However, if you have something that needs to be implemented on two platforms, you absolutely need a specification. Have a single document that defines exactly what the application does, and use that as the source for both versions. That way, they will never get out of sync with each other.
Keep the specification up to date. Avoid making ad hoc changes to one version or the other. Also make sure the specification is clear about any differences between the two applications.
Maintain One Bug List - Any time you discover a bug, put it in your bug list. Unless the bug is something very platform-specific (to the point that it doesn't even make sense on the other platform), verify that both platforms are performing correctly before closing a given bug.
Use Common Code if Possible - This is tricky, since iOS development is primarily C/C++, while Android is mainly Java. However, it is possible to have C/C++ portions of an Android program. See this StackOverflow question. It is probably worth considering whether you could put the core functionality in a single C or C++ library. Obviously, the less work you have to duplicate, the better.
Use a Common Design - Put common functionality in a library that works the same way on both platforms. Do this even if you can't use a common code base--think of it as a single library that is implemented in two languages. As far as is practical, use the same objects, functions, interfaces, algorithms, etc. When iOS and Android do things differently, put the differences behind a layer of abstraction. The benefit of this is, you only have to figure out one way of doing things when adding a new feature.
Don't force this: if the natural way of doing a certain task differs quite a bit between platforms, then go with what makes most sense. Just make sure your code has good separation between the similar things and the different things.
Develop in Parallel - Don't let one version get very far ahead of the other. Make incremental changes in both versions, then build and test both. If the code in question is similar enough, even try having both versions open side by side. It will take some discipline to do this, but in doing things this way, I think you will maximize the benefit of having similar code in both apps.
