5 comments about The Definitive Guide to SWT and JFACE.

1. If your main question is how to place widgets on your screens, then this book is excellent. But if, however, you would like those widgets to actually trigger events, then this book is a damned disappointment. They have a general chapter on events but for widget after widget, their examples show you how to place the widget on the page but not how to get its events. You can write code to trigger events but try to do something useful with those events and you will be greatly disappointed.
   Also, if you were hoping for some guidance or examples on how to use the 'asyncExec()' or 'syncExec()' methods, you will be disappointed. There is nothing. So, if you need anything beyond the basics, don't waste your money.



2. This is overall an excellent introduction to SWT and JFace. After working with the technology for over 2 years I can say that it would have been a great help to have this book back then. The book's layout was well thought out. My only wish is that they put out a follow up book covering some of the more advanced topics like Events, Embedding Swing components, Packaging and Distributing SWT/JFace applications (including using JWS), using Native code. Plus, even though is Java covering some of the things that can be done with ActiveX controls would be a plus.



3. Much of the beginning chapters in SWT are simply API listings - WORTHLESS! I've got those online...don't need them in a book, especially since they are not as complete as the JavaDocs. Otherwise, not bad. I'm looking for better...



4. Having being treated to a text called Windows Forms Programming for C# by Chris Sells in late 2004, and considering that's pretty much the closest book in spirit in terms of covering a high-level Windowing API and is relatively well-known, I'll go right ahead and use that as a metric:
   
   I am surprised to find no coverage of SWT and Java 1.5's threading abilities. I wanted to see a coverage of how to handle long-running worker threads that must call delegates that run on the UI-thread (like a web services caller threaad telling the gui-thread to update the progress update bar to show 75% completed). I wanted to see coverage on how to send events information back and forth between GUI thread and the worker threads. It's one of my favorite chapter in Sells' book because without it it is very difficult to write a responsive app. This is criticial in this day and age with the decent amount of web services and distributed computing being used in Intranets and Internets. If Harris and Warner are willing to write an extra chapter on this very topic, I would be greatly in their debt. We are all waiting for this chapter! I guess some of you will say, wait for Doug Lea's next book, but I trust Harris/Warner to get to the point faster and better--and stay on topic (I am not sure if Doug Lea would bother with SWT). I am hoping there's an answer to this, because I need to use this asap.
   
   There are some other surprises I find distasteful: data access and binding of data recordsets to grids are no where to be found.
   
   These are the main reasons why this book gets a four star. Because people like me are spoiled.
   
   Anyway, back to the book review:
   
   Real-world cross-platform development is a tough subject. If you ask most people, they'll relunctantly say the best way to go about it is to write platform neutral c++ model/controller code and write the view code in Qt or Gtk/MFC or WinForms/Carbon or Cocoa. Nasty.
   
   It goes without saying most small development shops simply can't budget serious competence in one, let alone three major GUI frameworks. This is not counting all the trouble you have to go through to evaluate count-less so-so [for one reason or another] libraries (wxWidget, MainWin, Swing, OpenStep API, Flash, Mozilla) just to arrive at the point where you can clearly say aha, I really want MFC/Carbon/Qt after all.
   [And let's not even get into strictly system programming libraries, for which there are several dozens on the sourceforge galaxy alone.]. So for light work, where you aren't trying to please 500 million users right away (Internet Explorer, Outlook Express) or even 200,000--you really want something like Java 1.5+SWT:
   
   > One productive language.
   
   > One well-supported effort to map a common gui api to all major windowing systems while preserving native looks.
   
   > A quick build that produces three executables. One for RedHat Linux. One for Mac OS X. One for Windows NT 5+.
   
   Which is why I am really happy Sun and IBM is trying so hard to make this option happen. I build small softwares for a relatively small audience. With IBM's contribution of SWT, all we need now is a good text that cover it thoroughly--from the perspective of developers--not the library writers. The Definitive Guide to SWT and JFace gives you just that.
   
   At times, I can see how some of the other reviewers might say, "It's just table listings rehashing documentations", and if you compare this book to Chris Sells' book you may wonder the same thing--but I think it's still an excellent try and the authors add something to the docs. I'll point out a few examples:
   
   * In the "Selecting Files for Open and Save" they went out of their way to write the correct version of how to handle over-writing an existing file. Hey, just imagine if the authors said nothing... ;-)
   
   * Throughout the book they document what the behavior will be if you did something undocumented: they'll mention when you shouldn't subclass SWT; they post questions to the eclipse group to clarify some of the bad decisions that had to be made and they tell us what we should do about it.
   
   * They explore some patterns they expect real world programmers will likely try (like Decorations, which is like a half-implementation of MDI), and warn you ahead of time what you can expect to find or even whether you should use it.
   
   The best part about them adding a bit of details is that you'll likely dig through the MSDN with Sell's book (which is not a bad thing), but you'll probably have everything at your finger-tips with Harris/Warner--so is it a bit wordy? Is it too referency? Maybe--see for yourself. :-)
   
   This is a great book, and I wouldn't hesitate recommending it. It's a key to a world of cheaper better cross-platform development--walk--no run to your bookstore and get it!



