5 comments about AppleScript: The Definitive Guide, 2nd Edition.

1. 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.



2. 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!



3. 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.



4. 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.



5. 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.

5 comments about Building Microsoft® Access Applications (Bpg Other).

1. Easy to read first few chapters with basic design info, remainder of the book focuses on complete applications that can serve as a template/best practice for almost any other MS Access application.
   
   Viescas clearly understands/communicates an in depth knowledge of Access Applications that I have not seen anywhere else.



2. Definitely not for the newbie. This is for the seasoned access programmers. I you are new to programming (at least in access) and are looking for a book on how to program with access, this is not for you. This is a great book for those seasoned programmers who are looking to make their applications better.



3. This book is a good start toward understanding how to build Access applications. Some of the details are missing. An example would include the proper syntax for referencing fields in a form.



4. Very hard to follow, poorly organized and written. Unless you're well versed in Access already, skip this book. Definitely NOT for beginners.



5. This book is written with the intermediate to advanced programmer in mind. There is much to learn from this book on options and techniques to use when building business applications in Access. There is explanations of every sample application and it's function. I would give it five stars if it were not for the title. The title maybe a bit misleading since it talks about building applications since it kind of sways you into thinking that it is a book on the step by step process of "Building Microsoft Access Applications." If you are seasoned in Access programming it is a gem to have in your bookshelf.

5 comments about Managing Projects with GNU Make (Nutshell Handbooks).

1. This book is a good place to start for learning how to manage large projects with GNU Make. It covers the basics and then moves on to specialized topics including writing portable makefiles, increasing makefile performance, and debugging makefiles. I've been using GNU Make for years and still found the book worth reading.



2. I've just begun reading the book and it's a nice book on GNU's make. As already mentioned, it is not a handbook but rather more like a discussion of how to best use make in your builds. That said, I'd like to point out that the text is available on the net for free. If you look at the associated O'Reilly web-page for this book, you can find the link entitled "Online Book" - click on that to see the index of the free, online book.



3. Make has been an icon in the GNU / Linux world for over thirty years now, and continues to be one of the most used utilities to ever be released on the platform. A good number of other projects have risen to take its place as an automated-build utility, but as of yet, none have been able to unseat Make. Some see Make as being too arcane and finicky to survive in the once it is confronted with an advanced, user-friendly, utility of the same purpose. However, as it stands now, Make is still the standard in the `industry', and Makefiles are distributed with almost every major software package on the GNU / Linux platforms (as well as some others!).
   
   Any avid Linux or UNIX power user, as well as most system administrators, will need to have some knowledge of Make to do what they need. Programmers, on the other hand, need to have an intimate knowledge of Make, Makefiles, and what the abilities of Make are. This book is more for the latter group, and goes into detail that the former group probably doesn't need to know too much about. For the former group, I would suggest a more concise, simplified version of this book. For the programmers, this book is a must-have.
   
   As I mentioned before, Make can be a little finicky at some points. This, some may say, is an understatement. There are a number of "gotcha's" in the language, as well as a lot of `hackish' features (when I say `hackish', think Perl `hackish'). Perhaps, more importantly, however, there are a lot of fairly advanced features that Make can handle, and few people seem to use these. This is where the book really shines - it goes over the rarely-seen, but perhaps some of the most advanced features, of the Make utility.
   
   This might seem obvious to most, but the novel assumes that the reader has previous programming experience, and throws C++ code blocks at the reader on the third page of the first chapter. If you don't have any programming experience, you probably shouldn't be reading this book anyways - but I thought it worth mentioning.
   
   The primary content of the book is split into two sections - basic topics, and then the more advanced topics. The author does an excellent job of starting out with the absolute basics, and slowly progressing into the more advanced topics at an easy-to-follow pace. I never felt like the pace was too fast, and the author does an excellent job of giving examples for each of the topics that require one. Each example is explained in detail, with an added bonus of a few "what-ifs" at some points.
   
   In fact, this leads into one of my few complaints with the book. There is so much code, and so much text, and... well... nothing else. There are maybe a dozen and a half pages in the book that aren't just one big solid block of text. After a while, it becomes hard to take. It doesn't help that each page looks almost exactly the same, so after a while, things start to kind of bleed together. In the next edition, it would be nice to maybe see some page styling, new layouts, some more images / tables where possible, maybe some funny side anecdotes or something - *anything* to give the text some life.
   
   Once you accept the pedantry of the text, you will find that it is extremely well written, and easy to understand. There were very few instances in which I had to re-read something multiple times to get an understanding of what was being communicated, and the author's ability to describe even complex topics in simple terms is really impressive at some points.
   
   The advanced sections of the book delve into some topics that I didn't expect to see, and was honestly pleasantly surprised that they made their way into the text. Included in the list of `surprise topics' are alternatives to Make, benchmarking Make, parallel Make, distributed Make, third-party programs that work with Make to add new functionality, and even sections on Cygwin and Make.
   
   Also in the advanced partition of the book were two other sections that I found to be extremely helpful, if not essential: Debugging Makefiles, and Example Makefiles. The Example Makefiles chapter includes both excellent Makefile examples as well as discussion of what is happening in them. The Debugging Makefiles chapter goes over a lot of the "gotcha's" in the language, how to find a problem, and then possible fixes for it. These were both nice touches to the book, and are examples of the dedication the author shows to covering the more difficult parts of the language.
   
   For the purposes of an in-depth, complete tutorial in Make, this book succeeds wonderfully. The author, although a little pedantic in the design and layout, does an excellent job of communicating each lesson. I recommend this book to any professional or hobbies programmer looking to get a little extra control over the build process.



