Advanced Programming Language Design [Paperback]

Raphael Finkel (Author)

Book Description

ISBN-10: 0805311912 | ISBN-13: 978-0805311914 | Publication Date: December 31, 1995 | Edition: 1

This accessible new volume examines and evaluates the principles of programming languages from both their common and language-specific elements. Each chapter is devoted to a particular programming language issue. These issues are illustrated with an example from one of the many programming languages used today.

Editorial Reviews

From the Inside Flap

This book stems in part from courses taught at the University of Kentucky and at the University of Wisconsin-Madison on programming language design. There are many good books that deal with the subject at an undergraduate level, but there are few that are suitable for a one semester graduate-level course. This book is my attempt to fill that gap.

The goal of this course, and hence of this book, is to expose first-year graduate students to a wide range of programming language paradigms and issues, so that they can understand the literature on programming languages and even conduct research in this field. It should improve the students' appreciation of the art of designing programming languages and, to a limited degree, their skill in programming.

This book does not focus on any one language, or even on a few languages; it mentions, at least in passing, over seventy languages, including well-known ones (Algol, Pascal, C, C++, LISP, Ada, FORTRAN), important but less known ones (ML, SR, Modula-3, SNOBOL), significant research languages (CLU, Alphard, Linda), and little-known languages with important concepts (Io, Go .. del). Several languages are discussed in some depth, primarily to reinforce particular programming paradigms. ML and LISP demonstrate functional programming, Smalltalk and C++ demonstrate object-oriented programming, and Prolog demonstrates logic programming.

Students are expected to have taken an undergraduate course in programming languages before using this book. The first chapter includes a review of much of the material on imperative programming languages that would be covered in such a course. This review makes the book self-contained, and also makes it accessible to advanced undergraduate students.

Most textbooks on programming languages cover the well-trodden areas of the field. In contrast, this book tries to go beyond the standard territory, making brief forays into regions that are under current research or that have been proposed and even rejected in the past. There are many fascinating constructs that appear in very few, if any, production programming languages. Some (like power loops) should most likely not be included in a programming language. Others (like Io continuations) are so strange that it is not clear how to program with them. Some (APL arrays) show alternative ways to structure languages. These unusual ideas are important even though they do not pass the test of current usage, because they elucidate important aspects of programming language design, and they allow students to evaluate novel concepts.

Certain themes flow through the entire book. One is the interplay between what can be done at compile time and what must be deferred to runtime. Actions performed at compile time make for more efficient and less error-prone execution. Decisions deferred until runtime lead to greater flexibility. Another theme is how patterns and pattern matching play a large role in many ways in programming languages. Pattern matching is immediately important for string manipulation, but it is also critical in steering logic programming, helpful for extracting data from structures in ML, and for associating caller and callee in CSP. A third theme is the quest for uniformity. It is very much like the mathematical urge to generalize. It can be seen in polymorphism, which generalizes the concept of type, and in overloading, which begins by unifying operators and functions and then unifies disparate functions under one roof. It can be seen in the homoiconic forms of LISP, in which program and data are both presented in the same uniform way.

Two organizing principles suggest themselves for a book on programming languages. The first is to deal separately with such issues as syntax, types, encapsulation, parallelism, object-oriented programming, pattern matching, dataflow, and so forth. Each section would introduce examples from all relevant languages. The other potential organizing principle is to present individual languages, more or less in full, and then to derive principles from them.

This book steers a middle course. I have divided it into chapters, each of which deals primarily with one of the subjects mentioned above. Most chapters include an extended example from a particular language to set the stage. This section may introduce language-specific features not directly relevant to the subject of the chapter. The chapter then introduces related features from other languages.

Because this book covers both central and unusual topics, the instructor of a course using the book should pick and choose whatever topics are of personal interest. In general, the latter parts of chapters delve into stranger and more novel variants of material presented earlier. The book is intended for a one semester course, but it is about 30 percent too long to cover fully in one semester. It is not necessary to cover every chapter, nor to cover every section of a chapter. Only Chapter 1 and the first seven sections of Chapter 3 are critical for understanding the other chapters. Some instructors will want to cover Chapter 4 before the discussion of ML in Chapter 3. Many instructors will decide to omit dataflow (Chapter 6). Others will wish to omit denotational semantics (in Chapter 10).

