You are on page 1of 9

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.

ORG

39

Architecture and Design of Web Application Framework: A Preliminary Review


Mohd Razak Samingan, and Wan Mohd Nasir Wan Kadir
Abstract Among the earliest issues to be solved regarding to web application (WA) architecture and de sign is the performance problem and business logic complexities due to some limitations in conventional CGI architecture. These issues arise when WA began to be used to provide services with a very high number of accesses by users and solve more complex problems such as large scale e-learning system, online banking, one-stop online shopping center, etc. Most of the solutions are not considering the complexity that also brought along with the new proposed architecture as long as the aforementioned issues can be solved. As WA evolved and used to solve more complex problems, the next phases of WA architecture and de sign research have going towards for more simplified design, further exploiting database technology maturity, and search for suitable aided-tools to facilitate on some aspects of WA development process. The research direction has also move towards on proposal for better insights on WA design via motivation or enforcement of particular design pattern and shows some awareness to the necessity for deep understanding on using technology appropriately as it was originally intended. Web application framework (WAF) that nowadays has been w idely accepted for WA development has to be i n tandem with the current research trends to provide better, profound and proven architecture-design inside the application. Index TermsArchitecture and Design, Application Framework, Software Engineering, Web Application

1 INTRODUCTION
he public perceptions among developers on application framework generally always with higher expectation which is it should cater if not all but at least most of the application development aspects (modeling, architecture and design, implementation strategies, tools, etc.). Web application framework (WAF) also cant escape from these public perceptions thus the aforementioned aspects are crucial to be fulfilled. The possible way to fulfill it is by elaborating and combining the fragmented ideas and solutions from the previous works to be incorporated inside the WAF design and implementation. For that purpose, this article will discuss several previous related works that are relevant with the WAF research topic especially those which have a close relationship with the idea of WA architecture and design. Though there are previous works that not directly deal with WA architecture and design such as done in [1], [2], [3], and [4] which put more concentration on web template system, but the idea from those works for clear separation on application components is highly valuable to be incorporated inside the WAF. The rest of the sections in this article will explore the existing proposed solutions for architecture and design of WA as follows. Section 2 discusses the performance and complexity issues try to be solved in conventional WA architecture and design (CGI). Section 3 mining out the

ideas on how to use database technology not only as application data backend but further extend it to support logical and control elements of the application. The rationales to choose either thin or fat client architecture in WA design are explained and elaborated in section 4. In section 5 the discussions is more toward to software engineering (SE) disciplines perspective. The implementations of SE related approaches (reverse engineering, software design pattern, and component-based software development) in WA proposed by previous researchers are presented in this section. Section 6 gives an example how particular technology should be used wisely to support WA. At the end of each above sections, how the proposed solutions can be applied as a standard architecture and design inside WA via WAF implementation are further discussed. In section 7 we discuss the most significant idea excerpted from the review and relate it with our current research work. Finally, section 8 gives the overall conclusion on architecture and design of WA in the perspective of WAF.

2 CONVENTIONAL CGI ARCHITECTURE

2.1 CGI Architecture Limitations Among limitation that is very critical in conventional CGI architecture is slow response rate even though the client already equipped with a very high-end computing re sources. Since all computations are made at the server, Mohd Razak Samingan, Faculty of Computer Science & Information Systhe client becomes too passive and all business tasks are tem, Univeristi Teknologi Malaysia. too focused at the server side thus increase burden on the Wan Mohd Nasir Wan Kadir, Faculty of Computer Science & Information server. It also increases overall network traffic since each System, Univeristi Teknologi Malaysia. business task requires HTTP request and response back and forth between the client and the server. Besides that, stateless HTTP communication also poses issues on user's

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.ORG

40

session management since client only connected to the server while HTTP's request-respond process was made. After the completion of request-respond process, the server doesn't have any resources to be accessed to get the current state of the client information.

less connection implementation.