4. Mr. Mecklernburg is definitely an expert in GNU Make and the book shows it. The information it contains is well organized and the author doesn't spend precious time on non-essentials.
   
   The downsize of the book consists in the total lack of fun it produces. The reader has no joy while learning about make and he may quickly find himself yawning at pages and pages of explanations with little or no examples that smooth out the learning curve.
   
   The book seems as if the author tried to show off his knowledge with the best eficiency per page and in the smallest number of pages. He succeeded, at least with me: I am convinced that Mr. Mecklenburg is an excellent engineer but a terrible teacher.
   
   Besides the content not being enjoyable, it is so much biased towards *nix that the Windows programmer righfully asks himself "what about me"? The solution offered by Mr. Mecklenburg for Windows consists in the... Cygwin environment. I'll abstain from commenting on this suggested choice.
   
   Despite its drawbacks, the programmer may find enough material to learn from it and get the job done. But make no mistake: this is not a feat and you'll need quite some determination to finish this book and extract something useful out of it.



5. I've used make and makefiles for many years. In my current product development there was suddenly a need for a little more than the standard make knowledge. For most Open Source tools there is a good O'reilly book, so I grabbed this one from the store.
   
   This book exactly fitted to my need. It does what it should do, it explain make, and nothing more. Already after part 1 I got useful new bits of information. Nothing major, just small "ah-ha, that's how the do it"'s.
   
   The book is structured ok (I felt it could be structured better, but have no suggestion how). It consists of basic and advanced parts. The basic part will cover rules, variables, functions and commands. The advanced will talk about large project, C++, Java, examples and some debugging.
   
   All the basic concepts chapters were pretty good. Somehow I didn't enjoy the advanced chapters too much. I didn't feel I was learning much new things there. The Java chapter was a little odd. I've not met any Java developer who currently uses make, most have switched to ant quite some time ago (book was 2004, so might be changed in the fourth edition). The example makefile of the book was somehow not interesting. The second example makefile was the linux kernel. This was more interesting, but it didn't go into too much details.
   
   All in all, I found it a good book. It gave me exactly what I needed. Somehow the writing style was a little dry. I couldn't really point my finger on what made it so.
   
   I'll give it 3 stars. Not because it's not good, but exactly because it's a good book. However, it didn't give me something extra, which I always hope a book gives me.
   
   Recommended when needing to know more about Make :)

3 comments about Refactoring HTML: Improving the Design of Existing Web Applications (The Addison-Wesley Signature Series).

