Open Source Science Journal Vol. 2, No.

4, 2010

Building Java Application Using Eclipse Integrated Development

Environment, EIDE

Cecilia CIOLOCA
Academy of Economic Studies, Bucharest, Romania
cecilia_cioloca@yahoo.com

Abstract: The open source Eclipse integrated development environment is presented.

The architecture of the Eclipse project is explained. The main brick of the architecture is the
extensibility property. The paper explains how to install the product. It describes and shows
the basic tools and features of the Eclipse integrated development environment. It traces the
steps to be taken in order to extend the functionality of the application using plug-ins. An
Eclipse plug-in is created using Apache Log4j distribution. Another plug-in that extends
Eclipse’s graphical interface is developed. This plug-in provides a tree structure of
information extracted from configuration files struts-config and tiles-defs. The advantages of
using Eclipse integrated development environment are identified and described. A
comparison of the product with a commercial one is stated, using few of both products
features.

Keywords: open source, software, eclipse, plug-in, java.

1. EIDE Presentation

The concept of open source, defined by the Open Source Initiative, OSI, provides
users with outstanding features:
• the right to obtain the source code of the product;
• the right to modify and redistribute the source code of the product.
Eclipse integrated development environment, hereinafter EIDE, is an open source
product which in the beginning was released under the CPL license, Common Public License,
now being distributed under the License Eclipse Public License, EPL. EPL is an open source
license for products, specially designed for the Eclipse Foundation and upon which sits CPL.
This license is also supported by OSI.
The product goal is to provide an integrated development environment. EIDE is a
product used for application development.
Although it is perceived as a dedicated development environment for java, EIDE is
programming language independent and there are a variety of eclipse plug-ins dedicated for C
/ C + +, Cobol or C #.
The main distribution includes the following components:
• Eclipse Platform is designed to integrate development tools implemented using plug-
ins. It is to be said that EIDE was designed as a wide selection of plug-ins that interact
and are integrated by the platform;
• Java Development Toolkit JDT is used for writing and debugging Java source code for
applications;
• Plug-in Development Environment, PDE, is the component used to extend the
functionality of the Eclipse product.
Figure 1 schematically presents the architecture of the Eclipse integrated development
environment.

23
Open Source Science Journal Vol. 2, No. 4, 2010

Fig. 1. Eclipse Architecture [17]

The main role of platform runtime is to identify the plug-ins and the links between
these plug-ins. Because EIDE was designed to be extended over and over, and some
distributions contain hundreds of plug-ins, they are loaded only when they are used and not
when starting EIDE. This way, the start time of the application is minimized. Another reason
for plug-in delayed loading technique is that many plug-ins might not be used, as they are
specialized plug-ins, so avoiding unnecessary consumption of resources and time.
The workspace represents the section where users’ resources lie. For each project in
the workspace there is a main folder with the corresponding subfolders in order to reflect the
structure of the project. The workspace is also used for keeping user’s resources history,
functionality that allows the user to track the changes made to a certain resource and to revert
these changes.
The workbench is the graphical interface of EIDE. In addition to menus and toolbars,
EIDE's workbench is also organized into perspectives and views. A main feature of this
component is that the controls also have a native look. The workbench has been developed
using two main libraries Standard Widget Toolkit, SWT, and Jface. Both libraries use native
operating system graphics, making Eclipse look more familiar to the user.

2. Using EIDE

First step in using EIDE as a development environment is installing it. EIDE requires
that the machine on which it will be run has java installed. Officially, Eclipse recommends
Java version 5 to be used but many users successfully use java 6. EIDE distribution can be
downloaded from the official site www.eclipse.org. Installation consists of unpacking the
distribution archive into a directory on the user's hard disk.

24
Open Source Science Journal Vol. 2, No. 4, 2010

EIDE installation does not change any registry, does not alter environment variables
and does not require system restart. Immediately after extraction of archive, EIDE is ready to
launch. EIDE is started using the executable eclipse.exe found in the distribution.
One of the basic components of EIDE is the workbench, the window that appears
when the application is started. Its role is to provide the user an interface to manage the
projects. The controls in the workbench make call to other components and plug-ins. Figure 2
shows the Eclipse workbench and its organization.

Fig. 2. Eclipse workbench – editor, views, toolbar highlighted in the plug-in development
perspective