5. if you are looking for something to walk you through widget by widget..holding your hand this is your book . Excellent reference and very clear structure.
   Good to have by your desk when you need to look up something and dont like reading javadocs from the source ...

5 comments about The Essential Guide to Flex 2 with ActionScript 3.0.

1. Let me quote Mr. Brown from the introduction in this book.
   
   "After years of doing technical training, where I have only a few days to cover large topics, I have learned to substitute shorter explanations that clarify a concept in place or larger more technical (and often confusing) explanations." - Charles E. Brown
   
   The author gets straight point with more code and less explanations. I've read many technical books and this book is by far the clearest and quickest reading. The steps you take are numbered, which makes taking notes easier and is followed up with a less than equal amount of talking. He covers a lot of ground with less chatter. This book is perfect for laying on your lap or taking anywhere. There are also no errors in code and only 2 typos presented on the Friends of Ed's website. I wish all books where written like Mr. Brown's style.



2. The guy who wrote this book took a more personal approach to teaching Flex, which makes it a really easy read. It's real easy to follow along and do all the excer



3. I am new to Flex and AS but experience Java Developer. I found this book easy to understand Flex & AS but also gave little confidence to move forward with Flex project. Only negative part is example not complete with source code (not provided for certain chapters) overall easy to understand not bad



4. I'm very glad i bought this book.
   I didn't have a clue about what flex is and know, half way this book i have a solid understanding of the flex framework.
   I can't wait for the other half!
   I recommend it to all begginers with Flex so they can learn the fundamentals the easy way.



5. I love this book and might get his newest book Flex 3.0. I think I can really build on the solid foundation of this book. However, I have a feeling that they are a lot alike. The new Flex 3.0 puts all files in a new directory call /SCR. Make sure if you use this book with the new flex 3.0 to put all your files in this directory and change the directories in the book as such.
   Example if assets/photo.jpeg,change to scr/assets/photo.jpeg. Also create all new folders in the src directory. Use the ../ to back out of a directory.

3 comments about Information Modeling and Relational Databases, Second Edition (Morgan Kaufman Series in Data Management Systems).

1. This new edition of Information Modeling and Relational Databases maintains its predecessor's achievement of being the best, most complete book out there on design of information systems, and particularly of database schemas -- and of seeming a few decades ahead of the rest of the pack! The relational database theory world seems to move at a rather glacier-like pace -- with the result that some of the schema design methods still in common use have stayed well past their "obsolete by" date. But as a reviewer of the first edition said, this book presents MATURE database design technology; and it can only be hoped that the database design world will sooner, rather than later, realize the immense, and immensely practical, value of the mature theory and design procedure that this book presents. Do you want to be able to arrive at the correct schema the first time? or even to know whether you've reached it or not? This is the book that shows you how, and gives you a rich, formal modeling notation that has very significant and improving tool support. Terry and Tony have both added very valuable new chapters to the book, and expanded and updated the other chapters, so that this is a very much improved book -- as amazing as that may seem to those (like me) who loved the first edition. This book will, in my opinion, be setting the standard for books on information system design for many years to come.