1. The Web means mostly webpages written in HTML. The popularity of HTML is overwhelming. Yet it has well known problems. There is no intrinsic separation of semantic content from presentation details. And the tag syntax is very sloppy.
   
   Harold explains in clear and strong terms why you should clean up your webpages. Mostly by using CSS and by making [and checking] that the pages are well formed and valid under XHTML. This is not a text on CSS, and if you are going to follow the precepts of the book, you will need another book, dedicated to CSS. The strength of Harold's message is in the clarity. He is trying to influence you in a top-down manner. To make these strategic decisions.
   
   For example, by going with CSS, you simplify maintenance. Because files are factored into CSS files, which layout people can work on, and semantic content files, which can be the purview of others who are more involved with intrinsic information processing. The latter files also have the advantage that they can be used with different types of display devices and programs, and not just for the typical web browser. Think of cellphones, or devices for the blind.
   
   The last aspect is another salient point he makes. Writing pages that are also accessible to the blind is not just good for that reason. It lets you focus not on what the page looks like, but on what it means. Why is this good? Because it improves the chance that search engines will look at and positively classify your semantic files. Search engines often deprecate presentation instructions and CSS files. They are also looking for files with high semantic content.
   
   Also, by factoring using CSS files, the resultant set of files gets to be smaller, which reduces outgoing bandwidth from your web server. For large popular sites, this can be a cost saving.
   
   While the writing of well formed and [better yet] XHTML-valid pages increases the chances that different browsers can accurately show the pages. The reason is that browsers have been written to pragmatically show HTML, where the tag structure is sloppy. To do this, a browser has to make certain display assumptions with a badly written file. The problem is that different browsers make different assumptions. And so some HTML files will not display well, or at all.
   
   There are also other smaller level tips scattered thru the book. Like suppose you have an image that shows essentially only text. Replace the image with text. Less bandwidth is consumed. Plus search engines don't really do much with images. [Image analysis is very intensive and hard.] So giving them more meaningful text instead of images helps your page ranking. As a side note, some spammers do precisely the opposite. They have images which are mostly to display text. To evade a search engine or antispam software that keys off suspicious text.
   
   In related wise, your image tag should always have an alt attribute describing the image. Helps the blind visitor. But mostly it helps a search engine classify the image.
   
   There is one unintended ironic aspect of the book's last page. It talks about hiding your email address in the webpage from screen scraper bots run by spammers harvesting email addresses. One way is to use JavaScript to generate the address. The script is run by the visitor's browser as it displays the page. This is to evade spammers. The irony is that a spammer can use this very method, when sending spam email. Many antispam programs now use a blacklist, since spam often has links to the spammer's domain. But the programs usually [always?] check against static links in an email. The spammer can write JavaScript that dynamically makes links, to evade this. Sure, browsers that have JavaScript turned off will not show these links. But in fact, most users turn JavaScript on, because many websites use it. And the spammer might figure that the loss of links due to no JavaScript is greatly outweighed by being able to evade the now almost axiomatic use of blacklists by antispam programs.
   
   Another example of how technology can be used for completely different and opposite purposes!



2. Despite years of progress by web standards advocates, and a significant improvement in the quality of the HTML on the web, many of us still end up grappling with outmoded, broken HTML on a regular basis. When confronted with a large site filled with broken pages it can be hard to know where to start. Elliotte Rusty Harold's Refactoring HTML offers a step by step recipe book for migrating such sites to clean, semantic code.
   
   Harold's is a well known name in the XML world, and that background shows through in how he approaches the book. While a general audience will probably find useful content, the reader needs to be prepared for a series of command-line and Java-based examples. Tools like tidy are featured prominently, as is the use of regular expressions to seek out broken code to fix and, in the music-to-my-ears category, automated testing.
   
   If you're equipped to do so, following these steps will lead to much cleaner, more manageable sites, but I found myself wondering how many of those comfortable with command line tools and regular expressions are in the market for a book like this.
   
   In general I suspect the key audience for this will be IT departments inside large organisations tasked with refreshing or extending an intranet. For those developers, who maybe don't spend much of their time working with HTML and like the idea of using scripting tools similar to those in their regular workflow, this book's worth a look. If you're already familiar with current trends in web development, then there are probably other ways of picking up on the scattering of techniques that might be new to you.
   
   Disclaimer: I was sent a copy of this book for review by the publisher.



