1 comments about Financial Applications using Excel Add-in Development in C/C++ (The Wiley Finance Series).

1. Microsoft was invested considerable effort in enabling its Excel spreadsheet to be integrated into a C++ program. Where the latter is Microsoft's version, Visual C++. Or, somewhat more broadly, you can hook programmatically into Excel from within Visual Studio .NET. Permitting the use of Visual Basic, for example.
   
   However, much of the book restricts to the discussion of using C or C++ code. There are lengthy explanations of how to pass data between Excel and the C/C++. A comprehensive API in C is available. Its use is certainly non-trivial, as will be evidenced if you start reading the chapters on it. You can even crash Excel from your C/C++ code by several inadvertant means, as cautioned in the text.

5 comments about Writing Apache Modules with Perl and C.

1. It's all in Perl. The book says "Apache Modules with Perl and C" but really, it's all in Perl. The only mentions I've seen in C are the very very beginning, and the end that restates the Apache documentation.

   If you bought this book thinking it will have sample C code, you would be wrong.

   If you like Perl, then this is the book for you, but if you prefer C, as I do, then you will have wasted your money.




2. Not much there for C, although it's not too difficult to make use of the Perl topics and covert them to C, it's more geared towards Perl (much more). That's too bad. Still, it's a good book and is very useful for referencing as well as for people looking to learn more about this topic.



3. I bought this book awhile ago USED here on Amazon (for $2.00!), and it was worth every penny!
   
   Although this book is old, it has some useful reference material that can still be applied today.
   
   It doesn't mention as much about C as it does PERL, but it does cover the basic fundamental principles of using either language to create your own apache modules, which was more of what I was interested in.



4. While this book is a bit outdated and technology has greatly changed since this text was released in 1999, this is still a solid reference for anyone that works with Apache and still needs to support writing modules with Perl (not as much with C). At a hefty size of over 700+ pages, this text will certainly help you do the job and it's a great bargain for this specialty text.
   
   Chapter Overview
   
   01. Server-Side Programming with Apache
   02. First Module
   03. Apache Module Architecture and API
   04. Content Handlers
   05. Maintaining State
   06. Authentication & Authorization
   07. Other Request Phases
   08. Customizing the Apache Configuration Process
   09. Perl API Reference Guide
   10. C API Reference, Part I
   11. C API Reference, Part II
   
   **** RECOMMENDED



5. Helpful for getting your head around the principles of Apache modules, but for modern API reference, see Apache's online docs.

5 comments about Sams Teach Yourself C in 24 Hours (2nd Edition) (Sams Teach Yourself).

1. this is a good book to get one started with C language. The explanations are clear and concise.

   The downside is that there is no download for computer codes used for examples, so one has to type in all the listings.




2. I absolutely did not know ANYTHING about programming. First chapter was a very simplified version of what will become a more complex outcome further on. The rest is filling in on details of math and vocabulary. By the fourth chapter it was very clear to me what is needed. In conclusion of the book you will be programming. Ive bought this book twice because by chapter six someone stole it. After reading this book i have understood most programming languages alot easier.



3. I have read an earlier edition of this book. I have to say it is the best intro to C I have ever read. None of the campy "For Dummies"-ish stuff. Just clear, concise, easy to read and understand descriptions.
   
   Tony Zhang is an amazing writer when it comes to making programming concepts accessible.



4. I hardly got anything out of this book. Understanding pointers was difficult, and the brief explanations weren't helpful. I can't imagine how someone else would learn C.
   
   If you want to learn C with good programming practise, skill and techniques, get Teach youself C in 21 days. You'll have a better time.



5. This book, even as the second edition, suffers from poor proof reading. The text and examples in some cases do not match causing confusion for the student. With persistance and perhaps the guidance of a teacher, that confusion can be overcome. The errata available on the SAMS website covers only 2 mistakes and none of the dozens of mistakes I spotted.
   
   You will have to learn your IDE for Windows on your own as the page that covers that is brief. Only MS and Borland environments are covered. If you use Unix or Linux, this book is not for you.
   
   The lack of a CD is a plus. Typing your own programs and learning the mistakes YOU make in creating programs is the way to learn. Some will say that this is a disadvantage. I see it as an opportunity to gain experience.
   
   The first few chapters discuss basics and indeed will get the student started. But when the going get rough, the explanations get hasty and sparse. Like many courses, they start with good intentions but the end of the term presses and the pace increases just when the material gets more difficult. The last half of the book should have been the last two-thirds. Check out a different C book, there have to be better ones.

