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.

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.