5 comments about AppleScript: A Comprehensive Guide to Scripting and Automation on Mac OS X.

1. Prior to getting this book as a gift I read every printed book and pdf on AppleScript written in the last 10 years, and still my progress hit a wall that I couldn't get past. Seeing as I've only been scripting for a year, that's part of the problem. Most AppleScript books are either severely outdated, poorly written, or both. This book breathed new life into a subject that really needed a fresh perspective. This book is an extremely thorough reference, a challenging and inspiring workbook and a treasure trove of ready-to-use scripts and tools that you can take and make your own in the real world.
   
   Don't expect:
   "This is a subroutine, here is what it does. This is a variable, this is what it does."
   
   Instead, expect stuff like this:
   "Here is a common problem, here are four ways to solve it. Here is why the first three work. Here is why the last one might not be a great idea. Here is how you can put this to use in the real world."
   
   This book is low on fluff and useless graphics and high on useful tools. It is important to maintain a rhythm and mood when trying to get an audience to make it through 800 pages and Hanaan succeeds in keeping the content fresh and throws in just the right amount of humor. And unlike just about every other technical book I've read, the jokes are actually funny.
   
   And you'll find that the approach to solving a problem doesn't focus on right or wrong, or the good or bad way of doing things. Rather, it shows the better or best way of doing something and backs it up with real world scenarios and in plain english. I could go on and on about this book and how much it has helped me and my business. Bottom line, if you use AppleScript then by this book now and keep it close by.



2. Easy to read and very complete, until with the least details (How to implement a debug mode, how to name subroutines, good practices to write the code, etc.)



3. this book suitable for beginner (as me) and advanced user. It start with basic AppleScript skill. And the best thing if the language it use is simple and interesting. You will not feel boring (like other training books) when read it.



4. A Mac aficionado, I began knowing nothing of Applescript but a burning need to tweak Filemaker and its interactions with the Finder. Specifically I wanted to incorporate files (or more particularly their pointers) to a Filemaker Database and then move these files to different locations on the network as part of a document storage system.
   
   With this book I have achieved my goals. In addition to freestanding (Finder based) scripts I have used Filemaker's ability to embed Applescript within its own scripts to better integrate my solution.
   
   Of course it is impossible for a single text to cover such a vast topic completely, but together with available web help, Mr Rosenthal's book has allowed me to feel I have at least a nodding acquaintance with Applescript.
   
   I would recommend this text to anyone needing to understand Applescript and its potential. The layout is simple and logical and the index useful. Like other reviewers I thought the "powerwrap" at the end of each chapter was very helpful.
   
   I found the PDF version of the book particularly useful. The example scripts are downloadable which also a great boon.
   
   I continue to use the text on nearly a daily basis as a reference document and look forward to the next edition.



5. Exactly what I was looking for! Finally, a book about Apple Scripting that doesn't teach you how to write a script that e-mails your friends when you upload new tracks to your iTunes library!
   Mr. Rosenthal has broken down Scripting to a basic level but the book can also be used by a proficient scripter too. My boss was borrowing it so often she went out and bought a copy of her own.

5 comments about The Visualization Toolkit: An Object-Oriented Approach to 3-D Graphics (2nd Edition).

1. The book gives you a good overview of the most important modern algorithms in computational geometry and computer graphics. AND: On the CD included you find a professional programming system with implementations of the mentioned algorithms in SourceCode! You can easily extend the system by your own algorithms in C++. Every Researcher who starts to work in this field should read this book and use these implementations.



2. The book gives you a good overview of the most important modern algorithms in computational geometry and computer graphics. AND: On the CD included you find a professional programming system with implementations of the mentioned algorithms in SourceCode! You can easily extend the system by your own algorithms in C++. Every Researcher who starts to work in this field should read this book and use these implementations.



3. This book is great for gaining an in-depth understanding of the underlying visualization algorithms used in the Visualization Toolkit.

   If you would like understand how to use the VTK software, you should purchase The Visualization Toolkit User's Guide. This companion book is updated for each major release of VTK, and contains many detailed examples.