3. First the good:
   It is an _excellent_ tutorial on modern xHTML for those that have used HTML from its tag-soup beginnings. He methodically gives examples on why we, as web programmers, need to utilize a particular technology (CSS, Accessibility, etc). For example, he doesn't just say "Use CSS" because its the new way of doing things. He gives no-nonsense specific examples in bandwidth savings, alternate devices, etc.
   
   His writing style is easy to read for computer geeks: a signature trait of any Martin Fowler signature series book.
   
   He also provides a series of regular expressions that you can use to search through your HTML code to find problem areas and does a good introduction to the program "tidy". Since I am definitely _NOT_ a Regex geek, these are highly appreciated.
   
   And finally, he shows usage of some xHTML tags and attributes of which I was not aware: such as proper usage of and tags.
   
   Onto the downsides:
   Originally I purchased this book thinking that I would be able to use it to get some tools under my belt to better transform the lousy auto-generated HTML that most graphics tools export and update them to decent, modern xHTML. However, the author is definitely NOT a "graphics design guy." And because of that, I know that several of the solutions he provided in his CSS sections would NOT fly with the designers where I work.
   
   If I had seen his website, I probably would have realized that he was an XML expert instead of a design expert and wouldn't have gotten my hopes up. So far, I've found that websites like "A list apart" are much better for working with CSS-based design.
   
   So for those looking to refactor your HTML code from ancient "Tag Soup" to modern sleek xHTML, this is a great book. If you're looking for how to best refactor from table-designs to table-less while maintaining a similar Look and Feel that you've been given by your designers, I find this book highly lacking.

5 comments about Microsoft® Windows Server(TM) 2003 Inside Out.

1. I have not read too many books about Windows 2003 Server but this book is far beyond of my expactations.



2. I needed a comprehensive book on Windows Server 2003 and this is the one I picked after reading through all the others at the bookstore. Stanek has the most comprehensive coverage I've ever seen in a single book on security, filesystems/availability, Active Directory, and most anything else you'd want to know about Windows Server. I've been an admin for 12 years and there's things I learned that I'll admit I didn't even know Windows Server could do. As an example, this book has TWO performance monitoring and tuning chapters. These chapters cover remote monitoring, command-line monitoring, performance logging, etc. Chapter 19 covers both MBR and GPT disks as well as SANs, RAIDs. Chapter 20 covers everything you'd ever want to know about NTFS including hard links, data streams, journaling, reparse points, sparse files, disk quotas, etc. Chapter 22 is covers shadow copy from its internals to everything about how it works. Chapter 24 covers everything you need to know about IP addressing and subnetting. There are two chapters on DNS with everything from setup to troubleshooting. Some of the best coverage is on Active Directory. There's eight chapters and the 300 pages covers more than some other entire books on the subject. Get this book jump straight to Chapter 12 and keep reading until you get to Chapter 41. You'll learn a lifetime's worth of knowledge and get more expert advice than in any other book. Thank you Mr. Stanek for such an excellent book.



3. I recently bought a copy of this book. I saw it on the desk of a colleague at work and decided to have a look. It is really great and I also like the writing style of Stanek. My only regret is that I didn't purchase it earlier. This would have saved me considerably time and effort in researching several administration problems that may crop up from time to time.



4. As a comprehensive Windows Server 2003 reference, there is no comparison as far as I'm concerned. Quality shines throughout the book and it is obviously the product of extensive research and lots of realworld experience. Stanek takes some pretty bland subject matter like DNS, Active Directory, and optimization and makes it understandable. This book made many things clearer for me, and I actually enjoyed reading it. Explanations are so much detailed that you can actually configure your system step by step by following the book. Also discusses the underlying technology in a detailed conceptual way, that gave me the overall understanding and insight of what really is going on. If you are trying to learn or working with Windows networks, this book is a must. The book never makes you confused, and virtually all aspects of networking are covered. You really cannot go wrong with this book it is well worth the money.



