EVENT MANAGEMENT SYSTEM:
DESIGN AND IMPLEMENTATION
USING AOP METHODOLOGY IN
ECLIPSE-AJDT ENVIRONMENT
AMITA SHARMA
“TULSI SHREE”, B-16, Kanta Khaturia Colony,
Bikaner, Rajasthan, India
S.S.SARANGDEVOT
Director, Deptt. of Computer Science & I.T, J.R.N. Rajasthan Vidyapeeth (Deemed) University, Udaipur, Rajasthan, India
Abstract :
Aspect-Oriented Programming (AOP) methodology has been investigated in the design and implementation of a representative Event Management System Software. Eclipse-AJDT environment has been used as open source enhanced IDE support for programming in AOP language – AspectJ. Twelve crosscutting concerns have been identified and modularized into highly cohesive modular units – aspects, thus reducing the complexity of the design due to elimination of code scattering and tangling. The impact of using this methodology on various quality factors of the software has been examined. The study concludes that AOP methodology in Eclipse-AJDT environment can help in evolving efficient, cost-effective and quality ‘Event Management System Software’.
Keywords: Event Management System, Aspect-Oriented Programming, Separation of Concerns, Eclipse-AJDT Environment.
1. Introduction
An event is a “celebration or display of some theme to which the public is invited for a limited time only, annually or less frequently” [Getz (1997)]. There are many types of events including cultural celebrations, arts and entertainment, business and trade, sport competitions, educational and scientific seminars/conferences, and political events [Presbury et al. (2005)]. Events are important contributors to a destination’s economic, social and cultural fabric. They play a part in creating, a favorable image of the destination as additional attractions, and image-makers [Getz (1997)]. However, sometimes an event may create negative social and cultural impacts, through crowding, crime, traffic congestion, community displacement and commodification of culture, resulting in visitor, sponsor, and community dissatisfaction. These impacts can disrupt the lives of locals for the duration of the festival or event [Small and Edwards (2003)].
The management of events must be seen as an interdisciplinary task field requiring effective and efficient cooperation between diverse partners [Thomas et al. (2008, a), Thomas (2008, b)]. The strategic preparation, as well as the planning and coordination of the execution of an event require professional handling in order to guarantee the optimal interplay between all participants. Due to the two characteristics – time limitation (clearly defined start and finish points) and singularity (often one-time initiative), events possess project character. As a result of these considerations, ‘Event Management’ comprises the coordination of all of the tasks and activities necessary for the execution of an event regarding its strategy, planning, implementation and control, based on the principles of event marketing and the methods of project management [Thomas et al. (2008, a)].
‘Aspect-Oriented Programming’ (AOP) [Kiczales et al. (1997), Elrad et al. (2001, a)] is a newly emerging methodology that aims to improve the modularity and quality of software by achieving better separation of concerns. AOP defines a new program construct – ‘aspect’ [Elrad et al. (2001, b), Filman et al. (2004)], which is a software entity that implements crosscutting functionality in a modular way. This provides most promising solution for elimination of code scattering and tangling, thus overcoming the limitations of OOP.
Kiczales and his team at Xerox PARC developed the first and most successful AOP language: AspectJ
[Kiczales et al. (2001, a), Kiczales et al. (2001, b)]. It is a general purpose AOP extension to Java. It adds to Java a few new constructs: pointcuts, advice, intertype declarations and aspects. AspectJ’s aspects work side by side with Java classes to develop a comprehensive application. AspectJ is very useful in design and implementation of business software. Eclipse-AJDT [Colyer et al. (2004), Arthorne et al. (2004), Daum (2005), Gallardo et al. (2006), Sharma et al. (2010, a)] provides enhanced IDE support for programming in AspectJ.
Literature on AOP suggests many potential benefits that it can bring to software design such as improvement in modularity, decrease in complexity and enhancement to the reusability of the software. It is claimed that AOP methodology is very powerful and using it through AspectJ can enable development of concise, modular, efficient, flexible and cost-effective source code in shorter span of time. Increase in understandability, adaptability and maintainability are also reported.
The Application of AOP design methodology using Eclipse-AJDT environment has previously been investigated in modular design of real life application software in the domain of banking [Sarangdevot et al. (2008-09)] and insurance [Sharma et al. (2010, b)]. However this methodology has not so far been investigated in the domain of event management.
In the present study, the application of AOP methodology has been investigated in development of application software for a representative ‘Event Management System’. Eclipse-AJDT environment has been used as open source enhanced IDE support for programming in AOP language – AspectJ. Twelve crosscutting concerns have been identified and modularized as aspects in highly cohesive modular units. Aspect browsing capability [Clement et al. (2003)] and other useful features of AJDT has been fully utilized in understanding and visualizing the effects of aspects in the program. The impact of this powerful methodology on various quality factors of the software has been examined.
The rest of the paper is organized as follows: Section 2 presents an overview of the selected event management system and Section 3 focuses on the identification of crosscutting concerns. Section 4 explains the identification of aspects. AOP design and implementation are presented in Section 5 and Section 6 discusses observations regarding the impact of using AOP methodology in Eclipse-AJDT environment on various quality factors of the designed software. The last section provides the concluding remarks.
2. Event Management System
This study focuses on modeling a representative ‘Event Management System’ for an ‘Event Management Company’. A customer contacts the company for event management. He provides the details of the event and its requirements. He explains its aims, when and where the event will take place, how long it will last, its format (Presentation/Workshop and/or Exhibition etc.), expected number of delegates/guests, equipment and furniture required, whether any delegate pack or promotional material is to be distributed, and other facilities required. The Event Manager studies the requirements of the event carefully and using the event management system finds the estimated cost and informs the customer about it. The customer may check whether the cost suits the financial provisions of the event. The company can also offer some readymade packages to choose from.
If the customer agrees, the event is booked and the advance deposit is taken by the company. According to the requirements of the event, different bookings are made. A strategic schedule is prepared for smooth conduct of the event. The Event Management System helps the manager in different tasks of planning, scheduling and conducting the event. This system provides instant access to event-related information. Thus resources are efficiently and economically utilized. Once the event is conducted successfully, the bills are generated by the system. The system is extensible. New functionalities can be added to the system, whenever it is needed due to changing requirements
3. Identification of Crosscutting Concerns
Separation of Concerns and modularity are at the heart of programming process. These help in breaking down a complex problem into smaller parts, and solve them individually. Following this approach, the system is structured into units of function and behavior which can be put together to produce a complete software system.
also crosscutting in nature. Apart from these, there are four more infrastructure concerns in the system, which are crosscutting: Logging, Schedule tracing, Booking tracking and Authorization. Thus there are twelve crosscutting concerns in the event management system and they cannot be modularized using OOP methodology.
4. Identification of Aspects
In Section 3 crosscutting concerns have been identified, which cause code scattering and tangling and increase the complexity of the system. They can be best modularized as aspects using AOP methodology.
4.1. Check_HallBooking Aspect
Whenever event is booked hall booking is checked. If the hall is already booked for that duration, event cannot be booked. Similarly when hall booking is modified and hall booking status is checked, advance booking of the hall is to be checked. So, instead of repeatedly calling hall booking check function in different modules: event and hall, Check_HallBooking aspect is created. This eliminates code scattering and reduces complexity.
4.2. Advancepaymentcheck Aspect
The event can only be booked when customer gives some advance amount for that event. So this should be checked before event-booking. Similarly, the advance amount is deducted from total bill amount whenever the bill is generated. Thus advance amount is also checked at the time of bill-preparation. This implementation using OOP methodology causes increase in code tangling. Advancepaymentcheck aspect overcomes this problem.
4.3. Bookingcheck Aspect
When the event is booked or booking is modified, other bookings like accessories and staff are also booked or modified. These bookings and modifications are part of the other modules: item and employee. In order to eliminate code tangling between these modules Bookingcheck aspect is created.
4.4. Event_modification Aspect
4.5. Eventdeletion Aspect
When the payment of the event bill is received from the customer, event is deleted from the database. Also when the event is accomplished, the booking status of hall, employees and accessories are updated. This functionality is tangled between several modules. Eventdeletion aspect creation is a better choice for it. This will delete the event and update status of other modules.
4.6. Reportforduebill Aspect
The report for due bill is generated whenever the bill or schedule status is accessed. Thus instead of coding in different modules (schedule and bill) Reportforduebill aspect is created.
4.7. Schedulereport Aspect
This aspect intimates the user about the daily schedule. This also furnishes the information about any modifications in the schedule.
4.8. Formtextcheck Aspect
This system has several interfaces (forms) for user interactions with text boxes where user has to input certain values. The text box value should never be null. This crosscutting concern is taken care by this aspect.
4.9. Logging Aspect
Whenever the booking is updated or bill is generated or any employee is booked, the log file is maintained for each of them. These files record the details of booking, bills and employees. This work is handled by Logging aspect
4.10.Authorizationchecking Aspect
Only authorized persons should be allowed to log in, log out or perform transactions or database modification etc. This crosscutting concern is best handled by adding Authorizationchecking aspect to the programming code.
4.11.Eventtracer Aspect
This aspect helps in tracing the event scheduling within the system. How event class is executed can also be checked and tested.
4.12.Scheduletracer Aspect
The sheduletracer aspect traces the execution of schedule module within the system. This is useful in understanding the behavior of the system as it lists the functions executed during schedule execution.
5. AOP Design and Implementation
The Event Management System Software has been developed using AOP methodology, to satisfy the requirements of the system. For coding and implementation, AOP language – AspectJ has been employed in Eclipse-AJDT environment.
In the design of this software, separation of concerns and divide-and-conquer approach was followed. This approach reduced complexity and supported effective code reuse. Core concerns were implemented as classes using OOP methodology. Crosscutting concerns were modularized and implemented as aspects using AOP methodology. Aspects were woven in the base program (containing core concern implementations) using aspect weaver of AspectJ. Thus final application software was produced.
The Software includes four packages:
eve.form: Includes interface classes. Important classes are Welcome, Parentform, Eventmodificationform, Scheduleform, Employeeupdateform, Billmodificationform, etc.
eve.src: Important classes are Event, Booking, Hall, Item, Employee, Bill, Schedule, Date1 etc. eve.aspect:All the aspects are stored in this package
.
eve.database: Includes all the database related classes. Halldb, Employeedb, Eventdb, Itemdb, Scheduledb, Evedbconnection etc.
Codes of two aspects are shown in Appendix for illustration. Figure 3 shows sequence diagram for Check_HallBooking aspect. Aspects are woven in the main program by aspect weaver to produce the final system. This is done by the AspectJ compiler through AJDT.
Event
-long eventid -String type -long day, time
+ addevent(long,long..) +modifyevent(long,Date) +bookevent(long)…
Hall
-long hallid
-String location,facility -long capacity -double rate + addhall(long,long.) +modifybooking(long,Date1) +hallbookingstatus(long,Date1) +bookhall(long,Date1)… Bill
-long billid -String details -double amt… + addbilll(long,long..) +modifybill(long,Date1) +billpayment(long,long,Date1) +billgeneration(long,Date1)… Item
-long itemid -String details -double amt… + additem(long,long..) +modifyiteml(long,String) +modifybooking(long,Date1) +bookitem(long,long,Date1)… Employee
-long empid -String details -double salary… + addemp(long,long..) +modifyemp(long,String) +modifybooking(long,Date1) +bookemp(long,long,Date1)… <aspect> Check_HallBooking +pointcut hallbookrecord1(..) +pointcut hallbookrecord2(..) +pointcut hallbookrecord3(..)
: execution after(..) (..) : execution after(..) (..) : executionbefore(..) (..)
<aspect> Event_modification
+pointcut eventmodify(..) +pointcut reportformodify1(..) +pointcut reportformodify2(..) +pointcut reportformodify3(..)
: execution after(..) (..) : execution after(..) (..) : execution after(..) (..) : execution after(..) (..)
<aspect> Advancepaymentcheck +pointcut advancerecord1(..) +pointcut advancerecord2(..)
: execution before() (..) : executionbefore() (..)
<aspect> Bookingcheck +pointcut bookingforitem(..) +pointcut bookingforemployee(..)
: execution before() (..) : executionbefore() (..)
<aspect> Eventdeletion
+pointcut billpaidcheck(..) +pointcut statusupdate(..)
: execution after() (..) : execution after() (..)
Schedule
-long scheduleid -String details -Date1 date -Vector schlist… + getschedule(long,long..) +newschedule(long,String) +modifyschedule(long,Date1) +paymentschedule(long,long,Date1)… <aspect> Reportforduebill
+pointcut duebillcheck(..) +pointcut duebillinform(..)
: execution after() (..) : execution before() (..)
X X
Figure3. Sequence Diagram of Check_HallBooking aspect.
In this study, AspectJ Development Tools (AJDT) provided good tool support for editing, building and debugging AspectJ programs on Eclipse Platform. AJDT provides several aids to assist programmers in understanding AOP with AspectJ. The most important are Outline view, Cross References view, Aspect Visualizer and Debugger. For advice within an aspect, the Outline view shows the places in the program that
Figure 5. Aspect Visualiser View of Event Management System
will be affected by that advice. The links are navigable, so clicking on them opens an editor directly at the affected location. The Cross References view and the standard Outline view can be considered partners. Whereas the Outline view shows the structure of the current document, the Cross References view shows the crosscutting relationships for the current elements. Figure 4 shows the Cross References view placed below the corresponding Outline view for the relevant aspect. These views are essential programming aid and feedback tools that are used to verify that a piece of advice is matching in all the join points it was intended to match.
The most powerful tool AJDT provided for understanding the impact of aspects across the whole system is its Aspect Visualizer. Figure 5 shows the screen shot of Aspect Visualizer, which represents the classes and aspects within the application as bars and the places where aspects affect the code as stripes on the bars. The lengths of the bars are relative to the file size – the longer the bar, more lines of code there are in the file that bar represents. With AJDT it is possible to step through the execution of advice in the debugger window and observe the full flow of the program to gain an understanding of the program’s behavior. These features help viewing how the application behaves and how different classes are affected by the aspects. This ensures correct implementation of aspects.
The Event Management System Software is user friendly and menu driven. It has several views and forms. To avail the services, employee code and password are to be entered.
For verification and validation, the Event Management System Software was tested by entering different data sets and the resulting output was examined. It was noticed that all the functionalities of the system worked correctly. This indicated the ‘Correctness’ of the application software. Thus, the software meets the desired specifications and needs. The software is extensible, so new functionalities can be easily added to it.
6. Discussion
This also resulted in easier comprehension and better understandability. This is in accordance with the opinion of Parnas [1972] that modularization reduces complexity and improves comprehensibility.
It was observed that there was cleaner assignment of responsibilities of different modules in this system. This
improved traceability. Using aspects it was always possible to add new functionality to the software without modifying the base program. This enhanced the extendibility of the software system.
The problem of software maintenance is widely known in software industry. By some estimates, 50-90% of software development resources are spent on software maintenance. Spiral model [Boehm (1986)] accepts it as part of software evolution. Thus producing software that is easy to maintain may potentially save large costs. In the present design, use of aspects increased maintainability of the program, because it allowed changes to particular functionality to happen in only one location. AOP design produces stand alone modules that can be changed whenever needed. Thus it is easier to adapt the software to accommodate the changing requirements.
Cohesive modular design in which each module implemented single concern only, reusability of the modules was considerably enhanced. It is in agreement with the findings of Elrad et al. [2001, b]. Results of Maghawry et al. [20] also support the above conclusions.
With aspects there are more ways to code the same thing. This offers more flexibility. It was also noticed that with AOP design, less code was needed to be written which facilitated easier systemevolution and reduced
development time. The end effect was cheaper implementation. Reduction in duplicated code led to clearer structure and less error prone implementation. All these benefits make AOP a favorite choice for trustworthy computing [Sofonov (2008)].
There are a few limitations of AOP relevant to AspectJ:
1. Debugging an aspect is very tedious. Aspects are notoriously buggy during evolution because there is lack of useful error messages and warnings. As such utmost caution is needed while applying AOP in design and implementation.
2. The capabilities of privileged aspects are far reaching. One can modify private member variables of any object within any class. This is very dangerous and should be used with utmost caution.
3. Generality of advice is another potential problem. This may generate misleading error messages in a large system.
Thus AOP should be used in a disciplined way.
7. Conclusion
In this study, a user friendly and menu driven application software for the selected event management system has been designed and implemented using AOP methodology in Eclipse-AJDT environment. A good design is intended to be modular, and this was achieved through cleaner separation of crosscutting concerns. Twelve crosscutting concerns were identified and they were modularized as aspects in highly cohesive modular units. Limitations of OOP design were overcome and the complexity of the design was considerably reduced due to elimination of code scattering and tangling. This study convinced that separation of concerns is one of the main requirements of good system design and implementation. Several benefits are attributed to software with well separated concerns.
Use of AOP methodology increased several software quality factors such as modularity, readability, understandability, maintainability, extendibility, reusability, correctness, traceability, flexibility, adaptability and ease of evolution. Reduction in development time and costing were also perceived.
Thus overall improvements in the quality and performance of the software system were realized. Several innovative visual and navigational features of Eclipse-AJDT environment made the development work of the software easy and reliable. Thus Eclipse-AJDT is the most suitable environment for developing aspect-oriented software. However AOP methodology should be applied with utmost caution and discipline.
Successful implementation of the application concludes that AOP methodology in Eclipse-AJDT environment can help in evolving efficient, cost-effective and quality ‘Event Management System Software’.
Acknowledgments
References
[1] Arthorne, J.; Laffra, C. (2004). Official eclipse 3.0 FAQs, Addison – Wesley Professional.
[2] Bernardi, M. L.; Lucca, G. A. D., Improving Design Patterns Modularity Using Aspect Orientation, RCOST, University of Saunio, Italy.
[3] Boehm, B. (1986). A Spiral Model of Software Development and Enhancement, ACM SIGSOFT Software Engineering Notes, ACM, 11, 4 (August, 1986), pp. 14-24.
[4] Clement, A. et al. (2003), Aspect-Oriented Programming with AJDT, Workshop on Analysis of Aspect-Oriented Software, ECOOP 2003.
[5] Colyer, A. et al. (2004), Eclipse AspectJ: Aspect-Oriented Programming with AspectJ and the AspectJ Development Tools, Addison Wesley Professional.
[6] Daum, B. (2005), Professional Eclipse 3 for Java Developers, Wiley – India.
[7] Dijkstra, E.W. (1974). On the role of scientific thought, EWD 447 (Nuenen, The Netherlands, 30th
August 1974).
[8] Elrad, T. et al. (2001, a). Aspect-Oriented Programming, Communications of the ACM 44, 10 (October 2001), pp. 29-32.
[9] Elrad, T. et al. (2001, b). Discussing Aspects of AOP. Communications of the ACM 44, 10 (October 2001), pp. 33-38. [10] Filman, R.E. et al. (Eds.) (2004). Aspect-Oriented Software Development, Addison – Wesley Professional.
[11] Gallardo, D. (2006). Eclipse in Action, Manning - dreamtech.
[12] Getz, D. (1997). Event Management and Event Tourism, Cognizant Communication Corporation, United States. [13] Gradecki, J.; Lesiecki, N. (2003). Mastering AspectJ, Wiley Publishing Inc.
[14] Hursch, W.; Lopes, C.V. (1995). Separation of Concerns. Technical Report NU-CCS-5-03 (February 1995).
[15] Kaur, A.; Johari, K. (2009). Identification of Crosscutting Concerns: A Survey. International Journal of Engineering Science and Technology 1, 3 (2009), pp. 166-172.
[16] Kiczales, G. et al. (1997). Aspect-Oriented Programming. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP) (Finland, June 1997), LNCS 1241, Springer-Verlag, pp. 220-242.
[17] Kiczales, G. et al. (2001, a). An Overview of AspectJ, In Proceedings of ECOOP 2001 (Budapest, June 2001), LNCS 2072, pp. 327-353.
[18] Kiczales, G. et al. (2001). Getting Started with AspectJ. Communications of the ACM 44, 10 (October 2001), pp. 59-65.
[19] Laddad, R. (2003). AspectJ in Action, Manning Publication Co., Greenwich, CT.
[20] Maghawry, N. E. and Dawood, A. R., Aspect-Oriented GoF Design Patterns,
http://infos2010.fci.cu.edu.eg/uploadCamera2010/noura.elmaghawry/AO_Gof_Patterns.pdf
[21] Parnas, D. L. (1972). On the Criteria To Be Used in Decomposing Systems into Modules, Communications of the ACM, 15, 12, pp. 1053-1058.
[22] Presbury, R.; Edwards D. (2005), Incorporating Sustainability in Meetings and Event Management Education, International Journal of Event Management Research, vol. 1, no. 1, pp. 30-45.
[23] Safonov, V. O. (2008). Using Aspect-Oriented Programming for Trustworthy Software Development, John Wiley & Sons, Inc., New Jersey.
[24] Sarangdevot, S.S.; Sharma, A. (2008-09). Investigating the application of AOP methodology in development of Banking Application Software Using Eclipse-AJDT environment. Journal of Management Sciences, AIMS, Udaipur, Rajasthan (2008-09), pp. 124-141.
[25] Sharma, A.; Sarangdevot, S.S. (2010, a). Eclipse-AJDT Environment: A Diamond from Open Source Technology, In Proc. International Conference on Next Generation Communication and Computing Systems (ICNGC2S-10), December 25-26, 2010, Chandigarh, India, pp. 120-125.
[26] Sharma, A.; Sarangdevot, S.S. (2010, b). Investigating the Application of AOP Methodology in Development of Insurance Application Software Using Eclipse-AJDT Environment, In Proc. International Conference on Computer Engineering and Technology (ICCET’10), Nov. 13-14, 2010, Jodhpur, India, pp. D-17 – D-25.
[27] Small, K.; Edwards, D. (2003). Evaluating the socio-cultural impacts of a festival on a host community, In Conference Proc. Australia Pacific travel agents, July 2002, Sydney, Australia.
[28] Sommerville, I. (2009), Software Engineering, 8th
ed., Pearson Education Limited.
[29] Thomas, O. et al. (2008, a). Reference Model-Based Event Management, International Journal of Event Management Research, vol. 4, no. 1, pp. 38-57.
APPENDIX 1Check_HallBooking
pointcut hallbookreport3(Hall h,long hallid,Date1
date):args(hallid,date)&& target(h)&& execution(void
Hall.modifybooking(long ,Date1 ));
after (Hall h,long hallid,Date1 date):hallbookreport3(h,hallid,date) {
Halldb hd=new Halldb();
int n=hd.hallstatus(hallid); if (n==1)
{
Dialogerror g=new Dialogerror("yes");
System.out.println("HALL BOOKED"+g);
} }
pointcut hallbookreport1(Event e,long hid,long day,long time,long
per,long emp,long food):
after(Event e,long hid,long day,long time,long per,long emp,long food):hallbookreport1(e,hid, day, time, per, emp,food)
{
Halldb hd=new Halldb();
int n=hd.hallstatus(hid); if (n==1)
{
Dialogerror g=new Dialogerror("yes");
System.out.println("HALL BOOKED"+g);
} }
pointcut hallbookreport2(Hall h,long hallid,Date1
date):args(hallid,date)&& target(h)&& execution(void
Hall.hallbookingstatus(long ,Date1 ));
after (Hall h,long hallid,Date1 date):hallbookreport2(h,hallid,date) {
Halldb hd=new Halldb();
int n=hd.hallstatus(hallid); if (n==1)
{
Dialogerror g=new Dialogerror("yes");
System.out.println("HALL BOOKED"+g);
2. Scheduletracer
pointcut scheduleaddition():
execution(void Schedule.newschedule(long ));
after (): scheduleaddition()
{
Signature sig =thisJoinPointStaticPart.getSignature();
System.out.println(thisJoinPointStaticPart.getSignature()); System.out.println("entering["+ sig.getDeclaringType().getName()
+"."+sig.getName()+"]");
System.out.println("\n\t** TRACE aspect FINISH **\n");
System.out.println("Functional Tracing Record in a file");
String info="Schedule signature:-"+ sig +"\n"+
sig.getDeclaringType().getName() +"\n"+sig.getName(); byte j[]=info.getBytes();
try {
scheduleff(j); }
catch(IOException e) {}