4. This book is poorly titled, because it discusses the algorithms and techniques of visualization much more than the use of the Visualization Toolkit software. However, it is a good introduction to scientific visualization, and the free software included on the CD is an extremely powerful and useful tool. However, if you only wish to learn to use the software, The Visualization Toolkit User's Guide would be much more appropriate for you.



5. I started to use the companion free software "visualization toolkit" back to the first edition of this book. My goal was to write a Windows application called "3D Groundwater Explorer" for the 3D Visualizaiton of data and results from groundwater flow and contaminant transport simulations. It was a tough time, partly because this book focuses on algorithms and does not explain how to use the Toolkit in details (maybe the Toolkit is too "big" to be explained in details). Despite of the rather high learning curve, the Toolkit provides virtually everything that one might need in creating impressive and informative visualization image. The Visualization Toolkit is a real tremendous accomplishment.

2 comments about UPnP Design by Example: A Software Developer's Guide to Universal Plug and Play.

1. This book gives very good overall overview of UPnP for somebody that is new to this matter. It is done from the Intel tools perspective, which is not surprising given writers affiliation. But, all in all, they try to give an objective picture.
   I would like to see more concrete comparisons with Jini though. None of the other, non-UPnP compatible, service discovery methods explicitly mentioned in the book but advantages and shortcomings of UPnP (and there are quite a few) could be understood only in conjunction with other developments. There are currently some domains, for example, where UPnP will simply not work. For somebody, that is interested what other similar technologies are available I can recommend the book "Jini technology: An Overview" by S. Ilango Kumaran because this book gives a broader view of the state of technolgy today (not just Jini).



2. I found this book to be a great introduction to the UPnP technology. The authors start with some reasonable assumptions about the skills of the reader, then methodically build a foundation for understanding and implementing the UPnP technology. Highly recommended.

1 comments about Apache, MySQL, and PHP Web Development All-in-One Desk Reference for.

1. I consider myself as pretty much a patient problem solver when I actually encounter problems. But as I begin to use this book as a reference book to build my first website based on MySQL, PHP, and many other languages, I found myself getting seriously annoyed at the fact that this book offered me.
   
   That is not meant to say this book is a horrible book. First of all, as this book is published as "For Dummies series", the author "is obliged" to write as you do not much about anything, though the author himself most likely did not incline toward the obligation. And, as it is written on book covers, this book truly covers the seven topics in one, and each of the topics is explained in detail and in plain language to make you easy to understand.
   
   But despite of these positive sides, it is unfortunate that this book seriously needs revision. To remind you, this book is a book targetting toward beginners. At the same time, however, this book is also a book targetting toward those who are actually intending to use PHP and other applications mentioned here to build a website. But before I mention what are the problems with the book, I want to let you know something about PHP. Those who already know or do not bother to know about it, just skip over to 2nd paragraph following this.
   
   For those who do not know, PHP is a language that can easily frustrate you if you make a single, minimal mistake such as: replacing a single quote as a double quote, absence/addition of a a blank line or a space, etc. To make things worse, when you run the PHP page with errors in web, it will give you errors that is not only unpleasant but almost entirely useless. I first used Notepad to write/edit the scripts, but lated I had to rely on Dreamweaver to make edits less frustrating -- but with no significant improvement. And for those who do not have these expensive IDE softwares, you will probably spend hours to see what have done wrong in your script.
   
   Now, continuing with the problem with the book... The author makes a serious mistake by leaving incorrectly written scripts on several portions of his book. For example, these is this PHP script written on Chapter VI, Chapter 7, "Creating a Username System for Your Website", that shows you entire scripts for useraccess.php file. The file itself is about 151 lines wrong(I say "about" because the script itself really depends on how you design the script), and there are 7 other files, either html or php, that works in conjunction with this file. By running the script, I got an error message that is basically useless. I ran the program in numbers of times more again, and I later found that the problem was actually in the book: there were 19 "{" sign but only 18 "}" sign in the script! I still ran in a couple more problems again after fixing the mistake. In any case, the book makes several mistakes that can guarantee you to get frustrated unless you are already a programming gru.
   
   In addition, while the author goes each portion pretty extensively, he somehow seems to assume that you read about previous parts of Books before you goes to next Book. What I mean by that is, for example, when he mentions about objects in PHP, he actually wants you to go back and read the parts in Perl to make you understand it. I do not think that is not really a good approach for beginners who will read this book because some users simply do not want to spend extra time to read over another books mentioning about Perl or Apache when they just wants to learn PHP. And often, I strongly felt that there needs to be more explanations regarding each issue, and I visited his website to see whether there is maybe a forum or a tutorial set up regarding the book. What I only found from his websites is articles regarding another computer language C, download search that is basically useless for me, and, oh, some Google and other affiliate ads to make himself some money. Nice...
   
   So, to conclude, I cannot really say that this book is a great book for beginners. Maybe, you will find that this book is not even an okay book, or maybe you will. However, what I suggest to you is that, if you buy this book from a bookstore, be sure to have a mind to learn through trials-and-errors with frustration rather than just using scripts written from the book.

