5 comments about Microsoft C# Programming for the Absolute Beginner (For the Absolute Beginner (Series).).

1. This book is exactly what it says, a book to teach C# to absolute beginners. I was just that. New to programming. I wanted to learn programming and after a reaserch on the internet I decided to start programming using C#. I bought myself a MS Visual C# step by step. Soon after a friend gave me C# Programming for the Absolute Beginner. I was amazed. The book is straight to the point, and everything you learn is supported by examples. So if you didn't get the idea by reading you figure it out by doing it. Great book! Great job Andy!!! Write one for c# 3.0 too!



2. I hadn't done any programming since I took Fortran in college 20 years ago and before that, I had taught myself DOS when it first came out (okay, age giveaway!). I did teach myself the basics of HTML, but I had no idea of where to even start with the newest languages out there now. This book led me from total ignorance through the basics of C# in a fun way and now I'm ready to progress into more advanced coding. I'm just a hobbyist, so this book was a perfect place to start for me!



3. I previously had started with Beginning C# Game Programming by Ron Penton, which was a disaster since much of his code doesn't work with DirectX 9.0c. I picked up this book and started back over from scratch.
   
   Harris does an excellent job of introducing a concept, explaining what it is and how to use it, then implementing it. Some of the code is a little dated and has to be altered to run in C# 2.0, but I was able to do it with only a little effort. Same with a few of the form components. Additionally, I contacted the author, and though he doesn't work in C# very often any more, he was able to point me in the right direction to get my questions answered.
   
   By the end of the book, I had successfully built a few C# applications to use at work.
   
   My only complaint with the book is that it just ends. There is no prologue at the end, just the end of the last chapter reviewing that material. It would have been nice for a summary and maybe some direction in where to go next.



4. For beginners who have not been exposed to any programming languages or their structures. He makes this subject very interesting by using games as examples. It is an easy read. I have been out of touch with programming for a long time and I needed a little basic introduction to get started into object oriented programming. It may be used as a stepping stone to understanding complicated subjects like threading, windows forms and event handling in other books.



5. If anyone has a problem with this ABSOLUTELY PERFECT C# Programming book it's because they never bothered to READ the cover! If you are a BEGINNING programmer and want to make GAMES, don't look any further. This is the book you've been looking for.

5 comments about Problem Solving, Abstraction & Design Using C++ (5th Edition).

1. In my opinion, this book is below average. According to the chapters it covers, this should be a book for beginners at programming. But by reading the book, only non-beginners would be able to follow all the examples. Rather than rely on the feedback of one person, I will give you the feedback of the students that I taught with this book. Most students beginning a programming class will have a hard time understanding this book that assumes that you already know a lot about math and logic. When I tried assigning homework from this book, most of my students had problems just understanding what the math and logic of the problem would require, and couldn't concentrate on the programming concepts. There are quite a number of inaccuracies in it as well, such as it's miscalling preprocessor directives a compiler directive. It also calls an array a data type which it is not, it is a data structure. It also calls the exponent of a scientific notation a characteristic. That term is only used in the natural science community. Even the IEEE standard for floating-point numbers calls it exponent and not characteristic. One of its first examples starts with a standard input statement without prompting the user with what input the program expects. These little annoying problems with this book have caused me to abandon it all together. I would much rather recommend Diane Zak's Fundamentals of Programming in C++ if you are a beginner to programming.



2. This isn't a great book as I thought it was. The begining chapters were pretty much detailed and explained program examples step by step. Starting on chapter 6 till the end of the book, there were few step by step explanations and the author for some reason assumed that brief explanations were sufficient.



3. This book was required for the first semester programming class. Now I was able to understand 'cause I was in CS and had been programming for 10 years. But the history majors in my class were crying cause this book couldn't really explain the basic concepts. many of the intro to programming classes are core classes in Univs in US. So, a guy who's in CS, I assume wouldn't have any problem cause it's way too low level for him. Whereas those who really need this book..Art majors, or those who want to learn what programming in C++ is..will have a tough time..

   I wouldn't recommend this book..cause it's too poor for a guy who knows C++ and too tough for those who don't.. They haven't been able to get that balance.

   Another interesting point I was able to observe was that this text gives all source code example with Visual C++ in mind. Most of the Univs in US prefer to teach this course on Unix platforms, and so a book more relevent to Unix would be appropriate.

   I give it 2 stars, cause it isn't all that bad a book that doesn't make sense. I still go back to it sometimes to look up the syntax and some basic stuff..But nothing more than that.




4. This book was required for a C++ course I attended at the local community college. I had been doing some minor programming in other languages but felt I needed at solid foundation in C++. This book would have been a difficult place to start. However, thanks to a talented and very patient instructor, the entire class did well. I would have given at least a four star rating but this Addison/Wesley paperback was very poorly published. Pages fell out daily throughout the semester. Have some tape and glue handy.



