5 comments about Practical C++ Programming, Second Edition.

1. Overall, the book offers a balanced and well-presented introduction to C++. However, there are too many typos and mistakes for a programming text. O'Reilly needs to kick their editing team into gear. In addition, many topics could and should be explained more in-depth. As is, many topics are only lightly touched on and more of the nuts and bolts of the language (i.e. characteristics that really lead to a quality understanding) are omitted.



2. This is the first time I am actually writing a review for a book, coz I find this book the best I have ever read for C++ programming. It serves great for sophomore level C++ programming class at my univ. and otherwise as a great book to have on your reference shelf too. It starts with an intro to setting up your programming enivroment in .NET and Borland enviroment. After that it delves into programming styles and techniques in general and then goes C++ fulltime. The chapters about pointers,advanced pointers and the debugging/optimisation are some of the best readings I have ever done on the respective topics. Throughout the book the material stays relevant to the title of the book and thus is a great reading for anyone who is making transition from java to c++ or from a beginner C++ programmer to advanced level. The book is great reading for strengthening C++ concepts. If you look through the contents of the book you might notice the only thing that the book lacks is a chapter on data structures. However dont let that fool you. You will be in a better position to perform pointer manipulation on your linked lists and trees after reading advanced pointers chapter in this book, than any other book that just has the code for the entire implementation printed. Besides the book is about letting you loose to do it yourself (rather than hand feeding you) which I believe is what programming books are about.The book has something about almost everything in C++ and lot more like using the gnu debugger .Highly recommended for anyone who wants to have a strong conceptual knowledge of C++.



3. This is not the one. The book is just swarming with typos and programming errors. But don't take my for it, just check out O'Reilly's errata page. The most astonishing thing is that they accidentally omitted an entire chapter. Even after I painstakingly marked every correction in the errata list, I was finding more errors constantly. The other major fault is that it is just too full of ideology, which has its place of course, but he's gone way overboard with it in a book that should be primarily about the language. If you happen to find a copy in the trash, you might give it a skim, but otherwise, I'd avoid it.



4. Stay. Away. From. This. Book.
   
   This book covers a great deal very quickly, and does so in an easy-to-understand way. Unfortunately, it is riddled with novice programming mistakes, has a poor and unmaintainable programming style, and displays many of the things that are widely considered to be "worst practise" in C++ programming. The coverage of the STL is poor and its proper use is not encouraged as it should be. I'm glad I never had the misfortune of ever having bought it. There are many, many other books that cover C++, and nearly all of them cover it better.
   
   If you're looking for a good book to learn C++, buy anything but this one. It is by far the worst O'Reilly book ever released, and I'm amazed that such poor code quality was ever approved by the editorial staff.



5. It's very difficult to write a good and clear computerbook, that's proven over and over again when I order books about the various subjects. Enter O'reilly and enter this book. It's follows a clear, logical path. Since programming is all about doing it and experiencing it on your own the many exercises (without them being worked out at the back) help tremendously. The author knows his subject and can translate this very well into easy to read, and lively chapters that are not boring in the least. For everyone that wants to learn C++. Also a note that the buildup of the book is such, that the very beginner can start with this, but also experiences C-programmers of C++ programmers can find this excellent (directions are given at which chapter to start for them). Excellent and truly deserves 5 stars.

5 comments about C++: The Complete Reference, 4th Edition.

1. Nice book if you want to learn c++. I bought also thinking in c++ by bruce eckel but it is difficult reading and understanding. If you really want to learn c++ search no further, buy this book.



2. Most of my work is done at a low level using C with occassional C++ work usually with certain parts of C++ heavily restructed due to performance and maintenance problems. So recently when I needed to brush up on all of C++ for some application level work where I knew I would be code reviewing and or writing using some of the more beastly aspects of the language I went through my 8 or 10 C++ books to pick one to spend some time with and remind myself of the particulars of things I don't normally use. I chose this book and was happily surprised. It is organized properly, clearly written, and accomplished what I needed it to do in a minimum of time.



3. This was my first purchase from amazon and I was totally impressed by the quality of the product and the service!



