The Xelfi system is an Integrated Development Environment (IDE) for
the Java programming language. Using the Xelfi IDE, you can easily build,
compile and test a java code. The Xelfi system should help you to create
your java applications and applets faster and easier. The whole system
itself is written in pure Java, which enables its functionality to many
platforms.
The goals of the project
We started our work on the Xelfi system in the beginning of 1996. At
that time, Java was very young and nobody could be sure about its future.
We like Java language and all these new ideas and we decided to support
this new and beautiful world.
We tried to search for a java IDE which would satisfy our requirements.
There were several IDEs for Java, but we found them incomplete and not
very powerful. We were thinking about a system which enables you to create
a Java program quickly and easily, with true support of "Visual programming".
You know, playing with user interface is always time-expensive and we would
like to see a system which helps a programmer in this procces. We were
also missing other things like source-oriented class browser, visual debugger
and so on. The results of our search make us try to bring our dreams into
the reality. A big inspiration for us was well known Borland's product
,the Delphi. There were several things that we borrowed from the Delphi
system, mainly user interface and look.
As a whole, main goals of our project are:
make the Java programmer's life easier
bring new power to the IDE world and implement a couple of new, untraditional
features
prove that Java is suitable also for bigger projects, not only for
little programs to spice up your web page
A typical user
The Xelfi system could be usable for wide variety of Java programmers.
It can help you to learn the Java language faster, especially when you
will watch and inspect automatically generated Java source code. We think
that the Xelfi system could be enough also for Java proffesionals, because
in the Xelfi it's easy to create and control your code. Another group of
the Xelfi users can raise from today's C++ programmers. They will certainly
like ability to run Xelfi on all platforms where Java applications can
be runned.
The features - parts of the Xelfi system
The Xelfi Integrated Development Environment consists of several parts.
Source Editor The Xelfi's source editor will allow you to write your code easily
and to watch automatically generated source code in real-time.
Visual programming system Helps you in the process of creating user interface of your programs,
automatically generate Java source code for you, including event headers
(and whole event management).
Source Class Browser The Class browser acts like the "class management central".
Using the Class Browser you will control your classes easier, which in
fact could spee-up your work significantly.
Compiler The Xelfi system hasn't its own Java compiler, the Compiler in Xelfi
server only as an interface to the Java compiler. The Xelfi Compiler interface
will let you use virtually any java compiler which exists.
Visual Debugger The Xelfi comes also with Visual Debugger system. It allows you to
debug your code, set breakpoints, watch and inspect data structures....
Main advantages
Here we summarize main advantages of the Xelfi system. Advantages of
the Xelfi system should minimize bottlenecks in the programmer's work.
It can help the programmer to put an attention to another, more important
problems of the work.
Rapid Application Development (RAD) The Rapid Application Development is very well known term. It comes
hand in hand with the visual programing support. The RAD in the Xelfi
system is ensured by an easy to use form editing, automatic code generation,
intuitive component inspecting and of cource by powerful set of reusable
components.
Reusable Components (RC) The Xelfi Components architecture ensures is open and ensures their
reusability. The individual component can be developed without any knowledge
of the Xelfi system. Connecting to the Xelfi system is easy. Only thing
you have to do is to implement well defined interface needed for communication
between the Xelfi system and the component. So, it is possible to extend
the Xelfi system with components which do not exist at this time and it
is also possible to take existing components and make them Xelfi-compatible.
The Xelfi system itself comes with powerful set of components, including
whole Java AWT library.
Reusable Layouts (RL) The Reusable Components architecture is not new, it was used for example
in the Delphi system. On the contrary, the RL architecture is brand new
and brings new power to the visual development. The main idea is the same
as in the RC architecture - make it open and reusable. With RC architecture,
user can visually attach some layout to the component container (form window,
panel or applet panel etc..), edit its properties and directly watch the
results. The layout specifies how the components will react to the reshape
event of their container. As a result, user can see how his/her windows,
panels etc. will dynamically reshape their content even in the design
time.
Real Mode The Real Mode advantage means the ability to see real behavior of the
components without compiling and running any code. With Real Mode, you
can test the user interface of your program in better way, which leads
in faster development.
Source Class Browser, Hint support You can browse your code without any compilation, all you have to do
is to save the source code and watch its structure in the Class Browser
immediatelly. The Xelfi's Class Browser is highly configurable and you
can configure it to suit your needs. The Class Browser also allows Hint
support, which means that you can view little hints to the methods. These
hints are written directly in the source code in the javadoc style.
Template System The Template System allows you to create your code not only from the
scratch, but also using some previously saved template. the Xelfi itself
comes with several basic templates like Plain, Class, Applet, Form, Application.
The user has the ability to save the source code as own template.
Background Processing Some time-expensive actions (like Compiling) runs in background to
speed up the response of the system.
Live breakpoints and errors The breakpoints and error lines in the source code are sensitive to
any source code change and their positions are changed properly.
Example: When I delete several lines before the breakpoint line or compiler
error line, the specified line will move up as the source code changes.