The Dylan Reference Manual: The Definitive Guide to the New Object-Oriented Dynamic Language (Apple Press series) [Paperback]

Andrew Shalit (Author)

Book Description

Series: Apple Press series | Publication Date: September 11, 1996

A new generation of innovative software -- software that can be built quickly and enhanced over time -- requires sophisticated programming tools. Dylan, the latest object-oriented dynamic language, means innovation. Dylan includes garbage collection, type-safety, error recovery, a module system and programmer control over runtime extensibility of programs. The language is object-oriented and dynamic -- like Java -- yet it also supports static compilation as efficiently as C++. The Dylan Reference Manual is the first complete reference to present all aspects of this unique language. It provides conceptual chapters describing the overall structure and semantics of the language and gives the definition of every class, function, and syntactic construct of the language in detail. You can also examine the BNF for Dylan's syntax and quickly look up new terms in the glossary.Discover how Dylan: *protects programmers from low-level implementation details while still producing efficient executables *thoroughly integrates object model, syntax, and control structures *avoids multiple ways of doing the same thing by using simple, powerful constructs to achieve several ends *uses multi-method dispatch to make programs easier to write, easier to understand, and easier to extend Whether you are a current user of Dylan or are interested in object-oriented programming and modern programming techniques, The Dylan Reference Manual will help you realize the full potential of the object-oriented dynamic revolution. 0201442116B04062001

Editorial Reviews

From the Back Cover

The Dylan Reference Manual is the first complete reference to present all aspects of this unique language. It provides conceptual chapters describing the overall structure and semantics of the language and gives the definition of every class, function, and syntactic construct of the language in detail. You can also examine the BNF for Dylan's syntax and quickly look up new terms in the glossary.

Discover how Dylan: * protects programmers from low-level implementation details while still producing efficient executables

* thoroughly integrates object model, syntax, and control structures

* avoids multiple ways of doing the same thing by using simple, powerful constructs to achieve several ends

* uses multi-method dispatch to make programs easier to write, easier to understand, and easier to extend

Whether you are a current user of Dylan or are interested in object-oriented programming and modern programming techniques, The Dylan Reference Manual will help you realize the full potential of the object-oriented dynamic revolution. 0201442116B04062001

About the Author

Andrew Shalit worked at Apple Computer, Inc., where he led the Dylan language design effort. 0201442116AB04062001

See all Editorial Reviews

Product Details

• Paperback: 469 pages
• Publisher: Addison Wesley Publishing Company; 1st edition (September 11, 1996)
• Language: English
• ISBN-10: 0201442116
• ISBN-13: 978-0201442113
• Product Dimensions: 9.2 x 7.4 x 1 inches
• Shipping Weight: 1.8 pounds
• Average Customer Review: 4.0 out of 5 stars  See all reviews (1 customer review)
• Amazon Best Sellers Rank: #3,890,454 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

10 of 10 people found the following review helpful:

4.0 out of 5 stars Indespensible; but not always an easy reference to read, July 29, 2000

By 

Douglas M. Auclair (Springfield, VA USA) - See all my reviews
(REAL NAME)   

This review is from: The Dylan Reference Manual: The Definitive Guide to the New Object-Oriented Dynamic Language (Apple Press series) (Paperback)

Anyone who will create more than the most trivial program in Dylan must have this reference (hereinafter referred to as the DRM). The author and contributors have no want of status for the Dylan community: Andrew Shalit (principle inventor of the language), David Moon (a luminary in advanced OO research, one of the board members for the Common Lisp Object System specification), and Orca Starbuck (who helped write the first book on Java: _Hooked on Java_ (a delightful work)). They have produced an authoritative work. I will discuss what this book is not (very briefly), its organization, where it fails and where it succeeds.

This book is, rightfully, not an introduction to the language. Study, instead, _Dylan Programming_ by Feinberg, Keene, Mathews, and Withington before you move onto this book.

The first 10 chapters are descriptive in nature. The organization goes from simple topics (program organization and program control flow, e.g. if statements) to more complex ones (conditions, collections, sealing, and macros). Then, chapter 11 and on are canonical reference material (the built-in (provided) classes, functions, macros and exported names).

This book is exhaustive, but it fails in two areas: choosing terseness at the expense of explanation, and assuming the whole is sufficiently described by its parts. First example (terseness), the reference section lists the (e.g.) functions, their inputs and outputs and has a brief description. Sometimes, these functions have an applicable example. Some of the advanced functions (such as mapping functions, iteration protocol functions, and higher-order functions) lack such examples, and I thirsted for some illumination by example, and, in fact, have avoided using some of the advanced Dylan functionality because I have not found suitable explanation. (A minor issue for C/C++/Java programmers: the DRM chooses a function signature familiar to the Functional programming community (e.g. Lisp), it will take some getting used to, as it is not as exacting with syntax as described in your reference materials). Second example (terseness), chapter 3 (program structure) gives a total of a scant 6 pages to modules and to libraries. I went to that chapter looking for how to build executables and libraries from multiple source (e.g.) files, and, at the same time, how to protect names in my code from clashing with names in the predefined Dylan system. Modules and libraries address both concerns, but after I read that chapter, I was still lacking the concepts and techniques to deliver my system. Third example (sum is not parts alone), I then turned to chapter 12 (built-in macros) and walked through the definitions of defining libraries and modules. The explanation of each element of the module and library definitions was complete, but I still failed to grasp how (particularly) modules and libraries work hand-in-hand to create advanced namespaces that put other, more popular, languages' namespace systems to shame. Overall, the DRM is a thorough, researched document, but these two areas of terseness and lacking comprehension of parts make reading it sometimes difficult.

Even though the DRM has its faults, it succeeds wonderfully as a reference manual for Dylan, as well as an explanation of the marriage of Functional and Object-oriented programming. Every day that I build systems in Dylan, I consult the DRM. And, every day that I consult the DRM, I get answers that help me toward delivering a finished product. Not only that, the DRM also provides novel problem-solving approaches. I often consult the DRM to solve one issue and start reading about techniques on three other implementation strategies and techniques.

A complement to this book is that I have worn it out because of daily (sometimes hourly) consultation. Many people have shown their regret of purchases by the uncracked book bindings. If you build systems in Dylan, you cannot regret this purchase.