4. Herbert Schildt's "C++: The Complete Reference" is a gargantuan tome indeed. It fully covers the C++ syntax, and gives useful, working examples that demonstrate each of the language's features. If you're a professional (or hobbyist) working on a project and need to quickly look up how to use some part of C++ syntax, then this book is absolutely perfect. If you're a developer who has spent his/her life working in C and want to (or need to!) learn C++, then you'll find this book's content well organized and you'll be able to find what you need instantly.
   
   Also, this book seems as though it could function as a tutorial for the complete beginner. Now, I didn't learn C++ from this book initially, so I can't really speak from experience, but the book DOES cover the entire syntax and it does so in an unpretentious and very clear manner. The only thing that it's missing for newbies is exercises -- but if you're really serious, you'll make up your own little tasks, or try to extend/modify the examples.
   
   I program video games as a hobby and have used this as a reference countless times in various projects. I've obviously bought other reference books ("C++ in a Nutshell", and Stroustrup's tome), but I find that this book is my most used and most beloved reference.
   
   So, if you're looking for a clear, easy to understand reference on C++, I reccomend this tome. If you're a true C++ neophyte, then perhaps you should purchase this book along with Schildt's "C++: A beginner's Guide" or "C++ from the Ground Up" (also by Schildt).



5. My older references are in storage and I thought it would be neat to have a c++ ref on my kindle. It says reference and the reviews are good, so I bought it.
   
   I wanted to be reminded of how to use variable numbers of parameters for macro defines. Forget whether this is a good idea. It's a language feature and I want to know how it works.
   
   #define with parameters is handled in one paragraph which doesn't even include the possibility of multiple parameters, let alone any details. Given this, I was curious to see if there was any discussion of the continuation-line functionality in the preprocessor. Nope. Not there.
   
   I'm sure this is a wonderful c++ primer as the other reviews indicate. My spot check demonstrates that this is in no way a complete reference.
   
   Even if you don't like a coding style, completeness allows you to read the code of others.
   
   So I'm out $28 bucks and my question isn't answered. oh well.

5 comments about More Effective C++: 35 New Ways to Improve Your Programs and Designs (Addison-Wesley Professional Computing Series).

1. Scott Meyers continues in the vein of his earlier successful "Effective C++". If you benefited from the insight presented in that book, you may well want to follow up with a study of this text. It assumes a general familiarity with C++, though not necessarily with all the obscure details. It continues in the style of the earlier book by collating useful advice garnered from the C++ community. Which is probably one of the largest groups of programmers in the world.
   
   Two items in the book stand out for the sheer likelihood that you will find them useful. First, install the Standard Template Library on your machine. And whenever possible, call routines from it, instead of writing these yourself. Faster and safer. Those routines have been heavily debugged. STL routines implement many of the common data structures used in computing. Like hash tables, linked lists and sets.
   
   Second, instead of using char*, try string objects. Far safer and thus easier to handle.
   
   Just doing the above two practices can greatly benefit your code.



2. It provides even more explanation than the first book and they both have similar advantages: easy-readable, explained in detail, large and useful topics covered.



3. Describing more advanced topics of c++, such as - things you should know before overloading special operators, inner works of exception-handling (and what you should avoid while using them), how the virtual table is built when using RTTI & Inheritance, general efficiency issues (such as the works of temporaries and multiple inheritance) and few Design-Patterns related techniques.
   
   The style of this book is light and easy to understand, which makes it a fine sequel to the first book.
   
   The author does tends to get carried away in some of the chapters into describing topics in too much detail (overloading operators ||/&&, forcing heap allocations, smart-pointers/refrence counting) and there are few duplication issues between this book and the previous one (I found myself thinking "hmmm... didn't I read that before?") several times.
   
   All said - although it's often a bit less practical and a bit more advanced than the previous book - you would definately gain new insights from reading it, plus it might be used as a useful reference as well.



4. Like every sequel, in my opinion, this book is less good than the original as if the topics covered in this book are the ones that did not make it into the original book. However that being said, this book is still very good and is just more of the same good stuff that made the original book a bestseller. If you liked Effective C++, there is not risk at all that you will not like this one and will get new knowledge out of it.



