Customer Reviews

AppleScript: The Definitive Guide, 2nd Edition

5 star:		(15)
4 star:		(7)
3 star:		(5)
2 star:		(6)
1 star:		(4)

 

 

Apple has long pushed AppleScript as an easy-to-learn, English-like way of automating repetitive tasks on a Mac. Alas, I and many, many others have discovered from painful experience that AppleScript is hugely difficult to approach -- its learning curve never seems to flatten out. Even after writing thousands of lines of code in several programs that (eventually) worked, I still feel I'm groping in the dark every time I try something new. I've read other books on AppleScript, looking for one that would open the magic door and reveal the simple, friendly AppleScript that's supposed to exist.

Matt Neuburg has given us the first AppleScript book that tells the deep truth: AppleScript is a quirky, inconsistent programming language that is not only hard to learn, but hard to learn for fundamental, structural reasons. Neuburg exposes the unavoidable difficulties that are built into AppleScript's design, and then shows us practical techniques for accomodating to them and using them.

Anyone who reads this book carefully will be able to apply AppleScript with greater understanding and less wasted time, and be able to use it with far less of the disappointment, frustration, and even rage felt by all too many people who collide unprepared with AppleScript's tricks and traps.

Since there's no "look inside the book" feature, let me summarize the main sections. Part I explores AppleScript in a system context: what it is meant to do; how it is used (with an intro to the Script Editor); and what its basic concepts are. (Contra another reviewer, this 90pp part contains nothing about history; it's all current and relevant stuff, needed later in the book.)

Central to Part I is Chapter 3, "The AppleScript Experience," which describes the actual process of building a program. This chapter so perfectly reflected the confusions, frustrations, and dead-ends that I've experienced with AppleScript that I was sold: this guy really understands the problems! He doesn't minimize them or blame them on me. Maybe he can show me ways to work around them, but whether he does or not, at least he'd validated them.

Part II, 200pp, is a detailed and insightful exposition of the AppleScript language. Early in this part is a discussion of "The 'English-Likeness' Monster," showing how the attempt to be friendly distorts the language and confuses users.

Then Neuburg examines every detail of AppleScript's syntax and semantics. He doesn't do this like a typical "tech writer," rephrasing the official documentation. He has taken the time to write code to test out every corner case and exception of the language, and he lays them all bare. He looks into AppleScript's baroque scoping rules and its inconsistent rules for implicit coercion of types.

All of Part II is meat and drink to a fan of programming languages, and I read it through like a good novel. More to the point, it's a deep and thorough job of documenting the actuality of AppleScript: what syntax works, what the tricks and traps are, and what to avoid.

