Programming Books

Attention Michael Pachis and others who purchased this book in 2006: I am the book's author and when I saw your comments, I contacted my publisher. If you purchased a copy recently and received it in 3-hole punch format, send me an email and I'll put you in touch with the publisher. They have a small number of perfect bound copies they can send you instead. Use the email address on the right side on my personal web site (kensall.com) home page. I hope this helps.
(I gave this 5 stars simply to not impact the book's current rating.)

This is an excellent book to understand, develop and code XML. However, in the parsing discussions (chp 7-10) an understanding of OOP and Java programming are almost required. Other than that, it is an excellent text.

I want to warn customers that the publisher has gone to a "print on demand" publishing model and this book is not delivered as a paperback, but as eleven hundred three hole punched loose leaf pages! This leaves you with the task of finding a binder after paying 40$ for the book! Since it is book size (8 x 10) it awkawardly fits into a standard 8.5 x 11 binder, not very convenient for reading or transporting, and you need the binder to be 3.5" thick to fit the book in the binder.

I gave it five stars for content, but this new method of publishing gets zero stars.

This book is not an "how to" guide, nor does it claim to be one. I mean by this that if you are, say a Java programmer looking for a book that concretely shows you how to integrate xml with Java then you would be better off with one of the so many Java/XML books on the market.

However, if in your work or your studies you feel that you need to gain a more thorough understanding of the W3C specifications related to XML, then this is the book to buy.

All the W3C specs are available for free on the web. The trouble is, W3C documents are designed to provide a precise definition of a standards, they are not designed to be especially intelligible by mere mortals (however technologically enclined). Some are quite readable, others far less.

Firstly, I really like that this book present all the relevant specifications and working drafts in perspective. Secondly, I found that it does a remarkably good job at translating these specifications (without simplifying them) in understandable terms.

In my work, I am interested in gaining as thorough as possible a view of XMl technologies and this book helps me greatly. I also like the fact that it present a well-organized bibliography at the end of each chapter (sadly many computer books from Wrox, O'reilly, Que an like don't have a bibiography as if to say "everything inside this book comes straight from the author's mind. DO not look any further).

I have reviewed for myself around twenty XML books. I found this book to be one of my top favorite. I recommend it especially for:
- CS students or programmer with a theoretical bent.
- anybody who wants to get a thorough overview of W3C standards.

Where to start? With the concise history of where XML came from and why each design decision was made and how the evolution of specifications took place over the years, or the thorough explanation of all the XML specifications, or the programming and parsing aspects of XML and metadata, or the cool XML timeline poster towards the end of the book? This book has much to offer any person interested in finding out what XML is and why and how it has changed our world.

Kenneth B. Sall, the author of this book, organized this book in a fashion where each section could be studied on its own, and if there are references to the previous sections, they are appropriately mentioned. This way, one does not need to sit down and cover this 1000+ page book cover to cover to realize that the topic of conversation is. The stage is set at the beginning by the author commenting on the fact that XML can describe everything under the sun, even the kitchen sink:

"XML: ... maybe it's everything but the kitchen sink? Say, have you heard the one about the XML Kitchen Sink Language? ..."

I have been working with XML for sometime now, and I am still amazed at how it has grown and expanded in to our everyday lives in the past few years. One can spend months coming up to speed with the specifications and the XML "realm", and that's not enough. This book does not even cover, in a great detail at least, the Web services realm. That alone is a couple of thousand page book. The background topics are essential to any reader: basic XML syntax, DTD, Canonical XML, Namespaces and XML Schema. Once you have these topics covered and well understood, you can jump around to any other part of the book, displaying XML data for example or XML programming API's.

One can spend a couple of hours trying to figure out how these specifications fit in, but the author hs already done the job with a very useful picture inside the cover page. What's your forte? Cascading Style Sheets to convert XML data into a PDF document for example, or an XHTML document to display on a web site? XHTML is also covered in length, if you do not know that is and what it offers over the plain old HTML.
My favorite topics were probably the authors explanation of the XML parsing and the available API's and resources. SAX, DOM, JAXP and JDOM are covered in great detail.
* SAX - the API that started it all. Minimal and light-weight. Fast and event driven.
* DOM - Memory intensive, complex, but very powerful. It's a tree based model, and the tree represents the whole document.
* JDOM - java specific. Can be used with either DOM or SAX.
* JAXP - java specific again, but easier to use than JDOM.
There are also a number of C++ XML parsers that the author touches on such as the Apache Xerces, C++ SAX and many others, but the main topics revolve around the four most popular parsers mentioned. These sections are mostly tutorials and how-to's. Each parser is used in an example and example is analyzed piece by piece. DOM is covered in more detail due to the number of levels (DOM level 1-3) that it has. Since DOM is more powerful and more complicated, the topic is a bit more advanced and would require more attention from a novice. If you read thru the SAX chapter and understand it well, DOM would not be that much of hurtle, but make sure that you read understand SAX first. Java centric API's including XML-RPC, JAXB, JDOM, JAXM are covered by the author to depict how XML can be used and how it would benefit the application - and developers in-turn. The icing on the cake is when K. B. Sall outlines the differences between SAX, DOM, JDOM and JSAX. He talks about each of the technologies in detail, tell you what the advantage and disadvantage of each one is, and then it compares them against each other. By the time you are done reading these sections, you would become an expert in XML parsing and programming.

XLink and XPointer. How can one leave without these two core technologies and tools? They are truly remarkable; easy to use, light weight and easy to learn. Well, they are well covered - as you would expect from this book. One thing about these topics is that they could be very abstract and need examples, and we got lots of those. The example depict the efficacy of how one can use XLink to create complex connections between sets of resources, even though you do not have a write access to those resources. This is very handy and resourceful technique is you need to build an e-commerce site. With XPointer, one can locate individual XML elements, set of elements or even a range of XML data between two points. The ability to specify "range" of elements is where the true power of XPointer is revealed.

The references, the related resources for each topic, simple to complicated examples and a CD filled with goodies, source code used throughout the book and the W3C specifications at your fingertips outline the some of the other benefits of Kenneth B. Sall's "XML Family of Specifications" book.

This book is an excellent resource for learning AspectJ. It is perfectly organized to take you from beginner, novice, to expert as you move through each of the chapters, just as you might expect if you were taking a class in AspectJ.

The author's presentation of the material is straightforward and easy to follow, and his examples are not too involved that you lose track of what's going on. Furthermore, the author has an excellent grasp of the language and is really able to show off the power AspectJ has to offer.

What I really appreciate about the book is that he focuses not just on coding, but also on design; I'm a software engineer and am very pleased that the author discusses an aspect as something to be used elegantly, as part of a well-designed system, rather than just another tool that can be abused. He even discusses several new design patterns that AspectJ makes possible.

I truly recommend this book!

I met the author of this book this weekend, and saw him give a presentation on this material. Finally, a book that shows real uses for AOP.
I have been watching AspectJ since I first saw it about a year ago. My first impression was that it was 'cool', but was worried about giving developers more rope with which to hang themselves. Yes, it was cool, but the most practical examples you would see in demos were thing like 'logging'. I was worried that it would just lead more more ways for junior engineers to 'convolute the code', without bringing much benefit for that risk.
The material in this book, ALONG WITH the support the author had from the Eclipse IDE changed my mind. Finally, there were some real examples involving transaction support, JAAS, exception handling, and more. Furthermore, he addressed these topics in the real-world sense of refactoring existing code to prove his points.
If you aren't using an IDE that gives you some support, then I still have my concerns about 'convoluting' your code; but I am more convinced than ever that AOP concepts are worth putting into my mental toolkit. I have no doubt that the way aspects 'inject' behavior into code will reduce our development time, and make our code behave more consistently (no errors because of inconsistencies in the way common things are handled). If you can add one more ball to the things you 'mentally juggle' while developing, add AOP concepts. This book will help.

I have got this book at local Austin Java User Group meeting. First impression: different cover. Most of Manning books are either greenish or almost black-and-white. This one is yellow.

Part 1 provides really good introduction into AOP. This is the first book I have read on AOP; all stuff I have seen before was online or magazine articles. One interesting fact is that this book took a while to consume, compared to the usual two-week cycle I have for technical books. I guess the reason is that the book has more substance than most of the techincal books and Mannigs does not try to pad their books with API references and other stuff that can be easily found online. After the chapter goes through AOP concepts, it explains AspectJ in application to those concepts. Basic syntax as well as some advanced techniques are explained.

Part 2 has examples of basic applications of AspectJ. Of course it starts with the mandatory logging implemented using AOP. Not a very good example in general, since logging is not really a cross-cutting concern, but works for illustration purposes. Other two application areas discussed in this part are implementation policy enforcement and optimization (pooling and caching examples). Policy enorcement part is really interesting, especially if you are into call patterns.

In general, every part follows the same pattern: first the author discusses the conventional approach, then explains challenges of the conventional solution, provides AspectJ-based solution, and gives one or two examples. Very clean language, easy to follow.

Part 3 discusses advanced applications of AspectJ. First it delves into design patterns and idioms of AOP; it's not by any means AspectJ-specific, so would be useful for any AOP implementation. Examples of patterns are providing thread-safe implementations using AspectJ, implementing security (very interesting discussion on JAAS), transaction management, and implementing business rules using AspectJ. The part ends with AspectJ usage in different development phases.

Two appendices: description of AspectJ compiler and Ant integration - only 15 pages for both. Useful as a reference.

Overall impression: an excellent book. Definitely worth reading, even if you are not into AOP yet.

I loved this book, first of all the introduction is the most interesting presentation of AOP that I ever read.

The other chapters are very good too since based on use-cases very easy to reproduce on projects...

A book to have is you want to learn abour AOP (even if not interested by AspectJ per se...)

AspectJ In Action is a great book to use as an introduction to Aspect-oriented Programming. However, AOP is not for developers to whom Java and OO are still new. Without a comfortable understanding of classes, polymorphism, and encapsulation AOP will only further confuse things.

With that said, AspectJ In Action is a wonderful book filled with plenty of examples and explanations about the well-lit areas of AOP as well as many of the dark corners. I enjoyed reading this book because it starts out with the fundamentals and works its way to more and more complex uses of AOP without getting bogged down in language tangents. Also, the direct application of AOP in real Java design areas is very helpful in getting a better feel for when and how AOP can be applied.

I am looking forward to Ramnivas Laddad's next book!

I have only recently delved into the further workings of AutoCAD 2000 and thought I'd try my hand at VBA Programming. So I bought this book. As an beginner to programming in general (though not to VB6) I thought the book would be a little above my experience.......WRONG!! This book is an excellent publication for beginner to intermediate users. If, as a VBA programmer, you can't find anything useful in this book then maybe you need to consider your career..........Absolutely outstanding

Great book for beginners and intermediate programmers. Want to learn VBA in AutoCAD? This is the book to get. It contains tons of sample code and a full object reference in the appendix.

This is one of the best book I have bought. Within a month's time I was on my own with VBA. Code examples and explanation presented in this book can be digested very rapidly. Of course, it is not dealing with forms at all. But still it is excellent piece of work. Simply click "Add to shopping cart" without loss of any time.

Joe Sutphin covers the broad spectrum of AutoCAD VBA pretty effectively. My number one reference source for programming in ACAD. Much like a dictionary or thesaurus for VBA in ACAD.

That is what I was looking for. It is great for beginners and professionals. You can find many examples and quickly use it in your needs.

I really think this is a great book for beginners in the php/coding area, It's very clear and with a clean and good practice in mind. As for me is not that useful because of my previous php knowledge, but it's a good point of reference for those familiar with php also. Overall... great book, great explanations.

If you liked Stylin' w/ CSS and want to make dynamic sites, this is the book for you. It starts very basic, and builds slowly. I enjoyed it.

Codin' was a good introductory if you already have a solid background in computers (OS, File Systems, file types etc...) and at least an intermediate understanding of html (although to the author's credit he offers some bonus material on html if you don't). It really works well if you are an advanced html person with at least some web design experience but want to dive into scripting and creating interactive websites. He does a good job of introducing php as a language and showing some simple techniques to get you up and running quickly, especially with forms. Not a book for advanced php developers and there is really no javascript which I think would be an important component to show how the two languages can be used in conjunction. Also maybe some explanation as to when php is appropriate vs. say a full OOL (object oriented language) like java or where it might make sense to use javascript instead of php to handle front end stuff. Overall it is a good book. I thought the author could have done a better job of explaining in the form chapter how the form fields can be input into a database but he stopped after explaining the input into a flat file which most people I have found wouldn't find all that useful since a db is the way to go in most instances. He goes into the db in the next chapter and sort of leaves you hangin with the previous form explanations. He circles back around and explains in later chapters but it was a little confusing because you had to infer some stuff to make the connection. Overall I recommend the book though and I have a Master's degree in IT and am very familiar with html, css, and SQL, and now a decent foundation in php.

BTW, I found the code examples offered on his site very useful and helped me get past some of the stuff that I had to infer.

I've spent a lot of time looking for a resource I could use to teach myself php. The biggest problem I've ran into is the book/website either being 1) over my head, or 2) unbearable to read.

