5 comments about Jakarta Commons Cookbook.

1. The Jakarta Commons Cookbook provides an excellent resource into the many useful features and functions in the Apache Jakarta Commons libraries. In addition to the nice cookbook style, there are large numbers of examples in one single volume. This is an indispensable book for the Java developers who want to understand the Jakarta Commons libraries.



2. This book does provide a good overview of some of the most popular libraries in the Commons project. Although I have read and enjoyed several other Cookbook style books on more general topics, I did not find this one as useful. This is because the Jakarata Commons recipies are very speicific, and cover a wide array of unrelated topics. If you have a specific need that is covered, you will likely find the book helpful. Otherwise, it may be like some of the real cookbooks in my kitchen that are interesting, but rarely used.



3. It is a very good book, but there is some stuff that's missing and it's important, like Commons Validator



4. This book serves as a good introduction to commons project. It gave me a brief overview and applicability of the projects. Though the Cookbook doesn't serve as a exhaustive reference in itself, it starts the ground work .



5. Although a bit out of date, this book is a great introduction to the Jakarta Commons libraries.
   The Jakarta Commons libraries are an invaluable resource for the Java programmer. So many holes in the Java class libraries are covered by Commons, that it can become an inseparable part of any Java code. As a Java programmer, I recognized such utilities and code fragments, found in the commons libraries, that I used to implement over and over again on my past various projects.
   No more! Commons is to the rescue, and much tested, working code can now be reused.
   The book itself follows some of the major libraries: Strings, IO, Templates, Networking, Collections and more.
   Some of the covered libraries are not any longer part of the Jakarta Commons (Velocity), and others are missing (commons-jdbc). It would be great to have a new edition for this book.
   But even so, the book provides a structural, well defined review of the most interesting features in these libraries. Written in an easy to follow language, having simple yet clear examples and making a point on where and why Jakarta Commons is a good choice.
   Many of the features are not well presented in the Commons User's Guide on the Jakarta web page. This book complements the online examples, and serves as a useful reference.

5 comments about Coder to Developer: Tools and Strategies for Delivering Your Software.

1. Coder to Developer is one of those books that you don't read just one time. In fact, you'll want to keep this book handy because it's one of the better reference guides on the market. Creating great software means examining the process you use to design, develop, test, and distribute it. Mike does a great job of covering all of these bases and more.
   
   The most important aspect of this book is that Mike doesn't tell you just one right way to get the job done. This book is all about options and alternatives. Sure, you can use a particular technique for testing your software, but what will that technique cost you? Mike gives you the answers so that you can make a resonable choice based on your specific needs, rather than what Mike thinks you might need.
   
   I liked the fact that Mike used the DownloadTracker application throughout the book to demonstrate various techniques. It's as if Mike is developing this application as you read and wants to clue you in on the techniques he's tried to build a complete application--not just code snippets. So, in addition to providing you with great theory, you get to see that theory in action. This is a great book and you should have it on your bookshelf.



2. The book tries to cover the whole of the software development process from planning, team management, coding best practices and finally creating an installer and releasing the product. With such a broad range of topics each one is only treated very superfluosly and shallow. The author has a very tool centric view on things and as such many chapters are just a market overview of available software for the task at hand. I don't think this is of much use for the reader since that is exactly the kind of information you can gather in half an hour of internet research with google - and even after reading the book you'd still have to do this research anyways in order to gather current prices for the latest gadgets. All software solutions presented in the book are for windows only and Microsoft's tools seem to get extra focus and attention. The intended target audience for the book are independant developers and small software shops. As such the author assumes that you are wearing multiple hats and are filling all kinds of different roles from designer to coder to management. I very much liked this perspective on the software world because for one thing I am one such lone wolf developer and second because there are already tons of software books for the large corporate software developer. Those books typically assume loads of process and management and different departments etc which all don't apply for the single developer. Two important things missing in the book's coverage are two chapters: One for the time before concrete planning actually begins on the question of "what to develop" and determining markets. Another one for the other end of the road on how to market your software, how to price it and how to present and distribute it. If those were included I think the book would truly cover the complete process a lone developer goes through from idea to product.
   All in all, the book gave me little new information but a good checklist to work through on a project.



