Some GALAXY Secrets

Introduction

There are many ways to skin a cat ('never try to out-stubborn a cat'), Grannies can suck eggs, one personage's meat etc etc. [Puts on tin hat and flak jacket]
 
The stuff which follows refers mainly to experiences with the GALAXY programs (currently written in FORTRAN) although many principles are universal and nobody wants to become involved in nerdy discussions about what is the best computer language to use etc etc.

More rants and raves will be added as they crop up (they have - lots. Hack) (if time ever becomes available. Ed)

Contents List

• The Run-Time Library
• Portability
• Frequently-Used Features
• Fast Access, Big Data
• Graphics
• The Interface
• Documentation

The Run-Time Library

Portability

Tempus fugit, for better or for worse. One day code will need to be ported, which could be a euphemism for 'gloomily rewritten' or (probably) 'angrily junked'.

There are inevitably some system-dependent calls somewhere or other - for example, when accessing the command parameters of the program, spawning external processes, setting and executing condition handlers, accessing environment variables and so forth. By wrapping as many of these as possible up into a Run-Time Library, much grief can be avoided when migrating to another platform as the changes need only be put into the library. Similarly, actions involving the external file system (such as creating and/or opening files) and the flow of execution are also best done via library routines so that a change of platform (and the consequent changes in directory structure, default file attributes etc) can be taken account of in one go.
 
Unfortunately, there can be system-specific things which might supervene - for example, the DEC (FORTRAN) need for a condition handler to be set by calling LIB$ESTABLISH in the top segment of its scope; but these can be minimised. When dealing with multiple-platform FORTRAN code under VMS, one trick is to prefix the DEC-only lines of code with 'D' and the non-DEC lines with 'C' (comments are then prefixed with '!'), and to use the /D_LINES compiler option. When porting the code, strip off the 'C's (using a simple program) - if necessary, the 'C's can be followed by further switch character(s) for the porting program to act on. One soon gets used to the extraneous lines of code and it is very useful to see them all together when amending the program.

Frequently-Used Features

Until FORTRAN 90, there was, amazingly, no equivalent to LEN_TRIM! In GALAXY, a library of such everyday string, date, sorting, file handling, input/output, formatting and other routines has gradually been built up; it avoids endless repetition and the disasters which ensue when one's attention wanders when re-coding some humdrum action for the squillionth time when a simple CALL would have plugged in a finely-honed library routine to do it instead. Sentence ends.

A run-time library needs to be nurtured and becomes part of a lifetime's tool-kit (or baggage).

Fast Access, Big Data

Now that the brainspace of computers is becoming less miniscule (oh for a jar of nanobots and an empty beach), it is often possible to hold the entire contents of a file in array space, making random access and searching vastly more efficient than struggling with file transfers and perhaps system indexes etc. Unless the file is 'live' in the sense that multiple users need to write to different records at the same time (a nightmarish scenario - much grief comes from anticipating that the same record might need to be re-accessed before intervening housekeeping) one need not stop at importing it into array space.

Having read in the entire file (or as large a chunk at a time as possible), the data can be indexed and written out in a form that can be used much more quickly next time, having checked that the original has not been altered in the meantime. If it has, the user probably won't mind waiting (probably no longer than a 'regular load-and-reorganisation' would have taken anyway) whilst the fast-access file is 'quickly' rebuilt - provided, of course, that a polite explanation appears whilst that is happening. A couple of easy ways to improve the pace of life are (1) binary storage and (2) pre-sorting.
 

1. There are sound reasons for the original 'archive' file format to remain human-readable. However, binary (unformatted) data transfer is quicker than formatted and is the natural choice for the fast-access 'derivative' files.
2. If it is possible to sort keys or their combinations into some linear order (say, ascending or descending numerical or character), do it in core before writing the data out again (tag-arrays are fine when there are multiple keys, or the rearrangement of a large database becomes silly). Knowing that the keys are in order, they can then be Fibonacci-searched (look halfway; is it above or below? go halfway in that direction and ask again; etc).
 
This stuff can make a tremendous difference, really!

Graphics

In the Bad Old Days when Mainframes were Slow and Terminal Connexions were Slower, it was very depressing when the plotter biro ran dry or the paper was chewed up. Consequently, that blow-your-month's-core-time-budget marathon program that calculated where all the pointillisms had to appear (after queueing up to run in the small hours of the morning) was best advised to put its thoughts into a 'graphics metafile' so that one could go over to the Computer Centre to look at the picture on one of those new-fangled graphics terminals whilst waiting for the same plot to appear (or not) in a day or so when it had finally reached the top of the plotter queue. Graphics metafiles were all very well; but some of them were huge and blew away one's filestore quota.

Consequently, a compact (binary) format was devised which is in use to this day and, under GALAXY, most graphics is still a two-step process: there is a universal Graphics Library to which programs are linked; when the program is run, it creates a compact metafile which is then plotted/printed, or viewed on the screen, by issuing a second command which typically generates a huge tranche of PostScript and sends it to the laser printer, or whatever.

Nowadays, the advantages and disadvantages of having the generating program send graphics to the printer immediately or instead to store its output in a file until deliberately printed by the user have almost converged. However, in the interests of forest management, it is usually preferable to give yourself a moment's pause to ask 'do I really need to print this, or am I just after something else that comes out of the program?' before wasting yet another fractional tree.

Some other advantages of the two-step process include being able to store plots electronically in compact form and, when a sensational new output device comes along, it being unnecessary to re-link (or, worse, to alter) and attempt to re-run all those old programs - the new driver is just added to the universal display/plotting/printing program.

The Interface

(in preparation. Hack) (they always are. Ed)

Documentation

Groan! 'Things are only documented when out of date'. Thank goodness for 'nets and hypertext, which almost makes it fun to outbleaurg (if not instuuf) such thingies. At the cutting edge of research, one just needs to leave a few hints for the next runner to pick up, screw up and throw away. It's harder on those who have to run (or, most unspeakably horrendous of all, alter) someone else's programs - possibly even operating outside their fields of expertise.

From a hacker's perspective, style prejudices apart, one is usually hugely relieved when an alien program can be compiled and then works correctly. Looking at samples that have produced the 'Thank God' factor in the past, such programs seem to have in common:
 

• Avoidance of machine-dependent features
• Programming tricks that don't step outside language definition
• Simple basic documentation, perhaps with sample input and output
• A few useful one-line comments about purpose, inputs, outputs, devices etc and nothing more
 
From a user's perspective, one requires (possibly amongst other things):
 
• A program that works correctly
• Ease of use
• Simple comprehensive documentation, with a few examples
• Help if/when the wheels come off
 
(finish this. Ed) (in a nutshell. Hack)

[Return to Hackers' Corner]

[End of document, updated to 17 March 1997]