3 comments about Object-Oriented Programming in C++ (2nd Edition).

1. This book is concise but clear. I think the typesetting in this book could be redone better to give it better readability.More diagrams & few more example would make it perfect.The authors explains many subtle points of C++. This book is good for academic settings if you already knows C & Data Structures. Overall, a good concise book.



2. A lucid traversal of basic OOP concepts and the C++ language. Lots of exercises, at a rather low level of detail. J&K focus on the basics, avoiding the trap that others (e.g. Lippman & La Joie) fall into of trying to cover too many advanced topics in an introductory text. A scattering of typos and minor errors should not confuse the perceptive reader.



3. This book covers the important aspects of OO approach as well as the STL for C++. It is definitely not suitable for those who have no programming experience in C, and indeed, I find that one actually even needs to have a little knowledge of C++ to benefit from the book. The first two chapters let the C programmer make a transition to C++, and explain clearly on input and output in C++. The next three chapters then strive to explain the OO features in C++.
   Generally, the book goes at lengths to illustrate classes in C++ and their workings, and offers many tips and traps as well as certain programming styles and approaches which would produce robust programs. The worked examples were also quite comprehensive. However I feel that the concepts of OO were not well illustrated, and from my experience, a thorough understanding of OO concepts help very much in being able to manipulate classes and using the methods in C++. The chapter on MFC was not very useful, it really looked as if it was just there to fill in space. It does not teach much about MFC.
   All in all, however, I would still consider it a fairly good book to keep as a reference.

5 comments about Windows Sockets Network Programming (Addison-Wesley Advanced Windows Series).

1. This is a Winsock 1.0 primer. There is a hastily-written ending chapter on 2.0, but it is far too brief.

   In short, this book was a disappointment and is badly in need of a new edition.




2. While this book has a lot of good information, it is out dated, sometimes wildly so. It continually hampers itself with discussions of 16-bit Windows which, while still in use in 1995/1996, was clearly on the way out, contrary to what the writers assert in the first chapter. Having said that, it is well written and the book deserves a second edition, dedicated to Winsock2 with nary a word on 16-bit windows.



3. Although this book is focused on Windows and most of my (current) programming focuses on that, I usually end up referring to two UNIX books instead ("UNIX Network Programming" and "Advanced Programming for the UNIX Environment"). Those books have nearly identical syntax, but do a better job of explaining things. For Windows, there are some peculiarities (i.e., shortfalls) that you need to be aware of, so you really should own all three books, as I do. The amount of time that you save will be well worth it.



4. I'd not recommend to read this book - waste of time. First 13 chapters contain tons of unimportant information about specifications, history and general words about how networking is great. Although these chapters contained a bit of example code - this didn't work at all. Since the 13th chapter there is a terrible example of a full scale FTP client that is totally unclear. At that point I closed the book. My friend had the same book, he went further - threw the book away.
   In fact I learned basics of Windows sockets from the greatest book of Petzold "Programming Windows", where every code was working and then ported my knowledge of UNIX networking to Windows.



5. I am a very experienced C/C++ software engineer currently taking a community college class on WinSock networking programming. I'm used to dealing with difficult text books. However this is one of the worst I have ever wrestled with.

   There are no exercises in the book. All their examples are long; no short examples of code to clarify any topic. Their way of explaining most subjects seems to me to be unclear, their wording such that I have to read a paragraph several times to figure out what they are trying to say. Finally and especially, their explanation of the key topic of socket states is flat-out awful. I have had a little experience dealing tangentially with socket states on my last project, and I still came away from this chapter confused and with my head spinning.

   I hope that there are better WinSock books than this out there!

2 comments about Adobe AIR (Adobe Integrated Runtime) with Ajax: Visual QuickPro Guide.

1. As an experienced desktop programmer (and some web design) I have been looking for the "best" (easiest) way to write programs that are cross platform (PC, MAC, & Linux). A must for me is the ability to write and read files! I have read most of the book while in a bookstore and I was very impressed with all it has to offer. I just ordered it and I have already written my first program in 5 minutes! Ok, it was "hello world". I am using Dreamweaver CS3 (or any editor) and javascript and ajax. Low cost programming with the Adobe AIR runtime. This is the best and newest technology I have seen in years. Larry writing style makes this look easy and it is!!