Part III tries to extend the same thorough methods to the process of creating applications in AppleScript, beginning with application dictionaries. Here Neuburg, like every other AppleScript user, bangs hard into the basic structural flaw of AppleScript: that all the interesting semantics and no small part of the syntax are implemented in other applications, not in AppleScript. Everything you want to actually accomplish with AppleScript, you do by sending messages to other programs -- the Finder, TextEdit, BBEdit, Mail, and so forth. The only documentation you have is each app's dictionary, and it can never be adequate. Chapter 19, "Dictionaries," contains a long editorial on "Inadequacies of the Dictionary" that details all the reasons that an app's dictionary can never tell you enough to use the app. Some of the reasons are structural (there's just no way to express the needed information) and some are due to human failure (the people who write dictionaries do a clumsy, inconsistent, and sometimes erroneous job). Neuburg can't fix these issues, but he does his best to prepare you to work around them. Nevertheless, as he says in another context, "AppleScript programming is often indistinguishable from guessing."

To sum up: this book is a deep, thorough exploration of all the quirks, dusty corners, and skeleton-filled closets of AppleScript. Reading it will make you far better prepared to use AppleScript productively.

Sorry, Mr. Dickens, I just had to.

First, the bad parts. If you are a beginner to AppleScript (particularly if you've had little programming or scripting experience), DO NOT even think about looking at this book. It will be so confusing and discouraging, you'll leave angry. There are plenty of books that show you how to do simple things easily with AppleScript. They may be deluding you into thinking that it will be simple to use AppleScript for more complex tasks, but at least, you'll be getting hands-on learning in the meantime. No book can be truly suitable for beginners AND experts and I never believed that claim about this book. Sorry, beginners, this book is STRICTLY for intermediate to advanced users.

Having said that, I can begin to shower praise upon this masterpiece. As someone who has done some AppleScripting and have been through a lot of frustration doing anything beyond cookie-cutter work, Chapter 3 boosted my self-esteem about 10 notches! That chapter details Matt Neuberg's odyssey through the labyrinthine task of scripting FrameMaker. Been there, done that (in other apps)! So, I'm not such an idiot -- some of these object models aren't crystal clear.

I had always thought that AppleScript was the underrated, undersold and underused secret weapon that the Mac platform could wield over the competitors, especially the dreaded Windows! After using it and then having my suspicions confirmed by this book, I realize that despite all its power, AppleScript has failed in its mission of being the intuitively obvious, easy-to-use, simple, everyday, plain English, "scripting/programming-for-the-rest-of-us" tool it apparently was developed to be. The good news is that if you are the true target audience for this book, you will be able to help out ordinary Mac users for fun and profit.

I believe there is a definite line dividing the people who must have and will love this book from those who should avoid it like the plague (until they get some AS experience elsewhere). I hope this helps you decide.

AppleScript The Definitive Guide

What the Book is About

This book aims to provide a complete explanatory manual and reference to AppleScript, up to date with Mac OS X 10.3 (Panther).

Target Audience

The introduction states that the book assumes no prior knowledge of AppleScript or of any other programming language. While I agree that no knowledge of AppleScript is required, it's challenging to consider someone with no programming knowledge starting out with this book to use AppleScript as their first programming language. For experienced Applescript users, the book is likely to be an essential reference.

What NOT to Expect

Perhaps like many others who had not used AppleScript, I believed it was a simple, English-like language that was very easy to use. I jumped eagerly in at the first chapter, certain that I would soon be told go sit at my Mac and type my first 'Hello World' AppleScript into some application or other.

As I read and read chapter after chapter from the sofa, I realized it was not going to be quite so simple in either case.

AppleScript, according to the author, has come close to extinction in the past, but is now entering a 'golden age'; it is a technical innovation and a labor saving device for the ordinary Mac user, yet it's not true to say that it's an intuitive language needing no real explanation.

What to Expect

In reading this book, the author's (Matt Neuburg) expertise in AppleScript becomes immediately apparent. So too does his extremely erudite writing style. For example, when I got to the list of 'apothegms' and discovered that this synonym for 'saying' or 'maxim' was dictionary.com's word of the week on June the 9th, 2000, I naturally began to wonder whether he read dictionary.com every week for fun.

As it transpires, the author has degrees in ancient Greek and Classical Philology and had a career as an academic classicist before starting a new career in computing. He thinks computer languages are relatively easy. (See http://www.tidbits.com/matt/).

The trouble with AppleScript is that to use it you have to use it to script an application, each application has a different vocabulary stored in its dictionary, and dictionaries in general have no manuals of their own. If someone tried to write one book that said precisely how to script every application, it would need to contain a dictionary manual for each application, and would therefore be enormous.

While there are books about AppleScript for single applications, Matt Neuburg quite simply wants to get you to see AppleScript through his eyes and learn to use it as he does, finding out what you need to know as you go along.

Part 1 - AppleScript Overview starts by identifying when and why you would want to use AppleScript - for example whenever you get bored doing something very repetitive with your computer. Also discussed in this part of the book are the different environments for creating AppleScripts and some of the important concepts and principles.

The singular feature of this section is that it contains a complete worked example of how to create an AppleScript to do a repetitive document management task. The example uses Framemaker; this has the disadvantage that people who don't have Framemaker won't be able to try it out. The point is to illustrate that no prior knowledge of the Framemaker dictionary is required - you can figure it out for yourself if you know how to ask the application !

Part 2 - The AppleScript Language, is intended as both a reference and instruction. As the author says, 'the order of the exposition is pedagogical' - you are supposed to read the chapters in order. This section explains all the language features and illustrates pitfalls including those caused by forgetting AppleScript is not English.

Part 3 - AppleScript in Action, is where, as the author puts it, having learned to use the sword in Part 2, you now go out and do battle. It covers dictionaries, scripting additions, working with applications both scriptable and unscriptable, working with UNIX and finally writing your own applications. Again in this section problems are foreseen and solutions provided.

There are appendices on Apple's 'aeut' resource and general AppleScript resources such as websites.

Highlights

The depth of the coverage is amazing and the approach of teaching you how to learn for yourself is refreshing.

If you are interested in linguistics as well as computer languages then this book is a delight. A language manual written by a linguist, it frequently compares and contrasts AppleScript to English and other computer languages.

Mac Guild Grade

A+ (Awesome)

Final Words

If you want to know everything there is to know about AppleScript, then this book is essential.

If on the other hand you are looking for a very practical tutorial or cookbook, be warned that after reading all of this book, I still have not typed any 'Hello World' AppleScript into AppleScript Studio. Maybe I just don't do enough boring, repetitive tasks with my Mac.

I have some programming experience in RealBasic and 4D's scripting language and decided to dive head first into AppleScript. The editorial review on this book says: "The book assumes no prior knowledge or previous programming experience, but nevertheless seeks to offer a complete treatment of the language's capabilities." After I quit reading the book when I got to chapter 11, I can safely say that I absolutely disagree with that statement.

I found most of the examples to be very confusing and the numerous references to explain certain exceptions and reasons in later chapters to be very frustrating. Perhaps the nature of AppleScript is just confusing so I do not want to fault the author. If you are looking to learn AppleScript as a total beginner, like me, this is not the book for you.

In writing this book, the author expressed a desire to create a "complete explanatory manual" for beginners and veterans alike. He clearly appreciates the immense power of the language, while also obviously enjoying AppleScript's challenges and quirks. The book is billed as requiring no prior AppleScript or programming experience, but having some of each is a definite asset; there are many occasions where some knowledge of programming concepts or other languages appears to be assumed.

The structure of the book is somewhat confusing. It starts off well with some practical examples, but then moves into very complex terrain, having the potential to quickly leave the AppleScript newbie behind. Throughout the book, Neuburg discusses many of the quirks and nuances of dealing with AppleScript. It could be argued that he deals with too many of these quirks, which gives the book a somewhat choppy feel at times. The value, however, is that this treatment does lend a sense of reassurance - when you're banging your head against the keyboard because a script doesn't work as expected, it's good to know that the language is not without unique "personality" and that you're not alone. This may not always help you get your script running any faster, but what a sense of camaraderie!

Far and away the best feature of the book is the third chapter, where the author walks through the "AppleScript Experience." In this chapter, the reader is led through the step-by-step process of how the author develops a real script to take care of an otherwise long and tedious repetitive task - exactly the sort of thing that AppleScript is designed for. Neuburg explains the thought process of building the script, and provides each iteration of code along the way, warts and all, until all of the kinks are worked out. This was both educational and entertaining, and we could easily put ourselves into the same place, having been there before. It should be noted that the thought process of creating a script is really one of the most challenging, and poorly explained, aspects of coding in general. If you're new to programming, you likely expect that learning the technical syntax and structure is the hard part, but in reality that's easy in comparison to wrapping your head around what to do with this technical knowledge. Neuburg's tour of his headspace during the scripting process is invaluable and you'll gain some worthwhile vicarious experience in Chapter 3.

Bottom line: it's a great book if you can follow it, and a hard read if it loses you. It makes for an excellent reference source, and is certainly a comprehensive look at the language, covering all of the significant aspects of coding with AppleScript. We would expect veterans to find this book to be a well written in-depth discussion, while most beginners (to programming) would likely be more than a bit intimidated. It is perhaps most ideally suited to programmers of other languages that are new to AppleScript, but can rely on their background knowledge and interest to relate to the finer points presented.

It is refreshing to find a book that is totally honest about the drawbacks of the language it hopes to teach. AppleScript: the Definitive Guide is one such volume. Matt Neuburg delves into all the flaws inherent in this language.

AppleScript as a language and development environment has some terrible problems, and I applaud Neuburg for not trying to hide them away. Personally I love the power the language can provide, while loathing it for it's "English-like" syntax and the problems inherent in having most of the language defined in differing ways in different applications.

One of Applescript's problems is that it is difficult to teach, as you almost have to understand everything before you can know anything. Unfortunately that problem is reflected in this book. Neuburg constantly finds himself having to resort to the "believe me for now, I'll explain later" strategy throughout the book.

The book is broken up into four sections: "AppleScript Overview," "The AppleScript Language," "AppleScript In Action," and several appendices.

"AppleScript Overview" is a well written look at what AppleScript is, what it is good for and how to use it. Chapter 3, "The AppleScript Experience" is an impressive warts-and-all walk-through of the author developing an AppleScript to solve the problem of renaming files to conform to a particular standard using FrameMaker and the Finder. It is here that the reader will first see the problems inherent with AppleScript as Neuburg battles with incomprehensible dictionaries, unknown object models and uncommunicative error messages to build his script.

Part II, "The Applescript Language," is the 200-page core of this book. Neuburg provides a detailed and comprehensive look at every detail of AppleScript's syntax and semantics. The first chapter of this section, "Introducing AppleScript" contains a marvelous section entitled 'The "English-likeness" Monster' that is a short, sharp (and entirely justified) attack on the problem of AppleScript's attempt to be English-like in syntax.

In the rest of this section Neuburg provides an exceptional survey of the language. I personally appreciated his examination of the intricacies of type coercion and the exotic scoping rules. He has also taken the time to write and elaborate a large number of small pieces of code to demonstrate gotchas and tricks throughout the language.

It is this section that truly separates this book from every other AppleScript book I have previously read -- it is a masterful guide to the language.

Part III is a concrete path towards writing your own scripts. Neuburg starts by examining application dictionaries in depth. The real power of AppleScript lies not in the language itself but in the ability to use language extensions built in to other applications. This also becomes a huge flaw when the only documentation you get is in the application dictionary. As Neuburg puts it "One purpose of the dictionary is to show the human user how to speak AppleScript to a scriptable application in order to drive that application. But a dictionary, by its very nature, is not completely adequate to this task." He then goes on to explain the flaws.

The first appendix is a dump of the AppleScript Suite from AppleScript's 'aeut' resource. This is the core of the language usable everywhere. The second Appendix is a good, useful guide to tools and resources for the AppleScript programmer.

Taken as whole, this is a great book for the AppleScript programmer, both beginner and expert. It has a good writing style, has been well edited and well constructed. Neuburg may be putting in too many forward references, though. Other reviewers, particularly those newer to AppleScript, have called the book frustrating and confusing. I think this may be due to both the high information density in this book and Neuburg's fast introduction to topics that are better explained later in the book. If you are a newcomer to programming and AppleScript then this may be daunting.

If you are new, however, this is still an excellent volume but you may have to force yourself to finish it and then go over at least Part I and II again to truly understand the language. It would probably be a good idea to start trying to build your own scripts after the first read through. I must say, that after taking a good hard look at the way the book has been constructed and ordered I couldn't really come up with a better way that wouldn't have doubled the size of the book.

Visit the O'Reilly web page for the book if you would like to see the Table of Contents or grab an example chapter.

Neuburg has said "My approach is not to rely on documentation, ... but to bang away at the language itself, testing and experimenting, trying to deduce the underlying rules" and this approach has certainly borne fruit in this volume. For all it's minor flaws you cannot say, as may be true of many other tech books, that it is a rewrite of the documentation. He has approached the problem from a different direction and given us a book that offers an excellent guide to the language.

I would recommend it to all Macintosh owners as the perfect way to unleash another powerful aspect of your system. For people who have no AppleScript or programming experience who want to be totally spoon fed this book is probably only a 5/10, for people with a little AppleScript experience, a fair amount of programming experience and a willingness to stick through to the end this book is probably a 9/10. It is certainly the best book on AppleScript I have seen.

It seems like key pieces of information have been left out of this book, which is very atypical for any of the Definitive Guide series from O'Reilly, and of O'Reilly books in general. I picked up this book because it was the most recently published on the topic, and I'm still confused even after reading it. The first three chapters were on very basic subjects such as why you would want to use Applescript in general, where you would want to use it, and basic concepts. Next, part two is all about the syntax of Applescript, piece by piece. This is all very nice, and it probably is complete and correct, but it is like handing someone a maintenance manual on a washing machine who has never seen one before. Now that I know how to fix a broken one, what do I do with the actual machine itself? Part 3, "Applescript in Action", at first looked promising, but actually it just tells you how to fine tune your applications and shows some advanced features without ever really showing you specific problems that Applescript could solve and then solving them using the language. This is probably a good reference for someone who already is an experienced Applescript programmer, but I didn't find it helpful. I've ordered "Beginning Applescript" by Kochan to try to get some more remedial help on the subject. Hopefully, between these two books I can really learn Applescript, rather than just dabbling in it, which is what I've been doing for some time.

This is an excellent book by a gifted writer. Neuburg has the ability to understand AppleScript at a deep level, and then communicate that understanding clearly and coherently. The coherence of his approach brings the novice along with the text while keeping the expert engaged by virtue of passing on little known facts, strategies for dealing with Applescript's eccentricities and frustrations, and amusing and important asides.
One chapter that struck me as indicative of Neuburg's strengths comes early in the text and deals with a real life scripting challenge that he had to meet in the course of producing the book. Beginning very simply he shows the reader how he worked through the process of making a script that would interact with the program FrameMaker: gathering information about the book's illustrations, listing the illustrations in a very particular order and renaming all the illustration files in a way that was mandated by the publisher. We readers can observe the habits of thought, learn some of the peculiarities of AppleScript, and follow the methodology of an experienced scripter as Neuburg works through this process of learning how to speak to FrameMaker to achieve the result he needs. By the end we are looking at, and understanding, a complicated and effective script.
The subsequent chapters that deal with the building blocks of AppleScript and the ways to combine them into increasingly powerful tools are written clearly and with a good humor and comraderie that make learning about AppleScript quite enjoyable for this reader. I highly recommend this book.

I am for the first time not happy with my O'Reilly purchase. I am fluent in many programming & scripting languages. I bought this book so that I could get past the limited information I found from Apple. I was wrong to do so. The Apple documentation, limited as it may be is much more useful. I have found little to no information that was helpful in this book. It gives few commands and fewer syntax rules or examples.

I don't dismiss the possiblity that if I had been AppleScripting for years I might not think the same way about this title. However, I think if you are looking to do practical things with AppleScript, like "arrange the year, day, and month in a string in the order of your choosing", don't expect this book to help.

I was so looking forward to a definitive, exhaustive guide to AppleScript, in the manner I've become accustomed to in the O'Reilly series. As for the author, I have mixed impressions, given his uneven contributions to TidBits -- but not so sour as to prevent me from buying this book. Also, I was greatly inspired to use AppleScript from the great, but now hopelessly dated AppleScript book by Danny Goodman: (...)

My AppleScript library was thus sorely in need of an updated reference to this handy system utility. After completing it and my attempt to apply anything I learned, I am very disappointed. After an introduction to AppleScript through an example, Neuburg proceeds to regale us with his extensive esoteric knowledge of many utility-related things e.g. scripting languages. However, he fails to deliver a cogent and cohesive discussion on the application of AppleScript. In fact, he proceeds to tear AppleScript apart in a death-by-a-thousand-scratches approach, spending much time on its many idiosyncrasies. We also spend much time as Neuburg delights in his own clever lingual manipulations. This book calls to mind the saying about the key talent of an effective teacher: the ability to make the complex simple, and thus applicable. Neuburg turns this on its head: he further obscures the complex and leaves a cloud of confusion.

The end result of reading this book is that I have once again turned to Google as my "exhaustive" AppleScript library, and I'll be selling this book. I continue to gaze longingly at my now antiquated Goodman, awaiting the true sequel.