5 comments about Agile Java(TM): Crafting Code with Test-Driven Development (Robert C. Martin Series).

1. I'm not a beginning programmer, or even an absolute Java novice, so maybe this book isn't really aimed at me. My biggest gripe is that the code snippets continue on and on making the book very poor for anything other than cover-to-cover reading.



2. I've gotten about 6 chapters into this book and I love it. I've been developing Java for almost 7 years and am currently teaching myself Agile principles and this book comes as a great help.



3. This book is primarily for new programmers who want to learn Java as their first programming language. The book can also be helpful for programmers familiar with test driven development (TDD) but new to Java, or vice versa. I am an experienced Java developer, and I found that going through Agile Java presented me with a new and better way of approaching Java code development. This book covers Java 2 Standard Edition (J2SE) version 5.0, but covers only a few of the additional APIs at an introductory level. Technologies that are used pervasively in the majority of enterprise applications, such as logging, JDBC, and Swing, are presented in Agile Java. Some of the information, such as that on logging, will teach you all you need to know for most purposes. Other lessons, such as those on Swing and JDBC, will give you a basic understanding of the technology and will tell you where to go when seeking further information.
   
   The core of Agile Java is fifteen lessons of about 30 pages each. It starts with baby steps in Java, TDD, and OO. The book finishes with a strong foundation for professional Java development. The core lessons should be read sequentially since each lesson builds upon the previous ones. Once you have completed the core lessons, you should have a solid understanding of how to build robust Java code. If you haven't completed the fifteen core lessons, you should not assume you know how to write good Java code. Each of the fifteen core lessons in Agile Java has you build bits and pieces of a student information system for a university. This single common theme helps demonstrate how you can incrementally build upon and extend existing code. Each lesson also finishes with a series of exercises. Instead of the student information system, the bulk of the exercises have you build bits and pieces of a chess application. Some of the exercises are involved and quite challenging, but they are where learning the methodology really begins.
   
   There are three additional lessons to cover a few more Java topics. Two of the lessons present an introduction to Swing. These two lessons will provide you with enough information to begin building robust user interface applications in Java. But the bigger intent is to give you some ideas for how to build them using TDD. The third additional lesson presents an overview for a number of Java topics that most Java developers will want to know such as JARs, regular expressions, cloning, JDBC, and internationalization.
   
   I really liked how the author integrated the three concepts of Java programming, TDD, and object-oriented design without confusing matters. The book is very clear with good illustrations. I highly recommend it. The following is the table of contents:
   
   Lesson 1. Getting Started
   Lesson 2. Java Basics
   Lesson 3. Strings and Packages
   Lesson 4. Class Methods and Fields
   Lesson 5. Interfaces and Polymorphism
   Lesson 6. Inheritance
   Lesson 7. Legacy Elements
   Lesson 8. Exceptions and Logging
   Lesson 9. Maps and Equality
   Lesson 10. Mathematics
   Lesson 11. IO
   Lesson 12. Reflection and Other Advanced Topics
   Lesson 13. Multithreading
   Lesson 14. Generics
   Lesson 15. Assertions and Annotations
   Additional Lesson - Swing, Part 1
   Additional Lesson II. Swing, Part 2
   Additional Lesson III. Java Miscellany
   Appendix A: An Agile Java Glossary
   Appendix B: Java Operator Precedence Rules
   Appendix C: Getting Started with IDEA
   Agile Java References



4. This is my new favorite-book-to-give-to-anyone-who-is-learning-or-using-Java.
   
   The title is misleading in that this book is about much more than just the Agile Programming stuff. While it does a great job talking about Agile techniques and always starts by creating a unit test, the book really is about all aspects of Java (specifically Java 5) programming. Anyone who takes the time to work through the examples will become a much better Java programmer.
   
   OO patterns, collections, type safety and more are covered and explained in the context of a rich, in-depth example. And because the author has you construct a high-quality test suite around the example, you are free to experiment with different ways to implement each new feature - thus proving to yourself the benefits of Agile design.
   
   Just like it says in one of the quotes on the cover, this book is now required reading for the Java programmers at our company.



5. I had originally bought this book for son who was going to spend the summer working for my development team writing unit test for our database POJOs. I was so impressed way in which concepts were incrementally introduced I read the book cover to cover. It is now the only book I recommend to beginners and I introduce it as a 'must' read for all my new hires.

3 comments about Big C++ with WeL Total Java CD Metrowerks Codewarrior 8 and Sleve for Horstmann Big C++ Set.

