My boss has big dreams.
He wants to write an application that runs on both the desktop and mobile devices. In addition, he wants it to be occasionally connected (can run without an internet connection). The application will rely heavily on data from a database.
Everyone he talks to keeps pushing HTML5/JavaScript on him for a write-once run-everywhere(ish) solution.
I don't have a lot of experience with this sort of environment--getting data from a database using JavaScript, ORMs for JavaScript and that kind of thing. I may be getting ahead of myself.
What are the kinds of things I should be looking at when trying to wade through a strategy to come as close to his goals as I can? Here are the assumptions and questions I have:
Expectations/Assumptions
- I expect that I'll have to use one of the "embedded" or local databases that seem to have sprung up with HTML5 and Local Storage.
- I expect that I'll also have to find some way to sync this data with data that's sitting out on a server somewhere.
- I expect that the synchronization of this data will have to be homebrewed.
- I would like to have some sort of ORM to make working with the data easier.
- I expect to run into all sorts of weird things related to the size of the local database.
- I expect to have to run all of the application's code on the client-side, since they are supposed to be able to run the application without an internet connection.
Question
What am I doing?
I'm kind of at a loss for even knowing where to start.
To turn this into something that has a chance of having right/wrong answers, here are the things that would be helpful to know:
- Does the HTML5/JavaScript approach sound like a good way to go (considering the targets of occasionally connected, mobile, and desktop)?
- What sort of frameworks and tools should I be looking at to make the development of the application easiest?
- Is he asking for too much?
Thanks in advance for any advice/guidance you might have.
By Request: What does the application do? The application is (more-or-less) a quoting/pricing application for a configurable product. There are a bunch of products (base cabinets, wall cabinets, etc.), a bunch of standard configurable options (wood, finish, door style), and a bunch of (less standard) modifications to them (reduce depth, increase height, etc.).
Depending on the standard configurable options you choose, it changes the base price of each product. You can then add modifications to them (which also come at a price).
The majority of the application exists already (albeit as a WPF application without locally stored data). It was designed so that it could be marketed to different manufacturers who make these configurable items (primarily kitchen cabinets and the like). Every manufacturer has their own rules about what woods/finishes/etc they offer and how they determine the base price of products (which also vary) and how you can mix/match the different woods/finishes etc.
Blah, blah, blah, every manufacturer is very unique.
To solve this problem we created a formula based approach where once you've set up their products/options/etc you can write some formulas to define not only the relationship between them but also how to price them.
In our current model, the application runs on the user's PC and the data is on a web server that the application makes calls to. He wants to turn this whole thing into an occasionally connected, mobile application that we can use on desktops as well.
There is quite a lot of data associated with it, since any manufacturer's data will contain images, descriptions, notes, thousands of products/modifications and lots of information about them (width, height, depth, number of doors, etc).
Edit after question update
I would test the client-side database approach with a mobile device first. You may run into unforeseen limitations (data transmission speed, data size) with the environments (Android browser, Mobile Safari). The when and what to update when you have an internet connection to work with, is also a big determining factor in level-of-effort. These questions may get informed by testing the client-side database limitations.
The rest seems fairly straight-forward to me. Good luck. =)