This is an exhaustive reference manual for AppleScript, a scripting language included with all Macintoshes. It is not a tutorial, but if you have some programming experience of any kind you will be able to use this manual to construct AppleScripts. The book was published in January 2006 and is up-to-date through Tiger (Mac OS X 10.4). It includes a little coverage of Automator. There is some description of other helpful tools such as Script Debugger, a third-party replacement for Apple's Script Editor that provides a lot of additional capability.

I did some work in AppleScript about ten years ago to automate a nightly build process. AppleScript was the right tool for the job, but getting it to work was a lot of aggravation and I didn't look at AppleScript again. Recently I was asked to prepare some AppleScript demos for my local computer user group, and I got this book as a reference. AppleScript is still as aggravating as ever, but I was able to answer all my questions and complete the demos by using this book and its wonderful index.

AppleScript has evolved a lot in the past ten years, in particular by adding a number of object-oriented ideas and by increasing its interoperability with other programming systems (for example, Python, JavaScript, Perl, Ruby, Carbon and Cocoa based applications). Neuburg does a good job of explaining all these features, and he is particularly good on strategy issues. AppleScript can be used by itself but hardly ever is; you should always be thinking of combining it with existing applications and systems to solve your problem.

The major challenge in AppleScript was and remains figuring out the data types and operations supported by a particular application. Neuburg is honest about this, and recommends extensive experimentation and test scripts to figure out how the applications work.

Is AppleScript worth knowing? Neuburg doesn't really make a strong case for this, although his Chapter 1 is a good try. He works through an impressive example in Appendix A, including all the roadblocks and wrong turns. But the example is to clean up a book manuscript prepared in FrameMaker to meet the publisher's standards before turning it in. I think this is a good job for AppleScript, but how many people would need to do this job? I think AppleScript is still a niche language, but if you work in that niche this is an excellent reference.

We wouldn't know something, especially certain technology very well until we know its limitations (or exceptions).

The extensive explorations in this book chart out the boundaries of AppleScript.

If one needs to consult "dictionaries" to acquire AppleScript vocabulary, this book is definitely the grammar book for speaking the language correct-ly.

We wouldn't know something, especially certain technology very well until we know its limitations.

The extensive explorations in this book chart out very well the boundaries of AppleScript.

If one needs to consult "dictionaries" to speak AppleScript, this book is definitely the grammar book of the language.

