eclipse newsletter 4.0

Dear eclipse users,

Finally, a major release from eclipse! Some very important changes took place everywhere. I will try to summarize what has happened on the code since October, a full detailed list can be found in the new features description file.

The library has undergone major re-design in some particularly tricky areas: memory handling, FITS performances, and various internal data structures. Hopefully, the only difference seen from the user's level should be better performance and higher reliability. The procedure to build eclipse has also been updated to look like the GNU configure ; make, procedure, although it is still using home-made scripts to detect functionalities and set compiler options accordingly. From an architecture point of view, support has been added for HPUX-11 and FreeBSD platforms.

In the instrument packages, nothing much happened on the Adonis side. The ISAAC package has been re-constructed as a single user command which also contains a complete manual accessible with the man command-line argument. This should make it much easier for users to use the ISAAC pipeline, but will force script programmers to update their scripts to call new programs.

Two new instrument packages have been added:

• WFI supports basic image manipulations to produce master calibration frames. This package is still very basic and un-documented, it is released here as a reference to share with other CCD-processing groups.
• CONICA supports only the main imaging mode (highest expected use of this instrument). Since the package has never seen real data yet, it is still to be considered experimental and highly untested.

The biggest awaited change is the support for two scripting languages: Lua and Python. Here is what you will get:

• Lua is a very simple and clean scripting language meant for "little pipelines", i.e. scripts that only need to perform a couple of commands and send results back. The hope is to replace all commands in the main sub-directory by direct calls to a scripting engine. If you have been developping C-shell scripts to combine Unix commands from eclipse, you will probably be glad to learn that you can now do the same thing, with:
  • A simpler syntax
  • No disk access necessary to talk between consecutive calls (always stay in memory)
  • One single program that contains all eclipse functionalities
  Interested users should download and compile the eclipse-lua package and give it a try. It is still largely un-documented, though. Expect some more complete documentation and a programmer's manual in the next months. Notice that you do not need to download Lua in order to use the eclipse-lua package, since an interpreter is distributed within eclipse already.
• Python rules over the realm of scripting languages. It shines by its simplicity, its clear syntax and the fact that it can truly be learned in a matter of a day or two. The eclipse-python package will let you program the eclipse library from a Python script. Notice that you will need to download the latest available Python version from http://www.python.org in order to be able to use eclipse-python.

The language packages are meant to give access to the wealth of image processing functionalities present in the eclipse C library to non-C programmers (or even non-programmers). Programming in C is hard, and it makes your programs depend on the frequent variations of the C API. Programming a scripting language is a very easy task in comparison, and you combine the advantages of both worlds: you get the speed of optimized C and the ease of script programming. Another advantage is that it is much easier to maintain a stable scripting interface than a stable C library API. If you program scripts making use of the language interfaces, you should not have to modify your existing programs to cope with newer library releases.

Why two language packages? In short: Lua is meant for little pipelines, to replace simple shell scripts. Python is meant for longer pipeline scripts, where rapid development is a key word. The idea behind the language packages is that they allow to write new recipes in the quick'n'dirty way to test out new ideas or get results without the need for true software development. Once the recipes are stable and validated, it is always possible (and rather easy) to convert back the recipe scripts to full-fledged C programs if ever needed. If there is ever a strong demand for interfaces to other scripting languages (like Tcl or Perl), this might also get implemented, but no plan is done in this direction yet.

The credits for this new version go to many people, probably too many to quote them all here. Special thanks for the Python module go to Roeland Rengelink and Danny Boxhoorn, who have done most of the job.

Many thanks to everybody for help and support.
N. Devillard and Yves Jung
Mon May 28 11:36:13 2001

Back to eclipse home page