3. Gunderloy assumes you can already program well. But he shows how making a commercial product means you need extra skills. It is the assimilation of these skills that makes you into a developer, in his eyes.
   
   Unit testing is one of these skills. Vital in verifying that crucial routines work. While this might not be feasible for all routines, you should aspire to do so as much as possible. Plus, it would be good if the unit tests could be run in an automated fashion. So that you can easily and often test.
   
   Another necessary trait is to use a source code control system. So that you can roll back to an earlier known good version if necessary. More importantly, it enables a team of programmers to work on the same code base.
   
   Having a streamlined build is also good. It is convenient to be able to type 'make' [or the equivalent] and have all your code compile.



4. This is a book that, while probably beneficial to all coders, seems particularly useful to junior programmers and technical managers. If you are a more experienced developer and/or don't develop using .NET, then you will find yourself skimming about a third of the book. Before you decide that a automatically disregarding a large portion of a book's contents qualifies that book as not worthwhile, I would point out that the other two-thirds of the contents make up for any "deficiencies." The important thing that this book does is provide a list of sorts of all of the areas that are important for a high-quality developer (or manager) to bear in mind.
   
   Gunderloy walks through the development process, from planning to delivery, discussing many of the ideas and processes that one learns by working on a high-quality software development team. Many of the code snippets or details concerning tools are MS, if not .NET, specific. However, a junior programmer will likely learn a number of things by reading these sections - even if they do not develop .NET applications. More experienced programmers may even discover some useful notions as they peruse these sections. The key here is that Gunderloy is covering the span of the software development process instead of addressing a single area in depth. Thus, where the reader may have a number of areas of expertise, he or she stands a good chance of shoring up weaknesses in those regions between areas of expertise.
   
   As this book is a relatively quick read and covers a wide area in less than 300 pages, it goes without saying that none of the areas discussed are covered in great depth. However, after reading it, one is more likely to be able to effectively investigate weak areas. Gunderloy does provide some useful starting places to begin these explorations.



5. Thorough but readable reference book for developers who have a clear idea of how to code, but may not have thought about all the supporting activities and tools to help do them. Probably more appropriate for new developers just out of university, where computer science, but not necessarily software development, is taught. Written for developers in small companies, but addresses same topics that apply in large companies too.

5 comments about Web & Software Development: A Legal Guide.

1. A straightforward and well organized book.
   
   I needed a brief on copyright ownership, a draft software licensing agreement and a software maintenance agreement. I got all 3 with this publication.
   
   It is nice to find a book so fit for purpose.



