5 comments about Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition).

1. I found the previous edition 5 years ago, and completely marked it up. This book was instrumental in passing the OOAD test certification.
   I continued recommending this book to my colleagues.
   Then found the UML 2.0 edition, and plan on using this book as much as I did.



2. This book was purchased for the Business Analyst in our IT Department. She is very pleased with the graphics which make the instructions much easier to understand. There are many practical applications in the book that have already been extremely helpful in her job.



3. It's a "must read" for a programmer. This book has opened my eyes for lots of things connected with programming I didn't realize before.
   
   After reading this book I recommend you reading followings:
   - "Agile Software Development, Principles, Patterns, and Practices" ew. "Agile Principles, Patterns, and Practices in C#";
   - "Patterns of Enterprise Application Architecture".
   
   I have to say that English is not my first language, but I found this book "readable" with no problems.



4. This was my first book on development process theme. Well it's quite interesting to read and full of useful information. It highlights some interesting methods of software design work. This book has one shortcoming: the actual useful information is hidden by huge amount of text which sometimes repeats itself. I had to make some efforts to begin to understand the ideas and principles. And after reading it twice you will have clear view of agile development in you head. Anyway it is worth to be read.



5. I needed the book because I did not pass the examen OOAA (Object Oriented Analysis Advanced). The cause: the study material did not cover all the subjects. Therefore I bought this book to increase my ability to apply the UML patterns and to pass the exam.
   
   I have read half of the book.
   It is clearly written, without any errors for far.
   That is why I consider this book as a valuable resource and give it five stars.
   
   Although English is not my native language, I am able to read and understand the subjects.
   
   René
   The Netherlands

5 comments about C# 3.0 Design Patterns.

1. I bought several copies of this book to teach my development team design patterns. I have a copy of and like the Head First design patterns book, but my guys wanted to learn some of the new C# 3.0 features and judging from the other reviews I thought this would be a decent book.
   
   Boy was I wrong. Do not trust the positive reviews. The examples and coresponding code samples are flat wrong. I don't mean code won't compile, I mean they don't teach the purpose of the design patterns or blatently defeat the pupose of them. I am only up to chapter 3 and I am having to create cheatsheets that show how the patter REALLY should work. If anyone is reading this and really wants to learn the design patterns, I would recommend the Head First or the original Gang of Four books. Beware, if you don't know design patterns and use this to learn you will be shooting yourself in the foot.



2. As with all books on patterns, I had high expectations from this book. I was really hoping that the author would have introduced new patterns utilizing new 3.0 language features that I have not yet thought of on my own, but was disappointed to see that the book is mostly another poorly written book on design patterns that happened to use C#.
   
   After realizing that the book was what it was, I was hoping that she would have done something a bit on the cutting-edge side of things by fusing new C# 3.0 language constructs and design patterns, but again, disappointed. The application of C# 3.0 features throughout the book seemed to be more of a showcase ("hey look what I can do") as opposed to practical or necessary.
   
   If you understand that this book is just another patterns book and doesn't introduce new patterns or really take advantage of new C# 3.0 language features, this book is ok. On a positive note, the book is a simple read. But if you're looking for a really solid book on patterns for the bookshelf, the gang of four patterns book (1994) is still the way to go.



3. This book was poor. The source code has errors. It does a poor job at explaining the issue a pattern is attempting to address. Made me very sleepy. If you want a good primer get "Heads Up Design Patterns", if you want more get the GOF book.