Each user application developed using EIDE is associated with a project, and a
corresponding directory in workspace. Using plug-ins, EIDE is used to develop many types of
applications. When creating a new project in EIDE, the user is asked to choose either to create
a new project in the workspace or to create a project from existing sources in the workspace.
After the creation of a new project, it is being populated it with packages, classes and
other resources necessary for the user. These resources are found in the proper directory in the
workspace. EIDE assists the user in writing code by providing a multitude of tools:
• Automated code completion while the code is being typed. The Eclipse code assist
feature displays a list of proposed methods and their description. This feature is
automatically triggered but may be also voluntarily triggered by pressing the
combination CTRL+space.
• Eclipse includes a special incremental compiler that evaluates the code while being
typed. The code is dynamically compiled and syntax errors are highlighted by
underlining them. EIDE also offers suggestions and options to correct these syntax
errors;
• Automatic code formatting. This feature rearranges the code in order to be more
readable;

25
Open Source Science Journal Vol. 2, No. 4, 2010

• By using Javadoc comments the user has the possibility to define his own comment
templates and EIDE will use these template for every new class or method;
• Automated code generation by using some predefined templates. The user has the
possibility to add new code generation templates to the existing ones. When the code
is typed, certain characters and sequences of characters are being replaced with code
instructions. Let’s consider a for cycle template, Figure 3. After the keyword for is
typed, EIDE will suggest the new created template. By selecting the suggested
template, the predefined code will be generated. The ${index} variable will be
automatically replaced with i, and if the user decides to rename this variable then it
will be automatically renamed in all three position it appears.

Fig. 3. Adding a new code generation template

One of the most important features of EIDE is the ability to run code interactively.
Using the debugger, java code is being run line by line. This feature offers the user the
possibility to examine variable values at different points in the program. This process is very
important for code debugging and for identifying problems. Figure 4 shows the perspective of
code debugging.

26
Open Source Science Journal Vol. 2, No. 4, 2010

Fig. 4. EIDE code debugging perspective

Code debugging perspective includes specific views, which are used during the
process of debugging source code. As shown in Figure 4, in the top left side of the perspective
the debug view is located. This view contains the line by line code navigation controls. In the
top right side of the perspective, the instantiated objects and the variable values may be
tracked. The central area of the perspective contains the source code editor.

3. Extending EIDE functionality using plug-ins

EIDE has been designed as a huge puzzle where plug-ins represent its elements. The
plug-ins interacts with each another and are being integrated by the Eclipse platform.
Considering this, one of the most important characteristic of this product is extensibility.
Using plug-ins new functionality is added to the existing one. In Eclipse, a plug-in is seen as
an extensible component that contains code, resources, or both. Plug-in extension is achieved
through extension points, which are being defined as mechanisms by which plug-in adds
functionality to a third party one.
In the main distribution, a “plugins” folder is located. This folder contains all installed
plug-in. Each plug-in has a corresponding directory with the following structure:
• plugin.xml – represents the manifest of the plug-in; it describes the plug-in like name,
version and provides information regarding required libraries and extension points
used and provided by the plug-in;
• *.jar – is the library used by the plug-in;
• lib folder – in case the plug-in uses more than just one library this folder is the one that
contains all plug-in libraries;

27
Open Source Science Journal Vol. 2, No. 4, 2010

• icons folder – contains all the icons used by the plug-in; these icons are usually in .gif
format;
• about.html – offers information regarding the plug-in and the license type;
• other resources, if the case.
At startup, EIDE platform creates a plug-in registry based on information found on
plug-ins folder. In case more than one version of the same plug-in is discovered, then the
latest version of the plug-in is taken into consideration.
Bellow is how to create a new plug-in. A new Apache Log4j plug-in is created using
the apache-log4j-1.2.16 distribution. It can be downloaded from
http://logging.apache.org/log4j/1.2/download.html.
First step in creating a new plug-in is creating the project in EIDE. The project is
created using the Plug-in Project wizard located in Plug-in Development folder as shown in
Figure 5.

Fig. 5. Plug-in Project wizard used for creating the new plug-in project

EIDE automatically generates the structure of the project presented in Figure 6 and the
project folder in the workspace. The example presented in this paper uses the library
previously downloaded from the official Apache website. The library is imported into the
Eclipse project as in Figure 6.

28
Open Source Science Journal Vol. 2, No. 4, 2010

Fig. 6. The project structure generated by EIDE