2.2 Object-oriented Based Solution To deal with the conventional CGI architecture issues, E. S. Cho et al. [5] proposed new object-oriented based architecture model for web application by combining Java based technology together with distributed computing model using CORBA and agent based technology. This new architecture model targeted as a replacement for the conventional CGI based architecture which has several limitations in term of performance, functionality, and usability. In the proposed architecture Java Applet intensively used to make client becomes more active and responsive. Some of business tasks that possible to be implemented at the client can be passed to and handled by the Applet. Executing business tasks locally at several clients at one time can help increase overall performance due to business process distribution at the client side and help avoid process overload on the server. Though Java has its own distributed computing technology using Java RMI, CORBA technology was choose due to language dependence problem in Java-based technology. Integration of Java and CORBA (Java/ORB) also solve problem in CORBA architecture where client's state management doesn't well supported. It's solved by using lightweight Java applet as a CORBA client's objects. The applet-based client objects also become more versatile where it can communicate with other objects written in different languages. To further improve Java/ORB architecture, an agentbased technology support can be added. Java-based agent technology such as General Magic's Odyssey, IBM's Aglets, and ObjectSpace's Voyager [Kiniry 1997] provides various options for developers to choose from. Mobile agent technology give extra benefit to the architecture especially in term of better performance and efficiency due to the new added features such as intelligent, less rigid client-server model, and agent operations that independent from the application it was invoked. The proposed architecture in [5] is considered too complex and only suitable for very large scale applications, having integration with other legacy system, and purposed for mission critical with sensitive data applications such as banking and finance. WAF should not obligate itself to follow the proposed architecture in [5]. Integration with other technologies either at the server-side such as using FastCGI and mod_perl or at the client-side using Ajax based technology is possible to improve CGI conventional architecture especially in term of performance and making the clients more dynamic and interactive. Integrated software architecture design inside the WAF with special components and software API that fully take advantage on relational database technology maturity such as done in [6] also possible to solve session management issues caused by limitation on HTTP state-

2.3 Server-centered Infrastructure Uhler [7] use different approach to solve limitations issues in conventional CGI architecture. Uhler put concern on server infrastructure for simple, modular, and scalable web architecture. One of the main issues to be solved by the new architecture is the limitation of one-to-one mapping between URL and files imposed in most web applications that are based on conventional CGI architecture. This limitation is left behind despite many solutions that involving architecture adaptations have been done before. For example there are several server architecture oriented solutions proposed such as Fast-CGI, internal server APIs, and Servlet to remedy performance problem in CGI applications but none of them specifically deal with the URL and files one-to-one mapping limitation. Though being simple and practical in implementation, limiting URL and files mapping as one-to-one basis bring several major bad impacts on today's more complex and sophisticated web applications. It will limit both web server and CGI application capabilities, thus application complexities at most of the time are all thrown inside the application APIs. The example can be found in Servlet API (2.0) where the number of classes and interfaces horribly increase from its previous version [7]. Extending web server capabilities will not totally worthy since it will centrically increase the size and complexity of the system inside the web server itself. The application logic also becomes too close bound with the web server and can result in coupling problem. The solution proposed by the new architecture in [7] is server-centered infrastructure. In that new architecture, servers are split into two main categories which are the content-servers and meta-servers. Content-servers functionally referring to the traditional web server but strictly limited to only deliver application content. On the other hand, meta-servers serve more complex task to handle and manipulating the content regarding to content aggregation, presentation, and security implementation. Application data from content-servers will pass through various meta-servers before reach and displayed at the client side. Using this mechanism, content-server becomes simpler and very lightweight. In other word, complexity in application development process shifted from application developers to other parties (meta-servers designers and developers). Extremely, it's possible that contentservers becomes a micro-servers embedded into other small appliances such as mobile devices and sensors. In WAF perspective, Uhler's works reflecting the fact that WAF developers suffering from design complexity due to the very limited in capabilities of most current web servers and CGI applications that empowering them. Since the work still at the experimental stage and metaservers concept is not widely available and understood by many developers, in the near future, there are no promises for WAF to rely on server-centered infrastructure such as proposed in [7] to hindering the complexity imposed by complex application domain problems. Furthermore, the new architecture mostly only benefits new sophisti-

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.ORG

41

cated web applications which functionality requires interaction with miscellaneous devices other than PC and servers.

3 DATABASE ORIENTED ARCHITECTURE