No, don't start with "AppleScript: The Definitive Guide." Although I was highly motivated, diligent, and intelligent (if I may say so), Neuburg's exigent, articulate, and idiosyncratic "guide" defeated me, and I had to buy and work all the exercises in another book (Kochan's "Beginning Applescript") to obtain the background needed to appreciate this one.

The highly praised chapter in the first edition about conquering FrameMaker has been moved to an Appendix in the 2nd Edition, but since Neuberg sends the reader there on page 75, it is still useful and timely. It would have been more useful had he chosen a scriptable application that is on every Macintosh, or one, at least, that is shipped with Tiger, so that readers could follow his adventure rather than simply read about it. The worst that would have happened is that a newer modification of the application might have come out, in which case, as with FrameMaker, the reader could read about, but not experience, the process.

'Introductory' books in the liberal arts ("The Discarded Image" by C.S. Lewis comes to mind) are larded with quotations in Greek, Latin, French, and German, not to mention others. In exactly the same spirit, Neuburg shifts shamelessly from AppleScript to Perl, especially, but also to Unix, Objective-C, Python, and JavaScript, not to mention others. If you can't follow such examples -- he tells you that is all right -- you get the point that AppleScript is compatible with these and more, and he has the chutzpah to mention his own JavaScript book if that is your deficiency.

The effectiveness of good programming books diminishes as you move away from the computer. Programming is learnt at the keyboard, not in the lecture hall. That said, this book has an astonishing amount to offer to someone perusing it in an easy chair and mulling things over, rather than trying a succession of incorrect guesses at the keyboard. Kochan's book taught me, quickly and easily, how to move a Finder window around the screen, but when I decided that the window I wanted to move was the one holding the AppleScript program, Kochan left me without a clue. The "Oh, yeah" that finally got it moving occurred to me over a sausage biscuit in a fast food place with Neuburg's book in front of me. He didn't tell me what to do, but his dictionary exposition got me to where I could figure it out for myself.

As other reviewers have pointed out, Neuburg's emphases are upon the obscure, the contradictory, and the difficult. To explain these, he has not bothered with the obvious, the consistent, and the easy. They do not interest him, and he pays us the high (too high) compliment of implying that the obvious, the easy, and the consistent need not be explained at all.

If you wish to learn AppleScript and must learn it on your own, begin with a book (Kochan's, for example) that will make you reasonably competent in a hurry (three months, in my case). Then, when you have discovered that AppleScript is not as easy as you thought, you are ready for Neuburg to confirm your worst suspicions about its intricacies, devastate your casual assumptions about obvious solutions, and give you pride in beginning to learn AppleScript.

If you buy this book, you must read it several times, or you will not learn much of what it has to say.

No, don't start with "AppleScript: The Definitive Guide." Although I was highly motivated, diligent, and intelligent (if I may say so), Neuburg's exigent, articulate, and idiosyncratic "guide" defeated me, and I had to buy and work all the exercises in another book (Kochan's "Beginning Applescript") to obtain the background needed to appreciate this one.
The highly praised chapter in the first edition about conquering FrameMaker has been moved to an Appendix in the 2nd Edition, but since Neuberg sends the reader there on page 75, it is still useful and timely. It would have been more useful had he chosen a scriptable application that is on every Macintosh, or one, at least, that is shipped with Tiger, so that readers could follow his adventure rather than simply read about it. The worst that would have happened is that a newer modification of the application might have come out, in which case, as with FrameMaker, the reader could read about, but not experience, the process.
'Introductory' books in the liberal arts ("The Discarded Image" by C.S. Lewis comes to mind) are larded with quotations in Greek, Latin, French, and German, not to mention others. In exactly the same spirit, Neuburg shifts shamelessly from AppleScript to Perl, especially, but also to Unix, Objective-C, Python, and JavaScript, not to mention others. If you can't follow such examples -- he tells you that is all right -- you get the point that AppleScript is compatible with these and more, and he has the chutzpah to mention his own JavaScript book if that is your deficiency.
The effectiveness of good programming books diminishes as you move away from the computer. Programming is learnt at the keyboard, not in the lecture hall. That said, this book has an astonishing amount to offer to someone perusing it in an easy chair and mulling things over, rather than trying a succession of incorrect guesses at the keyboard. Kochan's book taught me, quickly and easily, how to move a Finder window around the screen, but when I decided that the window I wanted to move was the one holding the AppleScript program, Kochan left me without a clue. The "Oh, yeah" that finally got it moving occurred to me over a sausage biscuit in a fast food place with Neuburg's book in front of me. He didn't tell me what to do, but his dictionary exposition got me to where I could figure it out for myself.
As other reviewers have pointed out, Neuburg's emphases are upon the obscure, the contradictory, and the difficult. To explain these, he has not bothered with the obvious, the consistent, and the easy. They do not interest him, and he pays us the high (too high) compliment of implying that the obvious, the easy, and the consistent need not be explained at all.
If you wish to learn AppleScript and must learn it on your own, begin with a book (Kochan's, for example) that will make you reasonably competent in a hurry (three months, in my case). Then, when you have discovered that AppleScript is not as easy as you thought, you are ready for Neuburg to confirm your worst suspicions about its intricacies, devastate your casual assumptions about obvious solutions, and give you pride in beginning to learn AppleScript.
If you buy this book, you must read it several times, or you will not learn much of what it has to say.

Matt Neuburg's AppleScript book is an excellent overview of AppleScript. Alas, it is limited, as all such books are, by AppleScript's peculiar nature.

The problem is that AppleScript is primarily useful when it interacts with scriptable Applications; this means that many important commands one may think of as belonging to AppleScript belong to Applications instead [2]. If you working to extend an existing script, and decide to research a command in the excellent book index Matt built himself [1], you'll often be frustrated. The command, you see, belongs to the Application, not to AppleScript.

On the other hand, there's a good chance Matt used in the command in one or more examples. In the absence of a companion book entitled "AppleScript for Applications" [3] you'd like to find those examples. Alas, that's where you want a full text search engine.

The good news is, there are two. The even better news is that O'Reilly could make their engine much more visible and useful, with advantages for everyone.

Consider the case of the 'Duplicate' command, which is supported by iTunes (among others) and the Finder (in slightly different ways, no doubt). When I tried Amazon's "search within the book" I discovered several illuminating references. Similarly, O'Reilly allows one to search within the book as a promotion for its Safari eBook library.

The Safari search works well, but they don't want to give away too much for free. You can only read a snippet of information in the search results. A snippet that doesn't, currently, include the page or section number. If you click further you get to the 'buy safari' screen, but you also get to see the section number. Now, you can return to the book and read the information.

O'Reilly could make all of us (and themselves) happy by keeping Safari just as closed as it is today, but merely adding a section reference to the search results they freely expose already.

Here's the win-win for O'Reilly, Matt, Amazon and us:

1. Include the section reference in the initial search results screen.
2. Promote the search facility in every published O'Reilly book and explain how to use it on the O'Reilly book page.
3. If need be, request readers register to obtain this service. O'Reilly doesn't do spam, but they can suggest email subscriptions, RSS feeds, etc during the registration process.

Let us count the wins:

1. Matt's book is suddenly a better book. Readers get more value from it. They use it more. They like it and O'Reilly more.

2. O'Reilly gets ongoing visits from its customers.

3. O'Reilly gets free, regular, promotion of Safari services.

4. Amazon sells more books.

5. O'Reilly does not reduce the value of Safari, they enhance it by introducing users to it without giving it away.

It's a win-win for everyone. I just hope someone at O'Reilly can see the profit in it for them.

john

[1] In my real life I'm a knowledge representation/informatics geek. I have a lot of respect for the unrecognized intellectual labor that goes into producing a truly excellent index. In this case Matt did the work himself!

[2] Many applications may use the same string to refer to somewhat similar functions with slightly different syntax and semantics. This "ontologic dilemma" is a kind of uncontrolled overloading, and it makes AppleScript very challenging to use.

[3] If Matt decides to sell an "AppleScript for Applications" as a Tidbits eBook I'll pay for mine in advance!

This is probably the best book in print about AppleScript. Yes, it's not a beginner's book, unfortunately I'm not sure there are any good beginner books in print. The situation reflects market problems with programming language books and the odd twilight zone life of AppleScript.

I'm writing here, however, to point out a way to get significantly more value from the book.

One of the weaknesses of the book is the index (this is true for almost all books on programming -- they strain the limits of the index [1]). Say, for example, that you want to learn more about the 'duplicate' command. There's no index in the entry, but when I tried Amazon's "search within the book" I discovered several illuminating references.

Well, it turns out that O'Reilly also allows one to search within the book as a promotion for its Safari eBook library.

It works well, but they don't want to give away too much for free. You can only read a snippet of information in the search results. A snippet that doesn't, currently, include the page or section number. If you click further you get to the 'buy safari' screen, but you also get to see the section number. Now, you can return to the book and read the information.

Here's the win-win for O'Reilly, Neuberg, book retailers and us:

1. Include the section reference in the initial search results screen.
2. Promote the search facility in every published O'Reilly book and explain how to use it on the O'Reilly book page.
3. If need be, request readers register to obtain this service. O'Reilly doesn't do spam, but they can suggest email subscriptions, RSS feeds, etc during the registration process.

Let us count the wins:

1. Matt's book is suddenly a better book. Readers get more value from it. They use it more. They like it and O'Reilly more.
2. O'Reilly gets ongoing visits from its customers.
3. O'Reilly gets free, regular, promotion of Safari services.
4. Amazon sells more books.
5. O'Reilly does not reduce the value of Safari, they enhance it by introducing users to it without giving it away.

Amazon has search within services (at the moment) for this book, so you have two ways to get more from it. With a small amount of work, O'Reilly could turn their search solution into a great way to increase value for everyone.

(This is derived from a posting on my tech blog, but Amazon (wisely) does not allow URLs to be included in reviews so I can't reference the original.)

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.

I'm frankly surprised by some of the reviews which suggest this is a great beginner's book... I really don't think so. It covers a lot of conceptual material which isn't going to help you figure out how to write a basic applescript function. In my opinion, this is a book for moderately experienced scripters who would like to know the inner workings of Applescript, and the critical little items that can cause a script to fail. It provides excellent insight into script objects, recursion, polymorphism, parenting, variable scope, closure, objects, targets/nested targets, references, dereferencing, raw appleevents, and other advanced topics. If you need a book to teach basic programming, I'd recomment Hanaan Rosenthal's book instead. Buy this one after you've finished that one.

Matt Neuburg has written a great text. It's easy to read and understand, and it's great a for a thorough understanding of the language. The first section of the book doesn't discuss code very much; moreso the practical application for the language in a real-world environment. The second section delves right into code, giving practical examples and helpful tips. After reading the first two chapters of the second section, I was writing simple programs to control applications. Great book for a beginning AppleScript programmer; even better book for a person completely new to programming.

This book makes it easy to learn the basics of Applescript. The author is adept at taking the reader (student) by the hand and covering the territory.

The problem with this book is that it seems to be the "default" book for the subject...which it should not be. It contains an in-depth and exhaustive look at all the nooks and crannies of the AppleScript language itself; but almost nothing about how it is actually applied (i.e., how to control other applications).

If you are looking for a "how do I use AppleScript to do stuff on my Mac" book, look elsewhere. If you are a programmer and looking for advanced details on AppleScript, this may be the book for you.

Have you ever wondered how to get your Mac to do more work for you? If you have, then this book is for you! Author Matt Neuburg, has done an outstanding job of writing the second edition of a guide that teaches AppleScript like its never been taught before to allow you to create scripts for whatever you need your Mac to do.

Neuburg, begins by explaining what AppleScript is, motivating the reader with examples of various ways and means for putting AppleScript to use, and defining fundamental terms that the reader will need to understand. Then, the author shows you how to develop AppleScript as a programming language. Finally, he describes aspects of AppleScript in practice and in relation to the wider world.

In this most excellent practical guide, the author shows you how to harness the awesome power of your Mac and control both the system and the applications that run on it. More importantly, you'll appreciate this guide's clear and straightforward approach.

I have programmed in Applescript for many years, but this book really helped to clarify a number of issues. This is no starry-eyed, AppleScript-can-do-anything fluff job, but a down-to-earth comprehensive description of a powerful, sometimes quirky, tool that will make your Mac even more useful, if you are willing to invest some time to learn.

I highly recommend this book for anyone thinking of using AppleScript, or anyone already using it.

Please note that any reviews prior to 2006 are for the first edition of this book.

The Matt Neuburg book "AppleScript: The Definitive Guide" is an excellent reference for those that want to start learning how to automate their Macintosh and get it to start performing like never before. For those that need to write scripts for the business world, this is a great book to get up to speed, but have fair warning that the training wheels will be removed in an expedient amount of time!

Several of the reviewers have complained that this book is meant for advanced users, but I feel that this criticism is a bit unwarranted. Is the book for newbies? No but it's not for the most advanced of users either. Chances are if you are working with AppleScript that you aren't the most basic user anyhow. Either your job requires this power usage or you are the type of computer geek that wants to become a power user on your Macintosh.

If you want to start learning how to use AppleScript to start doing powerful things on your Mac and you want to learn in an easy, straightforward way, this is the book for you. Written by the exceptionally intelligent Mr. Neuberg, you have a power user that really knows his way around and how to teach you this same ability. While more screenshots would have been handy to have, there is nothing about this book that stands out which makes me unable to recommend it. Rather I highly recommend this book and feel it's a great deal for the price listed.

***** HIGHLY RECOMMENDED

At no place in this book is there a simple example. Every AppleScript is complex, does more than one thing, and is anything but obvious.

Why can't there be one example where the author shows you something simple: maybe how to create a new folder on the Desktop? Is it so easy that it doesn't have to be demonstrated? Hardly.

I was thrilled when I ordered this book, then furious when it arrived in the mail. If you want something that is understandable, then go elsewhere, because this book does everything but explain how to use AppleScript in a straightforward way.

I was thoroughly disappointed with this book. Understand that you are not getting something that easily understood.

At no place in this book is there a simple example. Every AppleScript is complex, does more than one thing, and is anything but obvious.

Why can't there be one example where the author shows you something simple: maybe how to create a new folder on the Desktop? Is it so easy that it doesn't have to be demonstrated? Hardly.

I was thrilled when I ordered this book, then furious when it arrived in the mail. If you want something that is understandable, then go elsewhere, because this book does everything but explain how to use AppleScript in a straightforward way.

I was thoroughly disappointed with this book. Understand that you are not getting something that easily understood.

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.

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.

Less than two years ago, I made the switch from an MS OS to a Mac. I was thrilled to pieces to be able to make the change after about ten or twelve years on the other platform. Of course, I thought I knew a lot and yes, perhaps I did, and when I got to the Mac, I felt about clueless. Thus, I was eager to learn something more and more. Okay?? this was my motivation. I got one book...Mac OS X Hacks...and pretty much breezed through that peeking at this chapter or that after giving it the once over. In that book, it briefly touched on AppleScripting and after that treatment I wanted more, more, more. I was eager to learn.

In my "past life" I had studied programming some and knew that it might be a little intimidating but I desperately and anxiously wanted to accelerate my learning on this new toy. So I got AppleScript: the Definitive Guide as it was supposedly a great book for those who were just beginning to explore AppleScripting and a great reference for experienced scripters.

What did I know? Not a whole lot. After getting through the first section, I felt forewarned and ready to roll. Sure, I'm not totally through this book but what I've seen so far seems to pretty much equip just about anyone to follow through on the quest to learn AppleScripting. I've been told that to build a good house, one needs a good foundation. It really seems that that is what is happening in the first two sections of this book. And it goes from there.

Matt Neuburg gives us tools and helps us to think on our own. He prepares us for what seems to be an undaunting task in front of us. He tells us that he doesn't know everything and we probably won't either. He shows us how he did not back down and prepares us to follow the same methods and warns us about what may be ahead of us. This does NOT seem to be such a bad thing. It's something like a life skill. Sometimes the best tools a teacher can use are a gag and a pair of handcuffs while the student ventures out on his/her own to make a few mistakes and learn by doing. Why fear that sort of treament by Matt Neuburg?

Perhaps some are forced into learning AppleScript and that is somewhat offputting. My experience is different and I am motivated to learn. I have to say, I would be less than thrilled with any book if I were put in a position of having to learn this. It certainly casts a different light on your experience to be in such a position.

In my opinion, I have to wonder if there are some that just don't quite want to learn. It may be so. If not, I beg your forgiveness for thinking that you're not motivated enough. I'm thrilled to be doing this and to have Matt Neuburg's book to help in my quest.

Thanks Matt.

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.

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.

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.

To keep it short and sweet--if you have any interest in learning or using AppleScript, get this book. It is the book Apple should have put out years ago.

It's funny, I agree with much of what the other reviewers say, but they seem to not realize they are talking about flaws with the book. Applescript is entering a "golden age". It is declining and becoming redundant now that OS X allows us to run more up to date versions of free and open source scripting languages like Python, Perl, etc. I also agree with other reviewers that the author has an "extremely erudite writing style", which is a huge negative for a book about a scripting language meant for total beginners. The scholarly writing style used by academics is completely inappropriate for books to learn how to use a programming language or tool. David Mertz's book and articles on Python suffer from the same problem, and he too is a former liberal arts academic, but his writing is targetted to non-beginners using Python for text processing, not a "definitive guide" meant for everyone.