5. As an instructor of this course, I enjoyed stressing to my students that they must develop their problem-solving skills and programming style.
   
   That's the strength of this book -- a huge emphasis on the importance of breaking down a big problem into easier parts (it's clear that the authors paid attention to G. Polya's How to Solve it), and tips on programming style, from the naming of identifiers (variables) to the use of reference vs. value parameters.
   
   This was a great support as I taught this course to a class with a very mixed programming background.

5 comments about The ACE Programmer's Guide: Practical Design Patterns for Network and Systems Programming.

1. This book is yet another great example of how the ACE framework can save you a lifetime of development. Within this book is the knowledge and experience to excell your applications to the next level and become more productive then ever. If your code base deals with networking or even if you just need to have cross platform compatibility then this book is a must have to teach you the ways of ACE.



2. A good book for you to get into the world of ACE.
   A good book for newer of ACE.
   
   During the first 2 month I am using ACE, this book give me great help. But later I found a little issue of the example code in section 7.6.3 which will cause spin-lock when the output socket is blocked/flow-controlled.
   
   I post my comments to this issue below, hoping you can avoid this mistake.
   
   You know, so many people are using this book as guide for ACE, and may copy the example code ( just as me ) in their work with ACE.
   
   Section 7.6.3 ACE_Connector
   int Client::handle_output (ACE_HANDLE)
   {
   ACE_Message_Block *mb;
   ACE_Time_Value nowait (ACE_OS::gettimeofday ());
   while (-1 != this->getq (mb, &nowait))
   {
   ssize_t send_cnt =
   this->peer ().send (mb->rd_ptr (), mb->length ());
   if (send_cnt == -1)
   ACE_ERROR ((LM_ERROR,
   ACE_TEXT ("(%P|%t) %p\n"),
   ACE_TEXT ("send")));
   else
   mb->rd_ptr (static_cast (send_cnt));
   if (mb->length () > 0)
   {
   // Here will cause message_queue notify reactor
   // And get into handle_output again immediately
   // which cause spin-lock
   this->ungetq (mb);
   break;
   }
   mb->release ();
   }
   if (this->msg_queue ()->is_empty ())
   this->reactor ()->cancel_wakeup
   (this, ACE_Event_Handler::WRITE_MASK);
   else
   this->reactor ()->schedule_wakeup
   (this, ACE_Event_Handler::WRITE_MASK);
   return 0;
   }



3. ACE is great, no doubt. This book is not. If I had been scanning ACE code for years and needed a reference, this book might be great, but like a kid in a foreign land, this book only confused me more than it helped. Here's why:
   
   READS LIKE AN UNABRIDGED NOVEL. In order to understand each example, you must read the book from cover to cover. There is so much detail in ACE that there are almost no "trivial examples" and a thorough understanding is required. What if I'm not writing a high-performance server application? What if I want to work with small examples and work my way up incrementally? This book makes it difficult to do that.
   
   EXAMPLE CODE IS CHOPPY. Each example is presented in such a way that code is provided piecemeal, along with paragraphs of explanation. This is ok, but it is very difficult to piece the examples together and write code. Also, it's not listed in the book, but the examples are online, here:
   
   http://www.cs.wustl.edu/~schmidt/ACE_wrappers/examples/APG/
   
   This link is not in the book.
   
   THIS BOOK JUMPS EVERYWHERE. For instance, check out section 7.5, Timers. We're given a quick intro on Timers while we're kneed deep in talking about the omniscient Reactor that ACE provides. Now, section 8.5 talks briefly about timers and to reference further documentation in reference to Reactor/Proactor, which is unhelpful and unnecessary. Finally, section 10 gives great detail into using Timers. Chapter 7 should have been called Reactor.
   
   My biggest interest was writing a client/server application in ACE. Chapter 6 started with a terrible example of socket communication, saying that Chapter 7 is a better pattern for the client/server. By the time I got done with Chapter 7, there was so much rambling of hypothetical situations that I completely forgot what I was trying to learn. The big picture is often lost.
   
   NO API REFERENCE. Maybe it is not appropriate to put in an ACE API reference in here. I think it should be put in as an appendix. When examples are presented, the new data types come out of nowhere. What is an ACE_Time_Value, specifically? What other parameters can it provide? ACE Doxygen documents can't provide enough detail and neither can this book.
   
   What I would love to see in a second edition:
   - More descriptions of the standard types.
   - Description of ACE_TMain and other OS functions.
   - A better mapping of types to GOF patterns and better UML.
   - An API reference, even if it is small
   - Table mapping Unix/Windows/VxWorks functions to ACE functions.
   - A more readible text. The code blocks could be encapsulated in gray to take it out of the text somewhat.
   
   Also, most of the other reviews on this book shown above talk about how great ACE is for development, and I agree. However, isn't this the section where we are supposed to be commenting on the BOOK (APG) and not the TECHNOLOGY? These reviews hardly talk about the book at all!
   
   Huston, et al, I encourage you to come out with a second edition. I still want to learn about ACE, but I need a more organized reference and clearer examples.



