Host Independent Model Component

Host Independent Model Component

            The model component that take care of the complete logic of the application. Model component renders itself as logic and architecture of the application. How would the logic work in the complete application?  Where would the data be stored? The default format of the data, how would the data retrieved from the storage. Whether the client is thin or thick the Model component will reside on server as network element.

            The question is how to divide the functionality among the network elements. For example if we have to write an application that will calculate our route information from the destination using GPS and the target location. It will get the destination information from the client device and will search target information by plotting that information on some map application at server and after calculating the route information the resultant data will be displayed on the client device screen.

         So keeping in view the given scenario, this point is very crucial while writing a pervasive application that whether the application would be a thin client or thick client.  How to divide the functionality of the application among network elements residing at server side and rendering at client side. This is the major question and will affect the model of the application also.

            The view of the application should remain same whether the application is thin client or thick client. Because the same input and output is required to be shown to the user on client device and flow of application will also remain same. When we change the flow and orientation of the application then we are actually giving some hint to the user that there is some changes occur that might surprise the user.

            For example a user is opening a file using Wi-Fi and going through the data and eventually the location changes and the connectivity is degraded from Wi-Fi to GPRS so definitely the transcoding proxies will required to be changed and the view of the data might be changed. So the user will be surprised that few minutes ago the data was in some different format and now it is in different format.  That change will bother the user to be conscious about the change and that is a noticeable change.

            This will confront with the features of pervasive computing that the user will not be surprised with changes and the technology should be invisible or seamless.  That element of seamless technology is ignored or removed.

            What is required here that user interface should remain the same, controller should also remain the same and model at server side should be able to handle these things because model is responsible for the whole logic of the application and take care of the execution without user intervention and surprises.

            When we talk about connectivity the model component plays very important role. The way the architecture of the application is designed, depends very much on the connectivity. There are some instances where the application stopped working altogether. 

            For example the application is required to get the GPS coordinates, and the user is indoor, the connection with the satellite is broken, then the possibility of getting that requisite information from GPRS or Wi-Fi. But if there is no connection available and the user gone into dead spot.

          That simple application would stop working due to dead connectivity; these types of applications are considered as thin client application. In thin client applications the user component or interface will be rendering on the device and the model and controller component will be working at server side or as network elements.  

User Interface rendering at Client Device

            And now how the user interface will be designed device independent. We want to write simple application having single interface with 4 buttons. How that application will be make available in similar working capacity in all the mobile devices.

            One solution is to writing parent classes and can be used or inherited by child classes. In some devices it will be able to use all the features or in some others it will not.

            2^nd solution is by using transcoding proxies we can write some procedure that if the user is using mobile device with Wi-Fi or GPRS so that interface will be displayed with certain resolutions and the buttons would be of that size.

            This is not the platform independent interface rendering, but we are intelligently using the components on various devices. All the components are hardcoded for different types of platforms and intelligently placing the components and the feature of portability is totally ignored.

            The most suitable solution for that problem to use the web technologies. If we write any component in web technology that would provide platform independent feature. Browsers allow us to add buttons, they also allow us to add textboxes, dropdown menus, image list and many more.  

            The bandwidth issues and connectivity as well as the appearance can also be controlled by transcoding proxies which are already available for web technologies.

            As on thin client minimum functionalities and capabilities are available so everything can be written by using web technologies for interface rendering, input and output for the user as well.

            As thin client application the mode and controller is working at server side and majority of the components are coming from the server so disconnected operations as thin client applications are not possible. Because all we are doing is just input and output on the device, the logic, data and logic flow is at server so as the device is disconnected or no connectivity  the application will stop working.  This is the bottle neck of thin client application.

Host-Independent Model Component for thick client applications

            The thick client application model component will reside on server and controller and view component will be with the application at client side. It also provides some additional capabilities like caching data. The application will predict that there might be limited or degraded connectivity ahead so the data will be cached in advance.

            For example if the user is going through the website having multiple pages like he is browsing page 1,2, 3 and there are 10 pages and the connectivity is going to be degraded then thick client application will create a cache of all the pages depending on the available memory. In the absence the connectivity the pages will be displayed to the client device.

            If the user is making some transactions and changes the data in database then the controller will synchronize the inconsistent data and resynchronize again and again whenever there are changes in the data and application is disconnected. As the controller is residing at client side then it will resynchronize the inconsistent data when the connectivity is available. That is an additional advantage of having controller at Client side.

Host-Independent Model Component as Autonomous Applications

Autonomous Applications

            The third type of application is where the Model View and Controller component will be residing at client device. Disconnected operations are very much possible because the device is not relying on connectivity majorly. These types of applications are OS which can run on their own, but when patches are needed and updates are required to be installed, it will connect to the server and get all the required information.