The properties in the plugin.xml file are being edited either manually or by using the
Overview tab. The structure of the file is similar to the following:

<?xml version="1.0" encoding="UTF-8"?>

<plugin id="org.apache.log4j" name="Apache Log4J" version="1.2.16"
provider-name="cecilia.cioloca">
<runtime>
<library name="log4j-1.2.16.jar">
<export name="*"/>
</library>
</runtime>
</plugin>

Apache Log4j plug-in is ready for use, but in order to be installed by other users it
must be exported as an archive. This is done using the EIDE export function by selecting the
option Deployable plug-ins and fragments, the previously created plug-in and the export
destination shown in Figure 7. Finally we obtain a .zip archive that is used by other users.
In order to install and use a plug-in, the zip archive must be copied and extracted in the
Eclipse plug-ins directory. In case the plug-in archive is a .jar one, then the archive must be
just copied into the plug-ins directory. It is recommended to restart the application so that the
plug-in registry is being refreshed and the new installed plug-ins are available for use.

29
Open Source Science Journal Vol. 2, No. 4, 2010

Fig. 7. Plug-in archive export

The previously presented plug-in is improved by implementing a graphical interface.

A suggestion for future development is a view that extends the EIDE and that provides an
overview of each record in the log file. Using a table presentation that includes the date and
time of log, type of log, debug, error, info, message, log files are easier managed by the
programmer.
Another suggestion for improving the plug-in is storing records in a database. Often,
logs that are stored in a database are easier managed than those stored in files. It’s easier to
perform queries on a database, make reports, while log files become very difficult to handle
as they grow in size.

4. Application developed using EIDE

Below is presented how an application is developed using Eclipse as a development

environment. The developed application is a plug-in that provides the user a tree overview of
all actions in a java project based on the Struts framework.
The project is created using the Plug-in Project wizard, located in the Plug-in
Development directory as described in the previous example. Eclipse generates the directory
structure for the new plug-in. The interface of the plug-in will be a new EIDE view which is
displayed on user demand. The plug-in is loaded only when the user chooses the view to be
displayed. To load and use the new plug-in, the user must select the Struts Browser from Utile
category in the Show View window as shown in Figure 8.

30
Open Source Science Journal Vol. 2, No. 4, 2010

Fig. 8. Struts Browser plug-in selection

The view used by the Struts Browser plug-in was defined as an extension in the
plugin.xml file. In the same file were defined details regarding the category in which Struts
Browser will be displayed, the icon the plug-in will use, and also the class used to initialize
the view. The sequence below shows a section from plugin.xml file.

<extension
point="org.eclipse.ui.views">
<category
name="Utile"
id="strutsBrowser">
</category>
<view
name="Struts Browser"
icon="icons/sample.gif"
category="strutsBrowser"
class="strutsbrowser.views.BrowserView"
id="strutsbrowser.views.SampleView">
</view>
</extension>

In the project source folder has been created a new package strutsbrowser.views.tree.
This package contains the specific classes, later used to create the tree structure presented in
Figure 9.

31
Open Source Science Journal Vol. 2, No. 4, 2010

Fig. 9. The Struts Browser project containing the classes that define the tree structure

• TreeObject.java – This class defines a generic node of the tree structure. It

contains the following properties name, path, parent, icons and contains the
constructors, the setters and getters corresponding to the properties and the method
responsible for the expansion of a node in the tree structure. The method that
expands a node is presented below:

public void open( BrowserView browser ) {

if( path == null ) {
browser.showMessage("open: "+this.getClass().getName()+" "+name);
} else {
try {
IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().g
etActivePage(), BrowserView.getFileByPath(path));
} catch( Exception ex ) {
browser.showMessage("open error" + ex.getMessage());
}
}

• TreeParent.java – This class extends the TreeObject class. An instance of this class
is the parent node of the tree structure. This class contains methods for adding a
new node, deleting a node, remove the tree structure.
• StrutsActionTreeNode.java – This class extends the TreeParent class. It is
responsible for creating the tree structure located under each action defined in
struts-config.xml file. This class focuses plug-in logic, it contains methods to
extract and correlate information from configuration files struts-config.xml and
tiles-defs.xml. Below are presented pieces from configuration files in order to
illustrate and explain how the tree structure is created. Struts-config.xml file
structure is shown in the following sequence:

<?xml version="1.0" encoding="ISO-8859-1" ?>