2. There is a lot of good information and discussion in this book about the topics which a contract should cover. It falls down, however, when it comes to the actual contracts. Just comparing the website and the custom software contracts, there are differences where there shouldn't be. In the software contract, it's the Customer, in the website contract, it's the Client. A bit more than half of the contract sections with (mostly) identical headings and purpose have unexplained differences between them. Many of these differences are not trivial. In the text, the contracts are interleaved with explanations, but often the commentary/annotations are just restatements of the contract itself, which is a real time-waster, especially if you've read the background material earlier in the book. Other occasional editing snafus include explanatory comments inside the contract text, formatting syntax commands on the page (END SECTION), and a less than clear and concise structure for indicating optional clauses (the intended combinations aren't always clear, even though customization is to be expected). Given the fuzzy line between a website and a web application (ie 'custom software' (and really, what website is NOT custom?)), and given the marked similarities in over half of the two contracts, why not cover the overlapping sections just once, instead of twice, but inconsistently? And the sections that don't overlap, or overlap badly? No real explanation as to the reasons for the differences. I hope I don't have the same problems with the two versions of the independent contractor agreement. Fishman has written a pile of legal books for the layman, including the more recent "Consultant And Independent Contractor Agreements 5th Edition". I have to wonder: "Quantity over quality?" Perhaps when he is working on the next edition of this book ("Legal Guide to Web & Software Development", due out 8/2007), he will take the time to re-organize some of the content and get a capable editor. A determined reader can sort out the differences on their own, but it need not be so difficult. The content is 5 stars (including 24 documents in RTF format), but making it work for you is a real pain if you care about details.



3. I found this book most useful for the CD-ROM's legal contracts. As a consultant, I use these for all my clients.
   
   I have found my clients legal contracts to be biased entirely in their favor rather than this CD's contracts which tend to be fair and balanced, protecting both parties.



4. Nolo delivers again with its guide to web and software development. The book is easy to read, has sufficient tips and examples, and is a great primer.
   
   It does not get into incredible detail on any one subject, but that's not its purpose either. It gives you sufficient resources (including the necessary forms) to get a software company or product started. When the product / company start growing fast, it's worth doing a review with an attorney, but not until then.
   
   I recommend buying this if you are: a software developer looking to go freelance; starting a software company; or doing any consultant work in web or software development.



5. After careful research, I choose this Nolo book when it came time to license my company's software. I guess it's silly after spending so much moola to develop software, to not go to an attorney, but I like to think I can figure out all this stuff on my own. I looked at a lot of user agreements online, I figured I could just put together something the big guns paid a lot of money for. If their agreements worked for them, they should work for me. But, I didn't want to plagarize them, and, well, you never know what you don't know and you can't be too careful in business these days. What you don't know is what will bring you down. I have used many NOLO books as guides and trust them. They are always easy to skim and read. I also bought Quicken's Legal Business Pro 2007 software. The sum of the 2 is way less than attorney fees, and now I understand it myself as well. I am so happy I bought this book with a CD because it made me realize how important it is to also protect our work with copyrights, trademarks, agreements, etc. Most importantly, I found out who owns the software we paid to develop, and it's not us, surprisingly! So I have to get that signed off before I can license it to someone else. It's not in depth but I don't think it's meant to be, it's a GUIDE, people. Now I will buy NOLO's books to guide me through the process for legal protection. The employment & consulting agreement chapters were not useful to me, but they may be to someone else. There are other books devoted to that and NOLO has them too. (check out their website and e-mail newsletters.)I feel I got more information than I expected and know what to do to take the next steps. Very important info for CA users, the laws are not the same as other states,(what's different?) and this book points the differences out. The format is such that one is able to cut and paste together the different parts and verbiage you need which will apply to your needs. Buy the book and get your bright yellow highlighter out!

5 comments about .NET Framework Essentials.

1. Very well written primer on the .Net framework, internal workings of the CLR and language fundamentals. Great book.



2. IMHO, OReilly tends to have the best technology books (I own many) but this book isn't one of them. This book is lightweight even as an introduction. This book is certainly fine for managers, senior architects, and business types, but if you plan to design and write software I recommend Jeff Prosise's "Programming Microsoft .NET" and Jeffrey Richter's "Applied Microsoft .NET Framework Programming", though a bit dated, both cover the .NET framework essentials and then some.



3. This book delivers exactly what it promises - an excellent overview of essential .NET Framework. Easy to read format, good chapters on IL,Framework,COM+ Interop. Unfortunately very little or no .NET serialization, memory management or threading. But a lot of information for the size of this book. Gives excellent foundation to learn upon.



4. As the title says, this book gives the essentials of the .NET framework. It is not an exhaustive treatment, rather, it touches on the main features of .NET. The book assumes that the reader is fluent in object-oriented and component-based programming. Overall, the book was fairly well written with the main features of the .NET framework being clearly explained. The book has no distractive "fluff" in it, so one can easily dive into learning about .NET. The authors give an overview of .NET, and then present a description of the common language runtime (CLR). The common programming model and working with .NET components follow. XML data and web services are clearly explained with a lot of code snippets being given. The book concludes with chapters on ASP, Windows Forms, and mobile devices. The appendices are useful, as sometime acronyms aren't defined in the main text, but are explained in the appendix.
   
   Overall, I found the book well written. The coverage of topics is actually fairly decent. The authors have done a good job of focusing on the essential aspects of .NET. If you're looking for a book that gives gives an overview of the heart of .NET, this is a good book. If you're looking for an exhaustive reference, than you'll probably want something else.