3.1 Statefull Web Applicaton Support At the beginning of CGI application era [6] has successful solve HTTP stateless limitation in web application by fully depending on the database. The case study application has been developed with only using pure HTML without any support from other technologies such as Active-X, JavaScript, Applet or even a browser's cookies. For the case study application used in [6], links are extensively used to provide user interaction at the client side. It contains CGI data (a pair of variables and values) which feed from the database. These CGI data are regenerate dynamically in each transition to represent the same state but with different data content values for every next successive pages following user's navigational-behavior. The CGI data stored in the database as structured control elements possibly a grouped set of links. These structured control elements injected dynamically from the database to link elements in web pages and works like a state machine. The approach brought by Goschka [6] is implemented while internet users witnessing an open browser war between the Microsoft and Netscape. It's the era of immature browser technology, client script inconsistent implementation across different browser, and cookies still not a standard in many browsers. Despite all these hindrances and at the same time only used basic-plain HTML technology, the proposed approach still capable of delivering an application with some high degree of complexity for the client user interface and database interaction. Though the browser war has been long ended and there are so many great improvement with better standardization in client site support technologies, Goschka's ideas still relevance for today's web development activity due to the benefit of its centralized business-intelligence at the server site which can prevent the core application logic disperse in the client pages. This server-centralized approach will make application maintenance much easier. Forwarding Goschkas ideas in today's web applications dont mean developers should completely avoid from using other client-centric browser support technologies. Rather, it means that server-centric, thin-client approach, though might become classic nowadays, it still has its own place and prospects for solving many of today's web-based enterprise applications. Using other fatclient support technologies can be done if its requirement become indispensable in the application and can't be supported by the logic resident at the server side or its implementation will not caused tight logic coupling at the client pages. For example it's worth and very convenient to use JavaScript to check either users has complete the HTML form since the logic generally doesn't have a closedirect relationship with the core application's business logic.

3.2 Database Roles Extension Other work related to database oriented architecture can be found in [8]. Qiao-ming [8] extends database roles in web application not only as a dynamic data feeder to the web pages but also as a resource for handling and managing the pages itself. Generally the pages are categorized into two main categories which are the static pages and the dynamic pages. Though static pages conventionally can be resided within the web public directory using traditional file format and structure so later can be directly publish to the users, the approach use in [8] requires the static pages to be exist as a record in the database table. The implication is that the hypertext links will never refer to the HTML files but a dynamic script that making an HTTP request for database item access via SQL command. This task is done by a special script called as Common Script Procedure (CSP). In the scope of dynamic pages, [8] propose other type of script known as Functional Script Procedures (FSPs). FSPs are responsible for providing support to handle database items used as a source data inside the dynamic pages. FSPs are not call directly but through CSP and must return its result back to CSP. The CSP later store the result into the database table together with the calling conditions referring to the current FSP before pass it to the web server. Next call to specific FSPs via CSP with calling conditions already exist in the database will make CSP directly retrieve the result from database without actually execute the FSPs. Using this mechanism can improve the performance especially for FSPs that requires complex and time consuming business logic. It also helps developers manage static and dynamic pages in uniformed manner via single centralized CSP. Such works in [6] and [8] demonstrate how database has a great potential to contribute further on the improvement of the overall web application architecture and design. Database should play more active roles in web application, not only for application content feeder as commonly used before. While ideas in [6] lead toward well-managed and better-centralized control on CGI data and application main structure (links), [8] move further for uniform-centralized link-contents management together with performance improvement for dynamic content creation.

4 SERVER-CENTRIC & FAT-CLIENT ARCHITECURES


4.1 Blending Server-centric & Fat-client Architecture Dworak [9] propose architecture that can provide both thin and fat client web application deployment environment. Main issue to be solved is that thin client can benefit web application in term of low bandwidth usage and reduce server load but due to possible security threats not all user agents are friendly and open to the client scripts source code. There are also no strong guarantees that all user agents provide support on particular client scripting technology used. Thus application accessibility has become one of major concern in fat client architecture. On

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.ORG

42

the other hand, thin client approach is not affected with this issue but suffer from high bandwidth usage and an increase of server load since the application's business logic mostly run at the server side. The proposed architecture in [9] solved the above dilemma by blending both approaches into single deployment environment. In case of client script technology supported by the user agents, the web application will run in fat client mode and can get the benefit of low bandwidth and reduced server load. Otherwise, thin client approach will be used. Though it might use more bandwidth and increase server load but can help increase the accessibility of the application to the clients. This mechanism can help to optimize web applications in term of its performance and accessibility. Among the problem when implementing the proposed architecture in [9] are difficulties of using different languages for developing application components at two different locations which are the server-side and the client-side. Though there is solution but it will limit the choice of languages for the architecture which is only Java or JavaScript based technology via server-side JavaScript.

tion are only done at class property level at application run-time and not at class file level.

4.3 Server-centric vs Fat-Client In WAF perspective, for both works in [9] and [10], the proposed architecture is still considered too complex to be implemented directly inside the WAF. WAF should be first build on thin-client and server-side oriented architecture. Blending fat client architecture should be done later after server-side oriented architecture has been established within the WAF itself.

5 SOFTWARE ENGINEERING PERSPECTIVE