2. Larry Ullman's easy informal writing style disguises a highly focussed, readable, condensed and very lucid approach. He manages to put in a paragraph or sentence what other authors take a chapter or two and then explains it much better.
   This book gets you up, working with and understanding AIR very quickly. You may have to break off and learn a bit more JavaScript or IDE's but that is easily done. I had never heard of the runtime property of a window so read up about it even though it was not really necessary to do so.
   He does introduce you to Aptana Studio which is an excellent IDE for the purpose .Its free and does a huge amount of donkey work leaving you to do the fun part. Here too you may have to break off and learn a bit about Aptana.
   A handy web designer will find this book very interesting and useful. In short order you can write your own APIs.
   I should think that because of it layout and focus on AIR an experienced professional would scream through the book in no time but find it invaluable in showing him/her what AIR is all about and how to work with it.
   I have several of Larry Ullman's books and find he usually explains thing far better, more succinctly and lucidly than many more erudite tomes with many editions (which I also have).

5 comments about Kernel Methods for Pattern Analysis.

1. The book is divided into 3 parts. The theory is all in part I,
   the rest of the book is a cook-book with plenty of matlab code.
   The website contains most of the same code + data online. Readable, complete.



2. This work presents a coherent overview of an important field in machine learning. The unifying framework of kernel methods has proven state of the art results and the community has been waiting for a book like this to make both theory and practice of kernel methods accesssible for readers of all different backgrounds (researchers, students, practioners from both academia and industry, ...).
   
   It is theoretically well-founded, the resulting algorithms are well-explained and made accessible for practioners by providing pseudo-code and online, ready-to-use matlab code.
   
   This book nicely complements the previous, yellow book, written by the same authors. Indeed, after "getting into the field" by reading the accessible introduction to support vector machines (SVMs), it was clear to me that SVMs was only an example of a signifcantly larger framework, i.e., kernel methods. The blue book is the reference book about that larger framework I have been waiting for since then. I particularly like the way the book is set up, making clear the modular, flexible approach in kernel methods.



3. Well, at first I was petrified to find a book that sounded like it deeply explores the subject of kernel methods. But all in all, it did not quite achieve what I hoped for. As a practical approach, when it comes to implementation, it serves nicely as a reference. The deeper mathematical roots of kernels (especially when it comes to measure theory and functional analysis) are not dealt with at all or just scratched at the very surface. The notation is sometimes awkward, mentioning for example the representation of an object in a given vector space with respect to the basis. And: Too much copied and pasted from the former book about SVMs. Basically, reading papers of Carmeli, Aronszajn and others will give you a much deeper insight into the subject.



4. Sloppy language, sloppy definitions, sloppy proofs.
   Constant repetitions do not add any clarity either.



5. A very useful book and quite a nice read. I bought the book after reading a few chapters. Even now, an year after my grad school, I still read this. A good reference.
   
   Nice print, no mistakes, MATLAB code. You get everything on Kernel Methods, from theory to implementation. A perfect book and helped me a lot in my research.

5 comments about MCSE: Windows Server 2003 Active Directory Planning, Implementation, and Maintenance Study Guide: Exam 70-294.

1. This book will teach you the basics. iT does not prepare you for the test. I read the whole book cover to cover and understood it completely. The test is nowhere as easy as this books questions. It does not go into depth with scenerios that can be helpful. I recommend you get the microsoft books for this test. If you are currently working with 2003 it will help alot. but do not plan to only use this book unless you luck up and get the perfectly tailored test to what this books covers.



2. The book is an easy read, which is good. You'll have an easy time getting through the questions, but when you go to take the test you'll fail. This book is no where a good match for the exam. I suggest this book for people who want to learn about Win2k3 AD, but if you're getting it to prepare for the test you should think twice. Nothing this book discuss could have prepared me for the test. Bummer.



3. You could definitely tell when they switched authors. There were two chapters when I could tell the author really didn't know the subject and was merely regurgitating information. I stopped midway through those chapters and skipped onto the next chapter. I later got the info I needed for Certificate Services and High Availability Services from Whitepapers and I also discovered the MS Press book on this test. It was much better. Reading the Sybex book I had very little confidence in the author. Reading the MS Press book I had complete confidence in the author.
   
   For example in the Sybex book, when they were describing High Availability Services, I kept seeing a single point of failure. After a while I got disgusted and looked for better sources of information. I printed out the chapter from the MS Press book from Safari and my issue was addressed within a few pages. My point being is that the author of the MS Press book obviously knew how the brain of an IT person works and was able to answer my questions and concerns as they arose while reading. This was not the case in Sybex.
   
   I would say the MS Press author definitely understood the subject and me (as an IT professional) much better.



