FLAP(ID:8225/)for FLores Assembly Program Half parody/half improvement of FAP by Ivan Flores for the book "The Logic of Computer Arithmetic" 1961 and other subsequent books References: The sequence of chapter topics, with the possible exception of the chapter on graph theory, seems appropriate for self-study in machine language programming. The conversational style used in this book facilitates its use by a student. However, the chapters have so many sections, subsections and bold face titles without indices that a student could be easily confused about the goals of each chapter and might very easily lose sight of the forest while wandering through the many trees. The author includes many diagrams which the reviewer found to be mostly clear and helpful. Most chapters have exercises which are primarily intended for the novice. The book opens with a chapter which briefly covers the topics of machine organization, memory, control, and instruction sequencing. These concepts are illustrated for a hypothetical computer which has an assembly program called FLAP (FLores Assembly Program). FLAP is used throughout the book for illustrative purposes. A chapter on graph theory follows which, in the reviewer's opinion, should at most have been an appendix in a book of this nature. Other chapters refer to some of the terms introduced in this chapter, but the novice might well appreciate a less formal approach, especially since most of the book is written in a highly informal and conversational manner. The reviewer was advised that some errors and nonstandard terms and definitions (from the graph-theoretic standpoint) appear in this chapter. In the chapters that follow, the author presents program loops, subroutines, storage and programming techniques for arrays' lists, and tables. Most of the essential concepts appear in these chapters. Attention to detail and numerous examples provide adequate technical coverage although the organization of the material seems poor at times. A chapter on input/output sets the general framework for I/O commands and information transmission. The bulk of the chapter is then spent describing characteristics of I/O devices and their controllers, with many examples from commercially available equipment. The discussion of interrupt processing is quite abbreviated, it seems to be handled as a special case of I/O interrupts. Much more emphasis could appropriately have been given to this topic. The book closes with two chapters on the general topic of computer software. They give a brief overview of many computer software systems, including job supervisors, translators, loaders, IOCS type systems and interpreters. These two chapters might well have been the opening sections of [ 3 ] . To summarize, the overall progression of the topics in the book (except for graph theory) is adequate. There is much attention to detail which (perhaps because of chapter organization) often obscures the general goals of individual chapters. Exercises and examples for the beginner are numerous. Supervision and organization would be required if this book were to be used as a text. The conversational style of the earlier works is continued. This informality makes the book easy to read, and - tends to hold the reader's interest. On the other hand, it encourages a lack of precision, and an occasional ignoring of some facts of life. For example, one of the justifications of the book (p. 80) is: "When you consider how much computer time is spent in translation (at least 1%) and what part the assembler presently plays in translation (99%) can you avoid the conclusion that it is vital?". While recognising the use of assemblers, this reviewer notes that a number of compilers go directly to machine language, and produce the assembly listing as an afterthought. In addition, one of the objectives of some present higher-level language design efforts is the elimination of assembly language as a suitable vehicle for the original generation of software. Even as well-entrenched a language as FORTRAN- has been used to write compilers and assemblers. On the other hand, a careful attempt has been made to distinguish what is being talked about at all times. The language of the assembly language introduced in the book (FLAP - - an acronym for FLores Assembly Program) is consistently printed in sans-serif font, while the names of processors are printed in a script font. This type distinction is carried on for certain other things, such as list pointers; it is a useful pedagogical tool, and removes an ambiguity which has tripped many students. The scope of this book, then, is the assembly processor considered in the environment of an IOSC system, an interrupt monitor, a loader, a job supervisor, and a library. It is a pleasure to see recognition of the environment in which both an assembler and the assembled programs exist considered as equally important with the assembler itself. Each of these facilities is documented, both with extensive text and with high-level flow- diagrams; the student can learn not only the content of an assembler, but somewhat of how to describe the content. Unfortunately, the references are scanty, and much of the material is presented as though there were only one way of doing a given task; even for an elementary text, this seems gross oversimplification. There are comments on other systems, but they are used to introduce features which are not further discussed. One of the systems so cited (SLEUTH II, for the UNIVAC 1107) is fundamentally different from the macro-expanding assembler covered by the book, but no mention is made of this. In summary, it appears that in a supervised course where the instructor could introduce the alternatives and broader point of view that are notably lacking, a use might be found for this book as a text in an elementary course on assemblers. There are numerous examples and exercises, and the level is consistently pitched to the novice. However, on the evidence of his other books, the author's bent is towards hardware, not software. The author begins by defining some notations which aid in a loose formalism of the topic, including data structures and operators. Then, after laying a brief framework for the implementations discussed in the following chapters, he discusses in detail a number of different algorithms for sorting, beginning with a simple selection method and growing in complexity to multi-list methods, tournament sorts, merges, and various tape and disk methods. At each stage, timing and storage analyses, flowcharts, and concise mathematical representations of the methods are given. This presentation is aimed at two segments of the industry: students (for which it would make a good semester course text) and implementers (for which it is a good reference guide). It might also be worthwhile reading for the users of sorting programs, although the formal tone of much of the book might be discouraging to many. There are a number of good, if fairly difficult, exercises which, with the cooperation of a good instructor, encourage the student to dig deeply into the subject. There are, as I mentioned before, some things to quibble with. There is no glossary of terms and notations (although the end papers have a glossary of symbols), nor a comprehensive bibliography (although one appendix does include a bibliography pertaining to Polyphase methods). There are some typographical errors of minor effect, as can be expected from any new text. The implementations are mostly coded for the 7090, which is a questionable choice pedagogically -- it's the only machine I know of with negative indexing -- and the author has discarded the cryptic but familiar FAP assembly language for one of his own design, FLAP, which is not much less cryptic but a great deal less familiar. Worst of all, the author assumes that the reader can refer to some of his earlier books for precise and intelligible definitions of the FLAP language, and/or to the 7090. In this regard the book is a long way from being self-contained. (Fortunately, the FLAP codes are not essential to understanding of the methods.) Finally, one notation is ill chosen: a lower-case script z and a lowercase script a, indistinguishable to anyone with trouble reading fine print, are used to represent, respectively, the maximum and minimum permissible contents of a field. |