4. The ACE libraries are useful for developing cross-platform code, providing functionality such as loggers, configuration handling, communications, threading etc. Where ACE itself falls down is that the documentation supplied does not provide enough information about how best to use it and what it does under the covers. You might think that you don't need to know about what happens under the covers and for a simple application that could be true, but when you go multi-threaded and discover that in parts of the ACE library the code checks which thread you are calling from and behaves differently depending on what it finds, then this is something you need to know. Unfortunately the documentation doesn't give that level of information and neither does this book. Life-times and ownership of objects are areas likely to cause issues too - this book mentions an example of that relating to the logger, but there are others too. A library that decides ownership based on whether you pass a pointer to a method or a reference to that method is one where you want/need a good reference book, not just an introductory text.
   
   "The ACE Programmer's Guide" is a reasonable introduction to ACE, but it is certainly not a reference (despite the quote on the back cover calling it exactly that). Unfortunately, when using ACE the old adage about a little bit of knowledge is true. You can work from the documentation, this book and the books by Schmidt, and if writing reasonably complex systems you will still hit issues using certain parts of ACE resulting in you stepping through the library code to find out what is going on. I've therefore only given this book 3 stars. It's a reasonable introduction, but if you are doing anything significant with ACE, particularly if multi-threaded, you are likely to end up wishing there was a complete reference work (no, the HTML help is not thorough enough either) rather than just introductory texts and overviews.



5. 
   This book provides comprehensive tutorial for networked applications. ACE was my popular framework before Boost.Asio framework. Even though ACE has little dated approach, it is still the best framework for multi platform distributed application development and this book provides very valuable contributions to people needing to develop this type of applications.

5 comments about C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond (C++ In-Depth Series).

1. This book is called "C++ Template Metaprogramming" but it should be called "Boost MPL API Reference." The first portion of this book covers the basics of template metaprogramming fairly well, but what I wanted the rest of the book to cover were both advanced techniques and real-world applications. What I got was material on how to use the Boost metaprogramming library. This book mostly covers just that library, and the various templates that it offers, but what I felt the book should have provided was not only how the more interesting parts of the MPL were implemented, but also interesting applications of the MPL where some interesting algorithm was made possible by template metaprogramming. I can look up the MPL reference docs online, thank you very much.
   
   To summarize - this is a pretty good introduction to template metaprogramming, but seems to be suited for the unlikely position of someone who wants or needs to use this technique, but isn't academically interested in it, and so mainly needs a walkthrough of the set of standard functions available as part of the MPL.
   
   This book is a bad choice for those interested in template metapgramming and wondering if it might help them, but want to learn more about it and its applications first.



2. I would really like to learn about the boost mpl and I thought this book might help. Well, I'm learning, but only because I'm working very hard to untangle the mess presented. Here are some of the fundamental flaws in this book.
   
   1. There is no target audience. This book might have been about how to design an mpl like library, but it makes no attempt to address this issue. This book might have been about how to use the mpl, but it doesn't do that either. It seems to be about justification for why certain choices are made, but it gives false examples when doing so. For example 3.3's example of the add_pointer template is simply not what is in the library. You can see this yourself by visiting the boost site and compare what's in the text of this chapter to what's in the boost library's code. In the end I can't even tell what this book is trying to accomplish. The author should have stated the target audience somewhere, but doesn't. It is written as if the designer wrote note justifying design decisions to a co-worker already knowledgeable about both how to use mpl and it's design. Maybe this book was translated from notes between the two while they designed it?
   
   2. Example code on CD wrong. They include sample code on the CD from the book's text. The code says it was automatically extracted. Unfortunately it doesn't match even remotely. I think something was wrong with the tool they used. Even if it was right, it's a repetitive dump without any reference to page or section so you have to open many files and dig to find what you want. There is absolutely no way to look at the code in a particular section and find it on the CD in any reasonable way.
   
   3. No examples are complete. The authors like taking an attempt to solve a problem, then show a weakness to the suggested solution, tweak some code, show another weakness, ... This might be an okay approach, but I strongly suggest a final product at the end of the tweaks be somewhere. If that's somehow prohibitive in printing costs, at least put the final code on the CD.
   
   I could go on all day about just how bad this book is, but I really need to spend my time learning the concepts if I'm ever going to use it. If I get a chance I'll get back here and write more about the mistakes. To those thinking of purchasing, go to the boost site, read the free chapters, then assume you've read the "best of" materials. If these free chapters make sense and you learn a lot reading it, you are smarter than me. If not, then don't assume you will do better if you had the full text, because it won't help you.