I have not described complete languages, and I may have failed to mention your favorite language. I have selected representative programming languages that display particular programming paradigms or language features clearly. These languages are not all generally available or even widely known. The appendix lists all the languages I have mentioned and gives you some pointers to the literature and to implementations and documentation available on the Internet through anonymous ftp (file-transfer protocol).

The exercises at the end of each chapter serve two purposes. First, they allow students to test their understanding of the subjects presented in the text by working exercises directly related to the material. More importantly, they push students beyond the confines of the material presented to consider new situations and to evaluate new proposals. Subjects that are only hinted at in the text are developed more thoroughly in this latter type of exercise.

In order to create an appearance of uniformity, I have chosen to modify the syntax of presented languages (in cases where the syntax is not the crucial issue), so that language-specific syntax does not obscure the other points that I am trying to make. For examples that do not depend on any particular language, I have invented what I hope will be clear notation. It is derived largely from Ada and some of its predecessors. This notation allows me to standardize the syntactic form of language, so that the syntax does not obscure the subject at hand. It is largely irrelevant whether a particular language uses begin and end or { and } . On the other hand, in those cases where I delve deeply into a language in current use (like ML, LISP, Prolog, Smalltalk, and C++), I have preserved the actual language. Where reserved words appear, I have placed them in bold monospace. Other program excerpts are in monospace font. I have also numbered examples so that instructors can refer to parts of them by line number. Each technical term that is introduced in the text is printed in boldface the first time it appears. All boldface entries are collected and defined in the glossary. I have tried to use a consistent nomenclature throughout the book.

In order to relieve the formality common in textbooks, I have chosen to write this book as a conversation between me, in the first singular person, and you, in the second person. When I say we, I mean you and me together. I hope you don't mind.

Several supplemental items are available to assist the instructor in using this text. Answers to the exercises are available from the publisher (ISBN: 0-201-49835-9) in a disk-based format. The figures from the text (in Adobe Acrobat format), an Adobe Acrobat reader, and the entire text of this book are available from the following site:

ftp.aw/cseng/authors/finkel/apld

Please check the readme file for updates and changes. The complete text of this book is intended for on-screen viewing free of charge; use of this material in any other format is subject to a fee.

There are other good books on programming language design. I can particularly recommend the text by Pratt Pratt 96 for elementary material and the text by Louden Louden 93 for advanced material. Other good books include those by Sebesta Sebesta 93 and Sethi Sethi 89. I owe a debt of gratitude to the many people who helped me write this book. Much of the underlying text is modified from course notes written by Charles N. Fischer of the University of Wisconsin-Madison. Students in my classes have submitted papers which I have used in preparing examples and text; these include the following:

C++ Feng Luo 1992 Mike Rogers 1992

Dataflow Chinya Ravishankar 1981

Godel James Gary 1992

Lynx Michael Scott 1985

Mathematics languages Mary Sue Powers 1994

Miranda Manish Gupta 1992

PostChinya Ravishankar 1981 Rao Surapaneni 1992

CLPWilliam Ralenkotter 1994

RussellRick Simkin 1981K. Lakshman 1992 Manish Gupta 1992

Smalltalk/C++Jonathan Edwards 1992

Jonathan Edwards read an early draft of the text carefully and made many helpful suggestions. Michael Scott assisted me in improving Chapter 7 on concurrency. Arcot Rajasekar provided important feedback on Chapter 8 on logic programming. My editor, J. Carter Shanklin, and the reviewers he selected, made a world of difference in the presentation and coverage of the book. These reviewers were David Stotts (University of North Carolina at Chapel Hill), Spiro Michaylov (Ohio State University), Michael G. Murphy (Southern College of Technology), Barbara Ann Greim (University of North Carolina at Wilmington), Charles Elkan (University of California, San Diego), Henry Ruston (Polytechnic University), and L. David Umbaugh (University of Texas at Arlington). The University of Kentucky provided sabbatical funding to allow me to pursue this project, and Metropolitan College in Kuala Lumpur, Malaysia, provided computer facilities that allowed me to work on it. This book was prepared on the Linux version of the Unix operating system. Linux is the result of work by Linus Torvalds and countless others, primarily at the Free Software Foundation, who have provided an immense suite of programs I have used, including text editors, document formatters and previewers, spelling checkers, and revision control packages. I would have been lost without them. Finally, I would like to thank my wife, Beth L. Goldstein, for her support and patience, and my daughter, Penina, and son, Asher, for being wonderful.