5. A sequel to Effective C++. Unlike the prequel, which got a third edition in 2005, this has only been updated via the addition of footnotes in a few places (my copy is the 22nd printing from 2006), so some of it feels a bit dated: the items on templates and keywords such as explicit and mutable are somewhat rudimentary.
   
   The material is a mixture of items of a similar level to Effective C++, plus some more advanced topics, like how to find out if your object is allocated on the heap or not, how to prevent an object being allocated on the heap, and the mechanics of the object model, about which C++ users (or the authors of C++ books) seem inordinately fond, at least compared to Java users and Smalltalkers. As a result, the more advanced material has slightly narrower appeal than that in Effective C++ - many of the techniques seem more hassle than they're worth.
   
   That said, a good deal of the material is still universally important, such as exceptions and the new-style casts, which were new at the time of publication, but which are no longer considered 'advanced'. By now, though, this material is covered elsewhere, e.g. in the likes of C++ Coding Standards and Thinking in C++, or in modified form in the third edition of Effective C++. The last item in the book, on the use of the STL, has been superseded by the author's own book-length excursion, Effective STL.
   
   There's also a slight difference in format. The items are in general longer than those in Effective C++. For some topics, it works very well. For example, there's a great treatment of writing a 'smart' pointer and using it for reference counting that takes up 60 pages. That entirely merits the extended format. On the other hand, in some places, the book could have done with editing. Meyers' witticisms are welcome as always, but are sometimes a little too chatty, compared to Effective C++, where the writing is tauter.
   
   It's still a pleasure to read, and this has established itself as another C++ must read, but from the perspective of 2007, it's not quite as genre-defining as Effective C++.

5 comments about C++ Coding Standards: 101 Rules, Guidelines, and Best Practices (C++ In-Depth Series).

1. This book is a very readable reference book. The authors have read several books and condensed the best coding rules to prevent many errors. If you code in any language other than C++, read this book because many of the hints are useful. (If you code C++, then all of the hints apply.) And if you don't like rules and guidelines, then just read the "exception" section provided in each entry to be sure that your code meets the exception.



2. It's Sutter! It's Alexandrescu! It's both of them together! And the dark lords of C++ have combined forces to produce... er, some coding standards.
   
   Yes, another book of best practices. Some readers may therefore be a tad disappointed that the combined fruits of the authors' labours will not be shattering their puny human minds with the sort of C++ that cause lesser compilers to accidentally create black holes that destroy the entire universe.
   
   But let's evaluate the book on what it sets out to do, which is to give 100 bite-sized pieces of advice on C++ coding. And it's very good. You might prefer to see it as an annotated guide to the state of the art in intermediate C++ programming, in particular to Sutter's Exceptional C++ trilogy, which has become sufficiently sprawling that a reorganisation of the material, plus pointers to which book said what, has become quite welcome.
   
   Yes, it's true that C++ is hardly short of books telling you when to pass by value. But take a look at the bibliography - it's a synthesis of all those other tomes (the Effective series, Sutter's own Exceptional series of course, and older books like C++ Strategy and Tactics) plus magazine articles, into a neat and compact whole.
   
   Few of the items are longer than one or two pages. This is good because the advice stays simple, clear and direct. On the other hand, some of the items feel a bit squeezed into the available space, with discussion deferred to the books in the references, which is a little frustrating on occasion. After all, a lot of the best parts of the Exceptional C++ and Effective C++ series and their ilk is not so much what to do (or not to do), but the why behind it. There's plenty of the former, but not so much of the latter.
   
   If you've read any other coding convention books (like those in Steve McConnell's Code Complete) then the first quarter of the book may feel like the same old same old. And of course with there being exactly 100 items, some are more heavyweight than others. But there's definite C++ meat here, in particular with the items on Exceptions and the STL.
   
   C++ Coding Standards is as well-written as you'd expect from the authors - their friendly, slightly conversational writing styles mesh nicely and I couldn't tell who wrote which bits. And it's a great summary and unification of C++ best practices that someone just starting out could easily refer to in their initial forays. Perhaps even more experienced hands will discover a few tips, implications or issues that they hadn't considered before. It could also be a good way to ensure that a team are all up to date on best practices.
   
   Essential for those with a large C++ library? Probably not, but it does the job it sets out to do very well.



3. If you own the 3 "Exception C++" books, do not buy this book. It is just a mirror copy of those. And the explanation in this book is brief. Typically, if you are familiar with the content of this book, it works as a quick reference manual or pocket book.



4. I had high expectations about the fruit of the association of 2 authors that I appreciate but the result did not meet these expectations. Basically this book provides 101 rules or guidelines that you can get for free by looking at the table of content. Each of these rules is then followed by a very short explanation (1 or 2 pages usually). In my opinion, most of them are common wisdom that you can get from other sources. This is it. That is all you will get from this book. For that reason, I recommend to skip this one except if a convenient and compact collection of common knowledge is something that you are looking for.