5.1 Reverse Engineering Due to short time release cycle, continuous evolution, and undocumented development culture of earlier web developer folks, reverse engineering process mainly aimed to recover the architecture of existing running web applications such as done by Hassan [11] becomes crucial. Maintenance works for constantly evolving web applications are impossibly avoidable. Thus, application architecture documentation is mandatory for better understanding of the overall application design. Hassan's works exhibits the previous problems trend when web applications were developed without following any particular software design pattern. He suggests that in order to better understand the web application design it's essential to capture and visualize the interactions among application resources. These resources include active pages, web objects and the database tables. Active pages used to present application data and referred to technologies such as ASP, PHP, and JSP. These technologies provide facilities to mix HTML tag with executable code for the convenient of data presentation. Web objects are collection of compiled code that executed via client-server request to provide a service to the client. Within J2EE specifications scope web objects are the EJB components. Database as for many web applications ubiquitously used as a backend to store data regarding with the application's domain problems. All these components formed three-tier structure inside the application which is presentation tier, business logic tier, and data tier. This is actually an embracement on "separation of concern" for better architecture understanding and ease of maintenance. Such work in [11] doesn't encourage developers to first design web application with proper proposed architecture available in software-engineering disciplines. The ad hoc approaches remains preferred with the thought that application's architecture can be recovered later but any defect on the architecture only known after the system was complete and software refactoring is generally an expensive one. Refactoring should only be used to improve software qualities [12], [13] and not for fatal errors remedies on architectural design. WAF can play its distinctive roles on solving the above issues via enforcement and motivation of particular software design pattern. The concept of semi-complete application with pre-wired software components following

4.2 Business Task Partioning Kuuskeri [10] provide the guidelines (conceptually & technically) on partitioning business tasks between client and server. The work is motivated by the availability of asynchronous communication technology over HTTP protocol provided by Ajax. The guideline help to maximize client roles on running application logic but leave other part of logic such as persistence data, client-client communication, and shared data still handled at server side due to some technical limitations on client implementation. For both client and server, the application logic was developed using single programming language that is JavaScript. Java programming language also used but only as a proxy to forward all requests from client to web server to server-side JavaScript functions. The benefits gain from this kind of fat-client approach are the client-server communication can be minimized, straightforward development tasks using fewer technologies with single main programming language (JavaScript), and possible to centralized development activity at the client side. Though the approach used can't completely move business tasks to the client, but using single programming language at both sides (client and server) will help bridge the gap and provide seamless integration between the client and the server. However, there are some pronenesss at the implementation level where, conceptually, duplicate functions are implemented on both sides of server-client architecture though there are already clear separation (conceptually & technically) on task that should run at the server or the client. Class implementation for server and client business tasks are assembled inside single JavaScript file and made available at both side the server and the client. Though seamless integration between the server and the client can be achieved but in the perspective of application resource maintenance this will also lead to tightly-coupled business code of the server and the client since tasks separa-

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.ORG

43

specific architecture design pattern to support generic requirements of web application is possible to be implemented as an enforcement strategy inside the WAF. To motivate developers using the framework, it should be simple, lightweight, less complex, and provides plentiful of helpers development tools for developers convenience. There's already existing WAF that promote specific architecture design pattern even before such work in [11] is proposed. Apache Struts Project is one of the examples. Officially release in May 2000, Struts framework [14] implementing MVC design pattern for web application development but its approach is more toward to unease enforcement (not providing a semi-complete application) rather than motivation.

5.2 Software Design Pattern GuangChun [1] propose better separation on business logic and presentation in J2EE web development environment platform using JSP Model 2 at the controller level. The approach used is to divide controller tasks into three main functions which are the system, model center, and logical page module (LPM) center. At the system layer the controller is responsible to handle incoming user requests and find relevant business logic to the request defined inside the system description database. The ending process at the system layer is a call to specific application modules and will be continued with transaction messages passed to the model center. Based on the transaction messages, model center will select and call the objects that contain methods correspond to the transaction logic encapsulated in the message. The result is a data model with specific given format passed to LPM before rendered by selected logical page objects (view). At the LPM layer the logic for handling data model has been simplified without concerning about the data sources and its transactions thus prevent coupling complex business logic at the model-view level. JSP Model 2 used in [1] is actually an improvement of MVC design pattern implements in [14]. While standard JSP Model 2 can provide better and more flexible separation between model, view, and controller, [1] further tightened the principal of separation within the controller scopes. Other research works that related with this separation of concern also can be found in [2], [3], and [4] but all of them give more emphasis on view element. Looking at how other researchers give serious attention on this particular issue, enforcing the separation of application components within the context of model, view, and controller inside the WAF has become indispensable. The practice must be maintained and preserved even in the situation where MVC design pattern has not become the first choice. Its for the sake of better understanding of the application design and ease of application development and maintenance. Design pattern like MVC can also motivate the use of modeling notation such as UML and enforce specific architecture to be implemented within the application. It can indirectly help to disciplines developers to produce software with better documentations and clear architectural design. The example can be found such as in [15].