2. Everyone needs this book. Read more to find out why:
   
   If you intend to create genuinely useful business applications without first creating an accurate conceptual data model and deriving the database schema from the model, then I hope your projects have very large budgets and flexible deadlines, because you'll need both. Accurate conceptual data models are not an academic curiousity, they are a practical necessity. Well designed databases are the heart of every business application, and accurate conceptual data models are the foundation of every well designed database.
   
   This book presents a method for data modeling called Object Role Modeling (ORM). If you've never created a data model before, you might as well learn the best method from the start. If you've used E-R (Entity Relationship) modeling before, this is your chance to learn a method that overcomes the limitations of E-R, while building on the knowledge you already have.
   
   ORM is based on facts (assertions about the business sphere you are modeling), not entities and attributes. Business users understand facts much better than they understand data modeling abstractions. By using ORM facts, you create your data model in a language that business users can understand and validate. Poor communication with business users and inadequate understanding of requirements are major causes of design deficiencies. ORM solves these issues through its fact based approach.
   
   ORM is also much more expressive than any other popular data modeling notation, ncluding UML and all major flavors of E-R. Many business rules should be expressed as data constraints, but traditional data modeling languages don't do well at capturing these constraints. By capturing the constraints in an ORM model and validating with the users, you make the construction of a good application much easier.
   
   Halpin is an excellent writer, and this book is very easy to read. The many examples and crisp writing style mean that you'll actually understand what the author intends, a refreshing change from most computer books. If you've read the previous edition of this book, this update is very worthwhile. There is a lot of expanded and new material, and you'll be happy you purchased the new edition.



3. The first edition of this book was excellent - one of few books I have that I would call primary references - but with the addition especially of the chapters on advanced concepts and behavioral specifications this second edition represents a big step forward by presenting a more holistic view of conceptual modeling. As a specific example, I've long wished for the ability to do state modeling in ORM without a kludge. This book presents a method and a semantic foundation for doing just that. Now all we need is for the tools to catch up! Kudos to the authors.

5 comments about Game Programming Gems 2 (Game Programming Gems Series).

1. Like the first volume, Game Programming Gems 2 features an exceptional collection of articles written by a knowledgeable group of authors, most of whom are well-known and respected in the area they write about. This series (the third volume is already underway, as are related books focusing on AI and design) isn't intended to be a complete guide to all aspects of game development, but rather, a resource you turn to when you need help with a specific problem. As such, the series truly shines, and this volume is a worthy follow up to the first.
   

   The articles, or gems, included in the book cover intermediate to advanced topics in the areas of general programming, mathematics, artificial intelligence, geometry management, graphics display, and audio programming, each edited by an expert in the field. Most of the gems assume that you have a fundamental knowledge of the issues related to the topic, and get to the point quickly. As a result, on average the gems are shorter than the previous volume. Both of these things could be viewed as either positives or negatives, depending on your experience level. Regardless, almost all of the gems are well written and relevant.
   

   Most game programming books these days come with CDs packed full of demos, source code, and other information supplementing the book. Unfortunately, the CD that comes with this book isn't one of those. It does have source code from most of the chapters, but there are very few demos and no extras (unless you count GLUT and the DX8 SDK, which I don't since you can easily get those elsewhere). However, I'd count the CD as only a minor disappointment, since the book itself is so good.
   

   If you're serious about game development, I'd highly recommend adding Gems 2 to your library. You'll definitely find things in it that you can use.




