Extensible Requirements Patterns of Web Application for Efficient Web
Application Development
Romi Satria Wahono
Jingde Cheng
Department of Information and Computer
Sciences, Saitama University
[email protected]
Department of Information and Computer
Sciences, Saitama University
[email protected]
Abstract
Nowadays, web application has been going to be an e-business application. In the e-business environment, reducing time to market is a critical issue. Therefore, web application development process and time to market must be highly accelerated. On the other hand, a lot of redundant works actually occurred in the web application development. This paper presents the solutions for these problems, by proposing an extensible requirements pattern for efficient web application development. By reusing and reconstructing the extensible requirements patterns of web application, we can accelerate time to market and solve redundancy problems in web application development.
Keywords: requirements engineering, extensible requirements patterns, web application
1. Introduction
Currently, we use the web quite differently than the purpose for which it was originally conceived. The growth of web and Internet technology has already had a significant impact on business, commerce, and industry. Nowadays, web application has been going to be an e-business application. In the e-business environment, reducing time to market is critical. Therefore, web applications development process and time to market must be highly accelerated.
As the complexity of web applications have evolved, the demand placed on the utilization of the early design stages to elicit more detailed and specified customer feedback on requirements have also increase significantly. Although there are very clear reasons about why software developers should use standard practice of software and requirements engineering process [7] [13] [18], of course also for developing web application [2] [17], most web developers still pay a little or no attention to requirements
engineering phases when developing web applications [1] [8]. This problem appeared because of the time limit of web development [16]. Another reason that can be given is, the individual development practices based on knowledge and experiences of individual developers are dominant rather then standard practices in web application development. Therefore, it is demanded the rapid web application development approach that based on the standard practices of requirements engineering process.
On the other hand, there are a lot of redundant works actually occurred in web application development. We can investigate that a lot of web applications actually have similar basic requirements, although have very different in design. For example: registration form, online auction, homepage, guest book, online shopping, online newspaper, etc. Therefore, developing web application from scratch is a time-consuming work, because actually we can reuse the similar basic requirements to develop web applications. If there are the requirements pattern catalogs where the general characteristic of the web application requirements are stored, we can decrease redundancy problem of web applications development and increase developer productivity by reusing these patterns. The next problem is how to solve the validation problem in requirements pattern. However, it is also demanded the strategy to validate requirements patterns according to the customer feedback become possible.
The objective of this research is to solve the above mentioned problems in web application development. We propose the extensible requirements patterns of web applications for accelerating time to market (faster time to market), for solving redundancy problem and for
Requirements Pattern
The structure of this paper is as follows. In Section 2, the definitions of the terms used in this paper are presented. In Section 3, the proposed extensible requirement patterns of web applications are described. We also discuss about concepts and foundations, pattern elements, and pattern catalogs in this section. We continue with the explanation about how to use the extensible requirements patterns in web applications development, in Section 4. Section 5 focuses on the limitations of the proposed approach. Finally, in Section 6 a conclusion and the future directions of our research are outlined.
A requirements pattern is a framework for requirements that supports the product needs, minimizing gaps in knowledge that may cause project failure. A requirements pattern supports multiple design and implementations. A requirements pattern also supports any technique for capturing and specifying requirements. It is reusable framework based on experience that can be used to identify pieces of the needs that a solution must satisfy [15].
3. Extensible Requirements Patterns of Web Applications
2. Definitions of the Terms
Before discussing our research approach in more detail, due to the complexity of the terms used in the software and web engineering field, we will explain the definitions of the terms used in this research.
3.1. Concepts and Foundations
Patterns are one of the latest hot topics in software development. The goal of patterns within the software community is to create a body of literature to help software developers resolve recurring problems encountered throughout all of software development. Patterns help create a shared language for communicating insight and experience about these problems and their solutions. Patterns readily available include [15]:
Customer
A customer is a person, or persons who pay for the product and usually decide the requirements [10] [11].
Web Application
Web application is an application program that work in conjunction with a web server to perform a variety of tasks, ranging from displaying basic customized greetings to performing complex transactions [14].
• • • • • • •
Analysis Pattern Data Pattern Design Pattern Fundamental Pattern
Requirements
Message Pattern The definitions of requirements according to [10] are as
follows: Transaction Pattern
Requirements Pattern (1) A condition or capability needed by a user to solve a
problem or achieve an objective.
Until now, no extensible requirements pattern existed in software engineering field, specifically for web application development. As shown in Figure 1, requirements engineering is an iteration process, which contains requirements elicitation, requirements specification, and requirements validation processes. Therefore, we think requirements patterns should be designed to be extensible, in order to support the system analysts to improve and to validate requirements specification according to the customer feedback when requirements engineering process is done.
(2) A condition or capability that must be met or possessed by a system or system component to satisfy a contract, standard, specification, or other formally imposed documents.
(3) A documented representation of a condition or capability as in (1) or (2).
The term user alluded to in this definition may be an end user of the system or a person behind the screen. However, it may also denote several classes of indirect users, such as people who do not themselves turn the knobs but rather use the information that the system delivers.
Pattern
Requirements
Figure 1: Requirements Engineering Process
In the web application development, customer needs are mainly to develop a web application like “something” that have already known, but not exactly like it. We can say that because, the boom of Internet technology spread out to the lowest scale of the social community in the world, and it brings web application become more popular application for us. The new ideas in the web application commonly come from other already well-implemented systems, that we can reach them easily when surf in the web. In the requirements engineering, these phenomenon are known as the “Yes, But” syndrome (That is what I meant, but not exactly what I meant) and the “Undiscovered Ruins” syndrome (Now that I see it, I have another requirement to add).
As also shown in figure 2, the core idea of our research to propose the extensible requirements patterns of web application are based on this phenomenon. By reusing, extending, revalidating and reconstructing the extensible requirements patterns, system analysts can create a requirements specification that match with what are exactly the customer needs.
We can conclude that the definition of extensible requirements pattern is as follows.
An extensible requirement pattern is a reusable and an extensible framework for requirements that supports a system analyst to validate the customer feedback (and needs), by reusing and reconstructing requirements patterns. An extensible requirements pattern has some features related to the extensibility characteristic. Not like other existing patterns, an extensible requirements pattern has two kinds of pattern elements: constraint elements and
extensible elements. We will discuss more about the pattern elements of extensible requirements pattern in Subsection 3.2.
3.2. Pattern Elements
Every pattern we define must be formulated in the form of a rule, which establishes a relationship between a context, a system of forces which arises in that context, and a configuration, which allows these forces to resolve themselves in that context [5]. There are many stylistic
variants for describing pattern elements. Despite the use of these differing pattern formats, it is generally agreed that a pattern should contain certain essential elements. Some existing patterns books agreed that the essential elements of pattern are as follows: pattern name, problem, context, forces, solution, examples, resulting context, rationale, related patterns, known uses.
We argue that the extensible requirements pattern must contains the above mentioned essential elements that have constraint characteristic, and also contains the original elements for supporting extensibility characteristics. We designed the elements of extensible requirements pattern are as follows:
•
•
Constraint Elements:
pattern name, problem, context, examples, forces, related patterns,
Extensible Elements:
solution, user behavior, page behavior, prototype,
data behavior, architecture, security
In the constraint element, the validation and modification are not enabled. And the other hand, the extensible elements are designed to have the validation and the reconstruction functionalities, in order to support a system analyst for eliciting the customer feedbacks (needs).
We can interpret the elements of extensible requirements patterns easily by using algorithm shown in Figure 3. We will discuss more about how to use these patterns in Section 4. The detailed explanation about the elements of extensible requirements patterns is as follows. Some definitions of the common pattern elements are extracted from [4].
Pattern Name
Pattern names are extracted from the conceptual abstractions of the basic requirements of web applications. Pattern names also provide a classification of the pattern in addition to its name.
Problem
A statement of the problem which describes its intent: the goals and objectives it wants to reach within the given context and forces. Often the forces oppose these objectives as well as each other.
Context
Extensible Requirements Patterns:
A Pattern
(1)
Yes, I want web application like this, but exactly not like this. Extensible Requirements
Patterns:
B Pattern
Extensible Requirements Patterns:
E Pattern
customer
Requirements Specification
Extensible Requirements Patterns:
D Pattern
(2) Yes, this is exactly
what I want Extensible Requirements
Patterns:
C Pattern
customer feedback
Requirements Specification
Figure 2: The Concepts of Extensible Requirements Patterns and “Yes, But” Syndrome in Requirements Engineering
Forces
A description of the relevant forces and constraints and how they interact with one another and with goals we wish to achieve. Forces reveal the intricacies of a problem and define the kinds of trade-offs that must be considered in the presence of the tension or dissonance they create.
Solution
The solution describes static structure and dynamic behavior. The static structure tells us the form and organization of the pattern, but often it is the behavioral dynamics that make the pattern come alive. The description of the pattern's solution may indicate guidelines to keep in mind when attempting a concrete implementation of the solution.
Examples
Examples help the reader understand the pattern's use and applicability. An example may be supplemented by a sample implementation to show one way the solution might be realized.
Related Patterns
Related patterns share common forces. They also frequently have an initial or resulting context that is compatible with the resulting or initial context of another pattern.
User Behavior
User behavior element contains information about who are the users of web application. It can be user, customer,
administrator, etc.
Page Behavior
Page behavior element contains information about the behaviors of users related and defined at the user behavior element. Some browse functionalities and expected user navigation are also included in this element.
Prototype
Prototype is described using use-case model. The use-case model describes the proposed functionality of the new system. A use-case represents a discrete unit of interaction between a user (actor) and the system (use case). So, the prototype element consists of actor (the user that defined at the user behavior element) and use case (the user task that defined at the page behavior element).
Data Behavior
Data behavior element contains information about what kinds of database we should prepare.
Architecture
The information about system architecture is provided in the architecture element. What servers are necessary to built the application is also included in this element.
Security
3.3. Pattern Catalogs
We proposed some extensible requirements patterns based on the general characteristics and behaviors of web applications. Recently, the 30 extensible requirements patterns are available. These patterns are organized into categories as shown in the following:
•
•
•
•
•
Informational Patterns ¾ Online e-News Pattern ¾ Online e-Books Pattern ¾ Advertisement Pattern ¾ Customer Support Pattern ¾ Product Catalogs Pattern ¾ Online Classifieds Pattern ¾ Personal Page Pattern ¾ Access Counter Pattern ¾ Searching Directory Pattern ¾ Searching Database Pattern Interactive Patterns
¾ Registration Forms Pattern ¾ Guest book Pattern ¾ Online Games Pattern ¾ Web Portals Pattern Transactional Patterns
¾ Electronic Shopping Pattern ¾ Online Banking Pattern Workflow Patterns
¾ Online Planning and Scheduling Pattern ¾ Inventory Management Pattern
¾ Status Monitoring Pattern Communities Patterns
¾ Chat Groups Pattern
¾ Recommender Systems Pattern ¾ Online Marketplaces Pattern ¾ Online Auctions Pattern ¾ Bulletin Board System Pattern ¾ Online Organizer Pattern
4. How to Use The Extensible Requirements Patterns of Web Applications
In Section 3, we have already discussed the pattern elements in detail. The template and example of extensible requirements pattern of web application is shown in Figure 4. In this Section, we will focus on how to use these patterns. However, we can easily interpret and use the extensible requirements patterns of web applications by using algorithm shown in Figure 3.
First of all, a system analyst captures requirements from customer. Then he goes to the pattern catalogs for investigating the categories and the extensible requirements pattern of web applications that near to the customer needs. System analyst can begin with finding the
context of problem in context element. He can analyzes problem in problem element, and also refers to the example of the problem, in example element. If he thinks that all of the problem, context, examples, and forces are near with the customer needs, he has already prepared to go to the next step.
IF {
you find yourself in CONTEXT, for example EXAMPLES, with PROBLEM,
entailing FORCES }
THEN {
DO (until the final SOLUTION is decided) { apply and modify {
USER BEHAVIOR, PAGE BEHAVIOR, PROTOTYPE, DATA BEHAVIOR, ARCHITECTURE, SECURITY }
refer to {
new CONTEXT,
RELATED PATTERNS, other PATTERNS, }
to construct SOLUTION }
final requirements = SOLUTION }
Figure 3: How to Use and Interpret the Extensible Requirements Pattern of Web
Applications
Product Catalogs Pattern
Product Catalogs Pattern
Informational Pattern
... < problem description> ...
... <context description> ...
... <forces description> ...
... <the examples of how to use this pattern > ...
... <the other patterns that related to this pattern> ...
User Behavior Page Behavior Prototype Data Behavior Architecture Security
Customer
Administrator
Database
Database Table: product_table Customer:
Browse Product Search Product
Administrator: Add product Edit product Delete product
Client | Web Server |
Database Server
low level security Pattern Name:
Based on:
Problem:
Context
Forces:
Examples:
Related Patterns:
browse product search product customer
add product edit product delete product
administrator
Solutions ... <the description of the user behavior, page behavior, prototype, data behavior, archietcture and security in detail> ...
Figure 4: The Template of Extensible Requirements Pattern of Web Application: Product
Catalogs Pattern
5. Limitations of This Approach
6. Conclusions We addressed some limitations of this approach as
follows: In web applications development, reducing time to
market and solving redundancy problem are a critical issues. We proposed the solutions for these problems using the extensible requirements patterns of web application. By reusing and reconstructing these extensible requirements patterns, we can accelerate time to market and solve redundancy problems in web applications development. In this paper, the concepts, the foundations, the characteristics and available catalogs of the extensible requirements patterns of web application are described. How to use and implement these extensible requirements patterns are also presented.
•
•
This approach is not designed for solving the web creation or design problems. So, the artistic and humanistic aspects of the web applications are not discussed here.
References
[1] Athula Ginige and San Murugesan, “Web Engineering: An Introduction”, IEEE Multimedia, Vol. 8, No. 1, pp. 14-18, January-March 2001. [2] Athula Ginige and San Murugesan, “The Essence of
Web Engineering”, IEEE Multimedia, Vol. 8, No. 2, pp. 22-25, April-June 2001.
[3] Bashar Nuseibeh and Steve Easterbrook, “Requirements Engineering: A Roadmap”,
Proceedings of International Conference on Software Engineering (ICSE-2000), pp. 4-11 June 2000, Limerick, Ireland, ACM Press.
[4] Brad Appleton, “Patterns and Software: Essential Concepts and Terminology”, Object Magazine Online, Vol. 3, No. 5, pp. 20-25, May 1997.
[5] Christopher Alexander, “The Timeless Way of Building”, Oxford University Press, 1979.
[6] Daniel Schwabe and Luiselena Esmeraldo, “Engineering Web Applications for Reuse”, IEEE Multimedia, Vol. 8, No. 1, pp. 20-31, January-March 2001.
[7] Dean Leffingwell and Don Widrig, “Managing Software Requirements - A Unified Approach”,
Addison-Wesley, 2000.
[8] Fransesco Coda, Carlo Ghezzi, Giovanni Vigna, and Franca Garzotto, “Towards a Software Engineering Approach to Web Site Development”, Proceedings of the 9th IEEE International Workshop on Software Specification and Design (IWSSD), 1998.
[9] IEEE Standard Glossary of Software Engineering Terminology, ANSI/IEEE Standard 729-1983, Institute of Electrical and Electronics Engineers, New York, 1983.
[10] IEEE Standard Glossary of Software Engineering Technology, IEEE Std 610.12-1990, Institute of Electrical and Electronics Engineers, New York, 1990.
[11] IEEE Recommended Practice for Software Requirements Specifications, IEEE Std 830-1998, Institute of Electrical and Electronics Engineers, New York, 1998.
[12] Jeff Offutt, “Quality Attributes of Web Software Applications”, IEEE Software, pp. 25-32, March/April 2002.
[13] Karl E. Wiegers, “Software Requirements”,
Microsoft Press, 1999.
[14] Oktay Altunergil, “Easing Web Application Development with CVS”, O’Reilly Network, 2002. [15] Patricia L. Ferdinandi, “A Requirements Pattern:
Succeeding in the Internet Economy”, Addison Wesley, 2002.
[16] Roger S. Pressman, “What a tangled Web We Weave”, IEEE Software, Vol. 17, No.1, pp. 18-21, January/February 2000.
[17] S. Murugesan, Y. Deshpande, S. Hansen and A. Ginige, “Web Engineering: A New Discipline for Web-Based System Development”, Proceedings of the First ICSE Workshop on Web Engineering, Los Angeles, pp 1-9, 1999.