Real implementation of model within MVC design pattern requires model abstraction in the form of super class to be inherited by other sub classes. These sub classes later will become models to the application before injected into the view components for data presentation. Though the work in [15] doesn't show clear implementation of MVC design pattern as for model there are no clear definitions of model classes and too heavily depend on stored procedure but, the overall architecture clearly shows the pattern that application's components (business data, presentation, and business logic) are well separated among them. Thus in the perspective of WAF it become mandatory to have an enforcement on specific design pattern to ensure the development activity lead to the production of web applications with consistent-clear architectural and class design. Arthur [16] studies the strategies used in Java based web framework [17] which help increase development productivity by decrease the framework complexity. It's found that the main approach can be used to achieve this goal is to using simplest architecture but still can accomplish client need and sufficiently fit with basic requirements of its underlying framework platform (J2EE). For the case-study framework has been selected in [16], key to its simplicity that has been found is through the use of "Inversion of Control" (IoC) principle in the framework core design. This principle is one that can be categorized as a pattern in object-oriented design paradigm [18]. As architecture design patterns only provide higher level and abstract view of WAF, object-oriented design paradigm playing a role to provide a collection of class design patterns that work at implementation level in controlled manner under particular architectural pattern scope. The WAF [17] studied in [16] is Java platform based web framework. In Java world, class design pattern becomes burdensome as a Java class is hard (not fully objects, mostly source code constructs, unchangeable at runtime, and directly reference class name to class) [19]. Other dynamic language such as Perl, Python, and Ruby doesn't have all these trade-off thus basic OOD approaches is adequate. It's quite profound that simplicity and lightweight features are not totally depends on the architecture but also the choice of underlying programming language to be used inside the WAF. However, in WAF world, regardless the types of object-oriented programming language used, class design patterns which grasp IoC design principle has been quite widely accepted as a foundation for framework implementation simplicity. The key factor to simplicity in IoC is acquired through the abstractions of most generic application behaviors gathered via careful observation on main business process pattern. In the context of MVC architecture pattern, IoC design principle mostly applied at the main controller level.

5.3 Component-based Approach Murk [20] work on generic component based framework design to overcome incompatible issues that cause overlapping in features and functionality across different web appli-

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.ORG

44

cation frameworks. Each component in the frameworks is built as independent entities so reconfiguration, extension, and replacement are easy. This is the main aspect that helps solve the incompatibility problem. To cope with current available frameworks techniques and approaches, components is actually an abstractions of existing models and patterns such as high performance and low memory stateless components, event driven stateful components, modal processes based components, and asynchronous request support that more specifically is refer to Ajax technology. Using the types of abstraction proposed by Murk, frameworks components are assembled from several defined interfaces namely as Component, Service, Widget, and FlowContext. Service and Widget are subtypes components. Hierarchically Widget is a child of Service and grandchild of Component. Service is used to model stateless component that act as a controllers in the application. On the other hand Widget is customized controllers to model stateful components that facilitate data flow operation from and to web user interfaces (HTML form). FlowContext exist as a higher level interface equivalent with Component to support nested process for nested Widget. Using all these types of interfaces are enough to resolve basic aspects of web application which are involving configuration, security, error handling and concurrency. Being independent, highly extensible and flexible using dynamic hierarchy composite design pattern, there is no specific way how the components should be composed to become a complete application. Developers can use different approaches and techniques learned and reaped from different frameworks such as Struts, JSF, or Spring web frameworks. This higher flexibility is come from the ability to abstract most generic design pattern acquired from different frameworks but might rise other issue of being too abstract that give a bad impact in term of framework understandability by developers. Souer [21] brings solutions from legacy software engineering knowledge via web engineering discipline in web content publishing domain. The solutions are implemented as Web Content Management (WCM) software. The WCM incorporate three different technologies which are the OSGi to support dynamic component-based and service-oriented deployment environment, Java Content Repository (JCR) as a back-end data support, and Spring framework to provide MVC architecture within the application. Such work in [21] demonstrate how the earliest and most basic domain problem to be solved by web (content publishing) can also get benefit from higher-level software engineering discipline such as service oriented infrastructure architecture and MVC software architecture pattern. However, this kind of work is also considered too complex and requires highest level of expertise. OSGi, JCR, and Spring framework are three different complex entities for both concept and implementation. It not solves complexities on WAF, but rather only adapting it with other technologies to achieve other goals. Experiment on component-based framework architecture for web-based educational software development activities has been done in [22]. The architecture tested emphasizing on application modules interaction and composition, aiming