2. This is an incredible book that covers topics ranging from text parsers to audio engines. It also comes with a cd so I can put the great text parser in my game without typing a line. How sweet is that?



3. An excellent resource for the times when you encounter problems you diddnt know existed.



4. Game Programming Gems 2 is a collection of short articles detailing various aspects of computer game design. Personally, I found the first half of the book to be very helpful while the second half, on rendering and audio techniques, was too brief and lacked the depth to be of much use. However, the first half, covering general game programming technique and mathematics has proved very useful to me in my amateur game programming endavours.

   Pick up this book if you are looking to add to your reference collection however, due to the nature of the articles and due to the price, you might find yourself heading to the library to pick up this book. In the end, a solid addition to a programming library.

   Note:
   I am an amateur game programmer, not a professional
   In addition, many of the articles are not relevant only to games.




5. You don't have to be programming a game to find the gems like the ones for rendering and geometry useful.

   To get a feel for the quality of the gems I looked at the gem on "The Parallel Transport Frame". I'd encountered this problem myself when trying to get VRML extrusions to work properly. VRML extrusions use Frenet frames so fail when the curve has an inflection. I came up with the same solution as the one described in this gem, and I'm sure many others have reinvented this particular wheel. The gem accurately describes the problem and solution and if I'd had it while I was messing with VRML extrusions it would have saved me some trouble.

   Recommended.

1 comments about Software Quality Engineering: Testing, Quality Assurance, and Quantifiable Improvement.

1. Takes a while to get used to the book. Not the easiest to understand
   Lots of good information and concepts. Strongly recommended if you are willing to do the brain work

5 comments about Foundations of F# (Expert's Voice in .Net).

1. For a reader who already knows some F#, I think this book could be helpful. In the 100-page language tutorial, it seems to give a wide (though necessarily shallow) coverage of the syntax and programming paradigms of F#. Since there is a lot to the language, many readers will find something new to consider here. Then there are several chapters of applied F#: extremely brief explanations and samples of an ASP.NET app, a WinForm app, etc, written in F#. I'm suspicious that these chapters would be very useful to anyone: to those new to .NET, there is really not enough information here to get oriented; to working .NET programmers (which must be the widest audience for this book) there's just very little to learn here.
   
   Now, as someone completely new to F#, I found reading this book consistently frustrating. While the author obviously knows the subject, the presentation is not very accessible. The main problems I see are: (1) example code usually *follows* its explanation, which just confounds me why an author would do this; and (2) the prose is hard to read, containing tedious explanations of syntax, and an odd over-use of the second-person "you" when walking through an example that I found disorienting.
   
   Ultimately I spent a lot of time feeling frustrated trying to figure out what the author was saying, and wondering why it wasn't said more clearly. Judging from the sample chapters of Don Syme's book on his blog, I know that F# can be made accessible to the beginner. This book needed more editing to get there.



2. The author may know what he's talking about but the book fails to communicate. aPress should have (at a minimum) had an editor translate the text into (readable) English.



3. I found most of the this book to be a rehash of the F# manual and F# blogs.



4. Foundations is geared toward IT professionals who want to get up to speed on F# quickly. In general, I found the organization of the book and the presentation of F# syntax very programmer friendly.
   
   I really appreciated the high density of programming examples and the detailed explanations that generally followed.
   
   In general, I only have two complaints about the book:
   
   1) While the book demonstrates the syntax well-enough, I don't believe it emphasizes enough on functional programming style, such as how to replace Java-like design patterns with functional programming techniques. As a result, most programmers without prior functional programming experience will end up writing C#/Java code in an F# syntax.
   
   Its hard to sell a language without showing how it helps programmers write complicated applications more effectively. (Perhaps design patterns are outside the scope of this book?)
   
   2) The book is not accessible to beginners. I've been programming for 10 years, and it took some effort on my part to keep up with the pace of the book. A beginner would not be able to learn F# as their first programming language from this book.
   
   
   
   The best reason to buy this book is to keep up with the continuing evolution of programming languages. C# 2.0 has generics (parametric polymorphism), true closures, and allows programmers to pass functions as first-order parameters to other functions. C# 3.0 introduces type inference, lambda functions, LINQ (analogous to list comprehensions), etc. However, functional programming in C# is awkward and verbose. If you want to write functional applications, you'll do yourself a favor by using a real functional language like F#.
   
   I would recommend buying this book if you want to supplement your programming skills with a beautiful and expressive language, although you may want to supplement it with books on Haskell and ML to get the most out of functional programming as a whole.