5. I went to my local bookstore to get a functional understanding of ".NET". My previous readings had been hit and miss and provided little understanding of the new platform.
   
   This book provided that understanding. The writeups on the CLR, assemblies, garbage collection, net components, web services, etc. were skeletal but quite good. I came away with some understanding of what .NET is, why it was developed and why I believe it should leapfrog Java in the web development world.
   
   It wasn't an easy read since it provided good understanding with little detail, and takes some thought; but again, it serves it's purpose well.

5 comments about PHP 5 Objects, Patterns, and Practice.

1. Overall a very nice book. Certainly not a replacement for either "Gang of Four", OO design and PHP books, but a nice compilation. Don't expect any ground breaking strategies or patters. Good book for a person who wants to know HOW to use patters specifically for PHP. Pretty vague on WHY.



2. Zandstra has created a masterful overview of OO for PHP and provides the patterns to go with it. However, the code presented in a number of sections is far from self-documenting, particularly the Enterprise patterns section. A really great additional feature would have been to tie up, broadly, how the patterns interact with one another at various layers of enterprise design; as the book is written, it becomes hard to keep track of all of the objects Zandstra has created over the chapter, and many times he generates a new version of an old object without presenting a full overview of the newer version, making it difficult to see what his revision has actually done. A good example of this is during the ApplicationController pattern, when he rewrites the FrontController object.
   
   I appreciate the practical examples presented throughout, however, and the sections on UML, OO and Practice will very definitely help novice to intermediate designers.



3. This book does borrow heavily from the "Gang of Four" book as other reviewers have mentioned. But the latter is the definative book on Design Patterns.
   
   I would recommend buying both books as they do complement each other quite well. The examples in "PHP 5 Objects, Patterns, and Practice" tended be be a bit obscure but were clear and practical.
   
   I recommend this book.



4. The book gives an excellent introduction in object oriented programming (OOP), even when you want to learn OOP without using PHP. They first describe a clear problem and then show why and how OOP can be used to create a better solution.
   (Note that I already had OOP Java knowledge before reading the book.)
   
   The second part of the book focuses on Design Patterns, which I sometimes found not clearly explained; problems unclear and definitions not explained. The OOP part was clearer.
   
   The last part focuses on external tools to ease php programming, like testing, documenting, automatic deploying etc.
   
   A major problem about the book is that it focuses a lot on OOP and design patterns without simply showing how this can be directly applied on a webpage or website. The end of part II feels more like how to make a complete PHP Enterprise framework from scratch yourself, with a lot of details making it a bit hard to crasp. It will take a lot of (initial) effort if you want to apply the enterprise patterns described in this book. In a real project, you probably won't even make a complete framework like this yourself, but take an existing framework like CakePHP of Zend Framework, something where the book doesn't talk about....



5. Its probably one of the best books for understanding php5 concepts. It describes each and every feature of php5 with appropriate examples and is quite easy to comprehend.

5 comments about The Linux TCP/IP Stack: Networking for Embedded Systems (Networking Series) (Networking Series).

1. This is an in-depth guide to implementing and using the Linux TCP/IP stack. It begins with a general overview of TCP/IP networking, with background information on applicable networking standards. From there, it details the TCP/IP implementation in Linux by following a pack of data as it flows through the stack from the sending system, out the wire, and back through the input side of the stack in the receiving machine. This unique approach gives programmers an inside look at the entire process.
   
   The book is aimed at th engineers and programmers implementing dedicated or embedded systems including sockets, network interfaces, application protocols and practical considerations.
   
   The CD included with the book includes the source code developed in the book, much of which can be modified to fit many quasi-standard applications, and a considerable amount of additional technical information on Linux and the particular aspects of TCP/IP.



