Amita Sharma et al.

/ International Journal of Engineering Science and Technology (IJEST)

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)].
‘Event Management System Software’ is essentially business software and therefore, is collection of
modules that work together to provide the desired functionality defined by the set of requirements. ‘Separation
of Concerns’ [Dijkstra (1974), Hursch et al. (1995)] and ‘Modularity’ [Parnas (1972)] are the fundamental principles
that drive software evolution. Designing software according to these principles makes it more manageable,
understandable and reusable. Using Object-Oriented Programming (OOP) [Sommerville (2009)] methodology,
goals of modular programming and separation of concerns are seldom realized due to presence of crosscutting
concerns [Kaur et al. (2009)]. This leads to problems of code scattering [Gradecki et al. (2003)] and tangling
[Laddad (2003)] which increase the complexity of the software and degrade its quality.

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 139

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

‘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.
First step is to develop a Use-Case diagram. This diagram (Figure 1) explains the requirements from the
user’s perspective. From the study and analysis of the system, it is noticed that some functionalities cannot be
localized into single modular units using OOP methodology. They represent crosscutting concerns. Checking
hall booking, booking check for other requirements, event modification report, checking for due bills, schedule
reports, event deletion, handling advance payments for events are such functionalities. Text check concern is

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 140

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

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

The event booking can be modified but other bookings like accessories and staff are also modified
simultaneously. Feasibility of modification is to be checked with respect of advance booking of event,
employees and accessories. This implementation is crosscutting in nature, thus Event_modification aspect is
created. This will check the advance booking of accessories and staff.

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 141

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

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.

Crosscutting concerns have been modeled as aspects using the join point model of AspectJ. Each aspect has
its well defined join points, pointcuts and advice. Figure 2 shows the class diagram with functional aspects.

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 142

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

Hall <aspect> Bill

Check_HallBooking
-long hallid -long billid
-String location,facility +pointcut -String details
-long capacity hallbookrecord1(..) -double amt…
-double rate +pointcut
hallbookrecord2(..) + addbilll(long,long..)
+ addhall(long,long.) +pointcut +modifybill(long,Date1)
+modifybooking(long,Date1) hallbookrecord3(..) +billpayment(long,long,Date1)
+hallbookingstatus(long,Date1) +billgeneration(long,Date1)…
+bookhall(long,Date1)…
: execution after(..) (..)
: execution after(..) (..)
: execution before(..) (..)
Event

-long eventid <aspect> X

-String type Advancepaymentcheck
-long day, time
+pointcut
+ addevent(long,long..) advancerecord1(..)
+modifyevent(long,Date) +pointcut <aspect>
+bookevent(long)… advancerecord2(..) Eventdeletion

: execution before() (..) +pointcut billpaidcheck(..)

: execution before() (..) +pointcut statusupdate(..)
<aspect>
Event_modification : execution after() (..)
: execution after() (..)
+pointcut eventmodify(..) <aspect>
+pointcut Bookingcheck
reportformodify1(..)
+pointcut +pointcut
reportformodify2(..) bookingforitem(..)
+pointcut +pointcut <aspect>
reportformodify3(..) bookingforemployee(..) Reportforduebill

: execution after(..) (..) : execution before() (..) +pointcut duebillcheck(..)

: execution after(..) (..) : execution before() (..) +pointcut duebillinform(..)
: execution after(..) (..)
: execution after(..) (..) : execution after() (..)
: execution before() (..)

Item Employee Schedule

-long itemid -long empid -long scheduleid

-String details
-double amt…
+ additem(long,long..)
+modifyiteml(long,String)
+modifybooking(long,Date1)
+bookitem(long,long,Date1)…
-String details
-double salary…
+ addemp(long,long..)
+modifyemp(long,String)
+modifybooking(long,Date1)
+bookemp(long,long,Date1)…
-String details
-Date1 date
-Vector schlist…
+ getschedule(long,long..)
+newschedule(long,String)
+modifyschedule(long,Date1)
+paymentschedule(long,long,Date1)…

Figure 2. Class Diagram showing classes and functional aspects

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.

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 143

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

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 4. Outline view, CrossReferences view and Advice view of Check_Hallbooking

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 144

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

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 investigation has been made to study the usefulness of the AOP methodology in design and implementation
of real world Event Management System Software. Impact of using this methodology on various quality factors
of the designed software has been examined. Observations made in the study are presented in this section.
Crosscutting concerns create the problems of code scattering and code tangling, which degrade program’s
comprehensibility and decrease modularity, reusability, maintainability, customizability. They also increase the
complexity of the software design. By encapsulating the crosscutting concerns as aspects using AOP
methodology, helped in elimination of code scattering and tangling. Thus, concerns were cleanly separated and
modularity was enhanced. This is in accordance with the observations of Bernardi et al. [2]. Modularity
enhancement reduced the complexity and resources spent in software design and development. It was also
observed that cleaner separation of concerns and reduction in tangling, greatly improved readability of the code.

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 145

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

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 system evolution 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
The authors thank Prof. Divya Prabha Nagar, Vice Chancellor, J.R.N. Rajasthan Vidyapeeth (Deemed)
University, Udaipur for encouragement and providing necessary research facilities.

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 146

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

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.
[30] Thomas, O. (2008, b), Reference Model Management, In Kelley, G. (Ed.), Selected Readings on Information Technology
Management: Contemporary Issues, Hershey, New York, pp. 1-20.

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 147

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

APPENDIX
1Check_HallBooking

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);
}
}

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);
}
}

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 148

 Amita Sharma et al. / International Journal of Engineering Science and Technology (IJEST)

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)
{}

ISSN : 0975-5462 Vol. 3 No. 1 Jan 2011 149