5. I found that this book contained information and detail that exceeded what would turn up in a typical web search. The book devotes around 200 pages just to AD. I have several books and this one actually gets used!

5 comments about HTML for Dummies.

1. A few years ago I wanted to learn basic HTML. I figured the best way to do this was to buy "HTML For Dummies" and use it to set up a basic Web site for my church. That way I got both theory and hands on practice. This is exactly what I did, and the book came through for me. I learned enough HTML to set up a basic, but working, Web site for my church.
   
   The only thing I wanted to learn but never could figure out from the book was frames. I settled on tables for navigation since all my attempts at frames failed.
   
   I have since gone on to do a Web site for my cats, a text based site on the subject of the Sabbath, and a Web site to track my weight loss and measurements. I even coded my own little blog at one point.
   
   The next thing I want to learn is some basic CSS to have better control over the Web sites I've created.
   
   I recommend this book to anyone who doesn't know anything about HTML and wants to learn it.



2. I ordered this book along with Web Design for Dummies expecting to get started writing simple web pages. These books are not for dummies. It offers very little explanation of html tags; it doesn't offer pros or cons of the tag usage vs. another tag; examples are not near the explanation-you need to open the cd to view the eample in question. It spent too much time promoting tools and services outside of the "Dummy" concept.
   
   I was very disappointed with this book...I bought another book which out-performed the Dummy series.



3. This is a very user friendly book.
   On another note, I am impressed with the speed that I received my books.
   Thank you Amazon



4. Well I /was/ originally looking greatly forward to this book. I had been a fan of the "... for Dummies" books for a while now. Unfortunately I found this one to be a disappointment. Although I can appreciate having sections on good web page design, I felt it was too much to wait until chapter 4 to code your first page. Plus, there's just too much design-based content in the book overall, and not enough of actual HTML tag-based exercises.
   The examples on the CD ROM are awful. They really don't give any good insight as to how the tags work. Plus, many of the example files are identical. For example, TFOOT.HTM, THEAD.HTM and TR.HTM are the exact same file. That's just inexcusably lazy. How hard could it have been to exhibit some of the attributes of those tags?
   I give it two stars because if you already know HTML, it can be a pretty useful reference. Also, the troubleshooting chapter (chapter 16) was pretty good.



5. I'm never disappointed with Dummies books and this one is no exception. Great read, easy to learn.

5 comments about SCJA Sun Certified Java Associate Study Guide for Test CX-310-019, 2nd Edition - Incredible Update to the former ExamScam Book.

1. Excellent book that covers the exam material well. I bought this book and the sample questions book. Leisurely studied for a few weeks and passed the exam. Make sure you are scoring higher then 80% on all practice exams and make sure you understand the concepts, don't just memorize the questions.
   
   All in all - excellent book, it is a must get for anyone prepping for the exam



2. This book is really the standard if you want to get certified. All of the exam objectives are covered, it's funny and easy to read, and its full with mock tests and sample SCJA exams that are very similar to the real exam you write in the prometric center.
   
   If you can pass the exams in the book, you'll have no problem passing the exam. Just make sure you understand why certain answers to the mock exams are right, and why certain answers are wrong. It's all explained thoroughly in the book, but don't take anything for granted.
   
   The book is written in a very easy to read, conversational style. I actually read half the book in one sitting. It wasn't like reading a technical book, but instead, like having a fun and casual conversation with an expert in the field.
   
   This is the book you need to pass the exam.



3. I am not a huge fan of the certification process but I have noticed that many recruiters consider certifications when deciding between interview candidates so here I am. I took Java as part of my college curriculum some number of years ago so I am not a total newbie although I don't use it on a daily basis. I read the book, went through all the questions, sat the exam, and passed with an 82 so from my perspective the book worked. The book does a pretty good job of covering exam topics and I would recommend it even if you have some Java programming education/experience. I don't think the author will have a second career as a stand-up comedian any time soon but I praise his endeavor to make things a little interesting and trying to keep the reader from dosing off. (which I did on many occasions anyway despite his best efforts)
   
   The only thing I would do differently is carefully review the exam objectives on Sun's website and review the applicable sections in the book or even other sources for anything that I was hazy on. The exam objectives accurately define what you need to know to pass in pretty good detail so study them carefully.