32
Open Source Science Journal Vol. 2, No. 4, 2010

<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts

Configuration 1.0//EN" "http://jakarta.apache.org/struts/dtds/struts-
config_1_0.dtd">
<struts-config>
<form-beans>
<form-bean name="bookDetailForm"
type="ro.ceciliacioloca.form.BookDetailForm" />
</form-beans>
…
<action-mappings>
<action attribute="bookDetailForm" name="bookDetailForm"
path="/bookDetail" scope="request"
type="ro.ceciliacioloca.action.BookDetailAction">
<forward name="showBookDetail" path="book.detail" />
<forward name="error" path="/error.jsp" />
</action>
…
</action-mappings>
…
</struts-config>

BookDetail action is being received as an entry parameter, the action is looked for in
the configuration file and defined properties are extracted. These properties offer information
about the form used by the bookDetailForm action, and also about the pages towards which
the redirect will be made, after the action is executed. Information regarding the form and
redirect pages is memorized and added within the tree structure. In case the redirect pages
paths are defined as tiles in tiles-defs.xml, the search for information continues until the jsp
files are found. This information is added in the tree structure, in its turn.
For the above example, the redirect page - showBookDetail - is defined as a tile and
not as a stand-alone file, like the error page, therefore for this redirect, tiles-defs.xml from the
following sequence will be searched:

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/tiles-config_1_1.dtd">
<tiles-definitions>
…
<definition name="book.detail" extends="main.layout"
path="/layouts/bookDetailsLayout.jsp">
<put name="item-details" value="/tiles/bookDetails.jsp" />
…
</definition>
…
</tiles-definitions>

In the tiles-defs.xml file, definition of book.detail section is identified and information

regarding the jsp files is being added in the tree structure. In the shown example, the couple
book-detail and tiles/bookDetails.jsp will be kept and added to the tree. The source code of
StrutsActionTreeNode.java constructor is presented in the following sequence:

public StrutsActionTreeNode(Element e,BrowserView bw,String

prefix,StrutsActionTreeNode parent, String queryString) {
super( prefix+( e == null? "null element":(e.hasAttribute("path") ?
e.getAttribute("path").substring(1) : "no path" )) + queryString,null);
scope = e.getAttribute("scope");
type = e.getAttribute("type");

33
Open Source Science Journal Vol. 2, No. 4, 2010

form = e.getAttribute("name");
input = e.hasAttribute("input") ? e.getAttribute("input") : "none";
path = "src/main/java/" + type.replace('.', '/') + ".java";
this.parent = parent;
try{
XPath xPathForm1 = XPathFactory.newInstance().newXPath();
NodeList formList = (NodeList) xPathForm1.evaluate(
"/struts-config/form-beans/form-bean[@name='"+form+"']",
e.getOwnerDocument(),XPathConstants.NODESET);
if( formList == null || formList.getLength() == 0 ||
!((Element)(formList.item(0))).hasAttribute("type")) {
addChild( new ErrorNode("no form"));
} else {
String formType="src/main/java/" +
((Element)(formList.item(0))).getAttribute("type").replace('.',
'/') + ".java";
addChild(makeResourceLink("FORM: "+form,formType));
}
} catch( Exception ex ) {
ex.printStackTrace();
}
try{
XPath xPath = XPathFactory.newInstance().newXPath();
NodeList forwardList = (NodeList) xPath.evaluate("./forward", e
,XPathConstants.NODESET));
if( forwardList == null ) {
addChild( new ErrorNode("no forward nodes"));
} else {
for(int i=0,sz=forwardList.getLength();i<sz;i++) {
makeForwardNode((Element)forwardList.item(i), bw);
}
}
} catch(Exception ex) {
ex.printStackTrace();
}
}

As one can see from the source code, the constructor is the method which gathers and
stocks inside the data structure all the information obtained from the configuration files
presented above.
Class BrowserView.java, referred to also in the plugin.xml extension, is the class
which triggers the tree building. The key method in this class creates the tree’s parent node,
extracts all the actions defined in struts-config.xml file and for every action, it calls the
StrutsActionTreeNode.java class constructor, responsible for detailing the tree down to its
leaves. Source code of the method is presented in the following sequence:

private void initialize() {

try {
invisibleRoot = new TreeParent("",null);
IFile strutsConfigFile = getFileByPath("src/main/webapp/WEB-
INF/struts-config.xml");
if( !strutsConfigFile.exists() ) {
invisibleRoot.addChild(new ErrorNode("Proiectul " + projectName()
+ " nu este de tip struts!"));
return;
}
strutsConfigDomDocument=readXMLFile(strutsConfigFile.getContents());
XPath xPath = XPathFactory.newInstance().newXPath();

34
Open Source Science Journal Vol. 2, No. 4, 2010

NodeList actionList = (NodeList) xPath.evaluate("/struts-

config/action-mappings/action",
strutsConfigDomDocument,XPathConstants.NODESET);
TreeParent actiuni = new TreeParent("Actiuni",null);
for( int i = 0; i < actionList.getLength(); i++ ) {
Element e = (Element) actionList.item(i);
actiuni.addChild(new StrutsActionTreeNode(e,self,"",null,""));
}
invisibleRoot.addChild(actiuni);
} catch(Exception ex) {
showMessage(ex == null ? "null exception" : ex.toString());
}
}

Figure 10 presents the graphical interface of the plug-in.

Fig. 10. The graphical interface of the StrutsBrowser plug-in. The generated tree structure for
the example presented before.

Meaning of the prefixes used is the following:

• TO – corresponds to a redirect page for an action defined in struts-config.xml;
• FORM – the action form
• INC – corresponds to an import used when defining a tile.
The above presented plug-in offers the user a graphic presentation of the relations
between the two configuration files. Also, in practice, due to applications complexity, the two
files can reach hundreds or maybe over 1000 lines, which makes them difficult to read. With
the help of the developed plug-in, the user can view faster all the links defined in the two
files, especially as they are key files, very often accessed in the case of applications based on
Struts framework.
The plugin offers only viewing facilities regarding the page tree structure, but it is
improved with controllers that allow also the editing of the tree structure, adding new actions,
new redirect pages and forms, editing or deleting the existing ones. The result of these new
functionalities implies editing the xml-s from the two files.

35
Open Source Science Journal Vol. 2, No. 4, 2010

5. The advantages of using EIDE

EIDE popularity is owed first of all to the flexible architecture provided. Despite the
fact there are multiple distributions that have specialized plug-ins incorporated to fulfill the
most of user requirements, these specialized distributions can be extended further if the user
requirements are not fully fulfilled.
Being an open source product, with a remarkable community gathered around the
project, a variety of plug-ins have developed meanwhile, so that in many situations it is not
necessary for the user to develop his own extensions, but only to download and install them
inside the distribution in use. Besides the open source plug-ins there are many commercial
plug-ins.
Another advantage that underlies the project’s success consists in the development
environment’s ease of use, whether we’re talking about installation, or extending
functionalities. As previously said, by installing EIDE, registries are not altered, nor does it
create references inside the operating system. For this reason, cloning configurations or
porting a distribution with certain plug-ins installed, from one machine to the other, is
extremely easy, namely the folder is effectively copied and EIDE is ready to use.
From the business point of view, EIDE corresponds to a high integration level,
applications developed using the Eclipse platform compatibility is very high.
As presented in [1], there are a bunch of different versions of EIDE available, thus the
user is not limited to using only a stable, official realize, but he can choose the one that suits
the best his needs. The first step in using EIDE efficiently is understanding its organization in
perspectives, views and editors. Every component of the Eclipse Workbench—every view,
every editor, every menu—is defined in a plug-in. The specific editor and views that appear
one time depend on type of the resource that is being edited. Eclipse is also highly
customizable. Many settings are being customized using the Windows->Preferences option
from the main menu. If making lot of changes in the preferences it is recommended to export
these settings in a backup that is further used. These export preferences are used when cloning
an environment or any time a revert preferences is needed.
Table 1 shows a comparison of several characteristics between EIDE open source
development environment and a commercial similar product, Visual Studio.

Table 1. Eclipse versus Visual Studio comparison using few characteristics of both
development environments
Feature Eclipse Platform 3.4.1 Visual Studio Express
Editions
Code auto completion Yes Yes
Code syntax Yes Yes
highlighting
Unit Testing Yes No
Plug-in support Yes No. No explicit support for
plug-ins however third
party plug-ins can work
with the Express edition.
Code generation Yes Yes
Task List Yes Yes
XML documentation preview and Yes No
generation
Testing Regular Expressions Yes No
Refactoring Rename, Extract Rename, Extract Method

36
Open Source Science Journal Vol. 2, No. 4, 2010

Method, Remove
unused imports, Extract
Interface
Error List Yes Yes
Debugger Yes Yes

Table 1 shows that both analyzed development environments have tools that help the
user in writing and debugging the source code. The main advantages of EIDE toward Visual
Studio consist in EIDE extensibility by plug-ins and its operating system independency.
These two advantages make Eclipse the number one choice in terms of development
environment for many programmers.

6. Conclusions

The integrated development environment, Eclipse, is a competitive open source

product, very adaptable to users’ requirements due to its extensibility characteristic.
Although often it is perceived as a Java development environment, EIDE is more than that.
The interfaces used when building the platform available and were used to create new types of
editors. Also, the entire source code is available so that by using plug-ins new development
environments for other languages and applications were created.
By presenting the Apache Log4j plug-in has been shown that extending Eclipse with
new functionality is an easy task, as well as installing new plug-ins.

References

[1] D. Gallardo, E. Burnette, R. McGovern, Eclipse in Action, Manning Publications Co.,

2003.

[2] I. Ivan and C. Boja, Metode statistice în analiza software, ASE Publishing House,
Bucharest, 2004.

[3] M. Georgescu and D. Milodin, „Open Source Tools to Assist in the Development of
Software Applications”, Open Source Science Journal, Vol. 2, No. 2, 2010, ISSN 2066 –
740X.

[4] C. Ciurea, „Open Source Tools for Collaborative Systems Hierarchization,” Open Source
Science Journal, Vol. 2, No. 2, 2010, ISSN 2066 – 740X.

[5] M. Doinea, “Open Source Security Tools,” Open Source Science Journal, Vol. 2, No. 2,
2010, ISSN 2066-740X.

[6] J. S. Rellermeyer, G. Alonso, T. Roscoe, “Building, deploying, and monitoring distributed

applications with Eclipse and R-OSGI”, OOPSLA workshop on eclipse technology eXchange,
ACM, 2007, ISBN:978-1-60558-015-9.

[7] D. Rubel, “The Heart of Eclipse”, Queue Vol. 4, Issue 8, ACM, 2006, ISSN 1542-7730.

37
Open Source Science Journal Vol. 2, No. 4, 2010

[8] D. Hou, “Studying the evolution of the Eclipse Java editor,” OOPSLA workshop on
eclipse technology eXchange, ACM, 2007, ISBN 978-1-60558-015-9.

[9] M. Wermelinger and Y. Yu, “Analyzing the evolution of eclipse plugins,” International
Conference on Software Engineering, ACM, 2008, ISBN 978-1-60558-024-1.

[10] M. Georgescu and D. Milodin, “Techniques of Improving Open Source Software Tools,”
Open Source Science Journal, Vol. 2, No. 3, 2010, ISSN 2066 – 740X.

[11] B. Vintila, “Quality Standards in Open Source Lifecycle,” Open Source Science Journal,
Vol. 2, No. 1, 2010, ISSN 2066 – 740X.

[12] R. Munteanu, “Java Open Source quality management,” Open Source Science Journal,
Vol. 1, No. 2, 2009, ISSN 2066 – 740X.

[13] I. Ivan, “Open Source - State of the Art,” Open Source Science Journal, Vol.1, No. 1,
2009.

[14] I. Radulescu, “Open Source Tools to Measure Software Complexity,” Open Source
Science Journal, Vol. 1, No 2, 2009, ISSN 2066 – 740X.

[15] A. Engelfriet, “Choosing an Open Source License,” IEEE Software, Vol. 27, No. 1, pp.
48-49, Jan./Feb. 2010.

[16] http://logging.apache.org/log4j/1.2/download.html

[17] http://www.ibm.com/developerworks/opensource/library/os-ecjdt/

[18] http://www.eclipse.org/legal/epl-v10.html

[19] http://en.wikipedia.org/wiki/Eclipse_Public_License

[20] http://opensource.org

Author

Cecilia CIOLOCA has graduated the Faculty of Economic Cybernetics,

Statistics and Informatics from the Bucharest Academy of Economic Studies
in 2008. She is currently conducting doctoral research in Economic
Informatics at the Academy of Economic Studies. She is experienced in
software development using open source technologies. She has successfully
completed several projects using various programming languages and open
source frameworks. She is proficient in using Java Enterprise Edition.

38