5. I think this is one of the most useful C++ books one could have if working in a team. Most companies don't have a very large set of coding standards, and every now and then there will be a discussion about which is the best way to implement something. That is the time to when this book shines:
   
   1) You can show your co-workers the page for the related item, and the explanation for the underlying rationale will be so concise, they can read it while standing.
   2) Every item is backed with heavy references to standard works by the top names in C++.
   
   Basically it is a tool for effectively ending discussions in the most constructive way possible.
   
   It's the supreme index into the world of collected C++ knowledge.

4 comments about Programming Embedded Systems: With C and GNU Development Tools, 2nd Edition.

1. This book is the much needed update to the book on embedded systems also published by O'Reilly. This book assumes that the reader already has some programming experience and is at least familiar with the syntax of the C language. It also helps if you have some familiarity with basic data structures, such as linked lists. The book does not assume that you have a great deal of knowledge about computer hardware, but it does expect that you are willing to learn a little bit about hardware along the way. This is, after all, a part of the job of an embedded programmer.
   
   The book contains 14 chapters and 5 appendixes. The chapters can be divided into two parts. The first part consists of Chapters 1 through 5 and is intended mainly for newcomers to embedded systems. These chapters should be read in their entirety and in the order that they appear. This will bring you up to speed quickly and introduce you to the basics of embedded software development. After completing Chapter 5, you will be ready to develop small pieces of embedded software on your own.
   
   The second part of the book consists of Chapters 6 through 14 and discusses advanced topics that are of interest to inexperienced and experienced embedded programmers alike. These chapters are mostly self-contained and can be read in any order. In addition, Chapters 6 through 12 contain example programs that might be useful to you on a future embedded software project.
   
   Throughout the book, the authors strike a balance between specific examples and general information. Minor details have been eliminated making the book more readable, at least in my opinion. You will gain the most from the book if you view the examples primarily as tools for understanding important concepts. Try not to get bogged down in the details of any one circuit board or chip. If you understand the general C programming concepts, you should be able to apply them to any embedded system you encounter. To focus the book's example code on specific concepts, these examples have been left intentionally incomplete. For example, certain include files and redundant variable declarations are omitted. For complete details about the code, you can refer to the full example source code on the book's web site. I discuss this book further in the context of its table of contents:
   
   Chapter 1, Introduction - Explains the field of embedded programming and lays out the parameters of the book, including the reference hardware used for examples.
   
   Chapter 2, Getting to Know the Hardware - Shows how to explore the documentation for your hardware and represent the components you need to interact with in C.
   
   Chapter 3, Your First Embedded Program - Creates a simple blinking light application that illustrates basic principles of embedded programming.
   
   Chapter 4, Compiling, Linking, and Locating - Goes over the ways that embedded systems differ from conventional computer systems during program building steps, covering such issues as cross-compilers.
   
   Chapter 5, Downloading and Debugging - Introduces the tools you'll need in order to iron out problems in both hardware and software.
   
   Chapter 6, Memory - Describes the different types of memory that developers choose for embedded systems and the issues involved in using each type.
   
   Chapter 7, Peripherals - Introduces the notion of a device driver, along with other coding techniques for working with devices.
   
   Chapter 8, Interrupts - Covers this central area of working with peripherals.
   
   Chapter 9, Putting It All Together - Combines the concepts and code from the previous chapter with convenience functions and a main program, to create a loadable, testable application.
   
   Chapter 10, Operating Systems - Introduces common operating system concepts, including tasks and synchronization mechanisms, along with the reasons for adding a real-time operating system.
   
   Chapter 11, eCos Examples - Shows how to use some features of the eCos real-time operating system.
   
   Chapter 12, Embedded Linux Examples - Accomplishes the same task as the previous chapter, but for the embedded Linux operating system.
   
   Chapter 13, Extending Functionality - Describes options for adding buses, networking, and other communication features to a system.
   
   Chapter 14, Optimization Techniques - Describes ways to decrease code size, reduce memory use, and conserve power.
   
   Appendix A, The Arcom VIPER-Lite Development Kit - Describes the board used for the examples in this book and how to order one for yourself.
   
   Appendix B, Setting Up Your Software Development Environment - Gives instructions for loading the software described in this book on your host Windows or Linux computer.
   
   Appendix C, Building the GNU Software Tools - Shows you how to compile the GNU development tools
   
   Appendix D, Setting Up the eCos Development Environment - Shows you how to build an eCos library appropriate for your embedded system so you can compile programs to run on your system.
   
   Appendix E, Setting Up the Embedded Linux Development Environment - Describes how to install the embedded Linux tools for your Arcom system and build and run a program on it.