4. This book has several errors which sometimes make me confused. I have to try the question in a real project to test whether the answer is virtually correct. However, since 310-019 is pretty much easy, this book still can be your guide, and you do not have so many choices in Amazon.com, do you?



5. excellent book if your wanta pass the SCJA. I just cannot believe this little book covers all parts of the exam. From MIDlets, J2EE, EJB's to Strings.
   
   You will need to give yourself sometime to study. The exam is for IT managers NOT developers and thats why I failed it the first time....just an FYI

5 comments about Programming Challenges.

1. Very nice collection of programming challenges and very well presented.
   Lots of effort has been done to set up the automated program "judge" (basically an automatic test case generator and regression suite) -- i appreciated.
   
   A little bit confusing is that there are 2 different web sites and different interfaces to this.



2. If you are looking for a book that will :
   
   (1) Teach you how to solve typical problems appearing in the programming contests
   (2) Give you tips to write correct code, quickly
   (3) Teach you novel algorithms
   
   Look Elsewhere.
   
   This book is a mere compilation of questions appearing at different programming contests.



3. the only attractive aspect of this book is its website where you can submit your solutions in order to check them. However their website keeps giving errors. I spent enormous amount of time to be able to only register one of the sites given in the book and I could not register. Hello! What do you want me to do with this book now?
   
   The book is about programming and its website is giving errors. Now, are these authors credible enough? Plus, book is full of typos.



4. The problems are fun and I see more and more and more of these kinds of programming problems on job interviews these days so it's good to be quick at doing them. Beware though that problems are collected by the author from various sources and some are in my opinion, poor problem statements and you can fail their robots until you realize some part of the weasel wording in the problems. It's part of a game they play in the contests, which is more what this book is designed for than what I am using it for. On their web site after you pass a problem, you can then work on trying to beat the best time; that's the most fun part for me.



5. This books is simply weak. There are informal and formal books and sources you can start play in these contests. TopCoder is certainly the best one, ACM-ICPC is the most official one, and acm.uva.es, involving one of the authors of this book, is also an excellent source. But this book is simple useless.

5 comments about Illustrated C# 2008 (Windows.Net).

1. If you are like me, typically when I read a programming book or article, I feel compelled to download the code, and modify it slightly in order for the content to really "sink in". Remarkably, while reading this book, I rarely felt that to be necessary, as his code examples often fully "illustrated" the topic. The result was that I was able to read this book quickly, 2-3 chapters per sitting.
   
   I feel coverage of the main C# topics was excellent, as well as the order they were presented. His chapters on delegates, interfaces, and LINQ were especially good, with very little wasted time delving into esoteric areas that might be interesting, but not very useful. The only negative feedback I would offer is that occasionally topics were addressed to a general programming newbie audience, but I just skimmed those.
   
   In summary, my kudos to author Dan Solis, it's a terrific book!



2. Suppose you knew nothing of automobiles and wanted to know how they worked. A book using this author's approach would first tell you about every kind of screw in the automobile, it's exact size, material, thread count per inch, and type. Chapter 2 would tell you about the nuts into which the screws would be placed. Even for an experienced programmer, this book will tell you all about the trees, but very little about the forest. Why three stars:
   because it's an excellent reference text about the language, clear and thorough.



3. I now have 4 books on C# and this is by far the best (at least for me). The material is well organized with consice, well thought out explanations. In addition, the figures add a great deal of to clarify the text. To me, this book was written to inform.
   
   As I usually make numerous notes this book fits my needs very well with an ample amount of white space.
   
   Thanks to Daniel Solis.