4. Anyone who is seeking a Microsoft Engineering certification should obtain this book. In fact, the entire Sybex series of books are great.



5. A caveat: I don't care about the test. I was searching through lots of books for some information about creating a Windows server based network and this book really stood out. (I was setting up my first network and was lost trying to figure out some things.)
   
   I know many or most of you only care about the test, but I am writing this to tell others that if you need a good book about infrastructure I think you may want to get this one.

5 comments about Beginning EJB 3 Application Development: From Novice to Professional (Beginning: from Novice to Professional).

1. Over the course of a couple weeks I read the entire book. I found that the book provides the most value by doing this. I had some limited experience working on existing EJB 1/2.x apps and have developed some prototype apps using EJB 3 also. The book really filled in some gaps in my knowledge including the history of the specs. I don't know that I would use the book for a reference though. I will probably refer to the spec to get the details.
   
   Although I didn't follow the directions provided to get the code samples running in the Glassfish server I appreciate the detail the authors went through to help the reader. The directions seemed to be complete. I didn't feel like I had to go through this step because I already have code up and running deployed to Glassfish using Netbeans.
   
   Sometimes I felt like the book didn't provide enough detail using nontrivial examples in certain areas such as the lifecycle and interceptor methods. Other times it provided too much detail such as the examples using JSF. I'm about to start a project using EJB3 and JSF so I found the discussion of integrating JSF into an EJB3 app interesting but the average reader would probably be better of referring to a book specifically on JSF.
   
   The sections on performance testing were some of the best in the book. They explained how to set up the tests and the important statistics to look for. I was looking for some information on unit testing EJB3 outside of the container and was disappointed not to find any.
   
   Overall I thought the book was excellent and would recommend it to both developers new to EJB3 and more experienced ones that either want a good overview of the subject or are looking to migrate apps using the older specs. The book didn't blow me away but I still found it hard to find even minor points to be critical of. The book has definitely given me the confidence to apply the new technology appropriately.



2. EJB 3 took its time to get mass acceptance, primarily because many Java developers did not have great memories of earlier versions of EJB. EJB 3 is however now gaining momentum and a number of EJB 3 books have hit the market. Beginning EJB 3 is a Beginner - Intermediate level book from Apress.
   
   In their letter to readers, the authors say that "With EJB3, the EJB spec developers had at last settled upon a model that really made sense. Coming from EJB 2.x world, it was like a breath of fresh air.." So EJB 3, is widely believed to be a significant step forward in simplifying enterprise Java development.
   
   The book uses several examples to demonstrate the new found simplicity of EJB 3. The free, open source application server GlassFish, which is the reference implementation for all specifications in Java EE 5 is used in the book.
   One of the important changes in EJB 3 was the introduction of annotations. However XML descriptors are still very much around. Java development has a tradition of always taking the most complex approach and if there isn't one, it works at complicating the simple approach. So after the initial excitement about annotations, there's again uncertainty. It's now (Annotations) vs (XML) vs (Annotations & XML mix). On this, the authors say "A simple rule we follow is this - If we need to decouple our entity and bean classes from their EJB 3 metadata, as when we want to use the same entity classes with two different inheritance strategies, we put our metadata in XML. Otherwise, we stick with annotations" "And don't forget...whenever metadata is specified for an element using both XML and annotations, the XML always wins"
   
   Chapter 1 introduces EJB 3 and gives us a quick overview of all that's changed in EJB 3.0. Chapter 2 looks at session beans and dives into using dependency injection in session beans, interceptors, callbacks, local vs remote access even before a session bean example is deployed. So the book kind of works with the assumption that you have tried your hand or as some would say "burnt your fingers" with an earlier version of EJB. The book runs the risk of being too fast for someone who might be trying EJB for the first time.
   
   Chapters 3 and 4 look at entity beans and persistence and Chapter 5 looks at message driven beans. Chapter 6 begins with the basics of Web Services and then moves on to the various web services specs and how you can use the @WebService nd @WebMethod annotations to quickly get your app web services ready.
   
   Chapter 6 to 11 deal with web services, integration, transaction, performance and migration from version 2.1. The good thing about these chapters is that the authors first introduce the concept, the need and the basics and then delve into the actual development. Problems while deploying EJB across applications servers were commonly reported with earlier EJB versions, so it's good that the authors have dedicated a chapter to EJB 3 deployment and planning.
   
   JSF has become more or less the standard for new Java web development. So Chapter 12 is a useful one as it shows EJB client development using a simple JSF + EJB 3 application.
   
   Overall, for a beginner-level book I think it would have been good if there was more content and hand-holding in the initial chapters, as Apress has a book "Pro EJB 3" which could look at the advanced EJB topics in detail. But if you have been on the enterprise Java scene for some time and have tried out EJB earlier, this book will get you going with EJB 3 in no time.



