The Philosophical Programmer: Reflections On The Moth In The Machine (Signed By The Author)

A work for programmers and the computer illiterate alike first teaches the reader about the general nature of programming before tackling such philosophical and ethical issues as privacy and piracy. 20,000 first printing.

Defeating the moth in the machine?the origin of the term "computer bug"?is a challenge to which longtime programmer Kohanski has dedicated his life. But before he examines programming kinks here, he must lay the groundwork by explaining what a programmer's tasks are and the tools they use to accomplish them. In crisp prose, he offers up a programming and computer primer, expositing hardware systems, tracing the evolution of programming languages and recalling how memory works. He defines "assembler" and "algorithm" and shows us how programmers interface with each. Kohanski organizes his book in a highly structured way, with general points at the beginning of chapters that yield to specific examples. By turns technical and accessible, practical and philosophical, the book lives up to the dual billing of its title. Only at the end of this short, sweeping tract, when Kohanski makes the case that "there is no going back to a more innocent time," does it devolve into boilerplate. Though the book is at its best when delicately using metaphor to explain programming (he compares computer memory to human consciousness) and when making its broader points, readers wanting a factual introduction to the everyday tasks of programmers?or users wanting to better grasp the workings of their PCs?will not be disappointed.
Copyright 1998 Reed Business Information, Inc.

A lucid primer on the philosophy of computer programming from a systems engineer in San Francisco. With the phrase ``moth in the machine'' Kohanski refers to an engineering anomaly experienced on a pioneering wartime computer, the Mark I. Circuitry began behaving erratically; after running exhaustive tests, the engineers discovered why: a moth had crawled into a relay, preventing contact. Thus was born the bug in the computer and the necessity to debug, which, Kohanski points out, programmers spend more time doing than they spend programming. Juxtaposing the human capacity for ambivalence with the machine's complete incapacity for it, Kohanski argues for ever more intuitive programs: ones that will announce ``radiation overdose,'' for instance, rather than ``Malfunction 54.'' (Kohanski describes an actual case in which several patients were killed because the computer operator didnt know what ``Malfunction 54'' meant.) Kohanski explains clearly the differences between analog and digital computers by using cuckoo clocks (primitive analog computers) as a metaphor; explains the binary code and demonstrates how memory accretes in machines; and is at pains to explain the necessity for precise, elegant, and even esthetically pleasing programming. He then discusses the moths in the machine that challenge programmers: ever more complex programs, demanding an almost inhuman precision; the failure of programmers to translate their own mathematical shorthand into real-world terms (``Malfunction 54''); and, perhaps most important, the failure to design programs that really do the job, that wont create more problems than they solve. The greatest challenge to programmers, he says, lies in unlocking their imaginations. Good reading for anyone interested in how programs come into existence, and particularly good reading for those thinking of entering the programming profession. -- Copyright ©1998, Kirkus Associates, LP. All rights reserved.

This enjoyable and easy-to-comprehend primer is concerned with the whats and whys behind programming rather than the hows. Because Kohanski steers clear of any particular programming language, this work can be used as a starting point for understanding any of today's programming tools. Although he does briefly delve into some of the mathematical fundamentals of the subject, he keeps the writing light and interspersed with enough interesting anecdotes (e.g., the term debugging comes from an incident in 1944 when the creators of the Mark 1 computer fixed a malfunction after discovering a moth trapped in the electronics) to keep computer neophytes interested. Along with basic information on the ideas and processes behind programming, Kohanski provides refreshingly simple explanations on subjects such as fuzzy logic. He portrays his subject matter as an art form in logic--one that should be pursued with a sense of ethics and responsibility (a message that has been glossed over by most similar books). This well-recommended work also includes a handy glossary and bibliography. Eric Robbins