4. You will not read a better book on C#.
   
   The first edition (2005) was great, this one is even better.
   
   If you only get two books on C# then this should be one of them.
   
   But, if you only buy one book... :) then get this one.
   
   Sorry this review is short on content, but the other reviewer will bring you up to speed. (just the ones with 5 stars)
   
   The 2008 version vs 2005 version
   
   It includes a new chapter on asynchronous programming using delegates.
   It includes a new chapter on the new LINQ features.
   
   One small down side in the 2005 version (not sure about the 2008 version)
   
   The author states that fields should begin with upper case letters and local variable begin with lower case. In 2005 chapter on Methods, the author makes the mistake of using upper case for local variables...
   
   This may have been corrected in 2008 version.



5. This is the C# book that I always keep next to me. If I am unsure about some type of class, delegates, interfaces, etc. I open up this book and get right up to speed. While concise, Dan leaves nothing out in terms of details required for effective C# programming.
   
   The LINQ coverage is outstanding! It is so good that I hope Dan does an entire book on the subject. His mastery of informative graphics would be an ideal format for help to save us T-SQL hacks from having to stand on our heads to get at LINQ.
   
   I highly recommend this book.

5 comments about The Art and Science of CSS.

1. This is not a comprehensive A-Z book on CSS, it is a compilation of seven essay / tutorials by five different authors on specific topics (headings, images, backgrounds, navigation, forms, rounded corners, and tables). This book is much like 7 blind folks describing an elephant and whole swatches of the elephant are left uncovered and undescribed.
   
   It seems to be a trend amongst the tech publishers to put out books with multiple authors, yet very few of them provide any cohesive editing and authorial narrative between sections, of which The Art & Science of CSS is an offender.
   
   Publishers and Editors, please either take a cue from short story and essay compilations and give each author an introduction at the beginning of each chapter, tell my why I should care and what this person can educate me on. If that is not the approach you want take, then have one main author or editor who crafts all the chapters into a cohesive whole with good transitions and point of view.
   
   Sitepoint - Hire an editor who can edit. Pick one main author. Introduce the guest authors at each point where the authorship transitions. Give the reader a cohesive POV.
   
   Amazon leads one to believe that Jonathan Snook is the main author, he is not, but has a few bits on javascript & css in several chapters. I would have liked this book a great deal more if it actually was the Art & Science of CSS with a strong voice all the way through, rather than just a few drill downs into a few topics. Cameron Adams or Jina Bolton both had great written tones & POV, why not have one of them "lead" the reader through the content?
   
   
   



2. I've bought and already finished to read this book.
   
   I'm a interface developer with a good background into CSS and XHTML; i think that this book was not written to somebody interested into the fundamentals and step-by-step of the CSS.
   
   It's a collection of code-based insights (for each chapter, 2 or 3 progressive explanations) from the authors; it's amazing if you (like me, when i bought it) are searching for some inspirational examples, relying on standards to achieve impressive visual results.
   
   This book also encloses some aspects of CSS 3, and how it will unequivocally improve the standards-based design, with things like multiple backgrounds, table pseudo-classes, and others, even before the integral adoption of this standard into the mainstream browsers. It put the reader one step ahead, acknowledger of the future possibilities of CSS.
   
   I highly recommend this book. But if you are searching for something less visionary and more instructive, you'll need to search other options.



3. The Art & Science of CSS is a good book if you looking for creative ideas or inspiration for CSS but while the book says all you need to is some familiarity with HTML, you do need to know some basic knowledge of CSS. This book would be a good addition to you web design library but only after you learn the basics of CSS from another book.



4. There are many excellent tips and workarounds offered in this book. I have been working with CSS for a few years now but as it is a moving technology, one can never be "ahead." The authors do a good job of bringing newer tips and tricks forward along with offering some useful workarounds for cross-browser issues.



5. I think there are many books that cover this ground a lot better and cheaper as well. Friends of Ed actually has a couple that I would recommend before this. And most certainly Bulletproof Web Design by Cederholm.
   
   This book is really light on details and light on content. It's not at all worth its price, and it's only covering the very basics in a small number of areas. This is definitely not one of the first books you should be looking at about CSS.