Rating: 
Summary: Another awesome reference guide from O'Reilly
Review: I love O'Reilly & Associates' books, and have a number of them on my bookshelf. They are often the books I turn to first on technical subjects, and /AppleScript: The Definitive Guide/ is no exception in that regard. Matt Neuburg has a relaxed writing style that makes this guide enjoyable to read, insofar as reference books are enjoyable to any degree. He makes a point of going into detail about the quirks of AppleScript (of which there are tons), explaining workarounds when possible, the potential problems these quirks can cause, etc. Neuburg also is not shy about admitting his puzzlement at some of the particularly odd and inexplicable aspects of the AppleScript language.There's a great deal of information on a wide range of topics: the architecture of the language, the mindset you need when coding with AppleScript, how to combine your AppleScripts with other languages (such as Perl), how to use AppleScript studio to create GUI apps, and tons more. /AppleScript: The Definitive Guide/ has an excellent index, and I've yet to encounter a situation when the bit of info I needed couldn't be found quickly in this book. Ultimately, AppleScript books tend to fall into one of two categories. There are those that are primarily aimed at telling you how to automate specific apps (the Finder, for example) and not much else. Such books are unfortunately too common, and many of them are sorely outdated (usually covering not much after Mac OS 9, which is fairly useless now). At the other end of the spectrum are those that aim to teach you the language, its ups and its downs, its godsends and its bizarre oddities. /AppleScript: The Definitive Guide/ falls into the latter category, and this is its strongest feature. As the author points out, AppleScript is a very quirky language, and you never really "learn" all of it, or even the majority of it. There's so many hacks and poorly (or un-) documented applications, it would take a lifetime to truly master every aspect of AppleScript. Fortunately Matt Neuburg has come to the rescue with this excellent reference. It surely deserves a place on the bookshelf of any Mac developer or power user.
Rating: 
Summary: Not the successor to D. Goodman's classic AppleScript tome
Review: 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.
Rating: 
Summary: A useful resource, but not always the easiest teaching tool
Review: 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.
Rating:
Summary: A useful resource, but not always the easiest teaching tool
Review: 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.
Rating:
Summary: A useful resource, but not always the easiest teaching tool
Review: 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.
Rating:
Summary: Good book on AppleScript for all
Review: 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.
Rating: 
Summary: I agree with other reviewers
Review: 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.
Rating:
Summary: After the Switch
Review: 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.
Rating:
Summary: Big disappointment
Review: Sorry, but I'm majorly disappointed. A little background. I've taken a few unsuccessful runs at writing workable AppleScripts in the past but never pushed it. Now I foresee the need to jump back into the pond and really learn to swim this time. I'm the author of a successful FileMaker Pro solution which makes me quite skilled within that limited environment. I write no Java, no Perl, no Ruby, no Scheme. Going in I assumed I should be able to pick up AppleScript fairly quickly. Having read all the way through to and well into Chapter 7 I'm giving up. For the most part you're way over my head. You spend a long time, especially in Chapter 6, in highlighting the gotchas of AppleScript well before the basic concepts have been introduced. The assumption of deep familiarity with other programming languages continues on from there. Your text would have been the "Definitive Guide" if it had explained the fundamentals more clearly. No question you know what you're talking about, but for me you've made AppleScript obscure. I'll keep the book on my shelf as reference, but I need another text to guide me into the language.
Rating: 
Summary: It is the best of books, it is the worst of books.
Review: 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.
|