for easy module reuse, extension, and modification. The experiment demonstrates how component-based development techniques can be used inside WAF to provide flexibility in term of function extension and reuse within particular domain problem of web application. It also affirm that component-based approach can help to separate application architecture into different part of layers and make easier for developers to implement MVC design pattern that bring so many advantages in implementation and maintenance. The component-based architecture used in [22] make possible for the system to provide a web-based GUI tools for composing modules to build-up a complete application. Undoubtedly, GUI-based tools are the main key-elements that can help increase productivity. The architecture also capable to implement its own security model on users who access the application modules via role-based access control (RBAC) mechanism. The security model used also flexible enough to integrate with other authentication mechanism such as LDAP or specific database-based authentication system. Though the proposed architecture in [22] applied limited to particular domain problem (web-based educational system), such MVC component-based approach if used with more proper high level and general abstraction of classes can be applicable for other various web-based enterprise applications.

TECHNOLOGY SUITABILITY

There are tendency for developers to only use particular framework if they found that the simple architecture they choose at the earlier stage of development no longer fit for evolved complex application requirements. Choosing simple architecture might be practical to quickly having earlier working version of application available for the clients. However, in the long run project where the application scale become increasing larger at every revision phases, the risk of being trapped in difficulties to redesigning the architecture seems can't be avoided. Urgency for and appreciation to WAF only come after they found that it's too hard to maintain the complex requirements of application being developed as it scope going bigger over the time. Developers can't be totally blamed in the above issues since most existing enterprise WAFs are considered too complex and may looks overkill at the beginning of the project that usually only able to capture basic requirements of the application. The possible solution is to make WAF easy and flexible enough to be used for both smallscale and large-scale applications. For WAF to featuring this capability, it should have an architecture design that can catch up and adopt changes in application that might evolves from providing simple to more complex business tasks. The process to achieve this goal is demonstrated in Sun [23]. However, without deep understanding on technology suitability and careful consideration of its implementation effects, one might make wrong decisions. Sun, in the quest for better application framework, though without a full guaranteed, using XML and XSL as a key technology to prevent business logic from directly

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.ORG

45

deal with the presentation to fulfill the concern of separation. The need for separation can be realized by limiting business logic only to deal with the task to generate XML document from application data model. This will make possible to reside the view elements outside of application business logic using XSL template document. However as experienced in [23], XSL transformation causes application performance drawback and maintaining XSL document to most programmers is a tedious job and error-prone. Other examples that demonstrate and argue the suitability of using XML based technology can also be found in [22], and [24]. In [24], XSL has rising performance issues while [22] argue that XML based configurations in application development process such as applied in [14] is considered too complex even for large-complex application (e-learning system). However, it's not a smart choice and no rational at all to completely abandon XML. Instead, used it appropriately for data exchange between different applications in other platform and this is the actual intended purpose of XML technology when it was created (data interoperability).

DISCUSSION

In the previous sections we have discussed all the possible basic elements (infrastructure, database, SE approaches, client-server computing model, and other essential support technologies) that might be used for the realization of WA. All these elements must be well organized and composed together to produce high quality and fully well functioning WAs. This is of course not an

Fig.1. Interrelationships between WAF, WA, and WAs Elements

easy task for developers since all these elements require different knowledge disciplines including high level architectural design skills, SE techniques, database, comput-

er network communication, and hypermedia. Integrating them into single complete WA are also far more challenging. WAF can play its role to alleviate all these difficulties by providing standard and generic integration structure of all these elements to developers i.e. a semi-complete structure of WA. This is also the core substance that compulsory to exist in WAF architecture and design. Fig. 1 depicted how WAF in general acting as a tool to provides this predefined structure of WA. Our experiences facing a lot of troubles and difficulties while developing several real world web-based applications in our organization (Faculty of Computer Science & Information System, UTM) motivate us to develop our own WAF. The information gathered in this preliminary review is very important to us since we are still in the early stage to develop a new WAF. In our current research work, the selected application where the WAF will be derived from has been actively used to handle and manage course timetable at the faculty since 2004, available at http://web.fsksm.utm.my/elearning/ttms. It has been almost seven years that we are able to successfully maintain this specific application. Its strongly believed that there is something valuables can be learned and mined out from the application since it can survive for such long period of time. This success story motivates us to properly extract the architecture and design of the existing application and compare it with the ideas already reviewed in this article. In our initial study we found several approaches and elements that embodied within the architecture and design of the existing selected application as follows: The main infrastructure is using conventional CGI architecture with Apache as a web server, Perl as a main programming language, and MySQL as a backend database. The application embraces server-centered computing model. Though there are some of applications pages used JavaScript but they are only used to provide simple interactive features such as HTML element color changes at the client side. No single business task resides at the client side using JavaScript. Database-oriented approach is heavily applied within the application design. The database not only used to handle application data and content but also the link structure and some part of the business logic control. The implementation of some sort of IoC design pattern within the main controller of the application. The main controller is actually a Perl module written in OOP fashion and instantiate by main Perl -CGI script. There are only single main controller and Perl-CGI script. Other specific business logic and controls are written as a sub modules and instantiate inside the main controller. Application features which have been listed above will be used as an initial foundation for the new WAF development process. For that purpose, such work in [11] is most likely relevant for us to capture and grasp a deep understanding of the application architecture and design characteristics. These characteristics which are enlightened by other researchers ideas, supported by our own

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.ORG