5. Overall I think this was a good book. It served it's purpose well, and even goes through how to create a lot of objects using the programming language. The samples, demos, and explainations were pretty good as well. If you are looking at reading this book, I recommend looking over chapters 8-11. Those are really the meat of the book and where most of your time will be spent.
   
   The things I didnt like were that the examples sometimes were hard to follow. Code would be above or far below the explaination and that was confusing. The other thing is this book is NOT for the beginner level. Its more on the intermediate to expert level. You'll want to have a good understanding of .NET before you pick up this book.
   
   Overall if you are interested in learning F#, I would definately recommend this book.

5 comments about Digital Design (3rd Edition).

1. This was the text book used in one of my computer science courses.
   Trying to learn from this book was very difficult because there are many errors in the diagrams. Considering that diagrams are a vital part of a book on computer circuitry I would have expected the diagrams to be accurate and replete with detailed explanations. This book is in its third edition yet it somehow manages to still have errors, this is inexcusable; were it the first edition I may have been more lenient. If you look closely you will find errors in many of the diagrams, sometimes two or more errors on the same page. Definitely not worth the $100+.



2. In first year engineering at Simon Fraser University, many of my classmates and I absolutely hated Mano's other text, "Logic and Computer Design Fundamentals (2nd ed. updated)". However since I have picked this text up I have found Mano to be much easier to read, but that could be because I have adjusted to the material and his writing style.
   
   Unfortunately there are no solutions to any of the exercises in this text, only selected answers. His other text has some solutions posted on the companion site (http://www.prenhall.com/mano/), you may be able to use them to learn from with this text as well.
   
   And there are little mistakes in the text that may make things difficult to understand at first, but I did find a decent errata on the web (http://www.ece.uvic.ca/~amirali/courses/CENG290/textmistakes.html).
   
   I don't know how good the text is for self-teaching, but it isn't bad for brushing up on the basics after being away from digital design for a couple years.



3. It's a good book for beginners in Digital Design
   
   It gives a clear guidelines to understand the Combinational and Sequential Logics.



4. This book is one of the worst books I have seen. It does not help at all but is one of the required books that you have to get because the homework problems are in it. Book will not help you much.



5. This book is an excellent companion to computer science/computer engineering classes. It tends to be fairly short and concise for almost every topic, which is why I would only recommend this book to those who really need it (required). Without guidance the concepts of digital design, especially as presented here, will no doubt escape people quickly. There is a couple errors in the book, which can be expected when they have to include data from external sources such as block diagrams for integrated circuits. If you need this book for a college CS/CE/EE intro course no doubt the book, you, and your professor will have alot of fun with some basic computer engineering and labs, BUT, as a self-study or reference, I do not recommend, at all. I have used this book for a computer science course at MN State, and while everything has gone very smoothly, it's only because collaboration with a professor has smoothed out the bumps and even filled in minor gaps or shown alternate methods.

2 comments about Engineering Design and Graphics with Autodesk Inventor 2008 (Autodesk Design Institute Press).

1. I received great help using this book. This is by far the best study aid I have used for my engineering class.



2. This is a great book for learning and teaching Inventor. If you have never used Inventor I would recommend Shih's Book (Parametric Modeling with Autodesk Inventor). Once you get started this book is a great help.

No comments about VMware ESX Essentials in the Virtual Data Center.

5 comments about RT Essentials.

1. Are you an end-user, system administrator or developer who interacts with RT on an occasional or regular basis? Authors Jesse Vincent, Robert Spier, Dave Rolsky, Darren Chamberlain and Richard Foley, have written an outstanding book that is for everybody who has to use RT to manage tasks.
   
   Vincent, Spier, Rolsky, Chamberlain and Foley, begin by providing some background about what ticketing systems are and how they can help save your job and your sanity. Then, they walk you through the process of setting up an RT server and configuring sane system defaults. The authors continue by showing you how to get up and running with RT's web interface. In addition, they explain how to interact with RT from your shell or console window. The authors also step you through the basics of turning a virgin RT server into a useful tool for tracking what you need to do inside your organization. Then, the authors show you how to extend RT's standard behavior with custom business logic. Next, they provide a look inside the RT configuration at Yoyodyne Propulsion Systems, a nonexistent company that makes heavy use of RT to manage their internal processes. Next, the authors walk you through RT's files on disk; as well as, the details of its database tables. Then, they describe how DBIx::SearchBuilder works. Finally, they show you how to set up a local sandbox for modifying and extending RT without putting your production server in harm's way.
   
   This excellent book will be considerably more useful to you if you have at least a basic understanding of the Unix command line. Above all, this book will be very useful to you if you also have a basic understanding of Unix systems administration skills, and at least a little bit of experience programming in Perl.



2. We've been using RT for several years. As one happy customer mentions at Best Practical's site, managing a project or service driven organization without RT is like watching TV without a TiVo. The software is powerful, flexible, and above all, adaptable to many styles of management for more than just technology projects. No question, the software gets 5 stars.
   
   This book, however, is largely a reorganization of the information provided with the software. If you prefer to read printed materials instead of PDFs or HTML, this book will save you money on printer paper. But if you're looking for best practices, recipies, or enhancements such as those you'll find in the RT Wiki, you may be disappointed. In fact, for most of the advanced capabilities, you are referred by the book to other resources. The book does contain the occasional nugget, such as a half dozen lines of code to truly delete a ticket and related data. With some searching, you'd be able to find those, and better, at the RT Wiki, such as the particuarly valuable contributions from the University of Oslo (do an A9 search for "RT prosjektgruppen").
   
   Compared to most O'Reilly books which set the bar for excellence, this one is merely average. However, I do recommend this book as an introduction for those considering whether it's worthwhile to move to RT from some other enterprise ticketing system, and for techs to give to managers who are more comfortable with hard copies than electronic documents. For any RT admin, it's certainly worthwhile to have documentation printed and organized in an easy reference, considering how much you've saved on the excellent software itself.



3. Request Tracker (RT) is a great product. I am the only sysadmin at a small company, and having an automated tracking system is going to be an immense benefit for me. I bought "RT Essentials" to help me get up to speed on RT3 really quickly. And, since it was written by the programmer who's responsible for RT, the book had lots of detail and tips.
   
   However, when it came down to implementing some of the code in the book, I found that it was already outdated. For example, I tried to set up the Autoreply template with Password by copying the code straight out of the book. It didn't work because the program codebase has changed too much since the book was released.
   
   I was able to fix my template problem by hooking into the great RT user community, where the author contributes frequently.
   
   All in all, I thought the book was really helpful for getting RT installed and getting me up to speed. For the nitty-gritty, I'd rely on the online wiki and great user community.



4. I was very dissappointed with RT Essentials. I had been using and administering an older version of RT for some time, but when I upgraded to the current version I thought I would benefit from reading this book. There are a lot of new features in the later versions and this book just barely mentions them. I had the feeling that it just almost told me what I wanted to know, but not quite. I would very much like to see an expanded, more detailed more comprehensive edition. I think it would take a book twice the size of the current edition to do RT right. I want complete tutorials on writing scrips, using templates, using custom fields, using saved searches, etc.



5. I needed to assess whether this application would work for me, and this book did great with getting me this information.