1 comments about Digital Modeling of Material Appearance (The Morgan Kaufmann Series in Computer Graphics).

1. This is the future of Computer Graphics. The book begins with a solid, foundational overview of light properties and their current forms of implementation. The book then gracefully develops the more advanced concepts and smoothly transitions into digital modeling of material appearance. In this subject of light there is no better compendium of knowledge, especially one that can educate due to its salient command of technical language that never obscures the concept underneath.

5 comments about Programming Sudoku (Technology in Action).

1. This is a short, straight-forward book that shows the reader how to create a simple sudoku program for Windows. I read this book cover to cover in about 2 hours. It is a very practical introduction to programming a sudoku application in Visual Basic 2005 (I'm not sure what book the previous reviewer is referring to, as this one contains no C or Java code. Any competent C programmer could convert this code easily). The book walks through the creation of an interface, code to enforce the rules of the game (preventing illegal moves), a (limited) set of solving strategies, and an algorithm for creating new puzzles.
   
   The biggest strength of the book is that it is very practical -- you can type in (or download) all the source code and you'll have a running application. Using Visual Basic makes it ideal for the beginner/intermediate programmer (of course you need VB 2005 -- previous versions won't work).
   
   The biggest limitation is that the solver/puzzle generator only uses four basic strategies: Single Candidate (aka Naked Single), Hidden Singles, Matched Pairs (Twins), and Triplets. It also includes a brute force algorithm. The author presents the four strategies as if they represented all of the known solving algorithms. In reality, there are a variety of other, more complex strategies that are incorporated into good sudoku puzzles (a good place to start would be the Sudoku Programmer's Forum - http://www.setbb.com/phpbb/index.php?mforum=sudoku). When the aformentioned strategies fail, the program tries to find a brute force solution. While that may be fine for solving puzzles, it causes trouble when you want to create new puzzles. The puzzles created by the application's "Extremely Difficult" setting are not guaranteed to be unique. That is, puzzles at the other difficulty levels ("easy" through "difficult") each have a unique solution that can be discovered using up to only 4 solving strategies. Puzzles that are "Extremely Difficult" can be solved mostly by the existing (pretty simple) strategies combined with a number of squares that may be solvable by more advanced strategies or just by blind guessing, and they are likely not "True" sudoku puzzles because there is a good chance that they have multiple solutions.
   
   I also have some minor quibbles with the overuse of strings to store game states, but the author does a good job of using them in an efficient fashion. There's also a chapter thrown in at the end describing the rules and some basic strategies for playing kakuro, the newer number puzzle that publishers are hoping will be as popular as sudoku. The chapter has no real relevance in the book, as it does not discuss computer implementions, and contains no particularly useful information.
   
   In all, this is a good start for a moderately experienced VB hobbyist interested in creating a program that generates and solves (and lets users play) sudoku puzzles. The generated puzzles will either be easy to moderate, or will be a mixed bag.
   
   My recommendation to someone who has a moderate level of VB programming experience, but perhaps doesn't know how to go about writing a sudoku program would be to use this book to create the basic program, then go to the Sudoku Programmer's Forum to learn about other strategies that they could implement in the program. If you have a decent understanding of VB and just want to mess with the code, you can download it for free from the publisher's web site at www.apress.com.



2. The main problem I see with this book is that the techniques presented are hard to transfer to non-game situations. The main reason is that VB.NET is not a suitable choice of language for this problem. When I first opened the book, I expected a book on resolution-based logic programming or finite domain logic constraint programming in VB.NET, using soduku as a concrete example, but instead found the programs to be too specific to use except with soduku and other similar games. The programs in this book solve the problem the way a human would solve the problem. This approach doesn't take advantage of the computer's ability to perform simple calculations extremely fast. Taking advantage of this often requires a different approach to the problem, and this book doesnt discuss it. The section on using brute force doesnt really come close to the finite domain constraint programming that is extermely well suited for this problem.
   
   Part of the problem here is that VB.NET is entirely inappropriate for this type of problem. Prolog is far better suited for this problem than any imperative or object-oriented language. The choice of language is often the critical descision in programming. Make the wrong decision and a couple of pages of Prolog code suddenly becomes a book full of VB.NET code.
   
   If you want to learn how to solve soduku problems better (either with a computer program or with pencil and paper), then this book does just that. If you want to use what you learn from this book to apply to other domains, then it probably wont help too much. Buy an introductory book on Prolog instead.



3. Microsoft has hung it's hat on 'starter kits' for Visual Basic .Net Express (2005) both as a learning tool and as a starting point for developers. However those who have tried to use them have found the examples to date to be buggy, hard to understand, excessively complicated and almost impossible for beginners to get to work. Sudoku would seem to be an ideal subject as one of these starter kits. However this book, with the downloadable code, is a much better option. The code works right off, and most of the basics are there. It will generate and solve puzzles. The solver uses 4 basic methods, and, if those fail, it goes to brute force.
   This is not "Simple Sudoku" [...] That is a very sophisticated creator and solver with many additional functions built in. The program in this book is a junior version of that. However with the clear explanations of the code in this book and growing skills in VB .Net you can easily add extra functionality and solving methods as needed. Use "Simple Sudoku" to learn how to play Sudoku. Use this book and code to learn to program Sudoku.
   This book would make an excellent introduction to Visual Basic .Net Express. It covers a number of useful techniques for a beginner. As a teacher, I am always looking for projects which are the right size and which are of interest to students. Not everything is covered in this book, however by adding one or two more projects, say an RSS reader with persistence, you have the basics of a good introductory course.
   I recommend this book.



4. Programming Sudoku (Technology in Action) (Paperback) by Wei-Meng Lee
   
   This book teaches more than Sudoku, it covers the process of developing game logic development and intelligence.
   
   There are two games covered, Sudoku and Kakuro. Only Sudoku is covered as a step by step process on developing a game generator and solver. Kakuro, has enough information that a standard programmer should be able to build a generator and solver.
   
   The book is both informative and entertaining to read. When I was finished, I was very motivated to build my own variants.
   
   There is quite a bit of resistance to games built with .Net, specially VB.Net. This book does a great job in showing the power of VB.Net as a competitive platform outside of game development.
   
   The discussion on puzzle solving can be applied to any development language.
   
   Where this book has a short coming is that it does not cover other forms of logical puzzle solving. There are plenty of other methods not covered. An appendix of those, what they are, and what the benefits of them are, would have been a nice bonus.
   
   Over all, I liked this book.



5. This book does a good job of helping a person with
   even minimal VisualBasic knowledge write what ends up
   being an powerful Sudoku generator and solver. I was
   able to get through the example program and understand
   the source code with a minimal amount of exposure to
   VB.
   
   On the downside, a lot of the source in the book seems
   to be redundant. Some of the later
   examples--particularly the advanced parts of the
   solver--seem as though they could have been better
   modularized, making the code-writing less time
   consuming. The math geek in me was also hoping for a
   more in depth analysis of the different solving
   algorithms and their various efficiencies.
   
   If you enjoy Sudoku and want to build your own
   solving/generation program, but really aren't
   concerned with an in depth analysis of algorithms,
   this is a good book.

2 comments about Master VISUALLY Office 2003.

1. I've bought other instructional computing books, but I highly recommend the Visual line. Who wants to wade through a lot of text when learning to create formulas in Excel, or creating a query in Access? This book shows me step-by-step exactly how to do a task. Well worth the money!



2. this is another great Visual Book!, did lack a bit with the in depth Excel functins and fomula's but is one I have recommended to others , as i have done with all the Visual books!

5 comments about Data Structures with C++ Using STL (2nd Edition).

1. Excellent book! It was assigned for my Data Structures course. Basic knowledge of C++ and the way classes work is required, but it is an excelent reference. I would NOT sell this book back to the campus bookstore for anything after completing the class.



2. This text is for sophomore-level students, but as the authors claimed it's a good read for professionals as well, a reason being that a professional of many years may not have learned data structures together with designs and implementations in C++ with STL. Going back five to ten years, the book in its current form could not have existed, which is why it's beneficial for the professional to read it.

   As a professional, I envy the current college students who are lucky to have this book as the text of one of their courses. A student is also given a semester to digest its content, to do the exercises and projects at the end of each chapter, which is not usually possible for a professional. On the other hand, because of years of experience and perhaps plus college background, things students usually and sometimes must do aren't necessary for the professional, who should be able to read through the book in considerably shorter period of time.

   In summary, it's a great read on the subjects, though one star is taken off for its imperfection such as mistakes in the code and less than superior presentation of some materials.




3. Because of physical problems with this book, the authors' programming style, and lack of a proper audience, I just can't recommend it. There are just too many problems and too few positives for the book to be worthwhile.
   
   First, the physical problems with the book: in my case, the binding appears to be bad. As I took it out of its plastic wrapping, I noticed a gap between the cover spine and the glued/sewn binding of the actual pages. It looks like the glue that was supposed to hold the two parts of the book together failed. Turning the pages causes a lot of snapping, crackling, and popping and I worry that the binding will break. Second, it seems like the book uses too small a font (these old eyes don't focus like they used to). Oddly, if I compare the font size to that in other textbooks, it looks comparable. I'm not sure, but I think the publisher used a slightly smaller line spacing and either a lighter ink or darker paper. Whatever it is, it makes reading the book a bit hard. That's pretty subjective and minor, but more aggravating is that the publisher used an even lighter (gray) font for the code segments. This makes the code even harder to read than the text. Again, I'm not certain, but it also looks like the font in the code sections is even smaller than the font in the text. And finally, the authors don't use any color in their code. It's hard to distinguish the actual code from the comments. This makes reading the code difficult.
   
   Next, I highly disagree with the authors' coding style. Essentially, I consider it sloppy. In general, they don't write their class methods to ensure data integrity (and that's one of the big advantages of classes (which are at the core of this book)). Also, the authors tend to directly access private class members within the class methods instead of using the class' already defined public methods that do the same thing (get/set). I know this is allowed, but it's still bad software engineering: you should re-use code wherever possible. Similarly, and worse, the authors violate the principles of data hiding by writing classes with public data members instead of with private data members and public get/set methods. I also have a problem with the authors using "using namespace std;" in their code. Since this exposes all of the C++ standard library methods to the program, it can lead to conflicts. I understand that in a teaching environment this might be good for keeping the focus on the topic at hand instead of "cluttering up the code" with nuances, but the authors make no reference to this rationale. They just blindly use that line in all their code. I'd much prefer they explicitly did a "using std::whatever;" when they needed it. What's especially bad is that they do this in all the HEADERS they provide for their examples (not just in the "main" programs). Anyone who uses any of those headers automatically ends up with all the namespace names included in their code. And, finally, not only are the authors lax in their object oriented programming, they're also lax in their structured programming: they routinely, and without comment, use break statements to jump out of the infinite for-loops (which are feats in themselves) they set up to handle their file input.
   
   Finally, and most importantly, the authors don't seem to have a grasp on who their audience is. In the Preface and the start of the first chapter, they specifically state that the readers should already be familiar with objects and classes from a first course in C++. They note that they aren't about to review old topics, but, instead, will pick up where that left off. However, most of the book is a re-hashing of basic C++ programming. For instance:
   
   - Chapter 1 is a review of programming classes (and, thus, objects) in C++.
   
   - Chapter 2 discusses 1) software design, 2) handling runtime errors, 3) object composition, and 4) operator overloading.
   
   - Chapter 3 covers templates and recursion. The algorithms discussed are those usually presented in C++ programming courses: selection sort, sequential search, binary search, tower of hanoi, and greatest common divisor.
   
   - Chapter 5 goes over pointers, pointer arithmetic, dynamic memory allocation, constructors and destructors.
   
   - Chapter 7, stacks. Chapter 8, queues. Chapter 9, linked lists. Chapter 10, binary trees. Chapter 13, inheritance and abstract classes.
   
   All of this is what I consider to be basic C++ (see Deitel's "C++ How to Program" book to find references to all those things). I just can't see how anyone could learn even the rudiments of C++ without having covered those topics. I could be wrong (in which case, since I've provided my rationale for my rating, you'll at least know what to ignore in this review). But, for all intents and purposes, the authors don't really start teaching anything new until after page 500 (Chapter 10) in a 1000 page (16 chapter) book. And even there, I was so irritated with the various problems I noted above, that I kept wondering how much credence to put in the authors' presentation.
   
   So, in a nutshell, because of the physical problems with the book itself, the sloppiness of the authors' programming style, and their mis-identification of the audience, I can't recommend this book. I rate it at only 2 stars out of 5.
   
   As a side note, at the time I bought this book, Florida State University (FSU) used it in their COP 4530: "Data Structures, Algorithms & Generic Programming" course. They've now switched to a book called "Data Structures & Algorithms in C++," 3e, by Drozdek. I don't know anything about that book, but based solely on this book, FSU did the right thing.



4. having read 1st four chapters, i find Ford and Topp are stingy in examples and theory.
   You'd better do all the programming exercises at the end of chapter since that's where the value of this book lies.
   Thinking in C++ Vol.1 and 2 have better reference material. Please buy Bruce Eckels' "Thinking in C++"!



5. The book itself is great and illustrates the core concepts well.
   The code examples are grossly out of date (were talking 1990's) and completely ruins the beautiful text by adding confusing, poorly written code examples to reinforce good literature.
   
   If you are buying this to learn data structures as a reference, great.
   If you expect usable code examples this is not the book for you.
   Highly Microsoft Visual Studio Centric. Not ANSI C++.
   
   My note to the author's / publisher: You need to keep up with the times. This is technology and it moves quickly. Otherwise future-proof your code as much as possible.

2 comments about XML Processing with Perl, Python, and PHP.

1. XML is not so difficult, but when coping with Perl or PHP, you need something to tell you exactly HOW to do that. Add to this Python, a very well written book, and you get Martin C. Brown's book.
   I think that if you're really serious into programming XML with Python and Perl, you absolutely must have this book.



2. This book is okay, but is your development team really using all these languages? If you need to learn XML with a certain technology, get Professional PHP4 XML or Manning's new Java and XML book and many others. Not only do these books cover the same material as this one, they cover some really advanced topics such as architecture and design issues as well as giving you heads up on the latest versions such as php 4.3.0. This book also doesn't nearly tell you about all the potential problems that you can have with working with PHP where Professional PHP4 XML will answer just about every question you ever had plus everything else you didn't think of.

2 comments about Introduction to Engineering Programming: In C, Matlab and Java.

1. I loved the part where the little dog got run over by the truck and little billy ran after him



2. This book is very well put together. The material is presented in, at times, a jovial manner(hard to do with an instructional computer text). It's easy to understand and the authors have an incredible grasp on the subject matter.