4. Lets face it design patterns are something that we have to have but at the same token are usually difficult to understand where it should be used and how to create it. With design patterns C# 3.0 By Judith Bishop we have a little more help.
   
   From structural patterns to Behavorial we can all feel a bit better in designing our tiers for robustness and making things just a slight more easier on ourselves. When i had to create a protected class for an application that i was working on. I had difficulty creating protecting it from instantiation with the guidance in this book i was able to complete the application in less time and focus on other areas of code that needed improvements. I also found use for the decorator pattern, while i will admit some patterns in the book seem like a lot of work to include in an application Bishop makes the case for each one and also describes situations where patterns may be become anti pattern for example using the Singleton pattern to hold static information as a global variable.
   
   Overall, the quality of this book is top notch (figures since it is a O'reily book) and offers many sections on how to enhance your coding practices to make best of your limited time and also of your program. The examples in the book are superb and offer a introduction to what i feel is one of the more complex ways of designing a program. It also has a fair bit of UML diagrams and is "decent" practical guide to also adhering to UML based designs.
   
   Something though i wish they had in this book were more samples, at times there seems to be decent coverage on some of the easier patterns (singleton) and not so much on the more convoluted patterns like Model View Controller. While she does try to create a balanced ground sometimes, i have to re-read the section because she gets to technical sometimes. I guess with time and over the years her thoughts should become more clear.
   
   - Mike



5. Overall, the book seemed pretty useful. Some of the patterns covered in the book are probably rarely used in the real world, but others are design patterns that we use as software developers pretty constantly without realizing it. Getting a formal definition of what those are, and all the different parts involved ... as well as when it is a good idea to use it or what other pattern might be a better fit really offers some value. It was a pretty short book, so I thought it was worth the investment of time to read it.

5 comments about LINQ in Action.

1. This was one of the best technical books I've ever read. It was easy to follow and understand. The examples were very clear and the section on the new features of VB and C# were wonderful and needed in order to understand the rest of the book.
   
   I was slightly disappointed that most of the examples in the book were printed in C# instead of VB. BUT, I downloaded all the example projects and utilities and those are excellent! ALL of the examples are available in C# and VB. They are correct and a great on-the-go blueprint for my routines.
   
   It was also very nice that they talk about (in easy-to-understand terms) the performance implications of different implementations.
   
   The cover is a bit dorky, but you shouldn't judge a book by its cover!
   
   A great buy for the novice LINQ programmer.



2. This book is a well-written tutorial that is generally easy to understand. The logic is straightforward and the language is much better than in most of the other books I have been studying on ASP.NET 3.5 and C#. My only complaint is that I would have liked to see more depth in some sections. To fill in some of the gaps I have found "C# 3.0 in a Nutshell," from O'Reilly Media, to be very helpful, but I wouldn't consider it a replacement for this book. There is an online forum that goes with "LINQ in Action," and two of the authors and some other contributors are very responsive to questions. There are also some files of source code that can be downloaded from the Internet.



3. Most of the reviewers have given high marks for this book. No issue with that, as long as the first six chapters of this book are concerned. It gives the best intrduction on subjects such as lambda expression and various Linq syntaxes. But the most important chapters should have been those dealing with Linq in N-tier architecture - chapters 7 and 8. But those were written in such a confusing manner that, at the end of those two chapters, you are left wondering why you spent money and time on this book. It is a pitty that almost all internet articles, including those on MSDN, deal with Linq as if it is an add-on to Microsoft Access programming and show pages and pages of "drag-and-drop and voila it works great!!" approach. I don't think anyone could write a successfull n-tier Linq code with that approach. Although this book goes little further than the drag-and-drop gimmic, it could have avoided so much fluff and concentrated just on what is needed for a real world n-tier programming using Linq. But unfortunately I don't know whether there is any better book treating Linq as a serious enterprise development tool.



4. I think the expression is "don't cry over spilled milk...", well when my son spilled milk on this book I almost cried. Why would you cry over a book you ask? There are many reasons. Not only does the book go into LINQ in depth (I know there is a C# in Depth book) but the authors cover all of the parts of the .NET framework that were created and needed for LINQ to function. In addition, all of the samples provided are both in C# and VB.NET. These samples are not your basic "Hello World" samples but useful reusable code snippets that get the point of the book section across.
   
   The book starts of with an introduction to LINQ and the different versions of LINQ to xxx, more than enough to wet your whistle. The authors then go into the prerequisites of the .NET framework required, generics, anonymous types and lambda expressions. This chapter was so good I read it twice. The third chapter discusses how LINQ is made up. After this, the authors go in depth in describing the different types of LINQ, including LINQ to SQL, LINQ to Objects and LINQ to Amazon with useful examples.
   
   This book will be a reference book on my book shelf. I expect to refer to this book constantly.



5. I was pleased with overall quality of this book. By and large this is the most comprehensive LINQ book currently available on the market. The writing style is easy to follow and the material is presented in logical manner. I rate it four instead of five because it follows a trend very common to books written by multiple authors - uneven quality of writing. LINQ to Objects for example is pure please to read, but I wish LINQ to SQL was covered better. Overall this is a solid book and I'd recommed it to any working developer.

5 comments about Ajax: The Definitive Guide.

1. 'Ajax: The Definitive Guide' certainly is definitive. With 950+ pages of content, this book doesn't know the word brevity. Spanning 23 chapters and 4 appendixes, this book covers everything you would want to know about AJAX. From its history to how it's grown to where things are today and in the future, this text is very complete. If you are new to AJAX and want to learn how to use it in an extensive way, this is a great resource. My only qualm with this book is that I feel it is just TOO big in size. A 'Learning AJAX' book at around 200-300 pages would be a great companion book to have on the side, then switching over to this bible-size book would be a good transition. Overall this is written well, laid out in detail, and typical O'Reilly quality.
   
   ***** RECOMMENDED



2. My previous favorite, and most recommended, book on AJAX was the one by Crane et. al. because of it's completeness in covering the subject by taking a big picture view of Web 2.0 rather than just one technology. For developers though, the book by Holdener is probably the one to own.
   
   This book has some excellent information that seems to escape other books on this subject or is found across multiple titles. So even though it is certainly a large volume, I think there is some definite value in having quite a bit of related material in one title. For example, there are insights into JavaScript and use of JSON in programming the DOM (to name a few) that in my opinion made sense to include.
   
   If you are going to do rich, browser-based application work, you definitely want to consider this book.



3. While "Ajax: The Definitive Guide" is certainly exhaustive, it's hard to have confidence in a text so riddled with errors. Other O'Reilly titles I've purchased in the last few years suffer from the same problem: very poor copy editing. In a "Definitive Guide," this is inexcusable.
   
   Furthermore, he author's decision to rely on the Prototype framework is misguided. It saves a few lines of code per page, but one expects a "Definitive Guide" to define, explore, and use the actual objects and methods defined by the language itself, not those defined in one of many, many external libraries.
   
   It is also somewhat comical to read on page 10 that developers, rather than browser vendors, "are to blame for not adopting standards" and that they are "stuck with the mentality of the 1990s, when browser quirks mode, coding hacks, and other tricks were the only things that allowed code to work in all environments," and then to read on page 191 that "Yes, there are always caveats in the world of standards compliance" and that "Example 7-2 will not work in Internet Explorer because Internet Explorer does not support the CSS2 rules that are used to make this work." And on page 187 that "Internet Explorer does not natively support :hover on elements other than . For this reason, instead of using the CSS that will work for all other browsers, we must use this...."
   
   (It's hard not to laugh, too, at a sentence that begins with "To take the file menu example fully to the Web 2.0 level....")
   
   By the time all the errata are corrected and a second edition issued, it might be appropriate for the author to wag his finger at developers who can't yet afford to to be totally standards-pure, but by then the faddish jargon will seem very dated.
   
   And until O'Reilly starts employing copy editors, I'm not buying the first edition of any title they release.



4. i always trust "The defenitive guide" titles from oreilly and this book is no exception , it covers everything in the Ajax world begin with the fundamentals and every related technology , then dive into how using these technologies for real world applications , then covers WEB dervices ,mashups and API , then end up with modular coding best practices during all app developements phases , and the most interesting part is the reference which covers the most popular ajax frameworks , popilar web services api , and what you need to know about Xpath and XSLT .



5. Let me preface this review by saying that I have never been a fan of thick programming or computer books. If a book is 2 inches thick, I often find only 1/2 to 1 inch of it to be valuable. However, most of Ajax: The Definitive Guide seems to hit the mark. Since Ajax development is such an expansive, and rapidly changing, topic, it is perhaps a good idea to shoot for too much rather than too little information. Most developers will find this book not only a good learning guide, but also a handy reference for a wide variety of coding needs.
   
   One thing you will notice when scanning through this book is that there is a *lot* of code. The author is not afraid to publish pages and pages of Ajax code for readers to consider, copy and hack up to create their own applications. Not all is useful in real-world applications, however, since some of it is not cross-browser compatible (most often failing in Internet Explorer).
   
   The first three chapters are largely an introduction to Web technologies, and can be skipped by most developers. In Chapter 4, the author introduces the XMLHttpRequest object, the object that puts the "asynchronous" in Ajax (an acronym for "asynchronous JavaScript and XML"). He details how to make simple applications that pull information from server-based XML or JSON, an alternative data format well suited to Ajax. Chapter 5 deals with Document Object Model programming, a critical task that allows developers to change the look and content of Web pages that have already been rendered.
   
   After these foundational concepts, Part 2 contains nine chapters that provide specific solutions to common Web programming needs. Readers learn the ins and outs of creating Ajaxified navigation, forms, lists, tables, frames, etc.
   
   Part 3, called "Ajax in Applications," goes a step farther by showing the reader how to integrate Ajax with other applications. Chapter 16, for example, shows the reader how to incorporate Ajaxified Google search into a site and even include such dynamic features as search hinting. Other chapters in this section introduce Web services, Web APIs and even show how to create Ajax animated games.
   
   Part 4 contains two chapters that show readers how to create more modular code, and how to create faster, more compressed code. This is critical considering the importance of speed to the user experience in Ajax.
   
   One of the book's shortfalls is the lack of information about the various Ajax libraries. Libraries and frameworks provide solutions to common programming needs: ready-made widgets, improved JavaScript programming notation, useful objects and easy cross-browser compatibility. The author includes a brief introduction to the libraries in chapter 4 and a reference in Appendix B. There are also mentions of the major libraries scattered throughout the chapters. However, it would be worthwhile to include at least a chapter devoted to each of the major libraries such as Dojo, Prototype and jQuery.

5 comments about The 2007 Microsoft Office System Step by Step.

1. Since VISTA is new, it sometimes hard for a IT professional to use it, particularly the new feature. (I spent 22 years in IT.) This new book is excellent, fairly easy to use.



2. I have been an MS Office user for more than a decade. I have been using Office XP or 2003 on my systems but needed to add a new PC to my office and it came with 2007. While I do not need instruction on the basics of using Office, there are some new things about this version that are unique and it would be nice to know what the critical changes are, other than the graphics design and where they hid the buttons! And the 'manual' that comes with the MS software is, politely, a joke.
   
   So I bought this book because my business runs a number of things on Excel that are critical and I upgraded the other PC to 2007 for consistency. Primarily I needed to understand what be gained or lost from critical files in converting them to the new Excel format.
   
   For example, if you are working on an existing Excel file in 'compatibility mode' and hit 'save', you may well be presented with a dialog box that says that some formatting may be lost if you do not save in the Excel 2007 mode. It will nicely even tell you how many instances of formatting loss you will have and how 'important' those losses may or may not be. What it will NOT tell you is what the formatting losses are!
   
   How about the 'Save As' command? You have the option of Saving as Excel Workbook, Excel Macro-enabled Workbook, Excel Binary Workbook and Excel 99-2003 workbook. Each option has a brief description but is not at all clear on when and why one format should be used over the other. Even using the Help files is of no Help.
   
   Enter this book. Certainly a book sanctioned by MS would give me some good clues about what I gain or lose by using the compatibility format or certainly the binary format. Nope. The book offers NOTHING on what would seem to be a fairly basic bit of information - why use any given format and what is gained or lost when using one vs. another.
   
   Thankfully I know how to use most of the functions that I need anyway, even if I now have to hunt for them since the menu format has so radically changed. But what I wanted from this book it has failed to deliver in every instance. Other than helping to understand the way the new ribbon bar works and a few other fairly minor issues, this book makes a wonderful paperweight. Maybe if you are a first time user of Office this book can be useful. But if you are converting from an earlier version and have some critical documents that you will be using in an ongoing manner, look elsewhere - this book will be of no help.



3. this was for college, not enough chapters for class but it will be ok according to the teacher.



4. The book came exactly how I expected. Good condition and good price! Timely shipping too!



5. The book was received very quickly. Great packaging, good time frame and easy purchase. I was very pleased and will purchase again from this seller.

5 comments about MySQL Cookbook.

1. While I'm very familiar with working with relational databases, my MySQL skills are weak. This book was exactly what I needed while building a new web application that uses MySQL. For every question I had, I found the answer in this book. Highly recommended.



2. This book is useful for anyone looking to find examples of MySQL 4 usage in multiple languages such as PHP, Perl, Java, and Python. It covers many areas that are used in real world applications and is great as a reference material. This book is structured in the Problem/Solution layout of the Oreilly cookbook series.



3. As indicated, this book is true to its title. It is a cookbook, by which I mean it contains a great number of (generally useful) recipes of varying complexity, but lacks detail and analysis that a more focused text would have.
   
   Mr. DuBois and O'Reilly publishing are clearly targeting a wide audience: the recipes range from frighteningly simple (e.g. 3.1, Specifying Which Columns to Select) to fairly sophisticated (e.g. 12.14, Performing a Join Between Tables in Different Databases). The recipes are typically clearly written, with ample supporting code examples and few typographical errors.
   
   I must also note that Mr. DuBois nicely avoids a pitfall many authors (the competence of whom I have to question) in this genre encounter: failure to weave security considerations into the text. While other books often mention security as an afterthought, or worse include code examples featuring disasters like non-escaped strings (hello, SQL injection!), DuBois explicitly points out the need to sanitize input and writes code examples that demonstrate the use of prepared statements in best-practices.
   
   Unfortunately, in other areas he is less thorough. For example, only passing mention is made of the (possible) dependence of FULLTEXT indexes on choice of storage engine. There is an entire chapter on handling duplicate rows, but the oft-needed (and non-obvious) process for removing pseudo-duplicate rows differing only by a primary key field is not directly addressed. Stored procedures, triggers, and other new additions to MySQL are among the least-well understood but most powerful features of the database engine, yet astonishingly little space is spent on them. (I could understand not discussing them in depth as there are other books available, but length did not seem to be a concern anywhere else in this book.)
   
   In summary, the book is an excellent resource for novices and experts alike - but only as a starting point. To return to the cooking analogy, the book at times feels like it is loaded down with recipes on how to add sugar to flour, but omits recipes on how to ice the cake.



4. This book is
   -a great resource for those looking to implement various mysql functions
   -a great resource for database programmers
   -a trove of information on powerful query and sort techniques
   
   Finding information about the topic you're looking for is a breeze in this book - the chapters are well-organized, and this book has anwered all questions I've posed to it....
   
   The cookbook is a powerful tool to those who know some mysql, and some dB design. I recommend that you use another book to learn basic mysql (or just an online tutorial), and another to learn database design (Navathe).



5. At 900+ pages this book addresses a lot of common SQL tasks. And that's what a good cookbook should do. Not only does it present the SQL queries in the MySQL dialect, it also covers how to pump those queries through Pearl, Ruby, PHP, Python, and Java APIs.
   As an added bonus you can actually use this book to learn SQL. I thought the chapter on JOINS was especially well written.

5 comments about SQL Pocket Guide (Pocket References).

1. This book is the best form of remember SQLScript by engine details and lexical diference; I'm using Oracle v7, v8, v10 and SQLServer in my job; and mySQL and Oracle v10 in my own SOHO applications.



2. I love this little book since I work with many RDBMs and need use different syntaxes to accomplish the same thing. That's what this reference is good for - to remind you of material that you've forgotten.



3. I'm writing a review because of how impressed I've become with this over time. I have several SQL references and this gets used by far the most. I'm a big O'Reilly fan and I think I bought this title in addition to the Nutshell book because it was cheap and I also wanted multiple SQL reference books so I could have some at home as well as the office.
   
   I at first assumed that the Pocket guide would be inferior to the Nutshell book but I've found the reverse to be true for me. The strengths of this book are passages are always straight to the point, with tons of examples, and ALWAYS is very clear on relevant differences between different flavors of SQL (DB2, Oracle, SQL Server, & MySQL) without any blah blah blah.
   
   For knuckleheads who have worked in so many languages that they can't remember any syntax anymore, and who prefer a good terse example to a big syntax tree, this reference is highly recommended.



4. this pocket book is useful in that it touches on command sets from mysql, sql server, and also oracle. this cross platform approach is helpful when learning sql, or if one was to switch from one enterprise level system to the next. this mini book was shipped out in a timely fashion. i can say that the reference available in this book was well worth the moderate expense, as well as the shipping time.



5. A comprehensive and detailed SQL reference with sample code and result sets to make the content clear. An excellent pocket guide to take anywhere.

5 comments about Programming Erlang: Software for a Concurrent World.

1. I've been working through this book and am very glad for it. I'm not sure how else I'd efficiently have gotten up to speed on Erlang.
   
   The book does need lots of minor work, though - it still feels like a beta piece of software. There are examples / explanations that make use of not-yet (or never) explained functions/modules. The appendix describing some of Erlang's modules only claims that the set of documented modules is incomplete, but doesn't mention that the set of functions within some modules is also incomplete. Etc.
   
   Another issue is the license of the code examples. The author shows some example code for how to do certain things, such as a distributed map function (pmap). After reading the book, it's hard (at least for a newbie) to imagine a different solution than the author's. But if you go to the website containing the example code from the book, you find a pretty restrictive license on the example code. So this leaves the reader in a difficult position: the book only shows you one way to do something like pmap, and the author has a license on that code that makes it unusable to many readers. This is more than a little frustrating.
   
   Finally, the index is very incomplete.
   
   If you're new to Erlang you still want this book. But it would really be a good thing for the author to gather criticism (if he hasn't already) and go a second round.



2. I made an attempt at working through this book 6 months ago and didn't feel quite comfortable so I dropped it and instead pursued Programming in Haskell. Yesterday I decided to get back into Erlang and found it a complete breeze, powering through the entire book in a few hours.
   
   A lot of things seem to become really easy after working with Haskell, not to say that programming in Haskell is hard, just it twists and bends your mind into a different shape.
   
   Now that I'm abreast of the material covered in this book, I am leaping into a large project with great confidence.
   
   5/5, excellent book!



3. Overall, I liked this book. When I read this, I was looking at doing some Erlang work; I didn't end up using Erlang, but the book was still enjoyable, and gave me a good overview of the language.
   
   Some things were a bit odd: the organization was not clear, and the order of chapters was confusing. The authors choice of material was seemed unusual to me: he covered a streaming MP3 server, and mentions ID3 tags; he does not, however, describe what they are or describe in detail how his code processes them. Still, the important details of Erlang itself are covered, and perhaps that's the most important part.
   
   Take it easy,
   
   Dave



4. This book was well worth the money even if you don't intend to program in Erlang. It gives a very good over view of an alternative model of parallel programming that is currently not heavily used. The model emphasizes reliability by not having any shared state. I went on to use this model in C++ projects.



5. With a very amenable writing, Joe Armstrong presents a clear overview on the Erlang Language and basics of the OTP. The book presents the basic topics, with simple and yet powerful examples, and points the directions on how to find more informations.
   
   Definitely a great book.

2 comments about Head First Ajax (Head First).

1. Excellent product. Head First is a different type of technical writing. If you are looking for books with a lot of code examples this is not the one. But if you are looking for a book that will help you learn the actually concept, how AJAX works, then this is the one. I own multiple titles. They helped me learn C# when I was having trouble. Excellent in teaching. There are code examples such not a ton like other publishers.



2. This book is for people who already know HTML very well and are familiar - but not necessarily experts - with CSS and Javascript. If you are not in that category you should probably check out "Head First HTML and CSS" first. This is not a reference book, but a book for understanding and, more importantly remembering Ajax via an unusual presentation style. That unusual presentation style includes fake interviews, lots of illustrations, and question and answer sessions. You are also presented several designs and shown the right and wrong ways to approach problems. Ajax requires a non-traditional approach to web application design, and head first books are always good at adjusting your thought process as painlessly as possible.
   
   The topics covered include designing Ajax applications, Javascript events, multiple event handlers, asynchronous applications, the document object model and its manipulation, frameworks and toolkits, XML requests and responses, Javascript Standard Object Notation, forms and validations, post requests, leftovers, and utility functions.
   
   I liked this book not only for its casual and fun presentation style, but because it starts explaining Ajax at the beginning and does not get confusing as you go forward. The author knows how to ramp up the difficulty level without you really noticing. Plus, you don't feel like you need half a dozen other books to understand what's going on. The author is clear in her explanation of what the book's limitations are.

5 comments about C++ How to Program (6th Edition).

1. My teacher is using the 5th edition, but I have the 6th edition, and it is not a problem. The assignments are the same, so buy the 5th edition since it's cheaper. I think there are a few kids in my class that are using the 4th edition without any problem, but I don't know for sure.
   
   Programming is a hard thing to learn, so it would be unrealistic to think this book will magically teach you. However, I think it does a decent job with a very hard subject. The best way to learn is by trying to program, but if you get stuck, the book is probably not going to be much help.
   
   It also teaches about classes before you learn about functions, which makes almost no sense to me. If you don't understand functions, classes are impossible to understand other than in theory. And learning things in theory does not help you!! (It does later when it all comes together, but if you don't understand the first steps, you will never get there!)
   
   If you are buying this book to learn (and not for a class), get the 3rd edition because it teaches functions before classes. C++ has not changed significantly, so don't worry about it being old.
   
   The CD that comes with the 6th edition has Visual Studio Express Edition, which is FREE software that you can download from Microsoft anyway. If you buy used, you do not need to make sure you get the CD.
   
   I believe that previous editions actually had some content on them, like code samples, questions, answers, etc. (Again I don't know for absolute sure, because I don't have them.)
   
   The 6th edition has a code on the inside cover, you scratch it off and it lets you set up an account for the "Cyber Classroom." The cyber classroom has the entire book online, along with audio samples of people explaining things. (I have never listened to them, so I don't know if it's good or not.) If you don't have the book or your code has already been used, a subscription to just the cyber classroom costs $60 all by itself.



2. Picked this book up two weeks ago and I've been reading several different sections.
   
   Negatives:
   1) Examples are too long.
   2) Chapter on classes too early in book. Several basic chapters occur afterwards.
   3) Structs aren't mentioned till almost page 1000
   4) Bad need of chirp short points
   5) Lacks harmony in layout - subjects appear somewhat disjointed.
   6) I find the miscellaneous tips and points distracting.
   7) Horrible index, if one word is listed in a table, there's a page number for it.
   
   Positives:
   Easy to read, the multi-color is awesome when reading the code and staying focused.
   Good chapter on STL and templates
   Full examples are sometimes useful for full understanding.
   Explanations on subjects seems good, as long as the sample code is short.
   Book seems to include everything on the subject of C++. And some more.
   Lots of details on each point
   
   This book is dying to become a standard, but it misses the mark. It can't decide weather to be a reference book or tutorial. It would be nice to see a split design on the chapters with some quick examples.
   
   I think I rated it a little low, but I could not give it 4 stars. I have another Deitel book on C#, and while this one is a little cleaner, (and in color), they could cut 20% out of this book and still have a good product. However, with that said, if I could only buy one book on C++, this might be the one.



3. If you want to learn C++ and C++ in OOP, then this is not the right book for you. This book is written so badly that it is very hard to understand it. I suggest for any students or even programmers to pick up the C++ book that is written by Tony Gaddis and it is so well written that is #1 book among students, teachers and programmers. I have lost all my respect for Detiel books for any programming languages. I don't know why they even teach Detiel books in Colleges and Universities when all proffessors are saying is that this book is not well written.



4. I'm very satisfied with this book, it is great conditions like brand new not to mention I received the book a few days earlier than I expected.



5. This book provides error prevention tips and best practices for writing code while introducing the concepts from scratch. It introduces classes early and also provides exercises. It has been interesting reading this book and helpful.