3. 
   metaprogramming is understandably a difficult topic. but it could have been made easier to understand with a talented writer. obviously these two authors have no such talent. organization of book is bad, there is no clear flow. concepts are often introduced without explanation, and only defined a few chapters later.
   
   in the bigger picture, this is the problem with the c++ community. the language has evolved so fast, so much into a complicated mess that only the very seasoned programmers (often young ones) can keep up the pace. in consequence, these untalented young writers bubble up as some sort of experts, and write messy books.



4. I knew in purchasing this book that most of the time it would just be talking about the Boost MPL. That shouldn't be too bad - the Boost MPL is pretty much the fore-running meta-programming library, and there has to be lots of concepts in there to be learnt too, other than library specifics, right?
   Right.
   This book completely lives up to this explanation. Very quickly we are into the guts of the library, even within the beginner's tutorial section. There certainly is a LOT of concepts to be learnt and used, even if externally to the MPL.
   However, I found that very quickly I was having to reread and triple-read passages to try and distil a principle from the library construct being explained. They principles are there, and are good, but I find that they are not presented distinctly enough from the library itself. This results in what feels like a lot of work to really understand the book (other than just know how to use the library).
   I don't consider myself slow - I got through almost all of "Modern C++ Design" (by Alexandrescu) without having to go to a computer, but here I really felt like I NEEDED to try this stuff out on a computer and attempt the problems at the end of the chapter. This book is a lot of work - beware! - and particularly it is more than I feel should be necessary, if perhaps the authors allowed themselves more time to explain principles and concepts away from the interface of their library.
   However, there is a lot of knowledge here that I don't think that you can find elsewhere, and it is a topic that is, by nature, a bit mind-bending, so I am still definitely happy with the purchase.



5. I am not a meta programming expert, however I learned a lot from this great book. I suggest first to read Alexandrescu's Modern C++ first and a learn basic techniques then get this book to be able understand the mpl better.

5 comments about Numerical Recipes in C: The Art of Scientific Computing.

1. "Numerical Recipes" has been a staple in computing libraries for many years, and for good reason. It provides immediately usable implementations of all the workhorses of numerical computation, in production-quality form. Maybe there are better implementations out there, FFTW for example, but getting something to work correctly always comes before getting it to work fast. Numerical computation is a specialty, and vanishingly few of us are specialists. As a result, getting this much specialist knowledge for the price of a very few hours' wage, fully debugged and documented, is a great bargain.
   
   I have to agree with the critics who point out that the Gnu Scientific Library (GSL) is more complete in some areas, and offers better licensing terms. This collection has its own strengths, though, and not just in documentation. The writeup, however, is the major interface between the software and us, the bio-ware. GSL's collection of 'man' (help) pages serves a purpose, but this book's exposition describes a lot more of the background and rationale for the routines. The code and man pages are self-evident statements of the implementation - but "what" is a very different question than "what else" or "why."
   
   This one may not serve all needs. You'd be amazed how many it does serve, though. If you need more than a Matlab session for numerical computing, you need this.
   
   //wiredweird



2. A must buy for students or researchers who need numerical methods. Comprehensive topics. A good place to start to deeper levels. Online book is good for quick look.



3. This book, although published 15 years ago, is still very useful. In fact, its more recent counterpart "Numerical Algorithms in C++" is a mess, and I wouldn't recommend it to anyone. The explanations of the algorithms that occur in each section of this book are top-notch. It helps with such questions as "Sure you know how to evaluate an integral with pencil and paper, but how do you do it with a computer?" Everything from linear algebra techniques to integration and evaluation of functions to the FFT and spectral applications are explained clearly and coded up in C. The code is great too, with the exception of one problem that several reviewers have already mentioned - the author has a FORTRAN-like programming style in which each implementation has arrays going from 1 to n versus 0 to n-1. This does cause some implementation problems if you want to transfer the algorithms into another programming language. Overall, though, I can't think of one book that does all of the heavy lifting that this one book does as well as it does in the arena of numerical algorithms.
   
   The book is now available online. Just type "Numerical Recipes" into Google and click on the Numerical Recipes Home Page to peruse the entire book free of charge. You might also find the "Numerical Recipes in C Example Book" useful. That book is simply the source programs that demonstrate all of the Numerical Recipes subroutines. Each example program contains comments and is preceded by a short description of how it functions. I know I found it helpful in many cases.



