Steve Hansen, School of Computing & Mathematics. University of Western Sydney, Campbelltown Campus, Locked Bag 1797, Penrith South DC 1797 s.hansen@uws.edu.au
This paper discussed the use of open source content management systems as providing a high level framework for generic web application development. Web application development has been characterised by various C++ and Java frameworks along with component orientated development environments such as dot.net. With the rapid development of CMS systems that provide the core functions of many web applications from user management to specialised function-modules has risen the possibility of using these as higher-function frameworks. This paper examines this use of CMS systems and as an example, uses the architecture of a commonly used and maturing open source CMS called Drupal as a representative.
Web application development has undergone a number of developments over the last years both in the methodology of separation of content from presentation and with the development of various software tools and environments. Typical of these tools and environments are the development of C++, java and other frameworks, and the development of the Microsoft dot.net environments (Tony & Winnie, 2006). These have brought elements of object orientated design into the development process and the promoted the concepts of object reuse.
These frameworks and environments are typically associated with high learning curves and considerable investment in terms of skills, training and new versions (Ahamed, Pezewski, 2004) (Mattsson & Bosch, 1997). Also, this investment typically tends to “lock” the organization, team or individual into that particular technology.
From the need to develop management systems to cater for the shear volume of content that an organization maybe “webbing”, have developed families of “Content Management Systems” (CMSs). These vary as to their functionality and orientation. This functionality is typically in the form of modules that can bolt onto a core and that can accommodate community/social systems to full e-commerce applications along with interconnectivities from database level to RSS feeds.
There are increasingly a number of CMSs that are open-sourced (CMS Matrix, 2008) and have developed considerable audiences and numbers of developers. This paper puts forward that these open-source CMSs are a suitable extension of the framework concept into a set of higher-functioning objects for developing substantive web applications. It also postulates that this form of development addresses many of the shortcomings of the current frameworks.
In addition, as CMSs typically make use of themes with over-riding CSS for presentation, they provide an excellent mechanism of separation of content from presentation, one of the foundations of current web application development.
Section 2 addresses specific issues of web application development in terms of the model-view-control (MVC) architecture, objects and UML concepts such as state-transition. This is followed in Section 3 by an overview of CMSs, their typical architecture, operation and their relationship to MVC. Section 4 takes as a representative of an open source and widely used CMS, the Drupal CMS and discusses its architecture and operation and relates its concept of nodes and workflow to the MVC architecture and state transitions. Section 5 gives an overview of application development using Drupal which is followed by a summary and conclusion section.
There has been vigorous discussion on the distinctiveness of the web development process (Deshpande, Hansen, & Murugesan, 2001), (Ginige & Murugesan, 2001), in comparison to traditional software development. The web and hypermedia development share many of these distinctive features in common particularly in the diversity of skills needed, and the diversity of stakeholders or potential stakeholders, as put by Nora Koch:-
“the development of hypermedia systems differs from the developing process of traditional software in several dimensions. People with very different skills are involved in the process, such as authors, layout designers, programmers, multimedia experts, marketing specialists” (Kock, 1999) .
In terms of the Web Information System as compared to the traditional, there is the additional complication of large amounts of information and navigational schemes as noted by Peter Barna et al:-
“The most evident difference between WIS and traditional (non-web) information systems is that the large amount of information is organized in a web structure that is realized via (hyper)links that are available to a large number of potentially diverse end-users” (Barna, Flavius, Houben, & Vdovjak, 2003) page 420
The development of web engineering methodologies has come from a blending of hypermedia methodologies with Object Oriented UML based, incremental development concepts from software engineering methodologies. This has been complemented with the promotion of agile and rapid development methods as extensions of the Unified Process (Constantine, 2000; Gotterbarn, 2004; Larman, 2002; Perrone & Mainetti, 2005).
In terms of application modeling, these methodologies have encouraged and promoted the separation of content from the presentation logic being fundamental to the application development process (Yu, Kontogiannis, & Lau, 2003).
This separation of content from the presentation is simply expressed in the Model-View-Controller (MVC ) model for a design pattern and has been widely accepted as the starting model in many web software frameworks particularly in the java J2EE environment (Masoud & Halabi, 2006) It separates out the data persistence, user interface, and application control and decouples an application into three core components: the model, the view, and the controller.
The model includes domain logic and datastores and contains the core functionality of application components. Typically, the model has no specific knowledge of either the view or the controller. The view renders the model into a form suitable for interaction and can make use of templates, CSS and other HTML/XML rendering engines. It manages the visual display, contains no processing logic as such. The controller processes and responds to events, typically user actions, and may invoke changes on the model. This is shown in Figure 1.
Figure 1 Model-View-Controller design pattern
The application components and processing logic can typically be expressed in UML related terms, with the use cases, class/object diagrams, and sequence/state/activity diagrams. These can express the functionality of the application objects, their dependencies with each other and the timing and sequencing of operations from internal and external events.
Frameworks make use of this model in developing rich component objects and flexible and tailorable user-interfaces. However as pointed out in the start of this section, web application development integrates together people with very different skills, such as “authors, layout designers, programmers, multimedia experts, marketing specialists”. From the MVC perspective the controller developers who, since they have the specialised knowledge of the objects and their characteristics (often expresses in abstractions or a volume of specialised terms), have a controlling influence of the application development process itself (Ahamed et al., 2004; Polancic & Horvat, 2006).
The popular frameworks such as the J2EE itself, Struts, Trapestry, JSF have come under severe criticism from actual developers in terms of their complexity, learning curves and general skills investment (Masoud & Halabi, 2006).
Content management systems have developed to address a particular form of web application, namely the web presence of an organisation, institution, community or even an individual. Depending on their sophistication, they have a common core, handling user and administration accesses and privileges; a core of functionality handling the management of content and types of content and authoring; depending on the CMS, additional functions for e-commerce, reporting, calendars, events and the like. These functions are usually arranged as modules and can be added, removed, enabled and given user privileges. There may be workflow engines from simple to complex that link management operations for authoring and management. Finally there are theme engines, templates and CSS methods for presentation and layout.
In this context, CMSs can be viewed as extended frameworks, where the components are of a higher-order level and much more related to the end-user’s perception of functionality.
The separation of content from the presentation logic, and the modular architecture of most CMSs, has a direct analogy to the MVC design model. Since the core functions are inbuilt, the developer has a higher-order view of the application development and an easier and more understandable interface to the information architect(s) who structure the content and its access logic. The use of themes, templates and CSS effectively provides the view decomposition to complete the MVC model. In terms of OO terms and UML representations, the modules can be expressed in standard object/class terms and linkages.
With CMSs such as Drupal, the workflow engine can be used as a finite state machine and can provide a control logic easily expressed in UML state, transition and activity diagrams.
The open sourcing of many CMS’s and their wide usage has given a very broad and extensive developer base. The advantages and disadvantages of open source apply (Hissam, Plakosh, & Weinstock, 2002; Johndan, 2002; Joshua, Joshua, Lik, & Sameer, 2007; Knapp, Koch, Moser, & Zhang, 2003; Lawton, 2002). However as discussed by (Liu, Liu, Zhou, Chen, & Dabiri, 2007) there are many advantages particularly in the rapid development of new ideas and the rapid adaptation to requirements.
Drupal (Drupal Comunity, 2006; Mercer, 2006; VanDyk & Westgate, 2007) is an open source module based CMS that has developed over the last few years with a large developer base and a myriad of community to small/medium business applications. There are currently well over 300 hundred modules freely available, and a mature development community with standards for architecture, documentation and release. It comprises of a light weight framework as core which provides a basic level of functionality. A simplified diagram of this core is shown in Figure 2. Drupal’s core is easily extended by the additional of modules and it can be customised by the over-riding of the core operations rather than by code modification. It is written in PHP (with well developed coding standards) and uses a lightweight database abstraction layer for communication to a variety of databases.
Figure 2. Core modules (principal only) of Drupal. Adapted from “Pro Drupal Development” (VanDyk & Westgate, 2007) page 3
Drupal works on the generalized concept of a “node” this is a piece of “content” with a unique identity. By “content” can be a number of pre-defined objects such as a page, a blog, poll, or book page. A node is in reality a container object that can give birth to any number of developer defined content types.
Figure 3. Node types derived from a basic node, the children can add fields. Adapted from “Pro Drupal Development” (VanDyk & Westgate, 2007).
Node types can be elaborate such as RSS feeds or calendar pages and can have unlimited other fields or characteristics associated with them. This provides a powerful and easy method of developing particular application objects that can be linked in a seamless manner into the navigation scheme(s). In addition to nodes, there are a few other objects such as users, blocks and comments. A blocks are lightweight storage containers for pieces of content such as lists and menu items. Blocks can also be set up and positioned on defined areas of a theme or template and rendered accordingly. An example maybe a list of recently registered users, or a new item or some data from an external source.
Drupal’s method of communicating activities among the modules is in its concept of a “hook”. When Drupal receives a request, it performs a series of “bootstrapping”. This is an examination of the enabled modules and the sending out of a tagged message that contains the request name. Any module with a function defined as “module name” plus “hook name” will be called. For example when a user logs in, the “user” hook is “fired”. Any module say “module1” with the a function named “module1_user()” will be called. This allows an easy and independent interface to modules. In practice an array of functions will be activated on any event, Drupal requests from each module, the paths that the module will use and retrieves a parameter indicating if caching should be performed for that module.
There is a clearly defined standard for module writing and documentation. This allows any module to be registered by just placing its files in a module directory, Drupal knowing what to look for in registering and enabling it. This module standard includes the ability to automatically run scripts on enabling that can set up databases table, menu items and other interfaces.
By adopting these standards, modules work with other modules, databases and menu items. They act as mini-applications with the Drupal hooks providing the linkages to the rest of the system.
Existing tried and testing modules cover most activities as found on commercial and community web sites, from e-commerce systems, event management, multi-media uploads and displays, content management, RSS feeds, blogs and newsfeeds. There are a variety of user-management and node access control modules that provide simple to highly complex access rules. In addition Drupal makes use of “taxonomy” concept for navigation. As all content is stored in a database, its display and navigation can be redefined according to a taxonomy at any time to accommodate customized navigation schemes.
Workflow can be governed by a workflow module. One of the existing workflow modules from the developer community works as a finite state machine on nodes. Arbitrary workflows or node sequence control can be enacted.
Presentation is enable through a variety of means. Themes can be defined (there are many hundreds of pre-defined ones from the developer community) that cover the location and actual display characteristics of content. A theming engine converts the content into the display. This can be over-ridden by both CSS and direct code. Multiple themes can be used among different nodes and fine grain control over any displayed page is possible.
The lightweight framework of Drupal, plus its hook architecture provides a top-level view of application development. Application modules can be written as standalone applications or as combinations of other modules and in terms of the node architecture can be sequenced according to the workflow modules. Full fine grain access control at the node level is possible, again under module control.
The Drupal architecture is easily mapped to the MVC design model. In terms of a generic web application, Drupal modules either existing or to be developed can be organised to give “model” for the overall application, Drupal core, any associated workflow and access control modules providing the “control” and the “view” being provided by the theming engine and related CSS.
Drupal already has multi-site capabilities and methods of communicating to other Drupal sites allowing various forms of distributed activities even without the development of specialised modules.
The open-source developer community has its own community run Drupal site and well published APIs, document repository and development standards. The world-wide community is constantly developing new modules or revising existing ones under these open source conventions.
There are templates, a specialised Drupal based PhP variation, and a vigorous discussion community to assist developers and to provide feedback and to identify issues and fixes.
The application development process is based on similar principles but at a significantly different level to standard framework development. In both cases, the application developer has to define a model, in the CMS case, the application blocks are close to plain-speech descriptive terms, while with frameworks a variety of objects/classes are looked for, each having a naming convention making sense in terms of its class but necessarily in terms of the actual application.
This paper puts forward the proposition that the advent of open source CMSs such as Drupal provide an alternate methodology for web application development to standard frameworks.
By considering web applications in terms of the MVC design pattern as is the case in many frameworks such as Struts and Ruby on Rails, CMSs can be considered as application frameworks in their own right. With the addition of workflow engines, CMSs have the mechanism to produce generic web applications, not only those based on content management.
The Drupal architecture with the generic concept of node that can be used to generate a variety of objects, combined with its “hooks” for module communication and its core management functions provides a rich development platform for rapid and customisable web applications.
The native functions of the CMSs are more closely related to user experience and user terminology. In terms of both defining the requirements, in communication to the non-technical of a development team and in rapidly producing prototypes, the CMSs has distinct advantages over the high leaning curves and specialised jargon of frameworks.
The separation of content to presentation as found in CMSs and the inbuilt ability to customise the presentation logic at the user level, allows the end user to have considerable control over the final implementation and deployment.
Finally, the over-riding advantage of open source CMSs such as Drupal is that the developer can operate at a much higher conceptual level, can participate in a wide and supportive developer community and can share application development at the module level.
Ahamed, S. I., Pezewski, A. (2004). Towards framework selection criteria and suitability for an application framework. Paper presented at the Information Technology: Coding and Computing, 2004. Proceedings. ITCC 2004. International Conference on.
Barna, P., Flavius, F., Houben, G.-J., & Vdovjak, R. (2003). Methodologies for Web Information System Design. Paper presented at the Proceedings of the International Conference on Information Technology: Computers and Communications (ITCC™03), Las Vagas.
CMS Matrix. (2008). CMS Matrix. Retrieved 11th February, 2008 from [HREF1]
Constantine, L. (Ed.). (2000). Fundamentals of Object-Oriented Design in UML. USA: Addison-Wesley.
Deshpande, Y., Hansen, S., & Murugesan, S. (2001). Web Engineering: Beyond CS, IS and SE Evolutionary and Non-engineering Perspectives. In Web Engineering Managing Diversity and Complexity of Web Application Development.
Drupal Comunity. (2006). Drupal Handbooks. Retrieved 11th Februray, 2008, from [HREF2]
Ginige, A., & Murugesan, S. (2001). The essence of web engineering - managing the diversity and complexity of web application development. Multimedia, IEEE, 8(2), 22-25.
Gotterbarn, D. (2004). UML and Agile Methods: In Support of Irresponsible Development. SIGCSE Bulletin inroads, 36(2).
Hissam, S. A., Plakosh, D., & Weinstock, C. (2002). Trust and vulnerability in open source software. Software, IEE Proceedings -, 149(1), 47-51.
Johndan, J.-E. (2002). Open source basics: definitions, models, and questions. Paper presented at the Proceedings of the 20th annual international conference on Computer documentation.
Joshua, L. M., Joshua, L. M., Lik, M., & Sameer, V. (2007). Open Source Software Adoption in ASEAN Member Countries
Open Source Software Adoption in ASEAN Member Countries. Paper presented at the System Sciences, 2007. HICSS 2007. 40th Annual Hawaii International Conference on.
Knapp, A., Koch, N., Moser, F., & Zhang, G. (2003). ArgoUWE: A CASE Tool for Web Applications. Paper presented at the Proceedings of First International Workshop on Engineering Methods to Support Information Systems Evolution (EMSISE03) held in conjunction with OOIS03, Geneva.
Koch, N. (1999). A Comparative Study of Methods for Hypermedia Development. Technical Report 9905, LudwigMaximilians -Universitt Mnchen, November 1999.
Larman, C. (Ed.). (2002). Applying UML and Patterns, an Introduction to Object-Oriented Analysis and Design and the Unified Process Second Edition. USA: Prentice-Hall.
Lawton, G. (2002). Open source security: opportunity or oxymoron? Computer, 35(3), 18-21.
Liu, E., Zhou, J., Chen, P., & Dabiri, E. A. D. E. (2007). OSS Implementation in Utility Applications OSS Implementation in Utility Applications. Paper presented at the Power Engineering Society General Meeting, 2007. IEEE.
Masoud, F. A., & Halabi, D. H. (2006). ASP.NET and JSP Frameworks in Model View Controller Implementation. Paper presented at the Information and Communication Technologies, 2006. ICTTA '06. 2nd.
Mattsson, M., & Bosch, J. (1997). Framework composition: problems, causes and solutions. Paper presented at the Technology of Object-Oriented Languages and Systems, 1997. TOOLS 23. Proceedings.
Mercer, D. (2006). Drupal. UK: PACKT.
Perrone, V., & Mainetti, L. (2005). A UML Extension for Designing Usable User Experiences in Web Applications. Paper presented at the Proceedings of the CAISE*05 Workshop on Web Oriented Software Technologies IWWOST 05, Porto, Portugal.
Polancic, G., & Horvat, R. V. (2006). Towards an integrated acceptance model for software frameworks literature review and proposed solution. Paper presented at the Information Technology Interfaces, 2006. 28th International Conference on.
Tony, C. S., & Winnie, W. H. (2006). Taxonomy of Java Web Application Frameworks. Paper presented at the e-Business Engineering, 2006. ICEBE '06. IEEE International Conference on.
VanDyk, J. k., & Westgate, M. (2007). Pro Drupal Development: Apress.
Yu, P., Kontogiannis, K., & Lau, T. C. (2003). Transforming legacy Web applications to the MVC architecture. Paper presented at the Software Technology and Engineering Practice, 2003. Eleventh Annual International Workshop on.