2. Loads of info, all's good, but it's a struggle. I mean, explanations don't match the pictures, a lot of redundancies in the text (that make you wonder if perchance they're not redundancies and force you to backtrack -- to no avail, 'cause they *are* redundancies); strange hyphenation habits ("pre-pending and removal"... well, then make it "re-moval", be consistent, at least... "pre-allocated", "de-allocated", etc.); on one line it's "sk_buff" on the next it's "skb" -- I mean THIS IS NOT POETRY! This is a lot of precise, dumb and boring literal-minded stuff that, in order to be understood, HAS TO BE RIGHT! every time, all the time). p.256, "The array of frags is placed in memory ... It can contain as many as six pages in the array." In which array? Does this mean IT ITSELF contains six pages of memory, or does mean that it happens to be in possession of yet another array -- and it is this other array that holds the aforementioned memory pages?
   
   OK, it is an unfortunate fact of life that techies are massively deprived of the aptitude for verbal communication, fine, but where's the editor? It's a fifty-dollar book, for chrissakes. The book is very irritating in this respect.
   
   Otoh, it's got a lot of good stuff, so, in a paroxysm of charitableness, I'll give it four stars after all. But it's darn hard to read, 'cause the author, though he knows his stuff, is an inarticulate turdhead, and the editor took a nap -- 'cause, you know, you'll buy it anyway, why bother.
   
   Four stars, but only this time.
   
   PS. Be sceptical about the review by John Matlock "Gunny" (right below here). This guy cannot possibly have read what he's reviewed; to convince yourself, please visit his reviews page and count the number of reviews he posts daily, every day, since the beginning of time. A dozen of all-positive reviews every day -- yeah, I believe he's read these books. Buyer beware ("Gunny" is not alone: there are quite a few "reviewers" like that on Amazon these days; when you see one of those "Top Reviewers", be sceptical, check their reviewing record; I've seen people reviewing over a hundred books per day every day; others re-type a cover blurb or table of contents; there's a lot of smart alecks of this sort, so watch out).
   
   PPS. A couple of things I forgot to mention, but probably should have: first, there's nothing specifically embedded in this book; and second, there's a similar O'Reilly Linux networking book that is by an order of magnitude better. I didn't have it when I wrote this review (which was more than a year ago), but now I do and can compare. I forget the title off the top of my head, but search for it, it's easy to find. If I were writing a review for this book today, I'd not give it more than three stars -- though again, there's got a lot of good info in it: the book isn't bad technically, just confusingly written.



3. This is an excellent book which explains everything related to the TCP/IP Linux implementation in the 2.6 kernel. There are other excellent Linux networking books, but this is the best one in terms of the details for the TCP/IP implementation.
   
   It explains in detail Network devices, drivers, UDP, TCP, IP and IPv6. And it shows in detail all the steps a packet goes through when moving from the application layer to the socket layer, then through the transport layer (TCP or UDP), Network Layer (IP) and Data Link Layer and finally to the physical layer. Then it shows the details of the flow of the packet at the receiving side.



4. Before you spend your time and money on purchasing any books on the subject, buy this one first. Depending on your background and your needs, it may also be the last one you will purchase.
   
   At the time I got to place my two-cent's worth, there are already 5 other reviews rating this book in a very positive light.
   While the style of presentation of a technical subject may not be strictly original, there have been few attempts by other authors to use it, this author has actually delivered - very effectively.
   
   Technical writers, take a note of this work - it can serve as a blueprint for other technical subjects. Publishers, please a take note of the style and the thoroughness that this work employs to present a complex technical subject. The demand is there - the competition is very scarce.
   
   Yes, this book presents a comprehensive technical explanation in a very practical as well as theoretical terms, and more importantly, places all the components of the technology subject matter within context. After you get through this book you will not be left in a position where you sit in front of your computer and realize you really have no idea how to apply the knowledge of the book you just read. Instead, you will be off and running. Think back, how many books that you read in the past delivered this kind of ability to you?
   
   In closing, I appeal to the author of this book to select another subject of the current technology and write another book. Sadly, the bookshelves are full of "bibles", "primers", and definitive guides that leave the reader wondering what to do AFTER they read them.
   
   If you need to know how to DO networking, this book is a must.