Raphael A. Finkel
University of Kentucky 0805311912P04062001

From the Back Cover

Written for the student or professional interested in programming language design, this new book examines a wide range of programming language paradigms and issues. Author Raphael Finkel, University of Kentucky, intersperses the discussion of these models with in-depth coverage of the key languages to reinforce them. Finkel begins his presentation with control structures and types, and then introduces the reader to seven programming paradigms: imperative, functional, object-oriented, dataflow, concurrent, logic, and aggregate-based. He concludes the book with a discussion of formal syntax and semantics.

The author integrates this range of material by developing several themes, including the interplay between what can be done at compile time and what must be deferred to runtime; how patterns and pattern matching play a large role in programming languages; and the quest for uniformity seen in polymorphism. Written in a conversational style, this book challenges and encourages readers to launch into their own research in the field.

Features

• Starts with a review of imperative programming languages.
• Illustrates and reinforces key programming paradigms with in-depth discussions of several languages:
• functional: ML, Lisp
• object-oriented: Simula, Smalltalk, C++
• dataflow: Val
• concurrent: CSP, Linda, SR
• logic: Prolog, Goedel
• aggregate-based: SNOBOL, Icon, APL, SQL, Mathematica
• Refers to over 70 languages, including well-known ones (Algol, Pascal, C, C++, LISP, Ada, FORTRAN); important but lesser-known ones (ML, SR, Modula-3, SNOBOL); significant research languages (CLU, Alphard, Linda); and little-known languages with important concepts (Io, CLP(R), Goedel).
• Moves beyond traditional material by challenging readers with more unusual constructs such as power loops, Io continuations, CLU iterators, and APL array manipulation.
• Contains an appendix listing further reading and source locations for language implementations and documentation.
• Includes review and challenge exercises in each chapter.

0805311912B04062001

See all Editorial Reviews

Product Details

• Paperback: 512 pages
• Publisher: Addison Wesley; 1 edition (December 31, 1995)
• Language: English
• ISBN-10: 0805311912
• ISBN-13: 978-0805311914
• Product Dimensions: 9.4 x 7.6 x 1 inches
• Shipping Weight: 1.9 pounds (View shipping rates and policies)
• Average Customer Review: 3.0 out of 5 stars  See all reviews (4 customer reviews)
• Amazon Best Sellers Rank: #1,402,911 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

1 of 1 people found the following review helpful:

5.0 out of 5 stars Excellent book, October 9, 2004

By 

Derek W. Williams (Lexington, KY USA) - See all my reviews
(REAL NAME)   

This review is from: Advanced Programming Language Design (Paperback)

This is a wonderful book that covers tons of languages, including several that are far from the mainstream. The author demonstrates a very strong knowledge of all concepts discussed in the book, and wording is very clear and concise. This is an excellent book for undergradute or graduate courses on programming languages.

3 of 4 people found the following review helpful:

1.0 out of 5 stars Excruciating to get through!, June 2, 2009

By 

J. Carnie Littlefield (Austin, TX) - See all my reviews
(REAL NAME)   

This review is from: Advanced Programming Language Design (Paperback)

This book is awful! There is nothing positive I can say about it. It is also thirteen years old and very out of date.

The book purports to be "modern," but among the more than seventy languages Finkel discusses are many that have fallen into disuse, or have never been implemented, or were only implemented as academic curiosities. At the end of Chapter 1 on Page 28 he says, "The language concepts introduced here are in some sense classical Algol-like structures. They are developed in various directions in the following chapters ..." Much of the book emphasizes non-imperative languages. That may be fine for those in an academic environment looking to do research, but be aware that it has little to do with what most programmers do for a living. Besides Algol, most of the book is based on Ada, APL, CLU, Fortran, LISP, ML, Modula, Pascal, Prolog, Smalltalk, Tcl, and about sixty other mostly obscure languages. He talks a lot about Pascal and ML as if they were recent cutting-edge languages. He does talk quite a bit about C++, but never mentions Java.

