From line-editor to IDE

EXE Magazine, February 1999

I never used a goose quill and ink to write on parchment. I started using a microcomputer in my teens. You can work out how old I am! Until then most of my writing was done using any old pen or pencil on a sheet of paper. I never liked it. My handwriting is hard to read and I just don't enjoy the physical act of moving a pen on paper. It's clumsy. Since my encounter with a microcomputer most of my writing has been done in a text editor or wordprocessor of some sort. Ironically, I've started to ‘handwrite’ more since I bought a Palm III. I often ‘write’ email messages on it when I'm out and about or just sitting comfortably at home. Okay, it's Graffiti, not plain handwriting. I've not yet reached the stage of dictating to my PC...

All these different input/recording methods and the associated technologies probably have an impact on what is written. With pen and paper, one tends to try to avoid having to correct mistakes so one spends more time thinking before committing to paper. When using a computer, it's so easy to write sloppily and correct afterwards that one tends just to fire off shorter sentences with typo and grammatical errors and then make a second pass to correct most of them. Since screen technology only allows for a limited number of lines to be displayed, text modifications tend to be relatively local. When an article or a book is badly written or subbed, the impact of the wordprocessor is often noticeable: correct spelling but wrong word, bits of sentences that have obviously been moved around. When a text has been worked on purely on screen, it's not uncommon to have very similar paragraphs far apart, ie they were not visible on the same screen.

Writing technology has evolved tremendously through the years, from engraved tablets and Egyptian papyrus to the latest rev of everyone's favourite wordprocessor. (Such an evolution on such a timescale is not surprising. It leaves humans time to adapt and exploit the technologies at their best.) The shorter timespan covered in the first paragraph is just twenty years. Enough time to get familiar with one technology, only for it then to be displaced by the next one.

Let's turn to the art of writing computer programs, ie software. I'll put aside all the different language evolutions, new microprocessors, peripherals, and so on. Let's just concentrate on the transition from concepts held in the head to a written representation from which executable code can be generated more or less automatically. Back to when I was a teenager. At that time, most languages had their very own editors, all with their own conventions. Assembly was sometimes written in assembly and sometimes directly in hexadecimal. Basic had its line numbers. Writing code for UCSD Pascal was a very different activity than for Turbo Pascal. Interpreted languages such as Lisp or Smalltalk even had their own environment on some specialised hardware. The glorious days of the Lisp Machine. Then I started to use independent editors. Programs like ed or sed, where code was entered line-by-line, and commands were issued to modify the code entered. Then came the luxury of full-screen editing with tools such as Emacs. Eventually the days of the IDE started. Along the line came pretty-printers, grep, coloured syntax, code and class completion...

This is not a definite chronology, I continued to use line-editors at the same time I was using Emacs. When doing all the editing locally the speed impact was negligible, but when editing from a VT terminal connected to a remote computer via a 1200 bps connection, having a remote echo for each and every character was painfully slow. Now, unless you have the latest fastest meanest hardware, the all-singing and dancing IDEs can feel as painfully slow.

The impact of the evolution of code writing technology is amazingly similar to the impact of the evolution of prose writing technology. In the early days, I was thinking much more about the code I was writing before I actually entered it, I even resorted to handwriting some bits on scrap listings. This resulted, consciously or not, in compact code. Short variable names and tight algorithms. With the advent of more visual and interactive environments (and a better knowledge of computer science), I started to use more meaningful variable names and even included some comments. However, the code is not only more verbose but is probably less refined. Time that was spent purely on the functional aspect is now spent on the look – ie readability.

If you have kept listings of software you wrote many years ago, try to find them and compare the style with what you write today. The impact of the editing technology is rarely noticed (unless something goes wrong, like the editor crashing) but it does influence the way we write software.

David Mery

(C)1999, Centaur Communications Ltd. Reproduced with the kind permission of EXE Magazine.