Luckily this item was neither of the above. Though I haven't made it though the entire book yet I have found this to be -extremely- helpful and well written. I don't come from a coding background at all so I had to find something that really started from the ground up. I found this to be easily understandable to someone who doesn't get coding. Additionally his website has two extra beginning chapters if you really need to go over the basics (which I did for the coding part).

The language is clear and concise and not confusing or dull. So I would highly, highly recommend this title to anyone from a design background looking to expand their talents. So far it's one of the best I've found.I will definitely look at this other books, the next time I'm in the market for another computer book.

I'm a big fan of Wyke-Smith's "Stylin' with CSS" so I snapped up this book immediately. I'm not finished with it, just yet, but I think I can still point out one thing. I'm reading Larry Ullman's "PHP for the World Wide Web" (2nd Ed.) at the same time, and I find that the two work really well together. "Codin'" moves very quickly, and he tends to gloss over things a bit, but combined with Ullman's more in-depth book, I'm learning a lot. They reinforce one another, I suppose.

This book is clearly a "must have" for anyone developing with VFE. Despite spending a fair amount of time on the VFE Tech Support Conference, attending 2 VFE DevCons, etc., I have found this book to be invaluable. In particular, I like the narratives on the Instantiation of the Application object and Form, along with the discussion of various key properties and methods of the major classes. To the extent that one spends time actually studying these narratives, properties, and methods in conjunction with stepping thru the code, I feel this will reap rewards in the form of better productivity and higher quality applications. For those who aspire to get some depth of understanding of this framework, this book is for you.

This book is a "must have" reference for all Visual Foxpro programmers who use Visual FoxExpress. The information in this book will save many hours of development time. I highly recommend it.

I have read this book twice and will probably read it again. Everytime I read it I gain a little more insight into this great foundation and n-tier development. I especially like the explanation of the step-through logic in Chapter 10 and the explanation of each method in the various objects.

I think that if you buy Visual FoxExpress and buy this book, you will reduce your learning curve by several months.

This book is great for both new users of the VFE framework and experienced users alike. Not only does it provide step-by-step guidelines for building your apps with the VFE framework, but it also contains numerous tips and tricks for experienced developers. A required reference for all VFP/VFE developers!

This book is a crucial part of my reference library. Although Visual FoxExpress comes with good documentation and a sample application, it lacks the step by step walkthrough with explanations on the thoughts behind the concepts. This book fills in the blanks very nicely and helps the reader to gain a better understanding of not just the "how" but also the "why". The authors do not hesitate to inject their own observances and opinions about working this powerful framework. This makes it an interesting read as well as a good reference.

I ordered this book to serve as a reference for my symfony work. It has been an excellent reference guide to symfony, though it is not meant to be a "Introduction to.." or "Getting Started" book. I highly recommend if you work or have a solid background in symfony and need a handy desktop reference manual.

This book is really the definitive guide. It covers everything you need to know to build a web 2.0 application with symfony. It is written by the people behind symfony, so the book is extremely detailed and has a great format that makes it easy to understand. Well done.

The books contains all the information you can find in the online manual on the website of the symfony project.
If you know this before (and I did), the book has the same quality like the online manual, in my opinion a very good one.

I'm a freelancer that was in search of a framework that would allow me to expeditiously develop applications for my clients, without sacrificing reliability. After researching several PHP-based MVC frameworks, I landed on symnfony due to its comprehensive set of features, strong OOP support, PHP5 utilization, and (very importantly) the great documentation. Yes, this book is available in web format online - but I'm very glad I made the purchase so I could learn the framework as I traveled, and it's much easier to use as a reference (I have it sprawled across my desk as I type this review). If you're looking for a great framework, I'm convinced symfony is it. And if you're looking to learn symfony, and have a resource as you build your skills, this book is what you'll need. The only caviat is, if you have no Object-Oriented programming experience, I would recommend you pick up "Objects, Patterns, & Practice" by Apress before learning symfony.

Well written and understandable for such a large chunk of software. You can be the judge yourself, of course, by reading it online before you buy the hard copy. I'd definitely recommend having the real thing if you're just starting with symfony though.. you can't dogear or bookmark the online version.

I'm not an expert in either Interface Design or Programming Methodology, and I've only read a little bit in these areas. As I read this book, I found myself thinking: "You mean this approach isn't standard practice already?"

After reading Ellen and Alan's description of how a UI Designer and a Developer should interact with each other, it just seems so obvious that everyone should work this way. User needs should affect architecture, and technology constrains design--how hard can it be to understand that? But the implications--design and development are iterative, and ongoing user testing is critical to the iterative process--could change the way some people think about programming projects. (The old Specify, Design, Program, Test, Release process seems somewhat naive in retrospect.)

The book has a kind of fun and lively feel to it. It's clear that the authors were having fun telling their various stories, and were excited about illustrating their points. The writing is casual, which made it amazingly easy to read.

On the other hand, once the informal style sold me on the overall approach, I almost immediately wanted a more rigorous treatment. I'd have loved an Appendix that summarized the formats of the various documents, for instance, and perhaps one that reviews the process flow diagram used at the beginning of the later chapters. (As a former academic, I found myself wondering as well about the independence and completeness of the Design Guidelines, too, but that's my quirk. It's probably not an issue most readers would care about.)

I think this book could become one of those that inspires a sort of religious commitment to its vision, and that that would probably be a very good thing.

First let me tell you this is an interaction design (or user interface design) book, since the title of the book doesn't do this job well.

This is one of the books that have great impact on me. I agree with the review written by Kevin Mullet (printed on the book's back cover) that the ideas presented in this book are a bit "dangerous". It is dangerous because they are not the common practice yet. If people want to follow these ideas, they need to have changes. Changes are always dangerous to many people.

Those "dangerous" ideas include:

- Build fewer features but build them well. (The current practice is to build as many features as possible so that marketers can list those features for promotion. Is a product easy to use? Everyone can claim that since there are no criteria for such a claim.)

- User interface design should drive the system architecture, not the other way around. (Modifying system architecture is always hard. If we want to support a certain interaction afterwards, the architecture will probably can't support cleanly, if at all.)

- Technology should be used for user needs, but not for technology's own sake. (Visual design should also be treated the same.)

Last but not least, this book shows that user interface design is actually science but not art. We don't need a graphic design degree to be an interaction designer.

As an IT project manager supporting web applications, sites and portals, this book summarizes the story of my life. Not just a must-read, but a godsend for application developers and UI designers -- two groups who traditionally don't always see eye-to-eye or face daunting communication challenges. Can't we all just get along? Yes! This book tells you how, using simple, easy-to-understand language and real-life examples. End users and customers will thank you for reading it.

I highly recommend this book as an invaluable resource for anyone currently in, or looking to enter, the instructional design field. The authors have successfully been able to present information, which can often be dry and complex, in a clear and easy to read format.

I have a read many books in this area and they have been a fantastic cure for insomnia. This on the other hand is a compelling read from start to finish. Many of the concepts presented will not be foreign to people that work in this field or in the area of product development. However the logical order and detailed examples work brilliantly to drive home the principles.

Publishers in this area should use this book as a bench mark for design and layout for its susinct and logical passage. Thank you very much Ellen and Allan for such a useful tool!

This book has many examples of good and bad web pages and also consumer products. What it covers is seemingly obvious, but apparently not realized by many. It shows how users and designers can work together for optimal result. It should be a required reading for anyone doing user-interface designs. It is good that they actually have a good free product, HUBBUB ... .that was created using this design philosophy.
I didn't give it a 5-star only because, to me, the section of their HUBBUB experience and the conclusion was too long and could have been made more concise. Also, it was disappointing to see their product not following their own design goals well enough, which seemed to make the book less effective.

Robert Hoekman Jr. second book, Designing the Moment, focuses on improving the online user experience. His approach is a practical one: design interfaces that respect users and allow them to feel in control.

Robert's goal is to inspire the web professional to "improve the moment" for users. His storytelling method of explaining strategies makes the 220 page book a quick and fun read. The book contains 30 stories, based on his own experiences of real-world applications and the step-by-step approach taken toward resolving design interaction issues.

The stories are concise, and offer a critique of each phase as changes are made to interfaces. Robert has a "think out loud" method which allows the reader to better understand the decision making process. Question steps along the way and don't hesitate to make decisions you might change in the future. Designing interfaces is an iterative process.

Designing the Moment assumes the reader has knowledge of web design and development; it does not provide the specific code to implement the recommendations. As Robert mentions in the book, "This book is meant as a conversation starter. It's meant to get you thinking".

The book is divided into seven parts:
Part 1: Getting Oriented - give a good first impression to the user
Part 2: Learning - make it easier for users to find their way around
Part 3: Searching - improve the search interface
Part 4: Diving In - great tips on improving forms and video controls
Part 5: Participating - focus on social media
Part 6: Managing Information - how to manage lots of information
Part 7: Moving On - the sign out process

My favorite story in the book is in Chapter 7, where Robert discusses the simplicity of clear labels. Make it easy for users to to use applications. Provide users with simple, easy to understand labels and instructions. On forms or applications, rather than displaying an error message that the user didn't enter information in a valid format, add informative text on the form or application form field that describes what is acceptable.

Designing the Moment is a wonderful resource for information architects, usability experts, interaction designers and developers. I highly recommend it!

Since I'm starting to pay more attention to user-interface concepts and design, I felt this book was required reading for me... Designing the Moment: Web Interface Design Concepts in Action by Robert Hoekman, Jr. Besides offering a number of excellent concepts, he does so in a manner not often seen in other books. He tells you what he was thinking and how he got to that decision point. That's the kind of insight I need to improve my skills.

Contents:
Part 1 - Getting Oriented: Designing the First Impression; Showing Your Personality; Zen and the Art of Navigation; All Links Are Not Created Equal; Getting Your Head Out of the Tag Cloud
Part 2 - Learning: Surfacing the Trigger Words; Labeling the Interface; Beyond Words and Onto Video
Part 3 - Searching: Making Suggestions; Getting Through the Results; Refining Your Search
Part 4 - Diving In: Standardizing Playback Controls; Nailing Form Layout; Conquering the Wizard; Going the Extra Mile with Inline Validation; Simplifying Long Forms; Getting Them Signed In; Counting Characters
Part 5 - Participating: Building Profiles; Editing; Making Social Connections; Designing the Obvious Blog; Inviting Discussion; Getting a Good Rating
Part 6 - Managing Information: Making RSS Meaningful; Tagging It; Getting Reorganized with Drag-and-Drop; Managing Interruptions with System Notifications
Part 7 - Moving On: Signing Off; Dusting Off Dusty Users; Letting Them Go
Conclusion: The Keys to Great Design

Hoekman is well-known for design concepts, and I tend to like what he comes up with. The difference here over other books is that he starts off with a request or issue to solve, and then takes you through his mental process that got him to the resulting solution. For instance, All Links Are Not Created Equal... The need was to create a list of links for a call-center intranet page. The idea was to somehow communicate the current issues affecting the users, in chronological order, maximum five links. I would take the normal route (which is where he started) of just putting the last five links out there. But to communicate chronological order, that wouldn't work. Then he placed numbers in front of each link (1 to 5). OK, but still "flat" as he termed it. He started trying to incorporate a concept he learned about called "ambient signifiers", or ways to communicate information based on the way it's displayed. This led him to drop the numbers and use decreasing font sizes to show order and importance. Much better, but he still wanted more. He then stumbled on an "aging" technique whereby he would not only decrease the font size, but also lighten the text color the further down you went. This combination communicated both importance and age, and was exactly the solution he was looking for. Notice that he didn't go into it with a preconceived "spec" as to how it would work. But through his mental conversation, you see both how he got there and why he made the designs that he did.

I'm perfectly happy admitting I don't know it all when it comes to design concepts. But what I don't like is to read "do it this way because I said so" material that doesn't explain why. Hoekman makes that rare jump beyond "why" and reveals the imperfections and dead-ends before you get there. As such, this is one of the most valuable design books I've read.

I was was really excited about this book, because designing the obvious laid out several principles that was amazingly useful.

This book turned out to be a little disappointing. The principles are not as deep, and the examples are a little dated. Given the focus on examples, this would have been an excellent book 2 years ago, but now it seems dated.

This still serves as an excellent book if you are new to newer forms of information representation, but I dun think it is that great for veteran web2 designers.

I haven't read Hoekman's first book yet (but plan to now). I took this book on a 4 hour train ride last weekend and devoured it. It was like sitting with a friend and chatting. I dog-eared a lot of pages, each with a different client in mind and couldn't wait to get back and make some suggestions. I know at least one reviewer said this is old hat...Not for me it wasn't. I started as a print designer and moved into web out of necessity. I mostly do simple html sites. But more and more clients are needing to expand and I'm needing to know how to help them do that. I feel better equipped thanks to reading "Designing the Moment". I particularly loved Part V: Participating.

Sheila Hoffman
http://www.hoffmangraphics.com

Like many of you here, I write web apps. Some are written in the context (and confines) as hobbyist, others are for the job. I'm fortunate enough to have my passion and my career follow parallel disciplines. Unfortunately, it means when I'm stuck on something, its effecting me TWICE as bad as I can neither work nor play! I found this book quite by accident, digging through the digital stacks on web applications, and rocketed through it within a weekend - seriously, I winced every time I closed it, and could only think about when I could squeeze in some more time with it.

First and foremost: this book is not a "How To" in the strict sense of the phrase - it will not give you a primer on web application design from end-to-end. Which was great, I wasn't looking for someone to come around and up-end my own methodologies, my own principles, etc and tell me "this is how you do it." Instead, this book is a "this is how I do it" book: Mr. Hoekman will walk you through efforts he himself has made on behalf of his clients to better their web application experience. He describes and defines these zen-like 'moments' when the interface just 'works', and how he looks to create them whenever possible. The book is beautifully illustrated as these ideas take shape so you can see the progression. He really broadened my understanding of some core concepts on interface and how they are perceived by users that I have been overlooking, or simply ignoring as being irrelevant.

To re-state: you won't see a single line of HTML/Javascript/Perl/PHP/Ruby here! It's a wonderful departure from the tick-and-tack of the technical and I plan to keep it within arm's reach for those times when I need a mental 'reboot'.

I ordered his earlier book, Designing the Obvious, recently as well and can't wait. Robert: If I ever run into you in a Phoenix-area Starbucks I'll have to shake your hand ;)

This book is a great resource for when you're looking for that specific line of code. Its terrible to read from front to back, but its an excellent way to find exactly what you're looking for. Its so much code, it'll make your eyes bleed.

Director 8.5 is a monster application with huge range of functionality. Nyquist's "Bible" uses CD-ROM-based tutorials to carry you through the concepts with relative ease. The tutorials are part of one continuous complex project, taking the reader from the basics through media management, interactivity, project management and some pretty sophisticated Lingo programming. It is also organized to allow easy reference for specific issues. Having recently completed an 'Emedia & Design' programme I would have to say that Nyquist's book is probably the most valuable text in my library.

There is no better book with which to get involved in Director. I've read nearly all of them; nothing else comes CLOSE! Get IT! ENJOY IT! LOVE IT!

Este libro es realmente extraordinario para aprender a usar director, pues se ve desde el uso basico de cada herramienta aplicando los ejemplos que incluye el cd-rom.

Recomiendo este libro a quien nunca haya usado director antes, y para aquellos que habiendo usado, solo han aprendido por su cuenta sin referencias técnicas.

A well written book of the "Bible" series! Great examples and delivered in an understandable "lingo." This book is a must have for all Director developers regardless of your level or experience. There is a ton of useful information for everyone.

I just can't wait until I finish reading the entire book before I post this review because this is the best PowerBuilder book I have ever read. This book leads you through the steps on how to develop a distributed PowerBuilder applications. This is a must have and the only book you need to learn how to write DPB applications. Well done, Michael !!

This book cover all aspects of Powerbuilder Distributed components. It is clear, informative, well written and contain many examples. Although covering what is generally considered an advanced topic, this book should be understandable by Powerbuilder beginners. Most technical books covering a product are bad. This is a welcome exception. Overall an excellent book.

This book is very helpful in covering all of the details of building an Distributed PB Application. I recommend it for others to read for it is very helpful and informative.

If you are a Powerbuilder Guru, you must read this book, otherwise you'd take the risk to know less than your apprentices. If you are a novice, you must read it to become a Guru. Don't loose time with me, go to buy one!

Distributed Application Development with PowerBuilder 6 is dedicated to distributed application development in the PowerBuilder environment. It focuses on Distributed PowerBuilder. This text is packed with code samples to guide you every step of the way. Also included is a robust server framework I have used on real-world projects. A "must buy" for anyone preparing to go to the next level of PB development!