4. this book was likely a looker back in the day, but its 2007 now. Need to have better details for non "C"-users. wish i had bought "Idiots Guide to C".



5. I totally agree with another reviewer that the biggest drawback of numerical recipes (NR) is that first you have to buy them to see whether you need it or not afterall. Linux these days is way more user-friendly than it used to be. If you have fedora or ubuntu, get gsl with one line
   On fedora:
   yum install gsl gsl-devel
   On ubuntu:
   sudo apt-get install gsl-bin gsl-ref-html
   That's it, people! What can be harder!
   
   GSL documentation is free online, but you can order a book as well.
   GNU Scientific Library Reference Manual - 2nd Edition
   
   P.S. also GSL library can be used together with c++ code.

5 comments about An Introduction to Design Patterns in C++ with Qt 4 (Bruce Perens' Open Source Series).

1. I am extremely impressed by this book - not only does it provide excellent information on design patterns, and using Qt 4, but its written so that those new to C++ and Qt can understand and progress throughout. This book is heft, but extremely informative, and I would recommend it to anyone interested in C++ development!



2. If Qt is what you are interested in, go to trolltechs website or another online resource and don't waste you money on this book. The book is not very well laid out, the exercises are ambiguous and you have to work on the example code to get them to work. Although a lot of material is covered, the coverage of certain topics is barely adequate, although they do supply information on where you can get additional information.



3. The book is an easy read and has good examples, but unless you already know how to use Xcode or have KDE on your Mac this book is not for you, because you will find that the build instructions found in the book do not work in Mac OS X. Has anyone tested them on Unix or with KDE? I can only assume that they work there.
   
   Qt4 is not compatible with Xcode. (It is not possible to display Qt4 Objects like QString in the Xcode debugger. This used to work with Qt3, but was lost in Qt4.) While this is not the book's fault, it makes it very difficult to step through the examples or debug your own coding efforts in the exercises.
   
   I like the way the book introduces topics a chapter or two before going into detail. Also, the book makes an effort to reinforce what was learned in previous sections and chapters, making it a very good learning tool for anyone new to the topic.



4. This is a very good good which teaches you C++, Qt and design patterns.
   
   I am surprised by the commentaries saying this is not an introductory book. Quite the opposite: this is the perfect book if you do not know any one of Qt, C++ or design patterns but you want to use them together.
   
   Some may say the book worries too much about syntax. Wrong. The authors want to make sure you understand C++ perfectly well because subtle differences (such as the 'static in declaration' vs 'static in definition', introduced in chapter 2) may have devastating effects in your software. The same goes for Qt macros: the book explains them because when you know and understand them, you will write better code; the book by Blanchette and Summerfield barely names them.
   
   As the title says, this book is only an introduction. There are three natural companions you should get if you want to delve deeper in the wonderful world of Qt and design patterns:
   * A Complete Guide to Programming in C++ by Prinz and Prinz
   * C++ GUI programming with Qt by Blanchette and Summerfield
   * Design Patterns: Elements of Reusable Object-Oriented Software by Gamma et al.



5. I don't major in CS but I have to use C++ and QT for my PhD research. Although I had pretty good general understanding of IT and some experience in web programming, I struggled to teach myself C++ from scratch. I tried a few popular books, but none of them worked very well. As someone said, "the trouble with C++ is there's an awful lot to remember". Those big thick books are often quite easy to follow from page to page, but very quickly all the details become overwhelming. C++ is a powerful and flexible language that incorporates different paradigms so there're always many different ways of doing things but quite often (particularly for beginners) we only need to know the best practices. As Bjarne suggests: "A focus on details can be very distracting and lead to poor use of the language. You wouldn't try to learn a foreign language from a dictionary and grammar, would you?" (http://www.research.att.com/~bs/learn.html). Ironically, most of the big books I read did exactly the same for me. They all tend to provide too many details upfront. You could end up reading 500 pages but still don't have a clue what's the correct way of programming in C++. Plus you'll probably forget what read before...
   
   
   
   I felt a great relief when I came across this book. I would say the authors have done a marvellous job. From the very beginning they teach you how to program in the C++ way, more precisely in the Qt way. The book suggests Qt coding style is not "pure" C++ but that's a different story. By throwing away all the irrelevant bits, they give you a good idea of the whole picture so that you'll be on the right track very quickly. Then you can let you knowledge grow by accumulating more technical details - it's just a matter of time and practice. Of course, a big thick book is still needed as reference. If you don't know anything about programming, I would suggest you read the first few chapters of one of the primers, then switched to this book. I feel it still requires some basic programming background.
   
   
   
   I would definitely give it a five star and recommend to anyone learning Qt

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

1. I got this book as one of my first for programming a few years ago. I was able to compile some programs and have a basic idea of how the language worked. But it was really hard absorbing all of the information with just this book. It was the only thing I had to learn programming at first. When I took a class in high school for C, all of the information really came together. I knew everything we did in that class and then some. But the information gets a little dry. This book does what it is supposed to, though. If you spent enough time with it, you could very well learn how to program. But for me, I couldn't read it front to back like I had wanted to as a new programmer.
   
   I suggest buying a companion book or taking a class before buying a reference book. After you learn how to think like a programmer, thats when you buy a reference book. Learning a language without knowing how to apply it was getting me nowhere. Great book though; I'm just throwing out a warning for anyone that is considering getting into programming, and using this as your first book.



2. This is an excellent reference book for C programming. I have been programming in C for a year now and this book has proved to be a valuable addition to my collection of C texts. The book is not designed for persons who wish to start programming in C for the first time. However, even if you are a beginner in C this book will be a tremendous asset to you, especially as you become more advanced in the C language. The standard libraries are covered in detail and accompany lots of examples. Most of the concepts of the C language are explained clearly and are accompanied by suitable examples. There are some areas that are a bit vague but this is more than compensated for by examples. I recommend this book for anyone who wishes to program in the C language but note this book alone will not be enough. It is a 'must have' in your collection but to get a full understanding of some of the C concepts you will need to have more C literature.



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



4. [Helpful? Not? Please vote.] :: Mr. Hayes is undoubtedly a competent C programmer. This book isn't intended for him, nor anyone else who patently needs no introduction to the basics. For example: If you know and understand and can recognize fundamental differences between compilers (perhaps you've written a compiler or two yourself?) ... you likely don't need this book. If you know and understand different program extensions or have a nuts-n-bolts understanding of portability issues ... you likely don't need this book. If you're porting code across platforms in the first place ... I digress. I just hated to see the first review of this book rate it so poorly by being so obviously slanted or geared to the competent and experienced programmer ... Similarly, "Green Eggs and Ham" isn't really a Comparative Literature text either.
   
   This book is for new-ish programmers. I think it's specifically for undergrads who don't want to memorize the minutia of every single string function in C. Plain, vanilla C-code is all about syntax, order of operation and algorithms of the native functions. Most students understand how to solve labs on paper, but can't translate it to the infernal foreign language that is C-code. C is no mystery, and it's about exactness and handling every single possible input. It's also about reserved words, declaring and using data types and structures, and basically completing lab assignments, for the first 3 years or so. After that, C, C++, JAVA, whatever ... you know programming, and can find out what you need to complete any program in any language once you have the basics well in hand. Having taught at the University level, I find Schildt to be very good at making Sophomores out of Freshmen, and Juniors out of Sophomores. Beyond that, it's only a once-in-a-while grab to look up some small thing or another ...
   
   I used this book for undergrad and grad CS studies. It is THE preeminent reference for plain, vanilla C-language coding. It has data types, quirky ways compliers and loaders treat certain operations, and lots of "details" that you just can't and probably shouldn't remember unless you use them every day. This is the encyclopedia of C-language details, in a reference format; something lacking from K&R's books, which can have you searching and reading on a topic for some time, only to find an answer of limited utility. I do LOVE K&R's book(s), but it took a couple of years before I was fluent enough to really absorb their prose, which is no doubt, a more advanced treatment of what you can do with C. This "Schildt manual", as we called it in school, is more about HOW to do something, once you know WHAT you want to do ... This will not solve algorithm problems for you, per se, but if you're looking for the string operation that will make what your algorithm calls for easiest, they're all in here, explained with syntax and order of operations in plain English. I would hate to think what my undergrad years would have been like without this book. Worth the $$ at twice the price. (of course, people have found intermittent instances where this book was no help, or even outright wrong ... welcome to computer science and math ... ain't it grand?!?!? ... "Hilbert, meet Godel" :-)
   
   After an MS in CS, multiple applications and system level programming projects, several years in industry, and having taught introductory C-programming for 7 semesters, if I could have ONE and only ONE reference book on the C-language, this would be it. The "class time" instruction is available on any online C-coding tutorial ... the unforgiving nature of code/logic makes "correctness" imperative. Correctness is in the details. The details are in Schildt's C Reference, and they're easy to find ... thus, you can finish your lab, take a shower and make it to the party with all your friends, instead of sitting in the lab, sweating whether to use strtok() or strstr(), while your youth and "fun years in college" are ever more fleeting. Believe me, you have better things to do than try to solve a second year lab assignment using Kernighan & Ritchie ... ( K&R = "the authors", so reverently mentioned in several prior reviews, JIC that isn't common knowledge). Their books, and afrementioned reviews of this book, though correct in probably every way, are sort of like Microsoft Help Topic answers (Seebach's page contains rants from other would-be authors who seem to wish that they'd not only had the idea to write this book before Schildt, but also employed their many computer-geek buddies to help them edit it better as well. Neither happened.). To put K&R's work, as relates to the beginner, into the MS Help Page perspective:
   
   [ A helicopter was lost in the fog near SeaTac airport, radar was down, and they were flying blind. Suddenly, from the mist, appeared a large building. As people gathered by the windows to gaze at the helicopter, the passengers scrawled a sign for the onlookers, "Help! Where are we?". A few disappeared into the cubicle farm and returned with a sign reading, "You're in a helicopter!" The pilot promptly turned the chopper around, and said that's Microsoft headquarters, SeaTac is this way. "How can you know that?" they inquired. He replied, "I know it was Microsoft b/c that was a technically correct, but totally useless answer." ] That was the feeling I got early on while reading K&R. They now occupy a place of high importance in my library, but I could've held off on that purchase for some time ... just my opinion. Use Schildt until you get your parchment, then go off and organize a maverick and superior disposition of your own, like Schildt's detractors. The problems with the book are piddling compared to what it has to offer, and are unlikely to be an issue for it's intended audience.



5. First of all, it shoud be said that the C language is so widely used it's a shame that good and updated books no longer appears on the market. This book is an exception. To my knowledge, it's the only book that covers the latest additions from the last ISO/IEC 9899:1999 standard.
   This book covers (in addition to the traditional C89 standard):
   1) restrict pointers.
   2) the inline reserved word.
   3) The new _Bool and bool types.
   4) The new _Complex and _Imaginary reserved words.
   5) The new "long long" integers for 64 bit integer arithmetic.
   6) Variable lenght arrays.
   7) Type qualifiers in array definitions.
   8) Single line comments.
   9) Mixed code / declaration style.
   10) Variable arguments to macros.
   11) The _Pragma operator.
   12) Variable declaration inside for() cycles.
   13) The new compound literals.
   14) Flexible arrays inside struct members.
   15) Delegate initializers.
   16) Various additions and differences from the past standard.
   
   and, most importantly, it always underline when a concept apply to C99 only, when it apply to C89 and when it is usable in both standards. It also underline when something get in contrast with the C++ programming language. The difference between the two standards will be always clear.
   And, to my opinion, this is a *very good thing*.
   What matters the most is: this book will teach you C. It's not an advanced book nor a beginner book. It's intermediate. So, if you're looking for an updated book about the C programming language and you have programmed something before, get this book now and leave complaints to others. If you're searching for a pedantic syntax/semantic analysis for the C language, just buy the specifications. The last section of the book is fantastic to gain confidence with the language. While not C related, it teaches you how to solve common problems by using C in practice:
   a) Search and sorting.
   b) Queues, stacks, linked lists and trees.
   c) Sparse arrays with hash tables.
   d) Syntax analysis and expression evaluation.
   e) Some techniques used in artificial intelligence.
   
   An additional section covers the implementation of a small C subset interpreter!!!
   
   This book is not intended to be the most complete and advanced C book of the planet, but reading it surely it will contribute to your C knowledge and technical skills with it. Buy it without hesitation as a first book for this language. And don't skip more advanced books like "Expert C Programming" by Peter Van Der Linden, "C Traps and Pitfalls" by Andrew Koenig and "Memory as a Programming Concept" by Frantisek Franek.

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 Schaum's Outline of Programming with C++.

