Our Adventures into Creating a Secure MVC Framework - Part 2 - Design Requirements

When we created iPhora Touch version 2, it was a multiple page application that utilized Dojo 1.53 and Bootstrap 2.32.  The interface worked well on desktops but broke down when used on tablets. It was totally unusable in a phone environment.  Since it was a multiple page solution each page needed to reload Dojo as you jump from page to page. Since we wanted a secured environment, pages could not be cached. However, this slowed down the loading and response of each page.  Since we were using Dojo 1.53 at the time we did not benefit from any form of AMD.

iPhora Touch V2 Community Home Page

We wanted to redesign the interface to work well with mobile devices and desktops, have better performance, but at the same time to be a secured environment.

Though our iPhora Touch solution is a social community-based solution, we designed it to be a closed environment by default and it is assumed that you are not allowed access to anything, which is contrary to how most social collaboration platform are designed.  Social collaboration no matter how any analyst or others spin it, is all about data. Who has access to this data needs to be securely controlled. Being openly social and with no control leads to data breaches. Security is not just about SSL, firewalls, and encryption.

So for any community you may have access to one piece of information at any given state, but in another one you may have no access or limited access.  This holds true not only within a community but all the way down to individual web containers and components part of a community.

So the challenge was to create an infrastructure and interface that met these requirements. Over the course of many months, we looked at many interfaces and did not find anything that we thought was appropriate. I asked my oldest son who is an industrial designer on design, but that was of no avail.  So it was a struggle to find something that would work.

My youngest son is a big user of Pandora and was listening to music when I noticed their application on his iPad.  I thought to myself this is a nice and simple interface, but very powerful. So I borrowed his iPad and played with Pandora for hours trying to understand its functionality. Unfortunately, there was a number of things that I thought was not usable for us, but it was a good starting point, a design inspiration. The multiple pane approach is what we needed, but how in the heck do we implement something like that. Many of the cool things it did we did not need or I was not sure we could even do on a web browser-based interface.

So using my favorite mockup tool, Balsamiq, I moved forward in laying out what the next version of iPhora Touch would might look like.  So we came up with a multiple pane environment that is shown below.  Depending on the state of the application some panes would be hidden and some not.  Many application used a similar approach including applications like Facebook on the phone.

This was the easiest part.  The challenge was to create a multi-pane single page application framework and make it work.

So we came up with our design requirements and they were as follows:

• The JavaScript library that would be used to drive iPhora Touch need to utilize AMD to reduce the loading process
• The JavaScript library components needed to only load once during a session and when needed.
• Each pane needed to have its own independent security environment but at the same time could be dependent on the state of a different pane and controlled by the application developer
• The content of each pane had to handle multi-state of existence:
• Fully Cached, where both the view and scope is cached
• View Cached, where only the view is cached and scope is destroyed after use
• No Cached, where both the view and scope are destroyed after use.
• Defined Cached, where the existence of view and scope is programmatically controlled by the application developer or the server
• No data can be stored locally on the client, but create the illusion that data is local
• The MVC framework had to handle not only the defined pane structure shown above, but needed to function in any multiple pane layout that one can come up with. For example, it should easily function in a three pane environment shown below.
• All web container and components had to inhere to iPhora multiple level state environment. What this means is that for any web component there is a number of possible state of existence and the state in which it exist varies depending on the level of user access at any given time within its parent.
• The MVC framework had to use dynamic routing. Since the state of any content within a pane is dynamic and ever changing, routing needed to be dynamic so static hash tag routing was totally out.
• Data binding for components needed to be controlled by the application designer rather than being automatically performed by the system.
• Web containers and components within a pane had to inherit the security of its parent container
• All web containers and components needed to be generated dynamically and can not pre-exist since it is dependent on what a user is doing as it interacts with the application.
• The MVC framework had to function with the iPhora RESTful APIs controlled by the Gatekeeper on the server.
• The framework had to be lightweight and as small as possible
• It needed to function in all favors of web browsers, both desktop and mobile devices (modern versions)
• It needed a responsive UI.

Alternative Multi-pane layouts

So these were the design requirements and which there are many.

Coming next time, Part 3 - The Experiments