2. Programming Embedded Systems with C and GNU Development Tools appears in its second updated edition to include even more real-world and Linux examples, and is a recommended pick for programmers with a familiarity with C. It's been used as a college textbook and covers everything from basic debugging skills to determining the applications and needs of real-time projects. In updating details and clarifying routines, the 2nd edition of Programming Embedded Systems should be considered both a classroom and lending collection standard.
   
   Diane C. Donovan
   California Bookwatch



3. This book gives an excellent overview of programming embedded systems. It provides numerous examples of real-world hands-on embedded programming. I'd recommend that you have experience in C. Experience with operating systems concepts (such as interrupt service routines) would also be helpful.
   
   Unlike usual programming books, you won't be able to pick up the book, download something, and start working. You'll need to have an embedded system that you can use. The authors use a system from Arcom that will run you about $300. I've not used it and was very wary about it when I first started reading, but as I read through the various examples I gained a great appreciation for the system. It looks like a great way to gain hands-on experience with embedded programming.
   
   Before getting this book I read through the Lego Mindstorm NXT documentation and felt very lost. I didn't understand the symbols on the schematics and they used strange acronyms (like I2C and PWM). I also have an Iguanaworks USB infrared transceiver. I bought it to use in a MythTV system I am building. This book has enabled me to understand the schematics of both the Mindstorm and the transceiver as well as the documentation of both systems. I now feel ready to do my own embedded systems programming.
   
   That said, I did not like everything in this book. They gloss over areas that I felt would have helped me (such as how to use a JTAG adapter and how to create an interrupt service routine under Linux). There are areas where the writing does not flow well and is redundant. The book switched from using an embedded x86 processor in the first edition to using an ARM processor in the second and there are still references to the old processor.
   
   Even with its faults I am glad I got this book. It filled in many of the gaps that I have as a software engineer who is wanting to learn about embedded systems programming. I feel a whole new world has just been opened up to me and I can't wait to jump in.



4. If you are just getting into embedded systems and you want to understand the myriad of interacting concepts, this book is a good start. You will get a solid overview of the basic elements, such as hardware, software tools and techniques, memory and peripherals, processing controls and design strategies.
   
   As with any embedded systems book, there has to be some alignment with specific hardware and application examples. The author uses these examples to tie together embedded elements, but the integration is a bit choppy.
   
   The book is organized as a general introduction to embedded systems. About half the book describes the system elements and about half provides full system examples. A single book cannot cover all topologies and development platforms, so I wouldn't recommend it for someone who is trying to solve a specific problem on his/her embedded application. For cases like that, your vendors and FAEs are probably your best bet.
   
   So if you are trying to learn embedded systems development, this is a great resource. If you intend to use it to guide a current project or debug an embedded problem, it may become more of a distraction.

5 comments about Thinking in C++: Introduction to Standard C++, Volume One (2nd Edition).

1. If you're looking to learn C++ as your first language, or your first OO language, good luck to you! I tried learning C++ after FORTRAN77, and in retrospect, that was a big mistake. Go and learn another object oriented language first, Python or Java or Ruby (maybe even OO Perl). You probably also want to learn a tiny bit of C, just to get used to pointers and memory management.
   
   Done all that? Good. I will be assuming in this review that you already know how to program reasonably and you're not trying to cram C, C++ and OO into your head at once. So, you just want to learn C++. If that's the case, this is the perfect book to start with.
   
   The book assumes that you're coming to C++ from C, and builds up from C++ as C with a stricter compiler, then onto C++ as 'object-based' language - objects as structs with functions and encapsulating initialization and memory allocation with constructors and destructors. Finally, object orientation (i.e. inheritance and polymorphism) is introduced. Rounding things off is a brief chapter on templates and iterators, but it's only a sneak preview, really.
   
   Only the core of C++ is covered: the standard libraries and other topics (like exceptions) are deferred until volume 2. This leaves volume one as a lean and mean exposition of the core of the language. This is quite an achievement, especially as it manages to be both comprehensive and readable. The somewhat begrudgingly object oriented flavour of C++ is also on display in this book, particularly when compared to Thinking In Java from the same author: there are interesting explanations of what the compiler is getting up to behind the scenes, which should presumably assuage the fears of the more paranoid C programmer. There are copious code examples, although the expected output is not given, which would have been helpful. The introduction to the make utility will also be very welcome to many (including me).
   
   This is not quite as good as Thinking in Java, perhaps because of its C-centric opening section, which may require you to familiarise yourself with the differences between C99 and C++ simultaneously (this is particularly apparent in the discussion of the static and const keywords).
   
   But it's still a great introduction to C++, and it doesn't waste time with the basics of variables, loops and conditionals. Between this, the second volume, and Koenig and Moo's Accelerated C++, you have all you need to graduate onto the intermediate C++ books, like the Exceptional C++ and Effective C++ series.



