Form and Grid Pattern: A Hybrid Design Pattern for Rich Internet Applications Nalaka R. Dissanayake Informatics Institute of Technology 57/1, Ramakrishna road, Colombo 6, Sri Lanka. 094 71 4458658
[email protected] ABSTRACT Rich Internet Applications are very complex systems, hence engineering of them are engaged with many difficulties. Design patterns provide tested solutions for system designing and development, towards effective and efficient engineering. Rich Internet Applications also can gain the advantages of the design patterns, to simplify complexities, hence to gain better development experience. A hybrid design pattern – for database related data management, based on Create, Read, update, and Delete operations – is proposed in this paper, which is named as Form and Grid pattern. This pattern uses AJAX technique for communicating with the server, and also is included with a set of related features. This pattern is expected to deliver decent level of user experience, while assisting the developers in rapid development. And generalizing the algorithms for the operations/features in the proposed pattern is also discussed, which will be helpful to introduce a JavaScript based library in future, for easy integration of the proposed pattern.
Categories and Subject Descriptors D.2.11 [Software Architectures]: Patterns.
Keywords AJAX, Design Patterns, Rich Internet Applications.
1. INTRODUCTION Rich Internet Applications (RIAs) are much advanced Web applications, which deliver high user experience through their rich Graphical User Interfaces (GUIs) and faster communicating capabilities [1]. Since RIAs are incorporated with advanced features, the complexity of the development has been increased. Design patterns provide reusable micro-architectures that contribute to an overall system architecture [2]. The complexity of a system is related to the understanding of its formalism [3], which can be reduced by incorporating design patterns. Design patterns can help in reducing the complexity and increasing the reusability in system designing and development. Design patterns are also used in GUI development [4], thus can be used for rich GUI designing and development of RIAs [5]. Design patterns can help in delivering rich features of RIAs with less development efforts [6]. There are some products, which deliver design patterns based solutions, however they either heavily depend on techniques/technologies or need high amount of settings and configurations, thus lacks in flexibility. The worthiness of incorporating these solutions is questionable, when considering
the workload of configurations, compared to the quality of the returned results. To overcome this issue, this paper proposes a hybrid design pattern for RIAs, named as “Form and Grid pattern”, and presents the conceptual details of this pattern; discussing the architectural and design level results of an ongoing research towards producing a technology independent and flexible development library for RIAs. The presented design pattern is supposed to deliver enough realization of the concept for easy and flexible development. The flexibility provided by the proposed design pattern is expected to bring the desired quality of the results with less development hassle. Section 2 of the paper presents the background of the RIAs and design patters in the context of the paper. In section 3 discusses the features of some selected design patterns, which can be used in RIAs, and also which have been incorporated in the proposed hybrid design pattern. Section 4 introduces the hybrid pattern and its specifications; and the algorithms used in the pattern are also presented, and the generalization of the algorithms are also discussed. Additionally, some development related facts are also discussed in section 4. Then the section 5 briefly presents some similar work available. Finally, the section 6 concludes the work, specifying the limitations and future work.
2. BACKGROUND This section discussed the background of the research, under two spaces: RIAs and design patterns.
2.1 Rich Internet Applications RIAs combine the distributed architecture of the web, with desktop applications like rich GUIs [7]. They have become the norm of the world of web; and their capabilities are growing rapidly [7]. The key features of the RIAs can be seen as: the rich GUIs, faster responding nature, and the rich user experience catered by the result of the aforementioned two features [1]. The power of these features are coming from the evolution of the JavaScript (JS) and the introduction of asynchronous communication techniques and technologies. The JS based RIAs development approach uses asynchronous communication techniques/technologies, to communicate with the server, behind the GUI of the web page. Once the response from the server is received, the page will update the GUI with the results, by partial rendering the necessary sections. This techniques/technologies eliminate traditional page refreshes and the work-wait pattern, hence the user experience can be significantly improved [8].
International Conference on Innovations in Info-business and Technology, Colombo, Sri Lanka, March 04, 2016
AJAX is the first and the simplest technique for performing the asynchronous communication, which is based on the XMLHttpRequest (XHR) Object [9]. It is a data-pull technique, which is useful in non-real-time communication; and relatively simple and easy to implement, compared to much complex bidirectional communication techniques/technologies such as WebSockets (WS) [10]. The work in this paper is based on AJAX, and since it is the basic form of the RIAs, it can be possibly enhanced for other advanced techniques/technologies like WS.
2.2 Design Patterns As Gamma et al. [2] – who introduced the concept of ObjectOriented design patterns – say that the “Design patterns can be considered as, reusable micro-architectures that contribute to an overall system architecture”. Design patterns provide names, abstract common themes, and vocabulary; and they preserve design information [2]. They also help in reducing the complexities and increasing the reusability, in systems designing and development. Gamma et al. had presented a basic template for introducing and documenting design patterns, which details the design pattern name, intent, motivation, applicability, participants, collaborations, diagram, consequences, implementation, and examples [2]. The usefulness and the efficiency of using design patterns in software engineering, had been already evaluated and identified [6]. Though the concept of design patterns had been introduced for Object-Oriented design and development [2], nowadays the design patterns are used even for designing and development of GUIs [4] and also web applications [5]. In web engineering, patterns based development has become popular, since it enables the reusability and consistency [11]. Design patterns for web applications can be categorized in several ways; and Model-ViewController (MVC), Create-Read-Update-Delete (CRUD), datagrid, and pagination can be seen as some useful patterns for web applications [11].
3. DESIGN PATTERNS FOR RIAS Unlike traditional web applications, RIAs can communicate with the servers asynchronously and update the current web page with the results, by partial rendering the necessary sections. Hence the page refreshes or new page loading and work-wait pattern is eliminated drastically. These advanced characteristics of RIAs enable developing multiple features in a single web page with desktop applications like GUIs, which can provide better user experience. This setting enables the design patterns used in traditional web applications, to be utilized in RIAs in enhanced ways. By incorporating multiple patterns into a single feature, a rich GUI component, which can deliver comprehensive user experience can be developed in RIAs. Auto-Complete, and Periodic/Dynamic Data Refresh are some RIA patterns, which enable special features beyond the limits of the traditional web applications [12]. The intention of this section is to understand the features of available design patterns, which can be used for RIAs. This sections briefly discusses the features of some available patterns, which have been utilized in deriving the proposed hybrid pattern towards increased reusability and flexibility, with less complexity and less development difficulties.
3.1 Form pattern [13] Forms provide a common and effective way of capturing user inputs. Usually forms consist of set of input elements, labels for them and few buttons for executing operations, such as submit, cancel, and refresh. Several layout patterns are available for designing forms, and also best practices exist to be followed. Two main ways of using forms were noted in this research. The type1 forms are used for managing data of a single entity. The best example is a user profile. A user can utilize a form to enter data when registering himself, and the same or similar form can be used to edit/update the profile. The type2 forms can be used when there are requirements to manage multiple entities via the same form, as in an inventory system. Multiple items can be inserted using the same form, and again the same or similar form can be utilized to edit and update the entries. The main difference between these two form types is reflected primarily in the edit/update operation. In type1, the data of the owning entity of the form will be loaded and displayed in the form, when it is opened for editing. The type2 forms open an empty form in editing operation, where the specific entity’s data to be edited should be explicitly loaded to the form, by the user.
3.2 CRUD pattern [14] When data persistence is needed in a system, the data sources like files or mainly databases are utilized. The basic operations, which can be performed on a data source are: data Creation, Reading, Updating, and Deleting (CRUD). These operations are defined as a pattern, and it can be utilized in data management related features of the system. CRUD indicates the minimal set of operations for a persistence object, and all persistence operations can be realized through the CRUD pattern. In the case of databases, the logic of the operations can be split between the application itself and the database. In such situations, the logic will be developed using the native development language of the application, and the Structured Query Language (SQL), which is the standard language for databases. Implementing the logic within the application can be recommended in the direction of consistency, lower coupling, and easy management.
3.3 Pagination pattern [6] When the content of a page is getting lengthier, the pagination pattern can be used to split the content across multiple pages. The concept is like a long page versus a book with multiple pages. Pagination enables traversing the content through multiple pages, instead of scrolling down on the same long page. Usually the pattern comes with page numbers to be selected, and next, previous, first, and last operations. In RIAs, pagination can be applied to a section of a page, instead to the complete page. The user can navigate through the pages of the section while being on the same page, and only the page of the section will be changed/updated by partial rendering the section. Pagination provides faster traversal, and better user experience.
3.4 Grid pattern There are several UI patterns, which can be used when a set of data is needed to be displayed; the grid/table, list, tree, and accordion are some of them [13]. Grid/table is a tabular format for displaying a set of data. Grids can be merged with CRUD pattern to enable processing data within the grid itself. When the data set is lengthy, the grid can incorporate the pagination pattern for
International Conference on Innovations in Info-business and Technology, Colombo, Sri Lanka, March 04, 2016
better traversal. Similarly, the grid pattern can be merged with some other patterns and come up with enhanced grid patterns. Advanced GUIs and user experience can be delivered by combining such enhanced grid patterns with the power of asynchronous communication in RIAs.
4.1.5 Example
4. THE FORM AND GRID PATTERN This section introduces a hybrid design pattern, which is proposed to deliver abstract understanding of a set of available design patterns, and their integration. This pattern is supposed to provide flexible development compared to the available products, regardless the technologies used. The proposed pattern is named as “Form and Grid pattern”, which combines the form, grid, pagination and CRUD patterns into a single hybrid pattern. For the form pattern, the type2 form for managing multiple entities – as presented under section 3.1 – has been used. A grid is used to display the inserted entities, and pagination is used to manage lengthy data sets. The form and the pagination enabled grid is supposed to perform the CRUD operations within the pattern, utilizing the CRUD pattern.
4.1 Features of the pattern The specifications for the proposed Form and Grid pattern are presented in this section.
4.1.1 Context User needs to manage a set of related data, performing CRUD operations. Inserted data should be available for easy references/reading, and should be also available for edit, update, and removal operations, in a flexible manner.
4.1.2 Problem The context contains multiple related features; hence the complexity is high. On one side, improper GUI design may lower the user experience; and on the other side, provision of all the features – with enhanced user experience via good GUI – may increase the development complexity, thus increase the workload and the effort needed.
4.1.3 Motivation If the characteristics of the features in the context are identified, and their integration into a single operational unit can be realized, then the development complexity can be reduced, and also the workload and effort can be lowered. And also if this single operational unit can be delivered via a carefully designed GUI, the user experience can be drastically enhanced.
4.1.4 Solution A design pattern, which can provide all the features of the context, can address the problem. The GUI of the pattern needs to be designed well to provide all the features with enhanced user experience. Then the characteristics of all the features should be identified, and their integration should be realized. The complexity can be simplified by identifying the common behaviors in the algorithms of the operations, and introducing a generalized algorithm, which can realize the core processing of all the features. This core algorithm will be able to reduce the complexity and ease the development. Additionally, the asynchronous communication can be utilized to accomplish all the communication with the server. It will also assist in incorporating all the required features into a single GUI component, with enhanced user experience.
Figure 1. Sample GUI for the Form and Grid pattern
4.1.6 Operations This section proposes a set of operations/features for the Form and Grid pattern, and also discusses some other possible features.
4.1.6.1 Load/Reload data On the initial load of the page, if data is available in the database, they are supposed to be loaded to the grid and displayed. When save/update/remove operations are executed, the grid needs to be refreshed automatically and display the latest version of data. In cases of interrupted loading due to communication or server errors, the reload button can be used to reload the grid explicitly.
4.1.6.2 Change page For lengthy data sets, pagination should be provided, then the user can traverse through pages to read all data. For pagination, other than the page numbers, the next-previous and first-last buttons need to be provided. The current page number could be disabled. When the number of pages is high, only a specific page number range around the current page number can be displayed; and the other hidden page numbers can be displayed as the user traverse though the pages.
4.1.6.3 Save/Insert User can enter data into the form and save them by clicking on the save button. Data should be sent to the server and inserted into database.
4.1.6.4 Edit/Update In the grid, for all the entries, an edit button should be available in each row. When an edit button is clicked, the data in the relevant row should be loaded to the form for editing; and the save button can be replaced by an update button. Once the editing is done, user can apply the changes by clicking on the update button, then the data should be sent to the server and the relevant entries should be updated.
4.1.6.5 Cancel save/edit When the data are entered into the form for inserting, or loaded for editing, user can use the cancel button to cancel the process and clear the form.
4.1.6.6 Delete/Remove Similar to the edit button, each entry in the grid needs to have a remove button, for user to remove an entry from the grid. When the button is clicked, a request should go to the server and delete the specified entry from the database.
4.1.6.7 Status messages For all the operations, in either successful or unsuccessful case, relevant and meaningful status message(s) (Sts msg) should be
International Conference on Innovations in Info-business and Technology, Colombo, Sri Lanka, March 04, 2016
displayed to the user, indicating the situation of the process. In the example GUI illustrated in figure 1, a sample status message has been displayed between the form and the buttons row.
4.1.6.8 Other possible features Some other features like filtering, searching, and sorting, can be incorporated into this Form and Grid pattern as required, to provide additional functionalities.
4.2 Algorithms for the Form and Grid pattern
Receiving HTML formatted response from the server – which contains the structure for the grid and the pagination – can be recommended [15]. It will eliminate further processing of the response, hence reduce the client-side workload. Additionally, in the server-side, the same algorithm/code used to prepare the grid with data in the initial load, can also be utilized in the asynchronous communication. This code reusability can prevent code duplication and also can reduce the workload in server-side development.
4.2.2 Edit
When asynchronous communication is used with AJAX, the algorithm for each operation comes in a pair as: the requesting algorithm, and the response handling algorithm. Since AJAX is capable of handling the process asynchronously, the requesting algorithm only prepares the necessary inputs, register the response handler, and initiates the communication with the server. The results reading, processing, and displaying the output are included into the response handling algorithm. In following sections, the client-side algorithms for the Form and Grid pattern based on the CRUD operations, are presented and discussed. In the response handling algorithm, only the processing of successful asynchronous communication is considered. The error handling in AJAX is usually developed in a separate handler, and that handler contains a separate and dedicated algorithm. The discussions of the AJAX error handling are intentionally excluded in this paper.
4.2.1 Read/load data to the grid The initial data loading into the grid can be done in the initial page load execution in the server, hence there are no client-side algorithms engaged. A complete client-side algorithm for grid loading is required for the reload button click, and for changing the grid pages. Additionally, reloading the grid after save, edit/update, and remove operations are also required the grid loading algorithm. Figure 2 illustrates the algorithms pair for the grid loading process. The left side one shows the requesting algorithm and the right side one is the response handling algorithm.
In edit operation, the data in a grid row are required to be loaded to the form for editing, and the execution algorithm of this loading is mainly based on the nature of the data and the form. Furthermore, this loading does not incorporate any communication with the server. The server communication takes a place in the next part of the process, which is the update operation, and the algorithms for update operation are discussed in the next section. Therefore, any algorithms related to the edit operation are discussed here.
4.2.3 Save/update Save/update algorithms are used for two features. One is executed when the user enters data into the form and clicks the save button for initial data insertion. Second is, when an entry in the grid is loaded to the form for editing, and the user is performing the updating operation. In both cases the same algorithm can be utilized in the client-side, and the server-side algorithms can distinguish between the operations and process accordingly. Figure 3 illustrates the save/update algorithms.
START
START
Read form data Set form method
t
DISPLAY
DISPLAY
Error msg
Sts msg
Set URL
START
START Load grid
Set response handler Read page num
t
Error
f Send request
Set form method Set URL
f
Error
DISPLAY
DISPLAY
Error msg
Sts msg
Set response handler
Load grid
Send request END END Figure 2. Read/load data algorithm of Form and Grid pattern
Clear form/ reset settings
END END Figure 3. Save/update algorithm of Form and Grid pattern In the requesting algorithm, which is shown in the left side of the figure 3, the first step is reading data from the form. When using JS, it may need another long algorithm to read all data from the form; however, reading all data from the form can be done by a single line of code, using the serialize() function in jQuery. For the save/update algorithm, the form method is supposed to be POST, and the URL should be pointed to the server-side script file, which is responsible for processing the request. In case of
International Conference on Innovations in Info-business and Technology, Colombo, Sri Lanka, March 04, 2016
update, the ID of the entry to be updated, can be sent as a parameter in the query string of the URL.
START
START
4.2.4 Remove Remove algorithm is executed by the remove button(s) in the grid, and it is illustrated in the figure 4. The first step of the requesting algorithm reads the ID of the entry to be removed from the grid, since the ID is needed to remove the entry from the database in the server. The form method should be DELETE, and the ID of the entry to be removed, can be sent as a parameter in the query string of the URL.
Operation related processing Set form method
t
f
Error
DISPLAY
DISPLAY
Error msg
Sts msg
Set URL Load grid
START
Read item ID Set form method
Set response handler
START
t
Error
f
Send request
Operation related processing
END DISPLAY
DISPLAY
Error msg
Sts msg
Set URL Load grid
Set response handler Send request
END
END Figure 4. Remove algorithm of Form and Grid pattern
4.3 Generalizing the algorithms When analyzing the CRUD related algorithms of the proposed Form and Grid pattern, it can be clearly seen that these algorithms are directly affected by and based on the basic algorithm of the AJAX; and only few additional feature related steps are required, according to the operation. Hence, regardless the nature of the form and/or the number of the columns in the grid, we can derive a pair of generic algorithms for the asynchronous communication of the Form and Grid pattern. Figure 5 illustrates the generalized algorithms for request sending (in left) and response handling (in right). The first step in the generalized requesting algorithm and the last step of the generalized response handling algorithm are reserved for operation related processing (ORP). For the saving and updating operations, the ORP step of the requesting algorithm reads data from the form. In updating operation, reading the ID of the record to be updated is also needed, in addition to form reading. OPR step for the removing operation contains, reading the ID of the record to be removed. For the read/load operation, reading the page number can be done in the ORP step.
END
Figure 5. Generic algorithm for the asynchronous communication of Form and Grid pattern The ORP step of the response handling is needed only for the save and update operations; and it contains resetting of the form and initialization of some other necessary parameter(s) as required.
4.4 Development of the Form and Grid pattern A series of experiments was conducted based on a prototype, using incremental development in iterations, to identify the characteristics of the operations in the hybrid pattern, identify issues in their integration, test solutions, and verify the findings. Findings of each and every iteration were tested, refined, and applied into the later iterations. For the development of the presentation of the prototype, HTML 5 was used. The formatting of the content was not much considered, therefore only small amount of CSS was used for formatting. The server-side development was done using PHP. For hosting the system for testing, Apache server was used locally, and for the database a local MySQL server was used. Server management was done using the XAMPP tool. In server-side, the domain logic was developed using OOP, and for asynchronous communication handling, an RIA-Bus [16] was used. A customized version of REST [17] was used to prepare the URLs of the asynchronous communication of the operations. The client-side algorithm development was done using jQuery, based on the event-driven paradigm. Registering all the event handlers was done using jQuery in an external JS file, instead of using the inline approach of HTML, using event attributes [18]. The generalized algorithms were developed in a single JS function; and in that function, the jQuery ajax() function was used to implement the asynchronous communication. The response handling algorithm was contained as an inner function of the ajax() function, which was set as the value for the “success” option of ajax() function. The ORP steps were implemented in the click event handlers of the buttons of the respective operations. The HTML form method, the REST formatted URL, and the form data, were read/prepared in these event handlers and passed as arguments to the parameters of the generalized algorithm containing function.
International Conference on Innovations in Info-business and Technology, Colombo, Sri Lanka, March 04, 2016
As the result of this setting, all button click event handlers are intended to contain only the ORP, and after ORP they call the generalized algorithm containing function, passing the arguments. The generalized algorithm containing function encloses the major set of steps of the client-side logic of the Form and Grid pattern. This arrangement simplifies the development complexity and also reduces the workload.
5. SIMILAR WORK There are various products available, which deliver functionalities similar to the introduced Form and Grid pattern. DataTables [19], Editor [20], Dynatable [21], and tablesorter [22] are some examples for the available products, which are produced as development libraries. In depth discussions of these products are avoided; instead the common problems related to these products are specified, which the proposed Form and Grid design pattern has tried to overcome. First of all, these products are technology dependent, thus they limit the adoption into a defined environment. The client-side libraries are more popular than the server-side libraries, since the adoption is higher, regardless the server-side platform. Moreover, these products are incorporated with a high learning curve. The adoption of these libraries has to go through documentations and preparing the system to align to the requirements of the library. As a result of aforementioned facts, the flexibility provided by these product is really low. High amount of settings and configurations are engaged with them, and to get the desired results, a reasonable workload should be accomplished. However, not only the functionality, the look of the result does also matter; and to match the look of the results produced by these products to the target system, some more effort should be put into the development. The main question formed by all these problems related to the available similar solutions is that, will the facilities provided by these products worthy for the cost of adopting them? Sometimes developing these expected functionalities from the scratch may provide better results. The difficulty of developing from the scratch is engaged with the complexity of the features, and the realization of their characteristics and the integration. The introduced Form and Grid pattern has been able to overcome the complexity by identifying the characteristics of the operations in the pattern and increasing the realization by providing the pattern in a simplified manner, which is flexible, incorporates less workload, thus eases the development.
6. CONCLUSION AND FUTURE WORK
workload. Furthermore, the realization delivered by the abstraction of the algorithms provided for the pattern, may assist the adoption of it in more flexible manner, in wider environments, compared to the available solutions. At the moment the Form and Grid pattern had been experimented only using AJAX for the asynchronous communication, which is a data-pull technique. Real-time data-push handling or integration of publisher-subscriber like model, using other techniques/technologies like WebSocket, might need some modifications in the introduced algorithms, and also needs thorough testing. Form and Grid pattern is expected to integrate more features/patterns in future, mainly searching and sorting. And also the pattern will be continued with experimenting on incorporating WebSockets, for wider range of applicability. Furthermore, in future, it is expected to develop a jQuery based JS library, for easy and flexible adoption of the Form and Grid hybrid pattern into RIAs, hence assist rapid development.
7. REFERENCES [1] M. Busch and N. Koch, "Rich Internet Applications - Stateof-the-Art," Ludwig-Maximilians-Universitat , Munchen, 2009. [2] E. Gamma, R. Helm, R. Johnson and J. Vlissides, "Design Patterns: Abstraction and Reuse of Object-Oriented Design," in Springer Lecture Notes in Computer Science, 1993. [3] H. Zuse, Software Complexity Measures and Models, New York: de Gruyter & Co., 1992. [4] Å. Granlund, D. Lafrenière and D. A. Carr, "A PatternSupported Approach to the User Interface Design Process," in Proceedings of HCI International 2001 9th International Conference on Human-Computer Interaction, New Orleans, 2001. [5] D. K. Duyne, J. A. Landay and J. I. Hong, "Making the Most of Web Design Patterns," in The Design of Sites, Pearson Education, Inc, 2002. [6] P. L. Thung, C. J. Ng, S. J. Thung and S. Sulaiman, "Improving a Web Application Using Design Patterns," in International Symposium in Information Technology (ITSim), Kuala Lumpur, 2010. [7] F. Piero, R. Gustavo and S.-F. Fernando, "Rich Internet Applications," Internet Computing, IEEE, vol. 14, no. 3, pp. 9-12, 2010.
The proposed hybrid pattern named Form and Grid had been introduced for RIAs in this paper. A pair of generalized algorithms are also presented for the client-side development of this pattern, which reduces the development complexity and workload by increasing the realization of the characteristics of the operations used in the pattern and their integration.
[8] D. Crane, B. Bibeault and J. Sonneveld, Ajax in Practice, Manning Publications, 2007.
The Form and Grid pattern had been successfully implemented and tested using the introduced generalized algorithms; and this paper concludes that this pattern is effective for managing data in database based on CRUD pattern, via a GUI consisted of a form and pagination enabled grid. The Form and Grid pattern can provide better user experience, while reducing the development
[10] I. Fette, "The WebSocket Protocol," Internet Engineering Task Force, 2011.
[9] W. H. A. T. W. G. WHATWG, "XMLHttpRequest Living Standard," 19 October 2015. [Online]. Available: https://xhr.spec.whatwg.org/. [Accessed 03 November 2015].
[11] S. R, P. G and I. K, "A Survey of Design Pattern Based Web Applications," JOURNAL OF OBJECT TECHNOLOGY, vol. 8, no. 2, pp. 61-70, 2009.
International Conference on Innovations in Info-business and Technology, Colombo, Sri Lanka, March 04, 2016
[12] N. Koch, M. Pigerl, G. Zhang and T. Morozova, "Patterns for the Model-Based Development of RIAs," in Springer ICWE, Heidelberg, 2009. [13] T. Neil, Standard Screen Patterns v3.0. [14] J. W. Yoder, R. E. Johnson and Q. D. Wilson, "Connecting Business Objects to Relational Databases". [15] N. R. Dissanayake, D. De Silva and K. Dias, "A Comparison of the Efficiency of Using HTML over XML and JSON for the Asynchronous Communication in Rich Internet Applications," in 8th International Research Conference of KDU (KDU-IRC 8) on Inculcating Professionalism for National Development, Rathmalana, Sri Lanka, 2015. [16] N. R. Dissanayake, G. K. A. Dias and C. Ranasinghe, "RIABus: A conceptual technique to facilitate the AJAX-based rich internet application development," in Proceedings of the Research Symposium of Uwa Wellassa University, Badulla, Sri Lanka, 2015. [17] N. R. Dissanayake, T. Wirasingha and K. Disa, "Integrating REST with RIA-Bus for efficient communication and modularity in Rich Internet Applications," in 8th International Research Conference of KDU (KDU-IRC 8) on Inculcating Professionalism for National Development, Rathmalana, Sri Lanka, 2015. [18] N. R. Dissanayake, U. Liyanage and K. Dias, "A CONCEPT OF BALANCED-CLIENT FOR RICH INTERNET APPLICATIONS," in International Research Symposium on Engineering Advancements 2015 (RSEA 2015), Malabe, Sri Lanka, 2015. [19] SpryMedia, "DataTables," SpryMedia Ltd, 2016. [Online]. Available: https://datatables.net/. [Accessed 10 02 2016]. [20] SpryMedia, "Editor," SpryMedia Ltd, 2016. [Online]. Available: https://editor.datatables.net/. [Accessed 10 02 2016]. [21] A. Jango, "DynaTable," Alfa Jango, 2014. [Online]. Available: http://www.dynatable.com/. [Accessed 10 02 2016]. [22] C. Bach, "tablesorter," [Online]. Available: http://tablesorter.com/docs/. [Accessed 24 10 2015]. [23] J. Allaire, "Macromedia Flash MX—A next-generation rich client," Macromedia, San Francisco, 2002. [24] J. Farrell and G. S. Nezlek, "Rich Internet Applications The Next Stage of Application Development," in Proceedings of the ITI 2007 29th Int. Conf. on Information Technology Interfaces, Cavtat, Croatia, 2007. [25] J. J. Garrett, "Ajax: A New Approach to Web Applications," adaptive path, 18 February 2005. [Online]. Available: http://www.adaptivepath.com/ideas/ajax-new-approach-webapplications.
International Conference on Innovations in Info-business and Technology, Colombo, Sri Lanka, March 04, 2016