46

success experiences, and properly extracted with systematic approaches promise a success in our quest to produce a new useable WAF. We also discover one most significant finding throughout this review that is to make our new WAF mainly plays its role as a semi-complete application structure provider to help developers develop WAs in more efficient, less-complex, and rapid manner.

[6]

[7]

CONCLUSION

[8]

Based on other previous works discussed in this article, in general, to support generic architecture and design of WA, WAF cant escape itself from dealing with the concerns such as infrastructure provision (web server, browser, and CGI integration model), further exploit database as a backend support, clientserver computing model (server-centric or fat-client), semi-complete application structure outline, software engineering approaches to be used, and precisely use technologies with the main purposes they were invented for. All these are reflecting the main issues to be solved by WAF that mainly used at the implementation stage of overall application development phases. We believe that there are many other concerns such as support tools, template system, and security control by directly or indirectly have a relationship with the WAF. We also aware that SE design principles and knowledge such as object-oriented design, software design pattern, and component based software development (CBSD) have been widely used in WAs and have shown many success stories. Thus, its vital for us to further study how these SEs specific approaches can be incorporated inside the WAF. Though we not discuss all these other concerns due to space limitation, but what already have been discussed in this article are very helpful as a preliminary ideas to identify the basic requirements in WAF architecture and design decision.

[9]

[10]

[11]

[12]

[13]

[14] [15]

[16]