1. Who referred to this book having mistakes:
   
   They seem to be stuck in the stone ages of C programming.
   
   Since the new ANSI standard came out, (which compilers are still attempting to catch up to), header files have not used a .h extension, C Standard library headers have been renamed and so on.
   
   Every negative point the person makes indicates a complete lack of knowledge, especially accurate knowledge of the C++ standard.
   
   As such that review should be completely and utterly disregarded.
   
   This book is definitely head and shoulders above the crap that people like Herb Schildt have been putting out.
   
   Thanks.



2. The book is good but it doesnt cover struct's and unions. unions are worth there weight in gold in data i/o programming. The book has not got a mistake on it as the "Shaun G Pearson of nova scotia put it". Its using the newer C++ library and is part of it. (...) I suppose the book doesn't want to go to far into C stuff. C is essential to writing clear and concise code in C++. But at the price the book is at its a good buy. I've got it.



3. Very informative introduction to C++. I was new to C++ and most textbooks are hard to understand and hence requires a teacher to explain everything. I started reading it halfway through the course and got a C+ when I was expecting an F.



4. Dieses outlet bietet eine sehr gute Zusammenfassung der meissten Aspekte von C++. Es ist kein Anfängertutorial und auch kein Referenzbuch, eignet sich aber sehr gut zum Nachschlagen.
   
   Die Erklärungen sind, im Vergleich mit anderen Büchern, kurz und sehr gut ausgeführt, zusätzlich bietet es noch viele Beispiele zur Vertiefung. Es ist in einfachem, leicht verständlichem Englisch geschrieben. Durch das praktische Format kann man es auch leichter mitnehmen als 1000 seitige Wälzer.
   
   Besonders für die guten Erklärungen und den Preis vergebe ich die vollen Punkte.