2. This book was a pleasure to read. It does a very good job of teaching you the C++ syntax in the context of the C++ paradigm; a great improvement over many similar introductory books that seem to focus upon teaching you syntax only. By the time you get through with this book, you will have a good idea why things in C++ work in the way that they do, and such knowledge helps you considerably when you actually start writing useful code.
   
   Overall, this is one of my favorite programming books, and it's highly recommended.



3. this is a must have for all people that need to learn c++
   even if you are novice or experience developer this is a book that you will always open and consult.



4. Bruce Eckel's book very thoroughly covers the Standard C++ programming language. It may be a little dated (my copy says (C) 2000), but I don't think the Standard has evolved since his writing.
   
   The Good: Bruce does a terrific job going into gory detail on all aspects of this (let's just face it) complicated language. C++ has lot's of traps and ditches to offer compared to C# or Java, and if you plan to use a lot of the advanced concepts of the language, a helper like this book is almost indispensable. If you are coming from the C realm, this books is a real hit: Bruce constantly points out the subtle differences between C and C++, and also explains how C++ is a safer language than C in almost every facet. The book does a fairly decent job in going from the simpler to the more advanced concepts, though a few times he has to use constructs that will only be covered in later chapters (Bruce does point out these outlooks though appropriately). If you are really into learning a new language, the Exercises at the end of each chapter are a terrific way to learn the new concepts.
   
   The Bad: The text within the chapters is not very well structured. If you later on try to find something, the prose form of the sections does not really help you doing that. Also, the Index is not that great either. Often times you are sent to pages that just marginally address the keyword, and the essential introduction or explanation of the keyword may not be in the index at all. My real gripe though is with the practicality of the examples. While I previously stated that the Examples by itself are a great way to learn the languate, a lot of his examples are just plain bad ideas how to code. I understand where Bruce is coming from, he tries to find examples for all the subtleties he just covered in the section. Nevertheless, he often asks for pretty bad things to be implemented. On principle, from my own personal experience a lot of the special cases of the language are hardly ever used in real life situations.
   
   I do recommend this book, especially if you are coming from C. Just take the examples with a grain of salt. If you are a seasoned software developer, you can probably tell anyways which of the examples or techniques should not be used on the job.



5. Observations:
   - aimed at C programmers
   - gradual introduction to C++
   
   Constructive criticism:
   - lacking diagrams and elegance
   - detailed description of problems when using C

5 comments about Agile Software Development, Principles, Patterns, and Practices (Alan Apt Series).

1. In my role as an architect and a J2EE evangelist, I have to teach a lot about OOAD principles, the Java language and Agile techniques. There are lots of books in my armour that capture the gist of many of these practices and techniques. But none in my opinion better than this book.
   
   Robert Martin is a master at explaining OOAD concepts and applying them to the Agile methodology. For instance, the Agile practices mandate certain practices that need to be implemented in the upfront design and conception of the project. This is in contrast to the methodologies that were hitherto used that emphaisized methodology over design.
   
   This book provides that point of fusion. A great achievement indeed! Concepts such as dependency injection and the Single Responsibility Principle were explained before they became mainstream design tenets.



2. This book covers the most common, and usefull design patterns. Each patter is presented in plain egnlish, with full examples.
   
   In addition to patterns this book covers the principles surounding patterns that make them truely usefull.



3. After reading this text, I feel it deserves the attention of other great texts such as Design patterns and Refactoring, even though much of it's content expounds upon the ideas of these two classics. It's my opinion that this text has two strong points: it explains the ideas and details of agile development very clearly, and it does an excellent job of explaining the most popular patterns originated by GOF, plus a few more. The authors style was very good, with most of the examples in Java. Being a C++ programmer, I would have liked to see more examples in that language, but this is not any fault of the author.



4. I bought this for my brother. Got for a good deal on Amazon. Very happy with the fast delivery by Amazon.



5. It's a great book. As a senior developer with more than 5 year's experieces of Object-Oriented Design, I think this is a valuable pragmatic book about how to do in a practical project.

5 comments about C++ Without Fear: A Beginner's Guide That Makes You Feel Smart.

1. I have brought this book as a beginners introduction to C++ and find that the examples of code provided inside are more often than not incorrect or missing code. The compiler that comes with this book requires medium to complex instructions involving DOS installation, hence i used my another compiler that i downloaded and found the examples to not work correctly. I've had to add my own snippets of code to make the examples work and even then they still do not work!!!!!!!!!!!! I hope this review helps!!!
   
   Don't buy this book!!



2. I was putting off learning C++ because I though it would be too difficult to understand. I have been learning Python for the last few years so I understood the basic procedural and object oriented programming concepts, then I got this book.
   
   This book clarifies things on a level that elementary school kids can understand. At least the first half, it gets a little heavy towards the end, but takes the time to list complete code examples then steps through descibing each line as clearly as is possible when dealing with something as complex as this.
   
   This book never expects you to know anything about programming before you start. A lot of books will try to explain things using terms they expect you to already know, but every term mentioned in this book is completely explained in this book.
   
   The only cheap shot I can take at this book is that I don't like the Compiler/Development Environment that comes on the CD, I much prefer www.bloodshed.net free Dev-C++, which is easy to install and works perfectly with all the examples in this book.
   
   This is the best first programming book for anyone interested in C++ I've ever seen. Although C++ is a little more difficult to understand than Python, most of the concepts in the languages are the same.
   
   Topics like GUI (mouse based graphic environment) programming are not covered, but after this book you will be ready to tackle that next. Especially if you plan on using a cross platform graphic library like wxWidgets.
   
   If you read this book and fiund it too difficult, I suggest stepping down to Python, maybe get "Absolute Beginner's guide to Python" by Michael Dawson.
   
   That book uses simple games as examples to learning programming, then you can get a wxPython book to learn graphic programming which uses the same library as wxWidgets in C++, so it is a good stepping stone if you want to come back to C++.



3. This is one of the best books to actually understand C++. I recomend it both to beginners and to more experienced programmers - lots of gotchas made clear. It doesn't go very deep, however, and after learning this book you should look for more advanced books to expand your knowledge.



4. This book gave some fairly detailed explanations of how stuff worked, and even got Visual C++ working for me (there are special procedures to follow).
   
   However, he seems to assume you have more knowledge on programming than you really do. I bought this book when I was 14, and though I could copy stuff out of the book, I had no idea what the hell I was copying.
   
   This book is ok if you know another language like BASIC or Perl, or anything else for that matter, but for a beginner who wants to learn, I'd recommend the Sam's series.
   
   Another thing I saw that annoyed me is that it said how inferior C is to C++, and that you shouldn't bother learning c. I respectfully disagree, c is a powerful, and fairly simple language, that I feel is a great introductory language.
   
   All in all, 3/5



5. At first I was skeptical with the purple character on the front of the book that this would be a book that would make me feel childish, it didn't, it made me feel like a beginner and that this book would change that.
   
   I was impressed, they really covered everything in a way that is easy to understand. Despite some typos, I was able to work around those because I had already known that those were typos, probably because I learned so well in the book to know that they were wrong.
   
   I liked how they used a simple fraction program to explain objects and classes. It's as small as you can get, but you really understand how classes work without something confusing and at a level where most people do their classes. You basically build your knowledge after that.
   
   Despite the minor errors in the book, I enjoyed reading this.

5 comments about Programming 16-Bit PIC Microcontrollers in C: Learning to Fly the PIC 24 (Embedded Technology) (Embedded Technology).

1. I have thouroughly enjoyed reading and using this great publication. It is absolutely the best introduction to PIC24 in particular and C30 as well. This book makes a great companion for the Explorer 16 development board from Microchip.
   I look forward to a follow up edition with a few more projects and peripheral code segments.
   
   Very Well Done Lucio



2. I already had a problem to solve in my mind when I statred to read this book. The book worked out for me in two ways: First, the topics of the book cover my problems very well, and secondly the code in the book worked well as I tested them project by project as a learning process. Also, I agree with the points other reviewers made before my review. So, no need to repeat them. I am not an EE and new to microcontroller. To understand a topic of the book I still need to cross-check some sections in the data sheet of a PIC24 and its corresponding C header file. This slows down my reading, but turns out to give me a better understanding. I completely recommend this book.
   
   David W. at Ferndale, MI, USA



3. I've bought several books on microcontrollers, and most of them have been poorly written. This book is exceptional: the writing is clear, it has been professionally edited, and the audience focus is clearly stated. It contains a lot of valuable background that only someone who works at Microchip would know.
   
   I have to take off a star because the book does not mention the numerous hardware problems these microcontrollers have. All microprocessors have some issues, but the errata for PIC24F parts is unusually lengthy. Jasio neatly sidesteps the hardware minefields, for example by using an SPI communication protocol rather than the more elegant I2C. Don't get me wrong: I'm a big fan of these parts, and I think everyone who designs with microprocessors should look at them seriously. Still, I can't believe that someone could write a book like this and not mention the errata.



4. I WAS REFERRED TO AMAZON.COM TO PURCHASE THE BOOK. TRUSTING MY FRIEND WHO REFERRED ME THAT THEY ARE A REPUTABLE COMPANY, I TRANSFERRED THE CASH FOR THE PURCHASE. AMAZON CONFIRMED HAVING RECVEIVED THE CASH AND PROMISED TO SHIP THRE BOOK IMMEDIATELY. THAT WAS MORE THAN A MONTH AGO.
   
   I HAVE NOT RECEIVED THE BOOK YET AND HAVE CHECKED WITH ALL THE SHIPPING COMPANIES IN SOUTH AFRICA (BEARING IN MIND THAT AMAZON.COM IS UNABLE TO PROVIDE A TRACKING NUMBER). THE BOOK HAS POSITIVELY NOT ENTERED INTO THE COUNTRY THROUGH ANY OF THE ENTRY POINTS.
   
   NUMEROUS E-MAILS SENT TO VARIUS E-MAIL ADDRESSES AT AMAZON.COM FAILED TO PRODUCE ANY RESPONSE FROM THEM. I DESPERATELY NEED THE BOOK, AND IT SEEMS AS I WILL HAVE TO FIND ANOTHER SUPPLIER WHO CAN DELIVER BEFORE THE BOOK IS SO OUTDATED THAT I WOULD NOT WANT TO READ IT ANYMORE.



5. This book pretends to be a programming book on the PIC24 16-bit microcontroller family from Microchip. And if it were only that, it would easily earn a 5 rating. But the author has gone way beyond his calling. He turned this into a real insider's view of what gcc is doing under the covers with this MCU. This is better than good because there are so few good books on embedded C programming, and none of them do a good job of showing both sides. As a C programmer you normally don't care what the computer is doing under the covers. But as an embedded C programmer this is critical information! So I'd like to give this book a 10: 5 for PIC24 coverage and 5 for under-the-cover info on what gcc is doing. Even if you don't use the PIC 24, you need this book!

5 comments about C++ Templates: The Complete Guide.

1. The title says it all :)
   
   To keep it really short and sweet, learning about C++ templates is really painful till this book came along :)
   
   It's my opinion that advanced C++ developers use this book to guide them in understanding and navigating the world of C++ templates. It's simply easy to read and it has amazing clear presentations



2. I used the book when I was working on templates. Book is very clear and concise with proper layout of chapters. I was able to read relevant sections and get clear understanding. It is possible to get all information by reading C++ specs and other sources, but having this one book is a real time saver.
   
   If you work on templates and have some doubts ever then have this book next to you.



3. I like all those description and examples: the topic may be complex, but really an interesting thing when enjoying it slowly.



4. Nicolai Josuttis has written by far the best book on C++ templates. His is literally the only work out there that makes any sense of the utter mess that is C++ template programming. Absolutely essential for anyone using the STL or (especially) Boost libraries.



5. This is best book on C++ templates. C++ programmers who wants to learn modern template programming should start reading this book first, no more no less.