The Big Picture

Part 1 of 2 posts discussing my plans for an application. In this installment, I talk about phases of development and the approach to take.

My project is actually a collection of several separate, but related applications, and all share some common data elements. The conventional wisdom would be to develop the central functions first, and then bolt-on the peripheral applications after. However, real life often calls on us to do things the hard way. One of the add-on programs is needed in three months, while the basic system need is not urgent.

The central function is currently provided by an older, difficult to support application. It provides enough functionality to get the job done, but isn’t complete. Extending this system to provide the new features is unwarranted for a couple of reasons. First, the development environment (language, database, etc.) is outdated, and I have no one on staff that can work quickly in that language. Second, the platform on which it is deployed is a little shaky and certainly doesn’t meet modern expectations for scalability and security. In other words, we’re going to have to replace it more likely sooner than later, and we will have a tough time supporting it until then.

So with that background, here is my dilemma. As I work on the peripheral application, how much should I worry about later integration with the central system? I certainly don’t have the time to develop all of the central functionality needed, which would basically require that I design and write the central application. Creating what would be a stand-alone application for this peripheral would be quicker, but the integration work later would be extensive.

I’m reminded of a bridge that was built near my house. The big plan calls for a major highway to be built connecting this bridge to a new route around the city. But the construction (or even the funding plans) for this new highway hadn’t started, and there was no clear idea when or if it would. So, an approach that connected the bridge to an existing road was built, even though it would have to be torn out when the new highway came through. Now, nine years a later, the new highway is still a dream, while the bridge gets much traffic. It would have been a shame to leave it either unconnected or poorly connected to the highway grid for this long.

My plan calls for a (mostly) independent development of this add-on application. I will take the bigger picture into account when laying out the data structures, but I am not going to worry about writing all of the functionality in a generic way that will work in all cases. Focus will be on the current goal.

When it comes time to connect to the central application, some rewrite will be necessary, but my users will have a solid system to use in the mean time.

What do you think? Am I on the right track, or am I heading for big troubles down the road? Please leave your comments below.