What is it?, The goals of the project, A typical user, Features, Main advantages

Introduction to the Xelfi system


Index


What is it?

    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.

    Xelfi web pages

    Installing Xelfi