REFERENCES
[1] L. GuangChun, W. Lu, X. Hanhong, "A Novel Web Application Frame Developed by MVC", ACM SIGSOFT Software Engineering Notes, vol. 28, issue 2, Mar. 2003. R. Izquierdo, A. Juan, B. Lopez, R. Devis, J. M. Cueva, C. F. Acebal, "Experiences in Web Site Development with Multidisciplinary Teams. From XML to JST", Proc. of the 2003 International Conference on Web Engineering (ICWE 2003), pp. 459-462, Springer, Jul. 2003. T. Parr, "Enforcing Strict ModelView Separation in Template Engines", Proc. of 13th International Conference on World Wide Web (WWW '04), pp. 224-233, ACM, May 2004. F. J. Garcia, R. I. Castanedo, A. A. J. Fuente, "A Double-Model Approach to Achieve Effective Model-View Separation in Template Based Web Applications", Proc. of the 2007 International Conference on Web Engineering (ICWE 2007), pp. 442-456, Springer, Jul. 2007. E. S. Cho, S. D. Kim, S. S. Rhew, S. D. Lee, C. G. Kim, Object-Oriented Web Application Architectures and Development Strategies, Proc. of 4th Asia Pacific Software Engineering Conference and International Computer Science Conference (APSEC'97/ICS'97), pp. 322-331, IEEE Computer Society, Dec. 1997. [17] [18] [19] [20]

[2]

[3]

[4]

[21]

[5]

[22]

[23]

K. M. Goschka, E. Riedling, "Implementation of Database Powered Distributed Web Applications with the DEMETER Project as a Real-Life", Proc. of 23rd Euromicro Conference. 'New Frontiers of Information Technology' (EUROMICRO 97), pp. 132137, IEEE Computer Society, Sep. 1997. S. A. Uhler, Design and Architecture of the Brazil Web Application Framework, Technical Report TR-2001-99, Sun Microsystems, Inc., Sep. 2001. Z. Qiao-ming, Z. Lei, Q. Pei-de, A Simplified Database Oriented Web Framework, Journal of Natural Sciences, vol. 9, no. 5, pp. 706-710, Wuhan University Journals Press, May 2004. H. Dworak, "A Concept of a Web Application Blending Thin and Fat Client Architectures", Proc. of 4th International Conference on Dependability of Computer Systems, pp. 84-90, IEEE Computer Society, Jun 2009. J. Kuuskeri, T. Mikkonen, "Partitioning Web Applications between the Server and the Client", Proc. of the 2009 ACM symposium on Applied Computing (SAC'09), pp. 647-652, ACM, Mar. 2009. A. E. Hassan, R. C. Holt, "Architecture Recovery of Web Applications", Proc. of 24th International Conference on Software Engineering (ICSE'02), pp. 349-359, ACM, May 2002. I. Ivkovic, K. Kontogiannis, "A Framework for Software Architecture Refactoring using Model Transformations and Semantic Annotations", Proc. of 10th European Conference on Software Maintenance and Reengineering (CSMR 2006), 10 pp. - 144, IEEE Computer Society, Mar. 2006. Z. Lin-Hui, X. Le, Y. Mao-sheng, Z. Yi, X. Bing, "An Approach for Software Architecture Refactoring Based on Clustering of Extended Component Dependency Graph", Proc. of International Conference on Computational Intelligence and Software Engineering (CiSE 2009), pp. 1-4, IEEE Computer Society, Dec. 2009. Apache Struts, Apache Software Foundation, http://struts.apache.org D. M. Selfa, M. Carrillo, M. R. Boone, "A Database and Web Application Based on MVC Architecture", Proc. of 16th International Conference on Electronics, Communications and Computers (CONIELECOMP 06), pp. 48-53, IEEE Computer Society, Feb. 2006. J. Arthur, S. Azadegan, "Spring Framework for rapid open source J2EE Web Application Development - A case study", Proc. of 6th International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD 2005), pp. 90-95, IEEE Computer Society, May 2005. Spring Framework, SpringSource, http://www.springsource.org S. Koirala, "Design pattern - Inversion of control and Dependency injection", The Code Project, http://www.codeproject.com/KB/aspnet/IOCDI.aspx, Jun 2010. J. Weirich, "Dependency Injection: Vital or Irrelevant?, 7th Annual O'REILLY Open Source Convention (OSCON 2005), O'REILLY, Aug. 2005. O. Murk, J. Kabanov, "Aranea - Web Framework Construction and Integration Kit", Proc. of 4th International Symposium on Principles and Practice of Programming in Java (PPPJ '06), pp. 163-172, ACM Press, Aug. 2006. J. Souer, M. v. Mierloo, "A Component Based Architecture forWeb Content Management: Runtime Deployable WebManager Component Bundles", Proc. of 8th International Conference on Web Engineering (ICWE '08), pp. 366-369, IEEE Computer Society, Jul. 2008. E. Q. d. Silva, D. d. A. Moreira, "Developing Customizable Webbased Educational Applications through a Component-based Framework", Proc. of International Conference on Next Generation Web Services Practices (NWeSP 2005), IEEE Computer Soviety, Aug. 2005. D. Sun, K. Wong, D. Moise, "Lessons Learned in Web Site Architectures for Public Utilities", Proc. of 5th IEEE International Workshop on

JOURNAL OF COMPUTING, VOLUME 3, ISSUE 7, JULY 2011, ISSN 2151-9617 HTTPS://SITES.GOOGLE.COM/SITE/JOURNALOFCOMPUTING/ WWW.JOURNALOFCOMPUTING.ORG

47

Web Site Evolution (WSE 2003), pp. 93-100, IEEE Computer Society, Sep. 2003. [24] R. Gitzel, M. Aleksy, "Implementation of a Model-Centric Web Application Framework with J2EE", Proc. of 3rd International Symposium on Principles and Practice of Programming in Java (PPPJ '04), pp. 148-153, Trinity College Dublin, Jun 2004. Mohd Razak Samingan is currently a PhD student at the Faculty of Computer Science & Information System, Univeristi Teknologi Malaysia. He received his BSc in Science, Computer with Education from Universiti Teknologi Malaysia and hi s MSc in Distributed Mutimedia System from University of Leeds, UK. His current research interest includes software architecture and design, software design pattern, and component based software development. Wan Mohd Nasir Wan Kadir is an Assoc. Prof. at the Faculty of Computer Science & Information System, Univeristi Teknologi Malaysia. He received his BSc. from Universiti Teknologi Malaysia, MSc. from UMIST, and Ph.D. in the field of Software Engineering from The University of Manchester. His research interest covers various SE knowledge areas based on the motivation to reduce the cost of development and maintenance as well as to improve the quality of large and complex software systems.