5. This is an excellent supplement to most of the college level textbooks in C++ programming. Many authors of C++ textbooks are taken up by the apparent need to illustrate complex object oriented concepts (lest Java be seen as the alpha and omega in object oriented languages)with long winded "case studies" or "programming projects" that seem contrived (see any book by Deitel for examples of such.)Some other authors think that their exercises and examples are places to showcase their ingenuity and possession of programming tricks (see Daniel Liang's "Displaying A Pyramid Of Numbers" in Chapter 3 of Introduction to JAVA Programming, Comprehensive Version, 5th Edition, as an example of such.) But what about simple exercises to see if you've mastered the basics of arrays, loops, and simple functions? Let's face it, it will be a couple of years before you'll be asked to work on the code for an ATM machine (Deitel), in the meantime buy this book and focus on the basics.

5 comments about More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and Solutions (C++ In-Depth Series).

1. In this book Herb Sutter continues investigating of the problems that face C++ developers. Even discussions of the problems that one is unlikely to confront reveal important aspects of the proper C++ programming.

   The author often beats on a problem until it "has ceased to be ... expired and gone ... bereft of life ... rests in peace" (p. 118). In this particular book, most of the time this is a good thing, because in software development almost everything is a tradeoff, and you don't want to open the gates of hell as a side effect of plugging up a little hole.

   I have enjoyed reading this book at least as much as its predecessor, "Exceptional C++". Unfortunately on occasion the author spends too much time discussing trivial implications that appear not to be in line with the complexity of other topics. Also, constant restatement of the parts of every problem statement is quite wasteful and distracting, especially considering the amount of space they occupy (sometimes 25% of the solution space!)




2. I read this book after reading Effective C++ by Scott Meyers. Being able to discuss specific topics rather than viewing a language as a whole was my preferred way of understanding C++, so the books by Sutter and Meyers fit me perfectly.

   The main advantage the Exceptional C++ series has over the Meyers series is that you can tell Sutter is the better programmer. You can trust that everything Meyers says is correct but in the end all you really get is some extra pointers on how to do certain things. Sutter on the other hand gets a little deeper on the same topics and makes you feel like can write better C++ code, rather than just being able to format it better.

   One complaint I had about Effective C++ by Meyers was that most of the book is text and contains very little code. My experience with reading programming books is that around 90% of plain text will not be retained. The only way verbal programming text will ever stick is if there is good code to accompany it. Since Sutter is a programmer first, author second, he provides more code examples and they seem to be more thought out.

   If you have the time then you should probably read from both authors, however, if you don't want to read 4 books then you should probably read the Exceptional series over the Effective series.




3. If you liked its predecessor, you would do well to snap up this one, too. It's more of the same good stuff, in the same format: Sutter poses a question or series of questions, some of which are fairly general and some of which challenge you to spot mistakes in some code, and then uses it as a springboard to outline some best practices. There is more on exceptions, memory management, inheritance and polymorphism. You'll also discover several ways to get a stack trace and how to write a traits class.
   
   There's also slightly more advanced material on smart pointer members and copy-on-write implementations of strings, which is pretty extensive, particularly with regard to its problems with threading.
   
   This is not a reference book or the sort of volume you'd reach for to solve a specific problem. And Sutter's influence in the field means there's not a huge amount of fundamental stuff that hasn't diffused throughout the C++ literature since this book's publication, but reading the Exceptional C++ series is one of those things you just have to do if you want to call yourself a C++ programmer and there are few better ways to learn The C++ Way than quality time spent with More Exceptional C++.



4. This appears to be a good book. It was too much for me, but I'm keeping it for when I need it.



5. Mr. Sutter's books biggest strength to my opinion is that they bring together a bunch of original advanced C++ topics that you cannot find anywhere else. This book has its share of very original content but I feel like the ratio original content vs topics that you can find in other books is lower in this book than with the other books of the serie. The most interesting section in this book in my opinion is the one on exception safety and the less original section is the one on generic programming and STL as you can find much of the information contained in this section in other books such as Effective STL from Scott Meyer or C++ Template from David Vandervoorde and Nicolai M. Josuttis.