1. Lots of examples, very easy to follow along. A big downside that I noticed is that there is no website for the book to find the necessary libraries for the examples. I now found that I can find them on the site of the previous book the author wrote. After wich I had to find more libraries wich were either missing or incomplete. This come down to skipping chapter 3 and subsequent programming exercises that require the knowledge gained from chapte 3. Very frustrading, but I hope that that the author will create the site soon, making this a 5/5 book. Great otherwise.



2. This is an excellent textbook written by knowledgeable authors. Horstmann teaches at San Jose State University in California. He has in-depth knowledge of C++, having written the Safe STL library. He also writes for the Sun Core Java series of books.
   Although the book is large, it can be used for a 2 or 3 semester sequence of courses in software development using C++. After covering fundamentals, the authors cover advanced topics with modern relevance. Chapter 13 on Object-Oriented Design discusses the software development life cycle, Class-Responsibility-Collaboration using CRC cards, and gives practical tips for implementing class associations. Other advanced topics include templates (similar to generics), the C++ Standard Template Library, design patterns, GUI's, Relational Databases (using MySQL), and XML. Appendices cover C++ Language Coding Guidelines, and legacy C/C++ topics.
   
   The authors' writing style is very clear and easy for college freshmen to understand. The Random Facts sections help make the textbook interesting, and cover topics such as: Computing History, the First Bug, the Therac-25 bug (an ethical issue), the Ariane Rocket incident, etc.
   
   Sample code can be found at the author's website at:
   http://www.horstmann.com/bigcpp.html
   and also at the Wiley publisher higher education website:
   http://he-cda.wiley.com/WileyCDA/ (search by author for Horstmann). The book is well organized with a good set of end-of-chapter exercises, programming problems, and references for further reading.
   
   We have adopted this textbook for a 2-sequence course in object-oriented software development. I highly recommend it.



3. UPDATED AT THE END - ORIGINAL REVIEW LEFT UNTOUCHED
   
   I used this book as the required text for my introduction to C++ class. I'm currently enrolled in the advanced C++ course which uses this book also. As a beginning programmer I have a different perspective than most - I have never used or learned C++ prior to my introductory course. Just so you know I'm not a lazy student, I have over 40 hours of A and made an A in my intro course. I expect to get an A in the advanced course.
   
   I feel potential buyers need to know what it is like to use this book as a complete novice to C++. My professor was excellent and only used the book as a guideline to teaching us the subjects. This book has merit but there are better options available...hence the 3 stars. I was tempted to give it 2 but the ability to use it as a reference manual (after learning the language upped my rating).
   
   I do NOT like the writing style of the author, nor the progression of thoughts throughout the chapters. The author will introduce a topic, then immediately jump into an advanced example, then a couple of pages later explain what that advanced example does. However, sometimes this explanation never comes and he just moves on to another topic.
   
   This style of writing overwhelmed me at first and I found myself unable to understand the topics being discussed. I found that I had to reread the chapters 2 or 3 times to get a full grasp of the concepts.
   
   After passing my introductory course, I reread some of the chapters to see if my perceptions were correct and they were. What I think would help tremendously is if the author gave a complete program at either the start or the end of the chapter, then simply made references to that code.
   
   The author also relies too heavily on examples in previous chapters, without giving page numbers of the code he's referring to. Instead the student has to almost become a detective to find some of the referrences. This is amazingly frustrating as I have to search back through the chapters to find the examples currently under discussion.
   
   One example is using the :: operator to define class member functions, the author shows (via example code) that this definition (which is outside of the class definition) can access private member variables of the class. However, it gives absolutely NO explanation as to why this is allowed. It's not even discussed later in the chapter. Two pages before this example, the author introduces encapsulation. This left many students confused about the rules regarding encapsulation/function definition.
   
   This book is not without merit. There are many examples and at times very helpful discussions regarding certain topics. Perhaps as my knowledge of C++ grows I will be returning to this book as a reference...however, I doubt it. I found other books were more helpful to the beginning programmer. One such book is C++ A Beginners Guide by Herbert Schildt ISBN 0-07-223215-3. At 1/3 the price of this book, it's a much better deal and in my opinion a better book for the complete newcommer.
   
   As far as reference material, I found many other books on the market that were better explaning these complex issues. In my opinion, this book is overpriced and should only be considered by buyers if money is not an object.
   
   ***** UPDATE ***** (February 10, 2006)
   It has been quite awhile since I first wrote this review (orig was written Feb 12, 2005) and my skills with and knowledge of C++ have both increased. Not only that, I have a new found respect for this text. I stand by my original review and have left it untouched because I still believe this book is a bit difficult for the C++ novice.
   
   However, I have now progressed through Adv. C++ and Data Structures (made As in both classes) and I'm now into Junior and Senior level programming courses. I find myself returning time and time again to this book. As a reference manual, I'm finding a lot of very helpful discussions. Given my familarity with the language, I find the text thought provoking, insightful and very helpful. I suspect I will return to this book many times over the years.
   
   For the newcomer, I still think that Schildt has a better book for teaching this language. If you plan to continue using C++ then you should definatly pick up this book as a reference.