5. This book is not good to understand TCP/IP stack in Linux. The book has not gone through review for wrong section references. I have seen references mentioning to Chapter 4 when it actually is Chapter 7.
   It never explains the main processing of TCP like cwnd update and sshthresh. After reading the whole book I still didnt understand what is done in TCP like which function does what.
   
   A complete failure to qualify as a good book.
   
   I suggest "Understanding Linux Network Internals" which explains very clearly what is done in IP. I expect that the author of that book comes up with a second volume that deals with TCP.

No comments about Business Process Management: Concepts, Languages, Architectures.

3 comments about Flash Application Design Solutions: The Flash Usability Handbook (Solutions).

1. This book is fantastic. It brings to the Flash community a real discussion of the oft-misunderstood "usability" that so many Flash applications lack. Books like this, and the work that it inspires are critical to helping Flash mature as a serious application development platform, rather than creating simplistic little "applets" and simple web commercials.
   
   The authors here deftly weave a compelling tale around the actual pieces of usability and functionality that make up application development in general, and tie it all back together with Flash as the development platform. Some great books exist out there that teach about usability and functionality design (Cooper's "About Face", et al), but this is the first that truly brings that sort of learning in an instantly applicable way to the Flash development community.
   
   Highly recommended.



2. Flash Application Design Solutions was recommended to me by a co-worker of mine when I started learning OOP. I currently work at Avenue A | Razorfish in the Chicago office where we create sites such as Postopia [...]. In an ironic occurrence, it turns out that Craig Bryant, one of the authors of this book, was the person who set up the original framework for the Postopia site. I've met Craig only once when he and Ka Wai made a presentation (a really cool one, at that) at the Apple store on Michigan Avenue. They definitely know what they are talking about and this book is no exception.
   
   I was eager to get started here after I had already realized the basic building blocks of OOP and wanted to get a bit more of an edge on setting up my projects. The book didn't disappoint as it gave me at least two very valuable classes that I still use to this day. The UIObject class is now the core building block of any navigation system I build and the (what I named) Broadcaster class (that is essentially the same as the EventBroadcaster in this book) is just about the best way to communicate between classes.
   
   Chapter three is a great introduction into extending basic frameworks. Each and every chapter has a great introduction on what is an issue in the work you're about to tackle. Ka Wai and Craig then tell you how these issues can be improved and finally we go on to improve the issues to see exactly how much of a difference their process makes in developing your own solutions in the future.
   
   Chapter six has a fair warning by the authors that it is a bit long winded and is relatively hard to get through unless you are going through and following the source, but it uncovers a really neat system of inventory views and selection devices. I'm normally not a huge fan of building one large application throughout a technical book, but its almost necessary to show how to extend the core and your own classes and build up the concepts from start to finish.
   
   For anyone who has already read the Object Oriented Programming for Flash 8 title and is looking for a bit more on OOP, I'd definitely recommend this book as a companion. It'll help you get through that gray phase where you're now familiar with OOP concepts but you're not familiar enough to know how to practically apply them to your own projects.



3. this book has its good points and bad but it was poorly poorly written and poorly organised. the classes that can be downloaded from the companion site are probably worth the price of the book as an intro to OOP but the explanations and execution in the book are poor.
   
   The entire book supposedly leads to a culmination of the sample project coming together at the end so that the reader can learn how to tie all of the lessons together in a complex flash project...a point they seemed to completely forget when they got there

5 comments about UML and C++: A Practical Guide to Object-Oriented Development (2nd Edition).

1. Clear description of modeling OO with a lot of tricks. Helpfull in moving from C to C++ world.



2. I was very disappointed with this book. At least through the 150+ pages I struggled through before giving up, UML was barely covered and utilized. What passed for an example was convoluted and confusing. Some bizarre quotes may convey the tone of this book: "This is consistent with our phenomenalist view: ... dialectical process ... we believe the real world of objects is a reflection of social relations ..." "If you take the Eastern, or Taoist, approach to OOA, ... the Taoist (practitioner) ... the focus is on the path rather than the destination" Explaining is-a: "Generalization has its roots in the knowledge-representation paradigm used in ai ... psychological model of associative memory ... representing a semantic knowledge network" "meronymic relationships" "homeomorphic" "anyone who has studied philosophy knows that reality is the state of mind of each individual"



3. I would give it 0 point if that's available. I think the authors are idots who are not clear about what they wanted to write. Don't buy it!



4. This book is outdated (both first and second editions). It certainly does not teach you UML, it does not teach you C++, nor does it teach you OOAD the right way. I also found numerous errors, even in C++, supposedly their area of expertise.

   They confuse between OO technique and developmental process. They keep referring to development process as OO. Typically, OO is combined with UP in software projects. This is not mentioned anywhere.

   They also fail to see the forest, instead keep focussing on the trees. For example, there is a top-down analysis approach, and another is a bottom-up analysis approach. You can also do it both ways and come to the middle. Not a mention about this in this book.

   They keep preaching about their beliefs. That is annoying. Instead of saying, bottom-up analysis gives rise to more reusable class structure, they go on and on about Taoist philosophy.

   Lot of outdated stuff also in there. Who cares for Structured English.

   On the whole, reading this book will not help, will confuse you, and could potentially get you started in the wrong direction as an OO programmer/analyst.

   There are numerous other excellent books on the market that focus on the OOAD and software development lifecycle. Don't bother buying this one.

   The title is also nonsense. There is very little UML in this book. There is very little C++ in this book. It does not show you how to effectiely use C++ when you are grappling with certain design decisions. No mention of design patterns and how they could be represented effectively in C++.

   Can't find much virtue in this book honestly. Waste of paper.




5. This is a difficult book to categorize and I was left puzzled as to where it would fit into a computer science education. The first eleven chapters deal with the basic ideas behind object-oriented programming and the way they are expressed in UML. While this is a good introduction to the abstract ideas of objects in computing, the book then takes a dramatic turn. Chapters 12 through 17 (a total of 96 pages) cover the C++ programming language, far too much paper and ink to even begin to explain this complex topic. Therefore, this section is either incomplete for beginners or not necessary for experienced C++ programmers. The remainder of the book is devoted to a complete description of the game of "Breakout", where a set of bricks is at the top of the screen and a ball bounces off them and destroys them. The development of the game is described, from the design descriptions in UML to the final C++ code for the project.
   The main problem is that not enough time is spent on C++ or UML for the reader to truly get a grip on either one. Very thick books are written on these topics, so the reader is left knowing only a little bit about both of them, but certainly not enough to be effective or efficient in using them.

5 comments about Data Structures and Their Algorithms.

1. In this book, Lewis and Denenberg attempt to explain data structures and associated algorithms. They rely too heavily on obscure proofs, have few, if any worked-out examples and many ambiguously worded questions. Their assesrrtion that a "high school" math background is needed is clearly false. The book also suffers from poor typesetting.



2. One of the best ways to discover the strengths and weaknesses of a textbook is to teach a course using it. A few years ago I taught a senior-level course on Data Structures using this book. The book was a joy to teach from, and I would happily use it again -- I thought it was one of the nicest textbooks I've ever used.

   (In case you haven't figured it out from the above paragraph, I believe that Paul Schreiber's review of this book is far too negative.)




3. I seriously like this book. It's explaining is close to crystal clear to me when I read it, and the algorithms listed (in pseudo-code) take it to a practical level.



4. This is one of the 2 texts we've had for our data structures course. I'm not sure what the other book is, because this one was so good. It covered the material in a clear and precise way. I even have a copy of this book today, for further reference!



5. I never really appreciated this book until many years after graduating from college. I had this in my library just sitting around. The data structures course I took in school was completely uninspiring. However, when it came to researching and implementing appropriate data structures for my own software, I didn't realize how comprehensive this book is. It covers more algorithms and in greater detail than the ever popular Cormen book. The pascal-like examples are very thorough. There are times when code is not provided, but it gives you enough detail to extrapolate from what is already there to get started.