Recommended Reading: ``The Craft of Text Editing'' by Craig Finseth

As this  is the first  Recommended Reading entry,  I will explain that  I will periodically,  on the
fifteenth of  each month,  be recommending books  with reviews  thereof.  There will  be a  focus on
programming  or  technology-related  material  that  is nonfiction  and  freely  available,  gratis.


The book being recommended is ``The Craft of Text Editing'' by Craig Finseth.  It may be found here:
http://www.finseth.com/craft

This is a pleasant read for anyone interested  in or wanting to expand his knowledge of conventional
text editing.  The book is based on the author's bachelor thesis examining the underlying principles
of text editors at the  time.  The book was later expanded after eleven  years to cover advances and
other changes made in the interim.

The book pays special  attention to Emacs-style editors and the choices made  in their design, but a
majority of the work applies to all text editors and several different methods of implementation are
discussed for  each topic.  Each  unit of the  text features questions  that will help  some readers
acknowledge understanding or the lack thereof.

The book begins  with a simple and incomplete example  of part of a text editor.   The first chapter
discusses the users of text editors and the  various considerations that must be taken into account;
of particular interest are the constraints dictated by the human body and how to take disabled users
into account.  Building  from the last, the  second chapter discusses the various  types of hardware
available  to the  users  and  the considerations  for  all  of these;  this  chapter  is rife  with
descriptions  of problems  and solutions  that no  longer come  into question,  but nonetheless  are
extremely interesting for the curious reader.   Implementation languages and their various tradeoffs
and advantages are the  topic of the third chapter; the wide selection  of languages discussed makes
for a good list to pick languages to learn from, in some cases.

The  fourth chapter  concerns  itself with  various  common  models for  representing  text and  the
repercussions  of each;  the  various models  range  from the  most basic  editors  to complex  word
processors and includes models no longer in common use.  File formats and conventions across various
systems is the focus of chapter five, including newline conventions, formatted text information, and
line handling; again, this  chapter features a great deal of material no  longer relevant, but which
should easily interest anyone at all curious.   Chapter six discusses various ways of decomposing an
editor into  subcomponents, going  into great detail  concerning the data  structures used;  at this
point in the book, it is most certainly the most detailed and technical chapter.

Chapter seven  concerns redisplay; it  is an advanced chapter  on terminal redisplay  algorithms and
techniques.  Chapter eight concerns the main loop of the editor from the perspective of the user; it
is  rather  comprehensive in  describing  common  facilities at  the  command  level.  Chapter  nine
discusses the design of a  command set.  Chapter ten is a brief chapter  recounting much of the book
with some additional material related more closely to Emacs than more plain text editing.

The book makes rather heavy use of the C  language for its program examples and whatnot.  There is a
brief introduction  to C in  the first appendix.   The book makes for  an exhilerating look  back on
computing and  the considerations that were  taken into account historically.  The bibliography also
makes for good reading material for those wanting to delve deeper into the topic.

If you  ever want to implement  your own text editor,  this book is worth  taking a look at;  it's a
short and easy read, as well.
.