5 comments about File Structures: An Object-Oriented Approach with C++.

1. As a student, I have found this book to inhibit my studies more than help them. Instead of presenting the concepts clearly, concisely and with as little overhead as possible, this author seems to go out of his way to make it harder than it should be. The reader ends up wading through the examples, trying to find the core concept that should have been given up front. This student has discussed this book at length with fellow students, and has yet to find one who enjoys the book. We learn, but only after spending too much time filtering out junk.



2. This text was used for a junior-level File Manipulation Techniques course. We skipped around quite a bit in this book and did not use any of the C++/Unix material. I think (and I'm sure my professor does) that this book could be stripped down a quite a bit to present more topics when used for the classroom. What is presented is done well. This is a well-rounded text that should appeal to students and professionals alike. However, from the student's perspective, there is a lot of superfluous material. It is still one of the best, if not then it is the best, book on file structures and algorithms.

   The programs for class were in Visual Basic .NET . It was not hard to adapt sections from the text when writing programs for a different language.

   Our class moved through the book as follows: chapters 1-4 (introduction to external storage, files of records); start of chapter 8 (cosequential processes); chapters 5 and 6 (record access, insertion and deletion); end of chapter 8 (sorting large files); chapter 11 (hashing); chapter 7 and 9 (indexing and B-trees).

   Once I was able to figure out what I could skip and what was important, I was able to read the chapters quickly and understand the material without a lot of re-reading. This book shed new light on an area of computer science that I didn't know much about. After taking the class/reading the book, I feel that I understand well what was being taught. I would still recommend this book to students because there is nothing else quite as up-to-date and it is quite easy to read and learn from.




3. i love this book...used it in my file structures course obviously, and i found it very useful



4. I only bought this book because I needed to get an image of how fixed length records are implemented using C++. The book answered my question and provided me with examples. The examples compiled without a problem.

   4 stars instead of 5, because I had to write my own Makefile in order to compile. Aparently, presented makefiles were designed to compile all examples at once, and I only needed a little piece of that.

   Also, the information is a bit scattered around the book and it is not always easy to find what you need. But it is there, so you just need to work on it. After all, this subject is not covered at all in other books, so I would say it is a must have book for any programmer who works with files.




5. This book is very clear. You can skip the C++ stuff if you want, and it will still be excellent.
   It's the kind of book that you read without having to go back and re-read paragraphs (well, I did that sometimes -- but most of the times the text is very clear).
   
   If you're "somewhat" interested in filesystems, implementation of databases, information retrieval, it's a nice book. If you're serious about it, then you'll need newer and more in-depth material.

5 comments about STL Tutorial and Reference Guide: C++ Programming with the Standard Template Library (2nd Edition) (Addison-Wesley Professional Computing Series).

1. This was one of the earlier STL books, and even with its Second Edition, it hasn't caught up much. On its own, it would deserve 3 or 4 stars, but it's expensive and there are better ones out there for your money. I think even the publisher must agree, as this book's #1 competator is also an Addison Wesley book, _The C++ Standard Library : A Tutorial and Reference_.

   The real problem is that this book only does the STL, not the other parts of the standard library like strings and iostreams. The typical C++ programmer looking to become more modern is going to want to know all the new stuff, not just this little slice of it. If you're already familiar with the standard library and want a book on only STL, you can consider this a 4-star rating. The book is okay for what it does, but I don't see why anyone would want it, as you're going to have to buy a second book if you get this one.




2. John's reviews are interesting. While I agree with many of the points he makes, I disagree with some. And I found a few to be self-contradictory.

   He says, for instance, that "This is a good solid book that will get you up to speed quickly on all the important ideas in STL, and many of its basic usage idioms", but then naievely claims that "there aren't any higher level ideas than those presented here". Does the book cover only basic concepts, or is it that if the book doesn't cover it, it is not knowledge?

   The book is full of concrete examples. But my problem was that they were trivial. Reversing or sorting or finding characters within a string is great fun. But it doesn't help me understand who owns the memory within a container. Or how to directly and safely reference an element at an arbitrary position within a container outside of an iteration loop. A majority of the examples use trivial intrinsic datatypes for contained elements; how is using a struct or class different?

   All of those issues are important aspects of using the library, and not something I think a busy reader should leave to "a little imagination". While most of the disputed facts are eventually available in the text, they're not easy to find. The organization of the book isn't quite intuitive enough to make it a thoughtful reference or a breezy tutorial.

   And, in many cases, once found, they're not clear. John cited page 151 for an explanation of the differences between some of the collections. There, it says "With maps an multimaps, the data items are pairs of keys and data of some other type..." What's that mean? Two keys and data of some other type? Or a key and data of some other type? Does "pairs" mean "two", or an instance of the "pairs" utility class?

   The book really is missing information. None of the examples do any error checking whatsoever, and the exceptions that the templates throw aren't described. (Maybe, like priority queues, error handling was formalized after the book went to press. It is showing its age, and there's now a 2nd edition. I haven't purchased it.)

   It's ambitious to write a book that tries to serve as both a tutorial and the reference. (Me, I think it's just impossible.) This book does very well, but falls short of adequately completing either goal.

   I think that there's a bias against this book because it doesn't fit well with the way these reviewers would have liked to learn the subject at hand. I know that's where I landed. While true masters do indeed make it look simple, making it look simple doesn't help learning. Otherwise, we could all watch Tiger Woods for a few Sundays before taking home a Buick and a six-figure check.




