GNOMES: A Case History

W. K. Young

National Radio Astronomy Observatory, Socorro, NM 87801

Abstract:

We expect to move the functionality of the GNOMES prototype into AIPS++. We believe the lessons learned from making the prototype to pay dividends in the migration into the AIPS++ environment.

1. Background

The GNOMES project (Generalized NRAO Observe, Multi-telescope Experiment Scheduler) is a set of planning and scheduling tools for the Very Long Baseline Array (VLBA), Very Large Array (VLA), and Very Long Baseline Interferometry (VLBI) observing. First discussions began in April 1991, and formal work started in January 1992. The VLBA will make VLBI more accessible to all astronomers, not just the experts. GNOMES was to provide the tools and interface to help with the very complex task of planning and scheduling VLBI observations. In 1991 there were three main packages used for VLB scheduling:

1. PC-Sched written at Haystack observatory,
2. Sked written at Goddard Space Flight Center by the Geodesic group, and
3. Sched written by NRAO.

2. Analysis & Design

Background work started in April of 1991; in November 1991 the NRAO decided to proceed with the project. Analysis continued until June of 1992. Discussions with astronomers at NRAO and other institutions produced a series of objectives. An abbreviated list of those objectives follows:

• Show visibility of sources at various antenna locations,
• UV-Coverage plots of user defined arrays,
• Azimuth-Elevation plots of sources at various antenna locations,
• Interactive Scheduling---Dynamic displays of antenna site information including pointing and current tape usage,
• Produce VLBA Antenna Control Files,
• Produce VLA Observe Files,
• Produce SNAP & DRUDG files for Mk 3 VLBI scheduling,
• Flexible display of schedule information,
• Provide expert-novice modes,
• Read in the existing VLB style files,
• Provide multiple interfaces, and
• Be fairly easy to use.

We optimistically estimated about one year to implement the prototype programs.

3. Implementation

After completing an initial design in June 1992, coding began full-time in July of 1992. We changed the the original interactive Scheduler GUI early in the project. After continued interaction, we made substantial changes in the Scheduler GUI and the overall design in May of 1993. We dropped the workspace concept and kept the Scheduler, Antenna and Source Catalogs.

In late summer of 1993 we wrote a detailed-design document followed by a design review in October 1993. Prototype Scheduler testing started in February 1995. The Scheduler produced the first realistic VLBA schedules in September 1995.

We used a series of tools in the implementation:

• SunSoft's DevGuide to do the window layout,
• USL's Standard components, later switched to Rogue Wave's Tools.h++,
• Rogue Wave's Lapack++,
• GDBM for a keyword-value database,
• Sun compilers & debuggers, and
• UIT wrappers to sit on top of XView.

UIT is a very nice library that sits on top of XView. It helped greatly in learning and understanding XView. Unfortunately it was the wrong X library to choose and we stayed with it too long.

While implementing the prototypes, a number of things went well:

• Rapid prototype of Antenna & Source Catalogs,
• Schedule VLBA experiments,
• A very flexible GUI for viewing and editing schedules,
• Easily extended planning tools from Antenna & Source Catalogs into the Scheduler,
• C++ has evolved into a reasonable programming environment, and
• Learned a lot about VLB, C++, and X11 programming.

Unfortunately, there were also a number things that didn't go well:

• Slow to produce Scheduler prototype, concept to testing took much longer than expected,
• Flexibility in the Scheduler produced complexity in keeping the views of the data consistent (hampering the implementation),
• C++ and the tool kits were immature at the start of the project,
• Design was incomplete, lots of detail went missing during the design phase (too eager to code!), and
• The current Scheduler consumes too much memory and is not as fast as it should be.

4. Lessons Learned

Given all the time and effort put into the project, what did we learn?

1. Spend more time on design. The trouble with programmers doing design and analysis is they want to code. Many details went missing because we didn't spend the time up front identifying them. Initial object designs were sketchy at best.

2. Don't take on too many new things at once. The learning curve ate us up. We mixed an unfamiliar project (VLB scheduling) with a new form of analysis and design (object-oriented analysis and design) and did the implementation in an unfamiliar language (C++) with many unknown libraries (XView, UIT, X11, Standard Components, Tools.h++, Lapack++, and the standard C++ libraries).

3. Work incrementally. A series of small projects probably would have shortened the learning curves and produced useful software early on.

4. Don't use immature compiler technology. Turnaround times and debuggers are much better now at the end of 1995 than they were in 1992--1994.

5. Watch out for bandwagons. If you don't watch out you get run over. We were swept away by all the object-oriented and C++ hyperbole of 1992. Object-oriented design and analysis is hard, writing good interactive applications is hard and they both take time, especially if the project is complex.

Acknowledgments:

I'd like to thank Bob Hjellming who helped with the object-oriented speak and for being a backboard to bouncing ideas off, Chris Flatters for helping me find a path through the C++ forest, Craig Walker, Anton Zensus, Phil Diamond, Huib van Langevelde, and Tony Beasley for testing and answering my endless VLB questions, Rick Perley for letting me do the project in the first place, Tim Cornwell and Gustaaf van Moorsel for keeping the project going, and my wife, Lisa, for putting up with me.

References: