Human Interaction Books

Its not a bad book but its not exactly what I was looking for. Having said that there are not many books telling you what this does, so it becomes a must buy.

Many of us who are developing applications using CAB/SCSF could use a comprehensive "How To" book on this topic. Unfortunately, this book didn't sieze the opportunity to deliver such a book. There is *some* good information in the book, and the Introduction chapter nicely whets the appetite. Unfortunately, the rest of the book falls far short of providing the necessary guidance and examples to make it truly useful. There is certainly enough information in CAB/SCSF to fill a book with at least twice the content of this one. It makes me wonder whether the book was rushed to market or whether the author and editors just lacked the will and fortitude to write the type of book that this could have been.

If you are looking for a 3k page bible on SCSF and CAB, move along partner, because this ain't it.
If, however, you have been wanting to work with SCSF but couldn't find a good starting point, this is your book. If you've heard the alluring call of SCSF's decoupled architecture and want to get your feet wet, this is your book. If you've done The Walkthrough and found that you still didn't understand what it really *meant*, this is your book. If you are developing in the SCSF but want to read about pitfalls, tips and tricks from someone who has already traveled that road, this is your book.
This book begins top down by explaining the decoupled architecture and its benefits. It then dives down a level and explains how the WorkItems, Collections and Services work together to enable the decoupling. Finally it dives one more level and hits upon some key Services, Event Brokering, Action Catalog and some of the other "big" pieces of SCSF. At key points you get prudent advice about how real products are using SCSF features in deployed applications in the real world.

To summarize: If you are already an SCSF god, there is nothing new here for you. If you are an SCSF neophyte, this book is a worthwhile read to shortcut the SCSF learning curve.

David's book provides a necessary foundation for anyone wanting to become proficient with CAB programming. Unless you are already an experienced CAB developer or are looking for low level CAB framework details, this book will be of great benefit. A real asset in helping you understand the complexities of CAB, the SCSF and get you started toward successful CAB development.

I found this book to be well worth the money.

CAB on its own is a large topic, add SCSF and the amount of information is overwhelming. David's book is an attempt to distill and present enough information to shorten the learning curve, and enable someone to make an informed decision about what CAB can do for them. This book is not intended to replace the official Software Factory documentation, but it does provide a valuable piece of the overall puzzle.

David's book clearly explains some of the history behind how CAB became what it is today and how real world experience is guiding CAB's evolution. There are examples which leverage David's experience with the product to supply valuable information available nowhere else.

There is certainly a need for more detailed documentation and David shows in this book he has the knowledge and experience to write a volume 2 on CAB & SCSF Advanced Topics. And I for one hope he does so real soon.

This book is really out of date and is not the GUI toolkit I hoped it would be. I bought this book hoping that I would be able to copy and paste in the code into my project but that isn't going to happen. The code was rushed together and isn't very impressive. There's much more in the GUI sample that displays all the Directx ui widgets in the DirectX SDK.

Being very favourable it could be called a code listing. But the code is incomplete, the naming of the variables and methods seem almost purposefully misleading and the actually logic in some of the code is just off.

Avoid.

Many other reviews covered this but I will briefly restate what others have said.

PROS (not many)
- Easy reading book.
- Doesn't assume too much on the part of the reader. DirectX basics that are used was covered, etc.
- I don't agree with all of the control messaging system but the author's coverage/design is not too bad.

CONS
- As stated before, code in book does not match code on CD. Code on CD has some compilation issues that upon investigation are fairly straight forward to fix. Fixing requires knowledge beyond the basics of programming.
- The compiled executable examples, with very little happening on the screen, run very very poorly. I believe one of the basic issues with performance is with the overall design. That's a problem because then the book is pretty much useless. I suppose to be fair the writer might have been targeting a larger audience and not just gamers. WM_PAINT posted messages are done. That's slow. No respecting game engine will post paint messages, they will gain full control over rendering the window or full screen and "talk" directly to the Direct 3D device interface.
- (This one is personal) I do not like the coding style. Also, anytime a C++ programmer use "this->" the "this" pointer within the object itself doesn't fully understand that you don't need to fully qualify the pointer.

If you're looking for decent code with somewhat decent comments then save yourself some money and just download the DirectX SDK. In it, you will get many examples of UI things. Microsoft created a CustomUI application which runs very, very fast and handles GUI things very similarly to this book. But Microsoft's runs much faster. The problem with that is you won't find a very detailed writeup on "why" things are done the way they are. At least I haven't found it.

I read it once and i liked it a lot but then the second time i started Coding along the lines. And i am sorry that i have to say this but the code just doenst work the way its in the book.

The Code on the CD is a bit better but still there are things in that code that just wont let me compile it. I checked the Msdn and everything and its just not right.

I wish this book had a website with corrections because the book itself is good and thats what leads me to write this. I liked reading the book and wanted to program the stuff so bad and so i expected more from the code in it.


I hope this helps

First off, the book is good at learning how to design a GUI. It goes over all of the necessary information that will let you create a functional GUI.

However, there are problems with this book that others have stated. The code in the book and the code on the CD are VERY different. What you see in the book (screen shots of the examples) is not what you see on your screen when you run the code (the graphics used are very different too). This makes trying to learn some things very hard as you can't look at the code in the book and compare to it the code on the CD. If you have a question about how or why the code is doing something, a lot of the times, the answer is not in the book because the code is different.

There is also errors with the code on the CD. It compiles and runs, but the textures do not display correctly (they seem to have some wierd scaling going on). A 100x50 texture will not display as 100x50 on your screen using the code in the book, and there is no explaination in the book on how to draw the textures to their scale.

The best way to use this book is to use it as a guide to design your own GUI in your own graphics engine. Just using the UI code provided by the book is not something I would recommend.

It need more summary and definition of key term

I highly recommend "Social Psychology" to practically any adult who can read. We are social beings and understanding each other helps us to create better relations. A better world. This book is excellent to examine and understand not only others' behavior but also ours.

Here is an excerpt that caught my attention: "how we interpret, analyze, remember, and use information about the social world-suggests that we are far from perfect in our ability to think clearly about other persons and reach accurate decisions or judgments about them."

"Social Psychology" covers many branches of psychology but the chapters give you enough information to learn just the basics. I think that this is great for lay people or new students in Psychology. I found that the personal stories that both authors used, helped me to better understand the topic of the chapters; however the, I met this psychologist and have been friends with since, led me to believe that this reaction was due to a schema. Perhaps our society has created a schema in which others' names define who we are. I particularly don't sympathize much with this.

The colorful pictures and cartoons in the book, I enjoyed greatly. I tend to be very visual in many occasions. In fact, I feel that many of the pictures were more thought provoking than the text. I found them very helpful to understand the subject. I also sensed that the targeted audience was mainly young students since many of the studies were conducted or focused on young students. I just wished that the authors had not forgotten that there are older people (like this book reviewer) who go back to school or who want to learn about social psychology. Once again, I highly recommend this book to anyone. You'll learn to view the world under a new perspective.

I read several chapters from this book before I took a social psychology course, and saw that it was indeed very helpful. The author uses a lot of examples, which makes the concepts understandable. Also, the narrative text of the book is very high in quality according to me. It's pure, understandable, friendly and in harmony. (Look at the Franzoi's 1st edition: You will understand what I mean by no-harmony). I strongly believe that to write such a good book should have taken much time for the author. In addition, the author most probably had had an empathetic approach to understand the needs of the student and write accordingly. I don't mean to harm or criticize in any way those that made negative comments on this book. Nevertheless, let me convey you my opinion. According to me, using "I", the author only intended to provide a warm atmosphere to the student sharing his experiences and understandings. But, this is a way to encourage the student think of his/her own experiences in real life, which causes the assimilation of the knowledge more effectively. It's not to advertise himself(author), as far as I perceived from the book. Another thing is that, in psychology, phenomena that seem not logical to a human eye may be significant in a statistical sense. Very small differences, after the elimination of the error margin, may still be significant and therefore, meaningful. In the book, there are graphs not starting from the 0 point, and thus the difference may appear larger when looking superficially. Nonetheless, when looking carefully, undoing the illusory magnification, still the difference is observed, and I believe that the author made focus on the significant part of the graph to draw the attention of the reader and to make him understand better and easier. According to me, this is a good feature of the book and intention of the author.

As a university psychology instructor who favors a text demonstrating good science, I appreciate the careful documentation of research contained in this book. I also appreciate the personal touch of the anecdotes at the beginning of each chapter as a way of making the subject matter relevant to students. The authors do a masterful job of presenting a complex field, such as social psychology, to the college student. Teaching psychology as a science is a real challenge today and this text offers instructors a powerful tool for that purpose.

I make specific what book this is a review of, because if you look at the user reviews for Shelly Taylor & D. Sears' social psychology textbook, you will find the exact same 5 reviews as are below mine. Either Amazon or some user are up to something sneaky.

Despite the comments below, which may or may not reflect someone who has actually read or used the book, my comments are based on using this book when I took the course and ordering it for a course I am teaching this summer.

Regarding the infractions cited below, I have not found this text any worse than others. It covers a wide range of an exciting subfield of psychology, and it does so in a way accessible to an initiate to the field. Allyn and Bacon provide excellent support for the text, as well.

Finally, I wish to note that while I am currently working in the same Psychology department as Donn Byrne, the second author, we are not affiliated in any way.

This book is at best a sequel to "Design of everyday things". He delivers with a few interesting anecdotes but never really dazzles. As a fan of the other book I found this one to be a disappointment.

This book was very interesting, as all of Don Norman's books are. In this book he goes into detail about how future designers will need to design future devices, how they can make them more useful and more human. He talks a lot about how what sounds like seemingly 'no-brainer' new features (radar-based minimum distance following cruise control) can actually cause problems (speeding up when you pull off the road, slowing down when you merge into traffic.) He gives suggestions to designers on how to avoid these types of issues and how to design things that are truly useful for humans.

I thought it was a fascinating book and I learned a lot about design from it. He goes over the problems that making things too smart can cause and notes that when designing new devices the human interaction is the critical problem. A lot of future design will have to take into account how best to control human reactions in addition to providing the best features. Our devices are sometimes too smart (but not smart enough) and need to be designed to help humans in different ways than is first obvious.

A fascinating description of what can go wrong and how to design around it using a system view.

As Donald Norman points out, design today is taught and practiced as an art form or craft, not a science with validated principles through experimentation. Working with this premise, "Design of Future Things" (an ambitious title to say the least) is the authors attempt to move us towards distilling some universal rules on human-machine interaction.

For the most part, the book reads as a collection of essays - offering a fusion of discussions on industrial and "artificial intelligence" design patterns. Key takeaway: we need augmentation, not automation; machines should act deterministically, without introducing uncertainty.

Why four stars? Donald Norman skips over the non-physical world on which we all have come to rely: the internet, and how it is transforming everything around us. Virtually everything in our lives is now tethered to the online word, and it is only going to become more influential.

Having said that, still a highly recommended read, along with Donald Norman's previous best sellers: "Design of Everyday Things", and "Emotional Design."

Much of the book reiterates and repeats the same points over and
over again about communication between machines and man but I found
that it was very limited in scope. From what I have read in technology
advances I am forced to conclude that this author has not done adequate
research to write what the title suggest which is a much wider scope than what is written within its chapters. A more correct title would be
"The communication between man and machine" or "Communication between
future home appliances, cars and furniture with man". It patronizes
computers as hardly being suitable candidates for future sentience.

Given that we have had millions of years to evolve I hardly think
that this could be concluded from only about 60 years of computer
technology...certainly in light of the fact that all of NASA's expensive computers in the 1960's Apollo era filling out an entire room does not approach the computing power of even a single laptop computer today.

In general buying a book about future technology is not as informative as
reading about articles on a daily or weekly basis because the shear
breadth of the subject does not do well in book form where it quickly
becomes outdated. If you are reading about history, language an
autobiography and so on you are more likely to be adequately informed
because it is not an evolving topic and only a few new things get discovered over the years to amend to what you already know. On the
other hand if you are reading about PAST technology such as the works
of Tesla and his D.C. motors then you are on a topic which fits into
history which is adequately constrained in its breadth and is not
evolving unless you believe Tesla is somehow alive like Elvis and is still inventing new machines that no one can can guess at.

I did not find this book as thought provoking as I would have liked. I agree with the author on his various design principals - especially the idea of machines augmenting rather than completely automating tasks. I smiled at the anecdote about beeping from household devices as I have experienced that myself (Is it the smoke detector battery? Is it my cell phone discharging?). Obviously, there is great progress to be made in the design of common everyday devices. However, the examples kept coming back to cars (and often horses) which became repetitious; instead of getting excited about the possibilities of the future, I became concerned and even depressed. I definitely recommend skipping the Afterword which contains a fabricated conversation between the author and a machine.

A very good book that provides a solid foundation in a clear and easily readable format. If you're after a quick "HCI fix" or are trying to satisfy a course requirement where usability is seen as a niche then look elsewhere. If you want a good understanding of HCI and have a desire to make things more usable then this is a worthwhile read.

I used this book when teaching senior undergraduates HCI. Admittedly, it is quite dense, which made some of the reading assignments a bit of a bear for the students. The thoroughness, however, is a large part of what I liked about it. I only used minimal supplemental materials, and I found that using this book, students got not only an in depth history and theoretical underpinning of this important field, but they also got some insight into emerging related fields, like ubiquitous and mobile computing. I was very pleased with the rigor applied to the lessons, something very necessary as we in the field demonstrate there is real "science" and "theory" behind what we do.

Let me begin by saying that years back I won an international award for something or other to do with contributions to ergonomics - the design of a computer system in fact. I looked at this book as a possible text for an undergraduate course I teach. This is a good book, despite the reviews, if you have the time the read it. It is thorough at the theoretical end and pretty damn thorough at that. If you want to know the history of HCI, recent and possible developments, this is a good book - but it is just too long for most undergrads and this is the main problem. Most undergrads believe that HCI is just pure waffle and in many cases that is unarguable - it takes the likes of Jef Raskin to restore some intellectual credibility to the area.

One the major strikes against this book, and it isn't alone, is the lack of connection with actual software packages in common usage and the alleged 'software engineering' skills they require. For too long HCI books have operated at a distance from actual 'multimedia' software or else have assumed that everyone has a bespoke lab of geniuses under their arms when a novel tool is required. This book, despite the calibre of the authors, does nothing to challenge the "grandstanding" that defines most HCI. Over tweny years ago, when I worked on expert systems, there was a creeping scepticism about their practical value - a solution in search of a problem. I would have liked this book to have done more to convince me that this epithet is not applicable to HCI. I hope the next edition expresses that reassurance.

I'm a CS student with 7 years of IT experience. This book is compulsory for my course so I have no choice but to read it. I would rate this book among worst IT books ever. Although, some ideas suppose to be useful, but the language and lack of illustrations make them dull and unclear. Moreover, it has unreasonable complicity to describe a simple idea or situation, definitely confusing readers. It's kind of funny that one of the main purpose of this book is to teach you to design a good and understandable interface, but in opposite, it has a quite bad interface itself.

I am currently studying CS at university and one of my classes in HCI. All I can say about this book is that even the tutor for the class hated this book - as did all the students - so much so that the next semesters' book is going to be something else.

This book is informative, well designed and, in general, a good book.

The only thing I did not like about this book is the errors that it contains and the fact that the publisher doesn't publish a list of errors. Sometimes the explanation says one thing and the code that goes with it says another. (ex: Take a look at page 27 (the code) and take a look at the explanation on page 28. It claims that if eventDelete returns TRUE, the window closes. The code says otherwise)

Please put some pressure on the publisher so that he corrects the book in a second printing.

This book is a fast and easy intro to gtk and gnome programming. It contains large, complete examples which are good if you want to do what everyone else is doing. However, I'm trying to draw data and I need something better than calling gdk_gc_set_foreground(); gdk_draw_point(); 256 times for every data set.

He uses a large number of gdk routines without providing any overview. The routines are explained where they are used but it's very haphazard. Most of the routines I need seem to be missing.

The references for Gtk and Gnome widgets list functions, enums and signals for each but doesn't explain anything about them. Parameters and return values are only discussed in the text if they are actually used.

This book started out very good, although it doesn't explain alot of the widgets and getting data from the widgets very well, for example i had search for around 2 hours for ways to get data from the OptionMenu widget that was not explained at all in the book. The book also lacks good discription for what each function does in the GTK+ reference.

GNOME/GTK+ Programming Bible is a good book but has many short commings. The good part is that it discusses some of the more advanced features of GTK+ and GNOME; specifically Paned windows, MDI windows, and Scrolled windows. The examples are generally very simplistic and way too many of the function call parameters are never explained. In the listing of GTK+ and GNOME features, the main calls are completely omitted; listing calls that support the main Widget building call. Only the function prototype is given, with no explanation as to the meaning of the call parameters. This said, I still find it a very useful book for the examples it provides that do not appear in the other books. The appendices appear to give a fairly complete listing of: Inheritance, Arg Settings anf Getting, Enumeration Types, Signals, Functions by Return Type.

This book is informative, well designed and, in general, a good book.

The only thing I did not like about this book is the errors that it contains and the fact that the publisher doesn't publish a list of errors. Sometimes the explanation says one thing and the code that goes with it says another. (ex: Take a look at page 27 (the code) and take a look at the explanation on page 28. It claims that if eventDelete returns TRUE, the window closes. The code says otherwise)

Please put pressure on the publisher so that he corects the book.

Rosalind Picard's book shouldn't have broken new ground, but it did. The ignoring of the role of emotion in computing is both appalling and typical. Picard begins to rectify this "oversight" ("Whoops, I forgot humans have feelings!") in a fascinating and useful book.

This book is meant for a pop audience. Its completely out of date and does not take into account the vast research at major computer-human interaction conferences such as ACM SIG-CHI

This is an interesting book, and I strongly agree with Picard's assertion that computers ought to be able to "recognize" and respond to human emotions. She does an excellent job of making and supporting this point. The other part of her thesis, that computers themselves should have "emotions" is much less clear. She never seemed to adequately make the case that a computer with its own emotions would be of any significant value for anything, and frankly I can't think of any useful applications for such an ability. Some sort of emotional component may be needed to fully support and achieve AI (and she makes this point) but in terms of sort of the standard user interface types of applications it's hard to imagine how such a capability could be useful.

Anyway, good book on a very interesting topic.

In pop-culture there is the usual dichotomy between someone who "thinks with their head" and one who "thinks with their heart". In fact, the more enlightened thinkers realize that this dichotomy is at least half false: people who are emotionally-impaired are not more rational than the rest of us, but are rather quite crippled and incapable of facing everyday life. (Though if you are not already convinced of this, this book will do little to persuade you.)

At the time when I first read this book, nearly a year ago now upon the recommendation of a friend, I was already convinced of the usefulness of emotions in AI, and was hoping to find some real concrete and useful results here regarding AI-emotion, which I could then apply to the design and construction of an AI which would presumably be of use to someone in the real world. Much to my dismay, there are NO such applications listed; Picard suggests that AIs should be given emotions, but doesn't bother to give any real applications in which these emotions would be useful, or what kind of emotions they should be given, or even what an "emotion" is for an AI!

The book discusses almost exclusively the problem of AIs, not having emotions, but understanding the emotions of humans. Sounds great, how about some applications? Picard then proceeds to suggest the most absurd applications imaginable; here are a few of them:

-Emotive Markup Language: Modify the hardware of a keyboard such that the computer can tell how much pressure was applied on each keystroke. Then have the machine interpret these pressure levels as "happy typing", "angry typing", etc., and then mark each portion of text appropriately, with say, big red bold letters for "angrily typed" word, and so on.

-The understanding user interface: The user interface receives occasional feedback from the user, (blood pressure levels, questionnaire, whatever) from which it is to judge the user's mood, such as anger or frustration, and then try to help the user out somehow if the user is becoming frustrated. Little does Picard realize that most users find a clairvoyant-wannabe computer more annoying than helpful.

-Intelligent Answering Machines: Our answering machine receives a phone call, and presumably by talking to the individual on the other line, gathers some information as to the phone-call's content. Meanwhile the answering machine is monitoring the emotional-state of its master, and if it infers that its master is in a mood that can be interrupted, and that the phone-call is of interest to its master, then the answering machine will tell its master that there is a call waiting, otherwise it will just take a message.

If those are the most important problems facing an AI-researcher today, then the problem of AI must already be quite solved! In fact, in the past year I have been further enlightened, and have realized that AIs in fact don't need emotions: just because humans need them is no argument at all that AIs need them! It is foolhardy to simply give AIs emotions without understanding WHY emotions evolved: we would just be copying superficial similarity; feathers aren't the key to flight! It turns out that emotions are evolution's own peculiar way of implementing probabilistic reasoning and goal-systems: every emotion can be translated into purely decision-theoretic terminology. For example, "curiosity" is a heuristic which can be replaced with a system which sets up experiments so as to maximize its expected information gain on each experiment.

Of course, Picard could not simply say as much: she hints several times throughout her work that she believes in god, and that she intends her AIs to appreciate god as well. For example, we have the following quote:

"A system that truly operates in a complex and unpredictable environment will need more than laws; it will essentially need values and principles, a moral compass for guidance, and perhaps even religion." (page 134)

Funny, I seem to be doing quite fine without religion!

Overall and like most works of pure-philosophy, this book is intellectually quite sparse: Picard says more or less everything she has to say in the first 50 pages, but then somehow manages to drag her book out for another 200 pages by mentioning various things only tangentially related to the topic under discussion and rephrasing what she has already said. This short review alone contains a good deal more content than do a dozen pages from this book.

A fascinating book with many implications for the fields of artifical intelligence and human-computer interaction. Picard provides a rich background on modern research in emotion and puts forth compelling arguments for the need to incorporate affective abilities in computers as, perhaps, the only way to allow them to respond intelligently to their environment and make rational decisions. An entertaining and mind-opening read.

It is obvious that the authors do know their topic (Qt4 programming).
It is much less obvious that they master the technique to write a good programming book!

This book has lost of un-necessary verbiage but lack a clear sense of structure. The differences between the platforms (for me Windows/Linux) are poorly documented... so trial and error has been the mode to get simple things done.

Another comment would be the poor formatting of the examples (position of curly brackets etc...) making the example a lot less readable that their should be.

Conclusions:
1) I have not yet picked up another book, but this one was not my best purchase! I will probably at the usually good O'Reilly Books.

2) Usually Prentice Hall is a great editor, but this book may have been "rushed out" before it was ready. Suggest some prudence there, or possibly sell this book as a "Alpha Release" book?

In my opinion, the authors of this book used an inappropriate technique for explaining Qt concepts: they repeatedly show long excerpts of source code (C++ with Qt classes and macros) and then go through the source code line by line explaining what we are seeing. It's like exploring an art museum with a magnifying glass held 2 inches away from the paintings. You never get the big picture, you can never stand back and see Qt from the top down, you can never get your arms around it. Just these endless examples with fantastically detailed explanations in which absolutely critical concepts are buried deep in the text, casually mentioned in passing, and given no more space or emphasis than the unimportant concepts.

This technique didn't work at all for me. I got through the first 50 pages or so and was exhausted because I had to spend so much time combing through the code examples and the text, reading and re-reading and studying it. And rather than use simple examples that would spotlight and highlight new key concepts, the authors veer off into fairly advanced things way too early (like shape-changing dialogs on page 31 and dynamic dialogs on page 38) while the reader is still trying to digest the basic concepts like QObject and slots and signals.

Unfortunately, the two other Qt books out there and the Trolltech tutorial aren't much better. They all have this nutty idea that you can teach Qt to anyone if you just hang source code like wallpaper everywhere and then explain it line by line. The authors of this book obviously spent a lot of time on this book, and I don't enjoy criticizing their work, but the book would have been ten times better if the authors had prefaced each chapter with an introductory discussion of key concepts and not forced the readers themselves to dig the details out of dense source code.

So I got to page 51 and gave up... then the book turned into a doorstop, sadly. It might be useful to a Qt expert who is trying to refresh his or her knowledge of Qt, but as a tutorial to new students of Qt the book is unsuccessful.

Trolltech recommends this book as the best way to get started learning QT4. I cannot imagine why. Perhaps they think it is the best of a bad lot.

You don't walk away from this book with any kind of feel for the classes or widgets. No big surprise really, because the book constantly refers you to the APIs.

When it actually endeavours to explain something, the content is usually out of context and based on some class/idea that has not been presented yet (or at all).

Basically, these guys need to collect their thoughts a little bit better and present them more coherently. I also think the book needs a couple hundred more pages to drill down into some of the classes, so that the reader actually gets a feel for them. I don't know why I would want to pay for a book that just refers me to APIs.

I always feel let down when I fork out cash for a dud book. I guess self-education is like any investment; sometimes you just lose on your investment.

The fact that this is the ONLY official best-practice guide to QT 4 programming makes it a 'must have' for any college-level or specialty computer library serious about catering to C++ programmers. QT4 enables developers to build stronger C++ applications that run on systems from Linux to Windows without source code changes, and this revised, expanded documentary includes the latest, proven solutions for all kind of GUI development asks. This update includes new coverage of databases, XML and other programming concerns. A 'must' reference for serious, advanced programmers and computer libraries.

Diane C. Donovan
California Bookwatch

Qt continues to evolve. This book gives a comprehensive description of the latest major release, 4. Why does Qt even exist? Basically because now any object oriented language that seeks broad usage needs an extensive widget library for the making of graphical programs. Java and C# are the prime examples. But of course C++ predates these by many years, and the intrinsic definitions of the C++ standards have no widgets. So Qt is offered as the [mostly] graphical extension of C++. Akin to how the Standard Template Library has data structures that extend the purely computational aspects.

In some ways, the book is pretty simple if you've coded in any other graphical language. The concepts are the same. An attraction of Qt is how quickly you can write code to put up windows with several widgets, and attaching callbacks to button widgets for functionality.

Qt also has important classes dealing with other issues. Like reading and writing to the filesystem or SQL database. And multithreading. Or parsing XML. These sections of the book can be harder to assimilate. With the graphical classes, writing test code and debugging can be easy, since the graphics gives you a tight visual feedback loop. But for [say] debugging TCP client server applications, low level bugs can be very obscure to hunt down.

This book is an overcomplicated and useless study of the obvious. The author basically tries to apply structured development and database design theory to web design.

Anyone can create and I/O diagram or flowchart. Basically, anyone who knows structured programminging would gain absolutely nothing from this book. Anyone who doesn't know the design process, will only become confused an frustrated.

The author unsuccessfully tries to simplify the prototyping process, and never explains it either. Basically, he teaches that web design is a monotanous process that must be done over and over again until it comes out right.

Any Analysis and Design book would teach someone a great deal more than this book. The author tries to reinvent the wheel by creating a square.

This is certainly a poor book indeed.

A "user friendly' and practical guide to designing or transforming personal or professional interactive websites, John Cato's User-Centered Web Design specifically focuses on designing for the end-user. A concise, readable text presents a comprehensive overview, practical advice, proven methodology, ideas and advice for insuring that final web designs meet the needs of both the client and the end-user. Strongly recommended for the novice web designer, User-Centered Web Design will also prove an invaluable reference for even the more experienced web master in tweaking websites for maximum effectiveness and ease of use by site visitors.

This book by John Cato offers a great set of examples on how to move the the process of user-centered development for websites. The book is filled with examples that help developers, designers, and managers get a grasp of the steps, thought process, interaction with users, process, and documentation that is greatly helpful in building a product the intended audience uses. Cato includes helpful lists, advice, and points out common problems along with instruction for correcting them.

Some may consider that user evaluation is a "luxury" - but you may do well to consider the cost of NOT incorporating any user evaluation/involvement. Well documented examples of commercial websites that have failed are legion, often because the "designers" simply designed for themselves or their clients, ignoring their target audience.

This book offers practical advice that enables web designers to satisfy the people that really matter - the users. It is a very good example of academic research translated into everyday practice.

This book offers several academic methods for setting goals and measuring the success of those goals based on user evaluation. This is fine if your clients are willing to pay up to 5 times the cost of a less stringent design process. The problem with this book's guidelines is that they seem to be based in a world of fantasy where everyone has 30 hour days they can devote to working on the pre-design analysis of a site. While this would be ideal, it is far from realistic.

Overall I found this book to be full of nice ideas but lacking in real world application. If you want a guide to designing user-centered web sites for clients with unlimited budgets and patience, then this is your book. However, most of us live in a world with more constraints and less freedom than what these ideas would require.

When used as a graduate level textbook, this work places extreme demands on the student. The lack of simple examples to explain foundation concepts places the student at a disadvantage from the start. The summary examples at the end of each section seemed to be confined to the author's research work and leave the reader more puzzled than enlightened. The endless stream of acronyms is initially annoying, but then becomes almost comical as the experienced reader (ER) becomes more accustomed to the practice. The text is a good resource for anyone specifically interested in risk management of water resource projects. For the rest of us, we'll have to look elsewhere.

The author spends a great deal of time describing his models and methods (referred to by highly forgettable acronyms) as if they were standards of practice. The writing is not easy to read and the organization of the material and poor indexing do not facilitate use as a reference. A lack of problems and exercises (as well as the use of non-standard terminology) makes the book hard to use as a classroom text.

There are much better book available that cover this material.

I was dismayed by the low quality of the binding and general production values of this book. The cover binding broke in my first half hour of gentle and practiced use -- I have been handling textbooks as a graduate and undergraduate for nearly 20 years, and I know how to handle a book. The low quality is outrageous given its price of over 100 dollars. One has (sadly) come to expect some price gouging in the marketplace of advanced academic textbooks; however the least such pirates should do is to provide decent quality and production values in their overpriced wares.

On the other hand, this text seems to me to be practically indispensable in its coverage of the mathematical underpinnings of a part of Systems Engineering which has grown greatly in prominence in the past decade or so--That is, risk management. The book is pretty chaotic and appears hastily thrown together from recently published papers and other "young" sources. But (I believe) one has to look past some of the shortcoming and acknowledge that it contains some very valuable material, presented by one of the genuine pioneers in the field.

The book contains many modern risk analysis tools not found in other books of its kind. What I like with the book is that it presents very sound and meaningful challenges to many traditional risk methods and provides alternative techniques to correct these shortcomings. The examples are practical and easy to comprehend. I hope that the future editions shall include exercises (or problems) to serve as mechanism to further hone the understanding of the students (or any readers of the book).