5 comments about C++ Common Knowledge: Essential Intermediate Programming.

1. I was already a very productive C++ programmer when I first saw this book, so I didn't think it would be of much help. I was pleasantly surprised, however, by the wealth of information that this little book contains. Any casual or professional C++ programmer should have this book as a reference. It is not encyclopedic, but that is its main strength: it tells you exactly what you need to know and no more. After reading it I found myself structuring my code better and reusing more code (especially by utilizing templates more appropriately). Additionally, the book is very clear about the terminology of the C++ language so my communication with other developers improved. A must-have.



2. Yep, this is perilously close to supplanting Scott Meyers and Herb Sutter as the definitive book for propelling a neophyte C++ programmer towards competence.
   
   On the face of it, this is yet another book on 'intermediate' C++, of which there have been many since the early 1990s. The book consists of a few dozen short pieces on how wrestle some complexity of C++ into behaving itself, such as the use of const, how to implement copy constructors and the assignment operator. Do we really need yet another one of these?
   
   But this manages to stand out from the crowd. It covers more basic material such as references and the new cast operators. There's a very nice section on pointers to members. It's also very handy for people coming from other languages, such as Java, particularly as it highlights areas where C++ differs from Java, e.g. name lookup and hiding rules. However, some material assumes knowledge of the handle/pimpl idiom which is normally covered in other intermediate books.
   
   There's also an emphasis on higher level abstractions, general object oriented design principles, like the Hollywood principle, and separate items on design patterns (command, template, prototype).
   
   And nearly half the book is on templates. And it's a very thorough and systematic coverage, including traits, policies and some metaprogramming (e.g. SFINAE). I was very impressed with this part of the book, it is very effective at demystifying a part of the language that even the better introductory books can fail to enlighten fully.
   
   The only negative of this book is that, subjectwise, there is a fair amount of overlap with the author's previous book, C++ Gotchas. If you've already got that, you may find yourself skimming the first half of this one (and it's not a huge book). However, the excellent template section is all new. Nonetheless, you might want to knock a star and a half off my rating.
   
   In short, this is an excellent, well-organised book with clear coverage of beginners topics all the way up to OO principles like those found in Robert C. Martin's Agile Software Development.



3. This book like effective C++ gives very important pointers.I found that some topics are worth reading like function objects because this kind of information is something you gain only with good experience.
   
   Lot of optics are covered. There are couple of design issues like factory method discussed.The topics are well explained but I felt some topics are too short like for example, the items on smart pointers and auto_ptr.More explanation could have been given for better conceptual understanding (I don't think he explained why auto_ptrs can't be used in containers properly).No item on reference counting unfortunately.
   
   But in general this is a very good book, good for interviews(should be complemented with other books like that of Meyers) and to improve one's understanding of certain topics like, funtion objects, function pointers, how to prevent heap allocation, how to make concrete classes act like ABCs etc.



4. I was looking for a good C++ book to dive back in when I found this book and it was by miles the best book out there. The book covers a wide breath of C++ idioms and best practices in a succinct manner and with very skillful use of example code. The layout of the book makes it useful for programmers of all skill levels. It is approachable enough for a beginner to come away with solid practices that will serve them for a long time and yet it packs enough advanced material that it is a great reference for experienced developers. I felt that it covered the advanced topics in a way that even novice programmers could get a lot out of them, whereas most books on advanced C++ topics are practically arcane tomes for anyone without solid experience, "Modern C++ Design" (otherwise an excellent book) being the worst in that category.
   
   After finishing "C++ Common Knowledge" going back to the old standards such as "Exception C++, "Effective C++" etc... was pretty painful and made me wonder why it took so long for such an elegant and intuitive book on C++ to be written.



5. I really recommend this vook insstead of exceptional/effective book series. After reading some book about the C++ syntax (where Storstroup is an excellent election), you can take a look to this one in order to avoid common mistakes in C++.
   
   It is easy to read and all the information is useful in the day to day programming.

2 comments about Cross-Platform Development in C++: Building Mac OS X, Linux, and Windows Applications.

1. Logan tackles a lot of grubby little complications that are the bane and reality of programmers writing multiplatform C++. This is not a book about learning C++ from scratch. Conceptually, it helps to think of this book as about 1 level above writing C++ code. For example, it discusses compiling, linking and running, where needed libraries might be missing.
   
   The book describes 3 platforms. Microsoft Windows, Macintosh and unix/linux. Strictly, the Macintosh is nowadays using a unix variant. But it's done differently enough, and the Mac is popular enough, that Logan stands it separate from other unix/linux environments.
   
   Perhaps the best recommendation of the book is to use a platform abstraction library. So that you can far more easily maintain a common code base. The suggested choice of library is NSPR. One simple way that it helps is in how it makes explicit the byte lengths of various C/C++ variables. This legacy C ambiguity is still with us, and causes much porting pain. It is no accident that newer languages like Java and C# make these definitions explicit. But many of us still have to write in C and C++.



2. To be honest this one of the few technical computer books I've read from cover to cover. I usually just use them for reference. On the subject of cross platform development this is currently the best and most up-to-date however there were a few areas I would have liked to seen covered better most notably the build environment and makes. Mr Logan does touch on these subjects but they are not given as much focus as I would have like to have seen which is why I'm taking one star away. With that said if I was asked to recommend a book on cross-platform development it would be Syd Logan's, hands down..

5 comments about C How to Program (3rd Edition).

1. This book was required for a C programming class. It chalked full of great information. I learned a lot from this book and the instructor.

   4 stars instead of 5 because of the way the way the book is organized. Better organization could have been implimented. There are too many "Good Programming Practicees" and "Common Programming Error" boxes to clutter up the pages. Perhaps some Chicago style referencing and a section at the end of the chapter would help clean up the regular text. --- Also some of the subjects used for the codeing examples, and some of the coding examples themselves should be simpler. In other words the code examples tended to be difficult to follow at times.

   Overall the book is keeper. (That and because it has just been succeded by a a new edition and is no longer resellable for nearly what I paid for it. (This is the third edition.))

   This book is very usable even as an older edition.




2. I cannot stress more forcefully how utterly terrible all Deitel/Deitel books are, both for beginner programmers and especially for experienced programmers. My first Deitel book was "C How to Program", which unfortunately was the recommended text for a university programming course that was my first intro to C. What a horrible book that was. I didn't realize just how little substance there was in that book and what a poor job it did of explaining C until my first co-op job, when it dawned on me that even though I THOUGHT I had mastered C, based on that silly Deitel book, I was sadly mistaken. I had to learn C the hard way though my job, and when I looked at other C texts later on, I realized how bad the Deitel book really was. This book does not help you harness the true power of C - it seems more like a book on structured programming languages with the C language syntax. That is fine if you want to simply learn how to program for the first time and want to learn some basic C - it is NOT fine for those who want to really learn C and see what makes C a lot more powerful than other languages.

   All of the Deitel/Deitel "How to Program" books are very similar. I made the grave error of purchasing "Java How to Program" by Deitel/Deitel for another university course before I realized how bad Deitel books were, and I found the same silly recycled examples that they had used in "C How to Program" back in "Java how to program". There is so much content that is re-used in "Java how to Program". The Deitels are NOT interested in helping you understand the material well -they are only interested in making a quick buck. They wanted to bring their books quickly to the market, so rather than writing good examples and taking the time to teach each language the best possible way for that particular language, they simply reuse most of the content of previous texts they have written with some little alterations here and there.

   If their examples were actually good and helped teach you the language, I wouldn't care if they recycled them, but these examples are bad. They DO NOT demontrate the substance of the languages. The examples and long and drawn out, but that doesn't mean they are actually substantial. The examples are simply repetitious, long, and detailed WITHOUT substance. I enjoy details - usually, detailed examples help give an in-depth understanding of the subject. Unfortunately, in this case, detail is simply pointless and just lengthens an example that could easily be shortened. Why should you struggle with unnecessary long examples that require you to keep flipping pages back, and useless line-by-line explanations of code that do not explain WHY, but simply state things, when the examples can easily be shortened and simplified? The examples don't really help you grasp the subject material.

   The fact that they charge so much for their crappy books just adds insult to injury. If you want to waste your money and not learn much at all, go ahead and purchase Deitel books.

   Also note that "C How to Program" is definitely NOT for people who already know programming. It contains a couple of chapters (repeated, sometimes verbatim, in their other books, of course) of material suitable for people who have never ever programmed anything in their life. I found that highly irritating. For, most people, C will not, and should not, be their first programming language. I was forced to wade through chapters of endless minutia and on basic programming to make sure I didn't miss anything. These chapters would have been better spent concentrating on the actual C language.

   So to conclude, never buy any Deitel books. When I was in university, it seemed their books were the recommended texts for courses, which is how I fell into the trap of purchasing them, thinking that if they were recommended, surely that meant they were good books. How wrong I was. I will never understand why Deitel books are so popular with universities. This just goes to show you how out of step univerities (in Canada) are with the real working world. Save your money and look elsewhere.




3. There is a reason why Deitel books are used at so many colleges. I've used and reviewed enough Deitel books, including teaching myself, to know that the Deitels know their strengths. Based on the poor reviews I've read, It's clear that people, not surprisingly, are flat out jealous of their success. That's just human nature. There are many programming books I wouldn't recommend at any price! As with my review of the Deitel C++: How To Program, third edition, even more so if you're just learning C, I strongly recommend getting "The C Programming Language, 2nd edition," by Kernighan/Ritchie. I had programmed extensively with Pascal in the "real world" (It's come a long, long way), and that both made learning C, as well as differences and similarities, vastly much more simple. If you're taking a C course, this book is an excellent reference. If this is the text used, there is no better text book for C. If you're teaching yourself, This should be your primary C programming book with at least the aforementioned Kernighan/Richie book. REGARDLESS OF HOW YOU'RE LEARNING THE C PROGRAMMING LANGUAGE, THE DEITELS ARE ACCESSIBLE TO THOSE OF US WHO USE THEIR BOOKS, ARE VERY RESPONSIVE AND QUICK TO REPLY TO QUESTIONS, COMMENTS, ETC. WHO CARES IF THEY'RE SUCCESSFUL? THIS AND OTHER OF THEIR MATERIALS ARE FANTASTIC, AND THEY CARE ABOUT PEOPLE--STUDENTS, PHDs, INDUSTRY PROFESSIONALS. I can recommend trash C and other books, but I'll pan them where they're listed. This book also contains a couple of brief chapters that provide C++ and Java concepts. That doesn't help you learn C, but it's a nice addition, especially if you plan to learn and use more than just C.



4. assembly language was my first language i started with, then i wanted to move to learn C, i have recommended by a friend that the best book is "the c programming language", i started to read but i failed to learn anything because the book is very condensed and the author explains the material for someone who have learnt already high level language, so it does not work with me, so i just threw the book, then i bought deitel book, i found it a great book for beginners i finished it in some weeks, the book size is very big because of the too many comments and exercises so dont be afraid, but i give this book 4 stars only because the author did not explain some code samples as well as required, at the last chapters of the c section, and specially in data structures section, as i recommend that you read it from another book because i did not understand it as well from deitel book, i would recommend c primer 4th edition, the chapter of data structure is excellent better than deitel's data structure chapter..



5. When i read the title, i thought the introduction for c++ and java would be one or 2 chapters at the most, i didn't know that this introduction would take a little more than half of the textbook. i was very dissappointed. i thought that all the book was covering C in more detail than others, and probably advanced topics on c. if i wanted c++ or java, there's alot of books that cover that, but i really wanted a whole 1000+ pages on c alone. oh well, i guess i have to go back to C primer plus. that' book is fully deticated to learn the c programming language.
   don't get me wrong, this a really good book, but don't by it and expect it to fully cover c.

2 comments about Computer Science: A Structured Programming Approach Using C (3rd Edition).

1. I am a new beginner for learning the C programming, and this is
   our textbook. It's really helpful. I'll recommend it to others.
   BTW, the condition of the book is not so good as what I expected.
   Looks like a used one. That is the only thing I am not so satisfied.



2. If you want to learn C, this book might eventually get you there, but it felt pretty fluffy. 1000+ pages is a little much for such a simple language as C.
   
   I also was floored to see code samples in the book that have syntax errors and don't compile.

5 comments about An Introduction to Programming With C++, Fifth Edition.

1. A very good teaching book for students having the first contact with programming.



2. Okay, I'm baffled about the reviews that rave about how clearly this book explains things, because I'm a straight A student and the author has completely lost me. If you are trying to attempt to teach yourself a programmng language, this isn't the book. How do I know? Because even though I'm taking a college level class, that's practically what I'm doing - the professor isn't going over anything. I guess we're supposed to absorb it from osmosis, but it won't happen with this book. I'm reading chapters twice, and still not getting it. So, here I am, looking for something that will help me learn this stuff because this is a required class and I need to pass it...



3. Its ok, I suppose. I was not very impressed. Rather sloppy, alot of the examples did not compile properly. If you want to get away from Programming for Window, avoid this book, because it teaches using MS VisualC++



4. I bought this book for an online C++ programming class. It does have some info at the end of each chapter on programming in .NET which is cool but otherwise this book is hard to read. The author repeats herself again and again. The topics covered are very basic and introduced very slowly. This may not be a fair review since I have programmed in C++ before. But if you don't have to buy this book, there are many others out there that can teach you much more concisely. This is a text book and has lots of questions and problems at the end of each chapter.



5. I am taking an online course through the local community college, and this is their textbook for 2 semesters! I thought this was book was bad my first semester, but it has only gotten worse the second. The author repeats, talks in circles, has trouble making the valid point. When I read I want the point right there, not going around and around. Although the author has provided lots of exercises, she lacks any information on how to complete some of those exercises throughout the chapters. This book might be better if you had in-front-of-you instruction, but this is horrible for an online class or teach yourself. As another reviewer I am an A student, but I struggle in this book to understand the author's concepts. I have bought another book to help understand the C++, now I'll need another for the Visual .Net. It appears our instructor wants the exercises for the .NET done but again this book is extremely limited on providing the information needed to complete the exercises.

5 comments about Sams Teach Yourself C in 21 Days (6th Edition) (Sams Teach Yourself).

1. The book has a great structure, there is 21 chapters/days total about C and an extra 7 chapters about other languages basic beyond C; Java, C#, and C++. There are however many defects to this book, there are many typos that I was able to spot, and there are no answers to some of the questions. I really enjoyed doing the Bug Busters section at the end of the chapters and would like to see more in the next editions of the book.



2. The book is good for what it does, but Sams Publishing should be ashamed of the editing. The errors are beyond absurd. It wouldn't be so incredibly terrible if Sams listed the errata on their website as they do with many books. This edition has been in print for 4 years and no support yet. A better book for those starting out who don't need the added error induced headaches is the "C Primer Plus" by Stephen Prata.



3. I decided (perhaps foolishly) to dive into the world of computer science with the book. I mean a book that teaches me a whole programming language in 3 weeks? I was sold.
   
   What the book does well is that it can quickly teach you the fundamentals of C, right up to pointers. The book does well in borrowing material from a far better book, "The C prgramming language" by kernighan and ritchie. The book also provides a wealth of coding examples for you to disseminate at you leisure. There are also quizes at the end of each chapter.
   
   Not counting the innumerable typos and editing mistakes (even an example code that doesnt compile properly, even when copied from the CD the book came with), the book has many, many acheilies heels.
   
   For one, at an attempt to provide simple explanations and answers, the author merely succeeds in glancing over important information and causing confusion. I was really frustrated over the lack of descriptive explanations for many important topics, most notably typedefs, unions, casts, and void type pointers. Oh and the "bonus" topic on linked lists may as well not even be in the book since its almost completely impossible to follow unless you know what a linked list is already. Another problem is the coding examples. All to frequently you will see a library function that has not yet been covered, and you will have to thumb through the book to figure out what it is. Additionally, at several points in the book, you will need to skip ahead several chapters just to understand what is being said in an earlier one. An example of this is having to learn chapter 8 before 6, chapter 16 before 14 and chapter 20 and 21 before 18, and 19.
   
   By not providing enough explanation, this book teeters on the line between being comprehendable and not. Also, dont expect to learn how the library functions work until much later on (incredibly useful to know). the difference between knowing "char *gets(char *)" and "gets()" early on is huge. Id say its analogous to knowing to put in bread into a toaster and knowing toast will come out versus knowing you have to put 'something' into a toaster and relying on magic for something to happen, respectively.
   
   There are quizes at the ensd of each chapter which are pretty easy, if you were able to parse the confusing chapter before it that is.
   
   OVERALL
   This book teaches you the basics in an oversimplified and brief manner. As a result topics that would otherwise be easily explained, are unnecessarily difficult. However if you can piece apart the explanations, this book is actually helpful. I HIGHLY recommend getting "The C Programming Language" with this as a reference and supplement. The latter is fairly difficult and the SAMS books helps out to understand it.



4. The author jumps around with some topics...hinting at future chapters, but giving just enough info to get an rough idea of what he is talking about. Overall a good book, just be patient and keep reading.



5. If you are new to C and new to programming in general, this book will be very useful for you. The style is simple, the programs are not too complicated and the concepts are explaind gradually.
   While it doesn't explain all that is needed to master the standard C library, this book will make you feel confortable with the language and will give you some knowledge to follow more advanced and acclaimed C books. There is nothing advanced here, just an honest introduction to the language. So, while this book is appropriate for beginners, could be not well suited for the veteran programmers, who may look for more advanced concepts in order to really master the language.
   One of the major lacks, when speaking about C books, is a too simplicistic explanation of ponters. This book is no exception. It won't give you a deep explanation about ponters. But it explains them well, in an easy way fully understandable by people who have little or no programming experience. How to use them proficiently is not in the scope of the book, I suppose. After all, it worths the money it costs. So if you don't have big expectations from a programming language book, buy it without hesitation. Recommended.

5 comments about Embedded C Programming And The Atmel AVR.

1. I bought both this book and the C Programming for Microcontrollers book by Joe Pardue. This book would be acceptable, maybe even good if not compared to the other book. This book has a short 'tutorial' introduction to C even thought the title implies that it is about C. The Pardue book is entirely about C as used in micros. This book uses an expensive commercial compiler. The Pardue book uses the free WinAVR compiler (included on the CD). This book uses expensive and confusing (to me) development systems. The Pardue book uses the AVR Butterfly which only costs $19.99 and has everything you'd want and is simple to use. This book goes into a lot of details on stuff that I guess would be of use for filling time a college course and if you are an academic type you might like that. The Pardue book starts out holding your hand, but quickly becomes brief in getting you going with fun projects that help with my real real world interests. Finally this book costs more than the Pardue book costs with the Butterfly and the full projects kit thrown in. Yeah, the Pardue book has some typos, but an error sheet is included so that's no big deal. I wish I had saved my money and just gotten the Pardue book, an AVR Butterfly and the projects kit



2. Perfect book to help make transition from assembly language to C.
   Best if you know about internal micro peripherals and a little C but I stumbled along despite never having used C.



3. In a word, this book is Awesome! It takes the reader through beginner to advanced programming of the AVR in C and provides an extensive list of projects while remaining just abstract enough to allow the reader to translate the code and concepts into many different but similar real-world problems. The first section also provides a quick recap on basic C programming for people (like me) who program infrequently enough in C to forget basic concepts.
   
   You can find more AVR info at http://www.hobbyrobotics.org/avr.htm



4. Hi folks!
   It's amazing how reviews dated months (or years) prior to the publication date of a new edition got added here. I do own the earlier edition and find it to be *exactly* what I needed to both ramp up my knowledge of embedded C processing and learn the AVR micro.
   
   Now we have this new edition that just might overcome some of the valid criticisms of the reviewers as well as bring the explanations up to date for the newer processors. Or it might not. . .. An update review would be helpful as I don't want to spend $90 to get the same book with a different cover. Ahhh! Amazon's return policy. I'll order the new one and either write an update review or send it back. Nice!
   
   UPDATE!
   Well, I ordered the new edition. . .. Here's the scoop: the authors have updated the chip used in the examples to the Mega16 (and sometimes the Mega128) so this is a good thing as there have been significant changes in the naming of internal registers, etc. since the first edition was written. There are some short additions here and there (e.g. a two-page section on I2C) and "Lab problems" in addition to the exercises at the end of each chapter. The new book is thirty pages longer, but somewhat thinner than the first ed.
   
   So, if you're a bit of a newbie (like me) and are using a particular chip (like the Mega16 as I was) this edition is well worth the cost as it tracks the chip internals closely in the descriptions. If you are "just looking," maybe a used first edition will answer 99% of your questions for 50% of the price. In either case, the explanation of embedded C in the first 80 pages of the book is superb! There is also an excellent project example--start to finish--that ties it all together.



5. I have only just started programming with AVR and was looking for a book that would help me. After reading other reviews I decided to buy this book - and I'm glad that I did.
   
   It starts off with an introduction to embedded C, moves on to discuss the Atmel AVRs and concludes with a chapter on developing a project from scratch. But, what's good is that it starts off from the basics with plenty of explanations (so if you've never done anything with AVRs before, then this is for you), and moves on to the complex stuff later.
   
   The book covers almost every topic you would want, so you can always use the book as a reference later. There is a comprehensive Appendix in the back too which lists the various C functions and Atmel instruction sets.
   
   My only complaint is that the book dedicates to much space on the CodeVision C Compiler (there is a whole chapter on using the IDE, and several references are made to it throughout the book). It's a pity that there is no mention of the AVR-GCC Compiler - since it's free!!
   
   Overall, this is an excellent book, that I would definately recommend to anyone starting off with programming the Atmel AVR microprocessors.

5 comments about lex & yacc.

1. This book is a little out-dated. That is fine, though - this book goes over all the essential proponents of Lex and Yacc and Bison and FLEX and all the other variations ... which you will certainly know a lot more about by the end of this book. This books enabled me to read FLEX input from a c-string, which has played a role in a few of my projects. It is great when you just need a quick reminder of the syntax is the tools. This book does not go over how the programs work, which is a good thing, because that would make the book more oriented towards Finite Autonoma and Context Sensive Languages - leave that sort of thing to autonoma theory and compiler design. This is an excellent reference, so buy it if you really need it.



2. Yacc (yet another compiler compiler) and its companion lex (lexical analyzer) are primarily intended to allow quick and easy development of small special-purpose languages. The common mistake is assuming that they are only useful for creating compilers for massively complex eccentric languages. This is not the case, though you could no doubt use them for such a purpose.
   
   Lex and Yacc are commonly used together. Yacc uses a formal grammar to parse an input stream, something which lex cannot do using simple regular expressions since lex is limited to simple finite state automata. However, yacc cannot read from a simple input stream - it requires a series of tokens. Lex is often used to provide yacc with these tokens. As a result, building an application in lex and yacc is often used as an exercise in classes on programming languages and the theory of computation to demonstrate key concepts.
   
   The book starts out building a simple character-driven calculator, and then moves on to build a menu generation language that produces C code that uses the standard "curses" library to draw menus on the screen. The final application is a SQL parser which includes a quick overview of both relational databases and SQL. Some readers will dislike the fact that Lex and Yacc are only capable of generating C code. Thus, the logical conclusion is that you must be able to write C code in order to use these tools. While it would be nice if the sections about the menu generation language and the SQL parser had some information about how to do typechecking and other such things, this book is not about writing a compiler/interpreter using Lex & Yacc. Rather it is just a beginner's guide.
   
   The sections about shift/reduce and reduce/reduce conflicts are especially helpful, as are the sections going over the differences and caveats relating to the major versions of lex and yacc such as AT&T's Lex & YACC, GNU's Flex & Bison, and Berkeley's Yacc. In summary, if you've never used lex or yacc before and think they might be useful tools for you, and you already know the C programming language, this is a handy book to have.



3. To me a great book flows into your mind, magically providing the information in the order you need it. Of course it depends on whose reading it, but this book, though well worth the 96 cents bargain bin price I paid for it, does not build the constructs in my head the way I'd like.
   
   Authors should always proofread their books with novices, not the experts. Experts fill in the gaps as they read and don't notice if the logic is missing a link. In chap 2, "Using Lex", there is the sentence: "Lex itself doesn't produce an executable program; instead it translates the lex specification into a file containing a C routine called yylex(). Your program calls yylex() to run the lexer."
   
   I waited with baited breath for what it means to "run the lexer". Does it return a token each time you call it? Does it analyze all the input then return? The text ignores this detail and merrily goes on into other details. The chapter is called "Using Lex", but the authors omit how you use it! Of course you can scrounge around in the examples and finally root it out, but a book should paint a crystal clear picture, get you oriented, then drop in the details to build your understanding.
   
   The book looks so promising, sort of like the beauty of the original "The C Programming Language" by Kernighan and Ritchie, but disappoints in it's fragmented exposition.
   
   I did take a compiler course with the "dragon book" years ago and write a parser, so I'm not totally in the dark, but I expected this book to lay the subject out in a much clearer way. But it is still a good book to have and read "offline".
   
   I hope the authors take a crack at another edition and explain it all better.



4. I like this book because it is a good compromise between lex & yacc man pages and the theory found in books such as the Dragon book. You will get valuable information about the how and why of the tools that will help you to produce a quality grammar without being overwhelmed by details.



5. This item is a definite must for coursework dealing with scanning and parsing. I thought that I would be fine if I just relied on web sources to assist me in Lex assignments, but as a deadline approached and I still had no results I turned to this book. The content is clear, concise, and absolutely fantastic. If you want to know how to work with Lex and Yacc, this is the book you need.

1 comments about Problem Solving with C++: The Object of Programming (7th Edition).

1. This was my first foray into C++, and I used this text for both the Intro and Advanced courses at my school. It's a good text because he explains the concepts, shows examples, warns against "gotchas," and gives stepping-stone assignments to build skills. I don't recall any pap or filler material to waste time over. It's solid without feeling like it was written by a robot.
   
   Now that I've completed the book, I'm going to work back through it on my own and do more of the assignments to keep my skills sharp. Any book that helps one understand the concepts well enough to be kept for a reference is a good one.
   
   If you are an absolute beginner, I wouldn't recommend starting with C++. Otherwise, this book should be a good start for you, too.

2 comments about The C++ Standard Library Extensions: A Tutorial and Reference.

1. There are many, perhaps too many, books on C++. But Becker breaks new ground. He presents what is coming down the road towards the current C++ programmer. The existing C++ standard library is good but limited. The widespread use of C++ led to recognition of useful classes that should be in this library but are not. After some years of dilly dallying, Technical Report 1 was produced. Work started in 2001. Six years!
   
   This book explains the classes in TR1. While it is not guaranteed that all of TR1 will make it into the next official standard library, most certainly will. The only real question is when that revision will be released. Given the way C++ changes so slowly, don't hold your breath.
   
   In the interim, you can make good professional use of your time by studying TR1 via this book. It's not a simple rendition of the classes. Becker devotes considerable space to explaining the usages of the new classes. Giving you the gist of what they are about. Just as importantly, each chapter has a set of exercises involving its classes. Tackling these is probably the best way to gain experience.
   
   Of the new classes, what interests you most will vary with the reader. Personally, I was most impressed with the Numerics. Huge improvements in dealing with floats and overflows (NaNs). And for physicists or engineers, there are specialised functions that will save some coding. Laguerre polynomials, Legendre functions, gamma functions, Bessel functions and Hermite polynomials, amongst others. A far richer set than what you currently get in the standard library.



2. This will become a "must have" book for C++ programmers. It is both easy to understand and authoritative at the same time. It will be useful for a long, long time, first as a learning tool and then as a reference.
   
   Implementations of TR1 are now available from Boost (free) and Dinkumware (reasonably priced), so these library components are something that a C++ programmer can start using right away. Most or all of them will also be part of the next standard, so they are sure to become ever more widely used.
   
   I like the fact the book is hard-cover, since it is likely to get a lot of use. Maybe I'm old fashioned, but I still think a book like this is the easiest way to study something new, and really learn about it.
   
   I already posted one review, but Amazon seems to have lost it. I'm surprised there haven't been more reviews posted - the book deserves more.