3. This volume is a much improved version of the original of the same title. An additional author has come aboard. The major improvements I noticed were in the examples. There are many more examples and many more STL features now have examples showing how you can use them.

   The tutorial aspect of this book, which comprises the first part of the book, makes a strong case for not re-inventing the wheel, but rather using the containers, iterators and algorithms in the standard library. Practical examples come right from the start. This may take some getting used to by those who have never seen STL used before, however, the excitement is tonic.

   Also, the approach, of showing STL use before getting into the theories of iterator-based access, has been adopted in several subsequent C++ texts by teachers of C++ and has been found pedagogically sound.

   Don't overlook the precision and clarity of the (English) language discussion of the STL in the tutorial. It's worth reading every so often as a refresher.

   And the value of the reference section, which is easy to navigate and has everything in it that most other books dealing with STL don't is great indeed.

   On the whole, if you work in C++, this is a carefully put-together book that will have lasting value and continual use in your library.




4. As an advanced programmer, I must say that I'm disappointed that the level of information provided is not as deep and meticulous as I had hoped.

   Additionally, both the index and the overall organization of the book leave much to be desired.

   The book, however, is a valuable reference for beginning and intermediate programmers. It explains the STL (Standard Template Library) from the ground up, explaining when, where, and why you would use any particular aspect of the STL, how to use the STL, and sufficient examples to understand correct syntax. This book also contains a detailed section of applying the STL to real-life programming examples. Furthermore, the book also contains a comprehensive reference guide for quick and easy access to pertinent information about STL aspects you frequently use and modestly comprehend.

   If you are a beginning or intermediate programmer, this book is worth adding to your collection.




5. Whenever I need help with STL, I open this book only to find that it has nothing useful on it. For those who have MSDN don't bother to buy this book.

3 comments about Bundle of Algorithms in C++, Parts 1-5: Fundamentals, Data Structures, Sorting, Searching, and Graph Algorithms (3rd Edition).

1. Any professional programmer would benefit from having these books at hand. Excellent discussions of the basic algorithms which every programmer needs to know.
   
   But I would like to particularly highlight the discussions on binary and n-ary search trees. The most enlightening discussion in print, giving the reader a real synoptic view of search tree algorithms, how they evolved, and their culmination in red-black trees.
   
   Other reviewers have mentioned that the algorithms as presented here seem to be just warmed=over versions of their C counterparts presented in the C edition of this work. There is a germ of truth to this, but I really don't consider it to be a valid criticism of the books. The point here is not to present C++ coding techniques, but to understand algorithms. If you want to know what a state-of-the art C++ implementation of Red-Black trees looks like, just read the source code which comes with the GNU compiler toolchain. But you're not going to have a prayer of understanding it until you first understand how Red-black trees work--that's where this book comes in. If you are trying to explain the Red-black tree algorithm, you don't want all of the C++ do-dads and optimizations, templates, etc, all cluttering up the presentation of the skeletal algorithm.