3. I thoroughly enjoyed reading the "Beginning EJB 3 Application Development" book. (I'm a senior programmer, have been using Java since 1995 and am co-founder and co-leader of the Austin Java Users Group.) The book started off with a nice executive overview of EJB 3 and the usability problems with EJB 2 that it solved.
   
   On a side note, I have been impressed by the EJB 3 working group for making such a bold move forward while remaining backward compatible with the old specification. Typically as a given software technology matures and becomes well established, the software infrastructure and APIs develop a lot of inertia that leads to significant resistance to large improvements. The EJB 3 working group overcame this pressure and produced a bold new elegant design that should be a pleasure to work with. It always takes time and a lot of work to create a clean simple design and I think the team has done that finally with EJB 3.0. The authors captured the advantages of the new specification and leveraged the new capabilities and simplified approaches.
   
   I appreciated the section on setting up the environment and the mechanics of compiling and deploying the EJBs using the free GlassFish application server. Just enough detail of the incantations to work with the server was given in order to get started without getting bogged down in lengthy setup descriptions. The authors provide examples up front to get you quickly up to speed with the new paradigms. They continuously mix clear examples with explanations to ensure that you gain an incremental understanding quickly.
   
   Stateful and stateless session beans are covered. Comparisons are made between annotations and the XML descriptor files and the rules to override are clearly defined. I enjoyed the section on interceptors and was impressed how easy it is with annotations to intervene with preinvoke or postinvoke operations. I liked that the authors are succinct with their explanations. The authors get to the point quickly, which I appreciate given the volumes of material one needs to absorb to keep current in this industry. The examples start off simply and gain complexity as more features of the spec are added to the application. Useful process flow and database schema diagrams typically accompany the examples to clarify the problem.
   
   Early on I found a couple of small bugs in the sample code (mostly caused by a moving specification), but the authors have been very proactive about posting erratas on the website.
   
   JMS and message driven beans are discussed as well. A quick overview of JMS and MDB is given with a succinct, but very relevant status-notification example. The mechanics of setting up a JMS topic and a JavaMail resource is described, as well compiling and deploying the MDB.
   
   There is a nice brief overview of web services and the associated standards. A useful credit card verification example is provided complete with the mechanics of compiling and running the code.
   
   I thought the sections on the Java persistence API were well done. I felt the authors covered most of the typical issues that you run into when mapping Java objects to a relational database schema. Advanced sections covers hierarchical modeling and the advantages of user-defined primary keys for instance. Concrete table definitions and their associated Java mappings are illustrated.
   
   The authors demonstrated that they have solid design experience since they intermingle practical sage advice and admonishments througout the book.
   
   I thought that there should be more advice on forward versus reverse engineering of the database schema since there are a lot of lousy database schemas out there that have been generated directly from the Java object model.
   
   The authors provide a good overview of container versus bean managed transactions. The mechanics of using each approach and the associated trade offs are illustrated. I like that the authors included some of the basic information on transactions such as the definition of ACID for instance. (I need to refresh my memory every so often.)
   
   The performance benchmarking section was very well done. A clearly thought out methodical approach to performance testing is given with what I thought were surprising results between the two mapping approaches (single table inheritance and inheritance through joins). An overview of a very useful load testing tool is given as well. Salient performance comparisons between EJB 2 and 3 are also presented.
   
   For the seasoned EJB 2 folks, there is a chapter on migrating the EJB 2 applications to EJB 3. This chapter may help in understanding what EJB 3 does for you compared to EJB 2 as well.
   
   In summary, the book was definitely worth my time to read. Beginner and advanced programmers will learn from this book. I'd definitely recommend getting the book and I look forward to working with EJB 3 in practice.



4. The book is a good summary of the specs and gives a nice introduction to the new things in the world of EJB 3. The section on converting your v2 apps to v3 was particularly useful. Appropriately marked "From Novice to Professional" the book touches on many aspects of the J2EE world in a manner that treats the novice with care and the professional with grace and insight/direction.
   
   On the negative side... The book has a lot of repetition. Many pages are nearly identical (especially the sample building) and could have been condensed and made more useful by sticking to use of Ant and examination of the scripts. The same can be said for the "copy-and-paste nature" of some of the writing. However, one can tack that up to "consistency in writing style."
   
   The book is not what I would call an "easy read," but was informative none-the-less. It serves as a starting point and base reference.
   
   The authors have provided a generally well-rounded book and I would definitely recommend this to others.



5. Seems like a good book when you skim it in the book store. After you buy it and start reading, you realize that (a) there are many errors, and (b) APress (publisher) has "disappeared" the errata from their web site. Nice. I'll be contacting APress about a refund (unfortunately, I write in my tech books :-)

5 comments about The JavaScript Anthology: 101 Essential Tips, Tricks & Hacks.

1. It is a good book with useful tips and tricks.
   the authors use an elegant way to catch the target.



2. I didn't really think I needed this book -- I have sever other JavaScript books, including the O'Reilly JavaScript Cookbook, and it seemed like this would just be a duplication. But I kept reading really positive reviews of this and other SitePoint books on sites that I trusted, so I decided to take a flier on it.
   
   I'm really glad I did. Unlike some of the O'Reilly books, which are dated at this point, this has really up-to-date, professional code that incorporates best practices. Depending on what kind of JavaScript code base you need to integrate with, you may be able to use this code as-is in many instances. Even if you need to modify it for your own uses, you will never find poorly-organized hackwork here.
   
   Also nice is the up-to-date topic selection. Classics like DOM, form validation, drop-down menus, and cookies are supplemented with topics about accessibility, XMLHttpRequest, in-page dialogs, and using class prototypes. When the authors tell you how to launch popups, they also tell you about all the pitfalls and problems.
   
   No cookbook is going to cover ever possible topic (personally, I would have liked to see JSON examples), but this one is about as complete as you could reasonably ask for. Really, the only downside about this book that I can see is that you need to have at least an intermediate understanding of JavaScript to understand what's going on. There isn't a lot of handholding, and you will likely want to own both a good tutorial and a solid reference on JavaScript and spend some time with them before you're ready for this book. But if you have a good working knowledge of JavaScript and are looking for practical, well-written examples of how to incorporate new techniques into your code, you won't find a better book than this one.



3. This is an excellent next-step up from an introduction to Javascript and looks at its use in real world situations. You will need to be reasonably fluent in the language to get the best out of it.
   
   The book presents a topic as a question and then presents code to action that query as a solution, then goes through that code in a discussion section. This is where I have a relatively minor criticism of this book; the necessities of discussing the code do not always mesh well with the question and answer format of the layout.
   
   The authors have gone to great effort to ensure that the book is as up-to-date as possible, though this is a rapidly moving target of course, and detail how to ensure that the code will run on as many platforms as possible, rarely giving up and saying 'forget it..', though this proved necessary in a number of the more esoteric options and older browsers.
   
   A highly recommended read if you are looking for a quick solution, or a detailed understanding of what's going on.



4. I purchased this book out of desperation after using a 1000 page Javascript Wrox book published in 2000 that was worse than useless. The author's blog posting here is very accurate: it is a modern javascript book that gives usable solutions and concepts that work well. I recommend this book to anyone who has at least some programming background and is sick of cut and pasting garbage code from other mickey mouse tutorial sites that break at the slightest change. It is also a great start for working with AJAX, which is what I needed it for.
   
   That said, the book is surprisingly a great read. I am reading this book cover to cover and also use it as an every day reference with dozens of tips. It is obvious the authors have worked extensively with web sites and write from experience. Thanks for a job well done!



5. I should preface my review by saying that I generally love the sitepoint books. Simply Javascript (also co-authored by Adams) is hands down the best programming book I've ever read. That said, this book isn't really so much a "book" as it is a "handy reference." If you skim this book and find something you need, then you may be able to justify the cost. As a cover-to-cover read, it's definitely lacking and will leave you wanting. Taken as individual chapters, the writing is excellent and the solutions offer solid coding practices. My recommendation would be to find this book in a bookstore, skim the table of contents and chapters, and see if you will actually use any of the included solutions before you buy.

No comments about Beginning Python: From Novice to Professional, Second Edition (Beginning: from Novice to Professional).

No comments about RESTful .NET.

5 comments about The Apache Modules Book: Application Development with Apache (Prentice Hall Open Source Software Development Series).

1. Apache is more than a popular Web server; it's a versatile and complex platform covered well in THE APACHE MODULES BOOK, the first guide for developers who already work with Apache and want to make the most of its features. From code security and basic processing to C-based shortcuts and techniques, APACHE MODULES BOOK uses real-world code examples and techniques to provide an excellent manual of basics. Perfect for any serious programmer's Apache reference collection.



2. This book came recommended to me from a well-learned Apache module developer, and I can't laud it enough. It is simply impossible to find another reference text out there that covers this topic with this level of completeness. I'm not really sure why the HTTP RFC and the Apache Software License is tacked on to the end of the book, but the real content of the book make it well worth the relatively hefty price tag.



3. I tried to write an Apache module using only the documentation and reference material available on the net, and failed. The documentation you can find on the net (even on Apache.org's own website) is either completely out of date or maddeningly vague. If you spend enough time in trial and error you might get your module to work. Then again, you might not.
   
   If you're trying to write or maintain an Apache module, this book is an invaluable tutorial and resource. It saved me a great deal of time and frustration.



4. This book easily earns five stars despite a few glaring issues. Why? It's the best, most consitent, and approachable guide you'll find to writing Apache modules.
   
   I spent two weeks scouring the net for APR examples and explanations. I started with the O'Reilly books only to find they are incredibly out of date. I moved on to Apache sanctioned module source code. I dissected source code for other modules only to find that the examples fluctuated on approach and, apparently, on the author's grasp of the entire APR libraries. Some folks wrote against previous APR version libraries and macros. Others used the updated APR. Still others rolled their own versions of functions that were already written, just not discovered. Tutorials varied in reliability with similar issues. And my desk quickly filled with highlighted and sticky-noted annotated examples.
   
   This book replaced all those loose inconsistent notes with a solid example-centric nicely bound guide. Five stars. Just for that.
   
   This book is not without problems though. First, it makes reference to programming paradigms which, frankly, I've never heard of before and which this book inadequately explains. Brigade buckets is an example. Bridage buckets are incrementally explained as a ring data store (eh?), a doubly linked list (okay, firm ground), and then a mechanism for passing data through layered IO (another eh?). I couldn't get much from the explanation. Googling "brigade bucket" led to IEEE DSP circuit design and a heated debate on using solid state delay effects for guitar pedals. Apparently brigade buckets don't quote share the same prolific status as, say, something more Knuth-ess.
   
   The book explained thread safety in a similarly gap toothed summary. It offers this fatherly advice: avoid shared memory and make sure functions are reentrant. That wasn't much help for me. I'd prefer to have a detailed explanation of why the APR libraries have both reentrant and non-reentrant versions of the same functions. Wouldn't any reasonable programmer always use the reentrant version? If not, I'd like to know why... with some precision.
   
   The final gripe: the book includes RFC 2616 in it's entirety. This needlessly adds 200 pages of non-original and otherwise easily (and FREEly) accessibe volume. Granted, the publisher formatted the RFC nicely. It's a bit easier to read than the fixed format of the real RFC. But why not add a few notes? The author could have taken the edge off of the RFC-legalese and made it a bit more approachable (think learning bible with more notes than text). At the risk of discouraging future books of this level, the RFC is a blatant copout and just a really disgusting way of bumping page numbers.
   
   So, those are the issues I had. I'm still giving this a solid five as it outshines any other information I've found to date.



5. This should be considered a required resource if you need to learn about writing apache modules. It is the best introduction available to writing modules for Apache 2, and holds up well as a reference.