The book reads like a dissertation or collection of journal articles sometimes referring to topics that have not yet been covered or that will never be covered in the book. If you are a self-motivated learner, you will have difficulty, as I did, getting through Chapter 1, that supposedly reiterates what you should already know to prepare you for the rest of the book. Chapter 9 on aggregates, patterns, and database languages about which I consider myself knowledgeable, was rendered in such a confusing manner, that I could hardly make heads or tails of it. The author has little gift for teaching. He himself says on Page 114, "...an elegant program is one that is readable the first time by a novice, not one that plays unexpected tricks." None of the hundreds of code samples and snippets are "elegant," and many are indecipherable even after reading four or five times. His writing style, while attempting to be conversational, jumps to conclusions without the intervening logic. For example, he mentions "cons" on Page 87, "cdr" on Page 124, and "car" on Page 127. Then, on Page 277 he says, "Predicates specifying car and cdr are easy. ..." and gives the following two formulas without explaining what they mean.
car(cons(H,T),T) :- isList(T) .
cdr(cons(H,T),T) :- isList(T) .

The syntax Finkel uses for example code throughout the book is inconsistent. On Page xiii he says, "I have invented what I hope will be clear notation. It is derived largely from Ada and some of its predecessors." However, he never describes his syntax and semantics, so it appears to be a hodge-podge that is not clear at all. Not all terms that he uses are in the glossary or the index, and often terms are used without prior explanation. Symbols are not in any table or appendix; there is no guide to meaning or pronunciation, and none are listed in the index.

He uses the same syntax at different times with different meanings or different syntax at other times for the same meaning. Following are some examples: Type identifiers are ordinary identifiers prefixed by one or more tic marks (single quotes). Sometimes he uses the familiar C-language asterisk * prefix dereferencing operator, while at other times he uses the caret ^ postfix dereferencing operator. Sometimes the caret ^ is a binary exponentiation operator, but sometimes stands alone at the head of a statement. An asterisk * can be a type constructor, a binary multiplication operator, or it can mean "choose a type from each operand." Comma can be a list separator or a tuple constructor. Tilde ~ can be a deconstructor prefix or a binary operator. Null and nil have different meanings depending on context. There are a lot of single colons, double colons, hyphens, and equal signs in various combinations ( :, :-, :=, =:, ::, ::=, ::==) as well as various kinds of arrows (<, >, ->, <-, =>, =<, <=, >=) and parentheses(), square brackets[], and curly braces{} with various levels of nesting. Many have very different meanings than what you would assume. There are Greek letters, alpha, beta, epsilon, lambda (for lambda calculus), and nu. There are set theory symbols such as the upside-down capitals A, T, U, and V as well as circles with plus or x inside.

There is no consolidated syntax reference. Some terms or symbols have definitions or explanations embedded in and scattered throughout the 420 pages of dense text. Many are introduced casually in context with the assumption that the reader is already familiar with them or can deduce their meaning.

Don't buy this book! Instead buy one of the books by A. B. Webber, R. W. Sebesta, M. L. Scott, or F. Turbak et al.

1.0 out of 5 stars Poorly written and unhelpful, August 29, 2010

By 

E - See all my reviews

Amazon Verified Purchase

This review is from: Advanced Programming Language Design (Paperback)

Words cannot describe how awful the writing is in this book. Dense language is packed into poorly organized paragraphs; ideas are explained either in too much (overwhelmingly so) detail, or barely explained at all, and then followed up by other densely written paragraphs, which suppose that Finkel did an adequate job explaining, well, anything at all.

This is either the work of a savant, or a child - copying formal definitions of programming language design ideas out of the abstracts of research papers with the density of a neutron star.

My personal opinion? Finkel is able to get away with it because he is writing for an industry where good writing is seldom found. It's a good thing my class is using a different book... oh wait.

To end off, here's a paragraph I'll type out for you:

"The situation becomes surprisingly complex when procedures (and labels) are passed as parameters. They carry with them their nonlocal referencing environment, so that when they are invoked, they may access nonlocal variables that are otherwise inaccessible in the program. A procedure in combination with its referencing environment is called a closure."

That's the best paragraph I've read yet.