2. If you need a book to introduce yourself in data structures, thats not your book. This books are for consult, not to learn, cos there are leaks : insuficient code, insuficient large explanations and drawings about TDAs. Furthermore, its expensive.
   Even trough that, Id recommended part 5 because its a good collection of the most used algorithms based in graphs.



3. What happened to the sections on string processing, geometric algorithms, and advanced topics? The Introduction says parts 5-8 are contained in a separate volume, but the second volume contains only the part on Graphs (which the intro says is supposed to be Part 7) What gives?

5 comments about Financial Instrument Pricing Using C++ (The Wiley Finance Series).

1. implementation and design of classes wise this book is replete with ideas. Since this book dealt with FDM, which are either cubbersome or difficult to program say american options, better is to deal with FE methods.



2. Extremely accessible and professional, both math and software side are very well done, one of the best intro books about numerical modeling and software design. The finite difference methods in this book are very powerful.



3. The code is a real mess. Source files are missing, class member variables not defined, calls made to misspelled functions, basic syntax errors. Here are a few of the problems I have run into:
   - Missing Source Files:: BVPmechanisms.hpp. So files like BVPSOlver.cpp can't compile
   - Undefined members variables: AssocArray::contents. Can't build without it
   - Basic syntax errors: (if ass2 == this). Should be if(ass2 == this)
   - Incorrect function calls: standardDeviation(). Should be standardDeviation(x)
   
   Aside from all the kindergarten errors, the author over uses templates to such an extent that simple routines are hopelessly obfuscated.
   
   I think he built it on an old version of Visual C++. This is because the code fails to build on modern compilers with tighter error checking.
   
   I have no idea why the other guys love this book so much, they must never have tried to build any of the examples in it ... which is weird because the whole reason I bought the book was to begin building a library of financial tools.



4. I had been trying to build up the examples Daniel has been using. The CD comes with the book is a full mess. These are clearly not organized. No structure in the directory, several chapters are missing in the CD, code still have bugs, no make files.
   
   I am thinking about email Dan for a refund. This book does not deserve the price he charge.



5. This book is high on quantity and low on quality. The author clearly can't teach and his lack of clarity of thought is a little concerning to say the least. The quality here is so below par it's a wonder why Wiley bother to publish this kind of book without some kind of quality control standards in place. With his rambling and imprecise style, it's actually hard to believe this guy has a PhD - some of the undergraduate students I've taught in the past have handed in better coursework than this. You're better off buying a general book on C++ such as Meyers or even Stroustrup and simply applying the C++ techniques you'll actually learn in there to QF. Save yourself some hard-earned money and buy another C++ book.

3 comments about Beginning C: From Novice to Professional, Fourth Edition (Beginning: from Novice to Professional).

1. I decided to do some WIN32 API programming and all of the old documentation and Petzold's book uses c source code so I thought a formal presentation would be the thing to do. This book gives a very good explanation of pointers using lots of small but complete programs. This book is much like a college text in that there are problems to solve at the end of each chapter. Horton makes you work but the writing is clear with appropriate detail. C is a small language but the syntax can be obscure so I appreciated the thorough and detailed treatment. Page layout and fonts are attractive and the source code is easy to follow. I plan to follow up with Horton's C++ book.



2. It is really a very good book and Mr. Horton explains things very clear.If you want to learn C from the beginning this is maybe the best book.



3. I bought this book to get an introduction to C, however I found it lacking since I already had some programming experience (Perl, Python, Scheme, Emacs Lisp). As far as C goes, this book is complete and covers things in great detail, for example workings with memory. Since C is "close to the hardware," I think this material is the book's strongest attribute. The explanations of pointers are also really good. Again, pointers are one of the most important aspects of C, so if that's what you need, this book could help you. I surely learned a lot about C from this book, unfortunately I was turned off by the silly examples (e.g., organizing basketball scores).
   
   I don't recommend this book for someone with a mathematical background like myself (I would have rather had more abstract problems in combinatorics or numerical analysis). I learned as much about pointers from C Programming Language (2nd Edition) (Prentice Hall Software), and learned even more from that book about good programming practice, and the idiosyncrasies of C programming (while (c = getchar()) ;). If you already have some background in programming, or you need more realistic examples, get C Programming Language (2nd Edition) (Prentice Hall Software) instead. If you have no experience, then this book would be a good place to start.