Lingo in a Nutshell

December 3, 1998
by Zac Belado

Lingo in a Nutshell

Writing reviews is often an exercise in extremes. Sometimes you are offered the chance to pass judgement on a product that is of such little merit that even writing about it is painful. And then there are those rare gems that are polished to perfection. In both cases the act of preparing a review is very difficult, as it is hard to come up with anything more than "Buy it now" or "Never buy it!".

Thankfully "Lingo in a Nutshell" by Bruce Epstein (and published by the fine folks at O'Reilly Books) is a product which makes reviewing it difficult for all the best reasons.

The simplest form of this review is that you absolutely must buy this book. No matter what your experience level, this book is one that you will not only find yourself frequently using as a reference but also as a guide to exploring those parts of Lingo that you may not be familiar with.

About Lingo in a Nutshell

If you're familiar with the Nutshell series by O'Reilly then you might be in for a suprise when you first browse through Lingo in a Nutshell (hereafter referred to as LiaN).

Unlike other books in the series, such as UNIX in a Nutshell and Windows NT in a Nutshell (almost an oxymoron when you think about it), LiaN is not only a concise Lingo reference, but it is also a guided tour through the ins and outs of Lingo programming. Each of the 19 chapters (22 if you count those available from Bruce's website http://www.zeusprod.com/nutshell/ ) introduces and discusses a particular aspect of Lingo with meaningful examples, comments and warnings about idiosyncrasies or potential pitfalls.

There really isn't a single book currently on the market that approaches the depth of content in LiaN. If you've been disturbed by the amount of quality, technical information available in most other Director books then fear not. LiaN is most assuredly a book for Lingo geeks or Lingo geek wannabes.

And being that it is part of the Nutshell series, the book is thankfully free of the ubiquitous CDs that people seem compelled to add to books. Not only does this help keep the cost of the book down but it helps save yet another plastic tree from being cut down and turned into a CD.

What's in it for me?

The book is divided into 5 sections, with 19 chapters. An additional online section with three additional chapters is also available. Don't feel that you're missing anything too important though as the material available online is really only of interest to advanced Lingo programmers or programmers coming from languages like C++ who want a quick guide to Lingo.

Section 1, Lingo Basics, covers such topics as Lingo syntax and structure, events and an excellent chapter on debugging and error checking. The "Basics" section also includes a chapter on Lingo Internals that is anything but basic. If you read chapter 4 and feel a bit worried that you didn't understand it right away don't worry.

Section 2, Lingo Data Types and expressions covers almost everything you need to know about Lingo data types (things like Booleans, floats, integers as well as discreet types of data like constants, literals and symbols). This section also includes a very valuable chapter entirely devoted to lists. Lingo neophytes often misunderstand the power and flexibility of lists and it's good to see such care and attention devoted to such an important topic.

Section 3, Lingo Events, goes through the two main event generators in Lingo (and Director); the mouse, the keyboard and also includes a very interesting chapter on time based events such as timeouts (also included is a discussion of date type variables).

Section 4, Applied Lingo, takes the information in the previous three sections and puts it to good use by showing the reader how to use their new expertise to create behaviors, parent scripts and how to expand Director's functionality through the use of Xtras, fileIO and the MUIXtra. An expanded version of chapter 15, which covers the MUIXtra, is available online from Bruce's website. For those people suffering from Macromedia's extremely weak MUI documentation, help has arrived.

The final section, Lingo Command Reference, is, as you would expect a series of charts listing the Lingo keywords and commands. As well, there is a very interesting chapter that details undocumented or misdocumented Lingo commands and, as a true testament to Bruce's geekiness, a chapter describing Lingo's symbol table just in case you've ever wanted to check the your code against Director's internal list of keywords and commands.

The material is all very well written and scrupulously researched (as members of several mailing lists can attest to) with numerous examples of the topics and areas being discussed.

A book for beginners?

Is Lingo in a Nutshell an appropriate book for beginners? Yes, but with a cautionary note. New Lingo programmers (or those new to programming in general) are certainly going to have some difficulty with some of the material in the book. This is really to be expected, as Lingo is a very complex subject. That said, the book's structure helps temper this by breaking the subject matter into easily digestible pieces. Unlike some books the material flows rather logically and the reader is lead through Lingo instead of being pushed.

Most importantly the book discusses subjects like debugging and coding tips. Nothing helps a person along the path to becoming a good programmer more than advice about the very fundamentals of programming and debugging. Bruce's section on debugging actually starts with perhaps the best description of the debugging approach; "Debugging is the systematic challenging of our assumptions". Chapter 3 of the book, Lingo coding and debugging tips, is such a good introduction to not only programming Lingo but also turning your ideas into code that it should be included with every single copy of Director.

The book is only about Lingo. There is a companion book titled, as one would expect, Director in a Nutshell, that covers the details of using Director itself but LiaN only covers Lingo. This is actually a very good thing. The content is focused without distractions about the Pain(t) Window and Score options.

Beginners who have gotten a taste for Lingo and want to master the subject should certainly consider this book their first, and most important acquisition.

A book for experts?

The bane of experienced computer users is that most computer books are not aimed towards them. With one exception (Darrel Plant and Doug's Smith very exceptional Lingo Programmer's Reference) there has not been a book about Director that has been of use to experienced Lingo programmers. Publishers avoid the "advanced" market mostly because there are far fewer people in that category. Consequently technical material in computer books is quite frequently aimed at novice to intermediate users.

O'Reilly books are almost, without exception, the place where technical subjects get treated in detail and readers get treated as if they had a brain. So it's no suprise that a book like Lingo in a Nutshell found a home at O'Reilly. While it is certain that most "advanced" Lingo programmers will certainly find less new material in the book than other readers that still doesn't diminish the usefulness of LiaN. Some features, like the list of ASCII and keyCode values for standard editing keys like arrowkeys, Del, BACKSPACE and ENTER are a godsend (if they could include such things in the back of the Applesoft manual then why can't they have them in the back of the Lingo Dictionary?). Other details such as a table of undocumented or misdocumented Lingo are also of great benefit.

put the audience of me

Who is this book for then? Despite the wide range of users it targets the book is really for anyone who wants to expand their Lingo programming skills regardless of their skill level. Its a very delicate line to traverse but Bruce pulls it off and actually manages to put together a book that doesn't overwhelm beginners and doesn't bore more advanced users.

Is there a downside?

As with most things there are certainly some aspects of the book that aren't perfect.

Some of the material can get a bit "heady". Some sections of Chapter 4: Lingo Internals will certainly cause most people's eyes to water but then the section comparing Lingo's OOP usage versus C++ was very interesting. This is the danger to writing "up" to your audience instead of writing "down". Sometimes your material goes over some people's heads. Fortunately the way the content is compartmentalized means that most of this material is separated from other sections so you won't have to wade through a discussion of type assignments and conversion in order to find out how to use a list.

Some of the definitions and descriptions in the book are not as revealing as one would hope. The definition of a "chunk expression", for example, left a bit to be desired. But then it's certainly considerably better than the one in Macromedia's documentation.

Lingo in a Nutshell also only covers Director 6.0x and 6.5. The new features in Director 7 are not addressed in this book. Bruce has plans to offer online updates to the book covering Director 7. Despite this, you really aren't losing out. All the material in the book is still relevant even to Director 7.

The book can sometimes get a bit bogged down in minute details or pulled off into interesting, but diverting, tangents. A discussion of the foibles of random number generation turns into a rather lengthy code example detailing dice rolls and dealing cards; the section on mouse events goes into very extensive detail when the topic really almost demands to be broken into basic and advanced sections.

Overall

These are all very minor quibbles though. It is obvious that Bruce has poured a considerable amount of effort into making Lingo in a Nutshell the definitive guide for Lingo programmers. This isn't a training guide (and it wasn't intended to be) but Lingo programmers of almost any experience level will find this a very useful addition to their bookshelves. This book is the obvious succesor to Peter Small's Lingo Sorcery in that you will soon find it on everyone's shelves.

Simply put, you should stop what you're doing right now and go out and buy a copy. Well maybe check your email first but then rush right out after that.

mMessageList (Lingo in a Nutshell)

The book is divided into 5 chapters (6 including the online chapters) as follows;

Section 1 Lingo Basics

[1] How lingo thinks
[2] Events, messages, and scripts
[3] Lingo coding and debugging tips
[4] Lingo internals

Section 2 Lingo Data Types and Expressions

[5] Data types and expressions
[6] Lists
[7] Strings
[8] Math

Section 3 Lingo events

[9] Mouse Events
[10] Keyboard events
[11] Timers and dates

Section 4 Applied Lingo

[12] Behaviors and parent scripts
[13] Lingo Xtras and Xobjects
[14] External files
[15] MUI dialog xtra

Section 5 Lingo Command Reference

[16] Enumerated Values
[17] Changed, undocumented and misdocumented lingo
[18] Lingo keyword and command summary
[19] The Symbol Table

Online Bonus Chapters

[20] Lingo for C programmers
[21] The MUI Dialog Xtra
[22] Symbol Table Archaeology

Copyright 1997-2024, Director Online. Article content copyright by respective authors.