5 comments about C & Data Structures (Electrical and Computer Engineering Series).

1. Mostly I check reviews before buying a book. I bought this book even I saw by other reviewers that it is full of errors. I didn't care about that, but looking how the author tackles any problem or use the algorithms. I was NOT disappointed. I have seen many expensive books on this subject, but this is the only book which covers which other books left out. Let me say the last word this book is worth more than what I paid for.



2. It is not clear why the authors chose C into which to teach data structures. Of course C can do this. But other languages like C++, Java and C# could have been chosen. And those give object oriented functionality that could have been put to good use in the implementation of these structures. The book never really elaborates about the choice of C.
   
   Anyway, the material is clearly written. It gives good treatments of arrays, linked lists, stacks and queues. While for trees and graphs, the discussion is rather basic. In general, the algorithmic depth here does not approach the standard texts by Sedgewick, Aho or Knuth.
   
   The last part of the book is a set of chapters devoted to problems and their solution codes. This may have merit to you, if you have been searching for good exercise sets. A distinctive aspect of the text.



3. I was looking for a book to help me do beginner's data structure problems. This book has tons of example code that is simple, easy to read and understand. (That's what I was looking for!) A multitudinous variety of code to choose from - like a kid in the candy aisle. On the other hand, the book had some typos. Their was adequate explanations for the code but not rich. The book's dialog was also a bit choppy and wasn't the smoothest talking to the reader. I would give this book 3 stars but since I got a good grade in my beginning data structures class because of this particular book, I biasly bumped it to five stars. T



4. I am profoundly disturbed by the poor quality of this book. Here is an example to show why I feel that way. The example was chosen almost at random but even I was shocked when I came to type it in. I would not accept such code from a first year student.
   On page 139 the author provides the following code (I have taken great care to copy the code exactly as it is in the book):
   Struct address \\ A
   {
   plot char [30], struc char[30];
   city char[30]
   }
   struct student \\ B
   {
   name char[30];
   marks float;
   struct address adr;
   }
   main ( )
   {
   struct student student1; \\D
   struct student class[20]; \\E
   class[1].marks = 70; // F
   I have stopped at this point as it continues with a hard coded initialisation of class[1] followed by five printf() statements to output the contents of class[1] to stdout. Nowhere do the authors expalin why they want an array, why they ignore the first element of the array and why the bothered with defining student1. In addition the use of 'class' as a name introduces a gratuitous incompatibility with C++.
   There then follows a section explaining the code. The first item is:
   1. Statement A declares the address of a structure containing the members plot, street and city.
   That code is so bad that I can think of no explanation for how a book on C could be distributed with such code in it.
   I am disturbed by the number of positive reviews this book has had from readers because no one who actually tried the code provided by the authors could have got it working and the explanations are often bizarre.
   Were it possible I would give this book minus 5 stars because learning from it would seriously impede a reader's development as a programmer.
   There are numerous better books on both Data Structures and C. Indeed almost any book on either subject would be better.



5. As stated by many others, this book contains many errors; especially in the program code that is listed in the book.
   
   There are numerous places where function calls written in the programs given make reference to variables that don't exist and won't run without editing. There are some sections where functions are added to the program code that are not discussed nor relevant to the topic at hand as if sections were cut and pasted without checking for accuracy.
   
   The whole book is full of these types of things. So while the theory behind the logic seems to be sound, the examples and applications are so wrought full of holes that you'll probably spend more time trying to debug and decipher the code than focus on what you're trying to learn.

No comments about Starting Out with C++: Brief Version Update (4th Edition) (Gaddis Series).

3 comments about Object-Oriented Programming in C++ (2nd Edition).

1. This book is concise but clear. I think the typesetting in this book could be redone better to give it better readability.More diagrams & few more example would make it perfect.The authors explains many subtle points of C++. This book is good for academic settings if you already knows C & Data Structures. Overall, a good concise book.



2. A lucid traversal of basic OOP concepts and the C++ language. Lots of exercises, at a rather low level of detail. J&K focus on the basics, avoiding the trap that others (e.g. Lippman & La Joie) fall into of trying to cover too many advanced topics in an introductory text. A scattering of typos and minor errors should not confuse the perceptive reader.



3. This book covers the important aspects of OO approach as well as the STL for C++. It is definitely not suitable for those who have no programming experience in C, and indeed, I find that one actually even needs to have a little knowledge of C++ to benefit from the book. The first two chapters let the C programmer make a transition to C++, and explain clearly on input and output in C++. The next three chapters then strive to explain the OO features in C++.
   Generally, the book goes at lengths to illustrate classes in C++ and their workings, and offers many tips and traps as well as certain programming styles and approaches which would produce robust programs. The worked examples were also quite comprehensive. However I feel that the concepts of OO were not well illustrated, and from my experience, a thorough understanding of OO concepts help very much in being able to manipulate classes and using the methods in C++. The chapter on MFC was not very useful, it really looked as if it was just there to fill in space. It does not teach much about MFC.
   All in all, however, I would still consider it a fairly good book to keep as a reference.

No comments about Programming: Principles and Practice Using C++.

1 comments about Introduction to C++ for Engineers and Scientists (Prentice Hall Modular Series for Engineering).

1. I thought that the title was a bit grandiose. I would have thought a better title would have been: Introduction To C++ For Technical Applications. It does not have the depth of coverage for professional engineers and scientists.It would be ideal for budding engineers/scientists at high school, laboratory technicians and drafts persons etc. who are required to do complex, tedious and repititious computations. The author does not assume any knowledge of computers, programming or C++. A high school knowledge of algebra, trigonometry, inequalities and logarithms is all that is required. The text is easy to understand and is interspersed with style tips, bugs in programs, review questions with answers from which the reader can determine if he/she has understood the text and programming exercises of a technical nature. I was surprised that the chapter on Selection Statements, the Switch construct was omitted, also in the chapter on Loop Structures that the calculation converting degrees to radians was inside the loop. The chapter on Programmer-Defined Functions only discusses passing variables by value and omitting passing by reference, which means that the programmer can only return a single value. The section on disk file input/output is the best I have read, although it is marred by the fact that the author does not give a complete drive/directory/file example, so the reader would not know that a double back slash is required. An additional chapter on two dimensional arrays should have been included, since computations involving matrices are common place in engineering and science. I give the book 4 stars for the type of reader it is directed to. A useful companion to this book would be Schaum's Outlines Programming with C++ by J. R. Hubbard Phd, ISBN 0-07-135346-1 to fill in th gaps. Anyone using a Borland compiler must enter the following lines: cin >> "Press any key to continue"; getchr(); before the return statement, otherwise the fruits of the budding programmer's endevour will disappear before he/she has time to see it.

5 comments about Programming with Objects: A Comparative Presentation of Object Oriented Programming with C++ and Java.

1. This is a pathbreaking book that teaches Java and C++ as a package. I believe this is an innovation that should be universally adopted. Kak, who is legendary as a inspiring teacher, uses all his skills to abstract the main ideas of the two languages in such a manner that is illuminating.

   I recommend this book enthusiastically as a text for college courses and as a book for self study.




2. I have used this book as a text for my class. It helped me understand the concepts of Java and C++ better than the other books that I consulted.



3. 
   I took a C++/Java course based on this book and liked it very much.
   
   Of course, you will be better off if you get yourself two separate books on C++ (for instance, The C++ Programming Language: Special Edition (3rd Edition) ) and Java, but this one is as good as it gets in a single cover.



4. To put it simply, this book is the best book I have read on OOP. It will save you a LOT of time and annoying searching through the net to only read thousands of confusing and badly written explanations of the different aspects of OOP with C++/Java. It is also very good with the choice of topics. Highly recommended. The text is simple, terse, to the point and fun to read.



5. I'm not new to oop, as I'm a java programmer; I took this book because I had to study some c++ for a job interview.
   I liked this book from the beginning, I think the explanations are very clear and the examples go right to the point.
   The best thing about the book is that it's very detailed and precise, and it doesn't waste your time with ambiguous discourses (as many IT books do).

5 comments about Microsoft SQL Server(TM) 2000 Administrator's Pocket Consultant (It-Administrator's Pocket Consultant).

1. A lot of SQL Server books give you the same information included already in Books Online. SQL Server 2000 Administrator's Pocket Consultant is an excellent complement for Books Online, TechNet and MSDN. It covers similar topics, but it digs in where necessary, provides best practices, tips to the internal operations, explaining how SQL Server actually works, with unique information only available in this book.
   
   I always want to know how things work because it helps me to understand the behaviour of a system. In many cases if you don't know how things work it could drive you to some misunderstandings. Here is where SQL Server Pocket Consultant helps out and Stanek has excellent teaching skills.
   
   The book is very compact and full of information. It's all in the details. Chapter 2 "Configuring and Tuning" is a real gem. It helped so much with server and database tuning. Chapter 5 "SQL Server Security" is excellent on the security details. Chapter 7 provides deep detail of DTS and BCP. The final part of the book is the best, in my opinion. It covers performance, maintenance and optimization.
   
   The book's small size makes it easy to take with you where ever you go and its good enough that you'll want to. Overall excellent guide ot sql server.



2. I haven't found a better book for sql admins. This book is extremely informative. I worked for a year with SQL 7 and have been studying and working with SQL Server 2000 for a year and a half. I passed Exam 70-228 in large part due to what I learned from this book. If you are looking for a how-to book that shows just exactly how to accomplish tasks associated with creating and maintaining SQL 2000 this book is for you. This is an excellent book if you want to understand how SQL Server 2000 works as well.



3. This good and concise sqlserver administration reference manual has a complete online version on microsoft.com/technet.



4. It is a very good book to have for reference. I would definitely recommend this book to anyone who is looking for answers to SQL Server 2000. It gives good detail on configuration and tuning and it also explains how to set up SQL Mail, which I couldn't find in some books I have read. I pretty much use this book every day on the job.



5. If you work in SQL 2000 and do any administration then you are going to love this book. It does not get in depth as some other books but everything is easy to find and you do not have to search hundreds of pages to figure out what you need to find.
   
   Although I've been working in SQL since 6.5 this book still comes in handy when I need to do something that I haven't done in awhile or need to confirm something.

5 comments about C Programming for Microcontrollers Featuring ATMEL's AVR Butterfly and the free WinAVR Compiler.

1. This a fun book that is great for people that want to get started in embedded programming and design. And at a low introductory affordable price.
   
   This book, and the AVR Butterfly (~$20 at Digikey) are the best bargain you can get for getting started in Embedded programming and development. Together (the book, the AVR Butterfly and miscellaneous parts) form a complete development kit. AVR must be selling the kit for a loss to introduce their products. Buy it before they change their minds.
   
   Although this is not a professional development kit, you will be able to do a lot. This is more like a cookbook to introduce you to the concepts and to enable to easily put a project together.
   
   After reading through this and putting together the projects you will have the basics to understand more advanced books and enable you to design more advanced projects.
   
   The one basic I thought the author left out that was important to include, was the C programming type qualifier "volatile". Volatile before a variable tells the compiler that a variable can have its value altered by agencies other than the program. For example you would use this when you are reading from a hardware address that is set by an interface. Otherwise the compiler may optimize the variable as a constant and not actually read the value from the hardware address on repeat iterations.
   
   Code example: volatile int temp; Reads an 8 bit temperature code from a hadware address interfaced to a thermocouple.
   So now you have it.
   
   I found the book to be very readable, easy to understand and fun to read through.
   As prerequisites for this I would recommend:
   
   * Familiarity with the C programming language. For beginners:
   I recommend the book "Practical C Programming". There are
   many fine books to choose from.
   
   * Knowledge of very basic circuits, and how to solder
   wires.
   
   * A very light knowledge of microprocessors. For
   beginners: I recommend the book "Programming Embedded
   Systems in C and C++", by Michael Barr. There are a few
   other good beginner books to choose from.
   
   
   For the beginner, this is a must have that will enable you to quickly get started and build introductory projects. If you are new to embedded programming and design I would highly recommend getting this book and the AVR butterfly.



2. Pros:
   
   -Cost
   
   
   Cons:
   
   - The Free C compiler advertised on the front cover is free anyway. You don't have to buy this book
   to get that compiler
   - The AVR Butterfly is very small. To use it, you have to do a lot of delicate soldering. If one is not good
   at soldering, the AVR Butterfly can easily be damaged
   - The book seems to have been written in a great hurry. Therefore some mistakes there.
   - You have to know C in advance, because the amount of C programming covered here is not enough.
   The author teaches some very basic level of C and then uses bits and pieces of Atmel code that comes with AVR Butterfly. And
   they are not easy for newbies.
   - There is not a single flow chart there.
   - If you are good at C programming, you can look through the C codes the are used by Atmel to originally program AVR Butterfly. The projects are basically cut and pastes from those C codes with not added clear explanation and comments.
   - I bought this book in 2004 basically to learn about programming DataFlash memory which is part of the AVR butterfly but nothing related to that. I emailed him to get some easy piece of code related to memory programming, he told me to look at Atmel's code. You can learn some stuff from this book. But do not expect to become expert in programming micros. If you are absolutely new to microcontroller programming, I suspect you might not learn much from it. First, learn some C programming from some good books then you might be able to benefit from this. I hope in the next version, the author pays a litter more attention, cover more topics, include more projects and comment and explain code examples thoroughly.



3. I'm a mechanical engineer without background in electrical engineering or software engineering and this book literally provided me with a wealth of valuable information beyond just the AVR Butterfly doing some great tricks. Some reviews seem to suggest the book is unclear, but before reading I literally barely understood what a bit is, and Pardue illuminates all of that with examples that you implement right away. I have a mechanical background, but the stuff the book deals with is ubiquitous and helpful all over.
   
   Yes - you have to read and think and re-read, but C and microcontrollers are complex inventions accomplish a huge variety of tasks - which you'll actually be able to start doing with this book. I recommend it.



4. I have a 2-year degree in computer science, and so I understand the basics of C, how electronics work, etc. While I'm able to wire-up interesting AVR projects from many online tutorials, I found most of the code in this book too confusing and poorly laid-out to be of any help.
   
   What many other reviewers here say about the text is true: a little bit of basic C is covered at the beginning, and then all of a sudden you're hacking away at Atmel's own code. If I knew how to hack up code like that, I wouldn't need to learn about it!
   
   It's possible to teach from others' code, but the author misses opportunities to help newbies as they transition into the "AVR-GCC community" -- ALL the deprecated functions and macros that are included in the Atmel code are kept, and you're given NO clue as to what the new "proper" functions are! So if you don't understand something in the book, and you check the current AVR-libc documentation, you're even more lost from the mismatch between the two.
   
   It's difficult and confusing to complete even basic projects with the material you *should* have been able to learn with this book. I have read through it twice and I still don't understand much of the book. I'd also like to note that unless you have a butterfly setup EXACTLY as the author has it setup -- which means having a specific OLD, OUTDATED GCC compiler setup (good luck getting that if you bought the book used or in PDF) -- none of the examples work at all: they're too entangled in little shortcuts and hacks that only work for the specific setup.
   
   I'd appreciate if, in the next edition, the author threw out a lot of the fancy tricks and hacks and instead focused on providing a solid foundation on things like interrupt handling, comprehensive bit manipulations, etc. If I can figure all this out by myself before the next edition, however, I certainly won't be buying this -- or any other -- title from this author.



5. The author bills the book as "...a low cost way to learn C programming for microcontrollers", for beginners. Low cost it is, but for beginners, it's likely not.
   
   Pardue's book is about two things: hardware, and software.
   
   For hardware, Pardue commendably picked Atmel's Butterfly. It's a truly amazing and compelling miniaturized machine, guaranteed to mesmerize and puzzle anyone with a desire to learn microcontrollers. For less than the cost of a dinner, one can have the Butterfly, and for a song, download the free software to program it. Pardue's book is also reasonable in cost.
   
   What makes the Butterfly come alive is a program, a compiled C program. And the software side of Pardue's book is centered around the C language. Briefly, the author takes you through the process of learning C, writing programs, compiling them, loading them on the Butterfly, and executing them. While C is a relatively "low level" read "simple", language, it is still complex and difficult to understand for beginners.
   
   What makes this book a bad choice for the newbie? Well, you can't teach C and microcontrollers in 269 pages, period. Basically, the author's scope for the book is simply too ambitious. But don't misunderstand: Learning C with the Butterfly is a really good idea, it's just not practical in so few pages.
   
   For example, a good C book covers mostly C, unsurprisingly. For instance, Prata's very good "C Primer Plus", is over 700 fairly concise, but beginner friendly, pages. (Granted, Prata's book covers more C topics than Pardue's book, but the comparison is still valid and compelling.)
   
   Contrast that to Pardue's short 269 page book, that attempts to cover appx 700 pages of C, and at the same time, covers microcontrollers. Not gonna happen.
   
   Then there's Pardue's chapter six, which is a prime example of the problem. Until this chapter, most example programs are short, if not just fragments. And for the most part, they are easy to understand, because Pardue takes the time to explain the program verbosely. Chapter six, to the contrary, slams you in the face with nearly six pages of solid code. While it's commented inline, there is little "direct" text explanation to augment the comments. I was limping when I got through the first five chapters, but chapter six blew me away. I fully expect the majority of true newbies will be blown away also. The remainder of the book has long programs, similarly lacking in adequate explanation.
   
   Other reviewers have mentioned the author's poor grammar and typography, so I will not harp on it here. The author also attempts to inject humor in this dry technical subject, and mostly he succeeds. The reader will have to decide if his humor is appealing though.
   
   Pardue does some things well. He gives adequate attention to guiding the newbie through putting the semi-kit-like Butterfly together, and introducing the compiler and Atmel IDE tools. For those unfamiliar with breadboards, those images will also be helpful. Pardue is obviously a gifted engineer, programmer and teacher, and many sections of text illustrate it well.
   
   If you insist on buying the book and the Butterfly, here is my best recipe for success:
   1. Buy and read another book on C first. I found "C Primer Plus" to be outstanding.
   2. After you have a handle on the elementary aspects of C, then buy Pardue's book and the Butterfly, then get the errata and pencil in the numerous changes.
   3. You should expect to read each chapter at least twice, and the chapters that cover the Butterfly will likely require more readings.
   4. Type the code in yourself, as opposed to copying it from another source. Add your own comments to his, to reinforce your understanding.
   5. I am sure you will need to refer back to your C book, when Pardue's book covers something in typical whirlwind manner.
   
   There is one major mitigating factor to the negatives listed above. Joe Pardue, or "Smiley" as he is called on the avrfreaks forum, is a prolific poster and easily approachable online. He has a long track record of answering questions, many of them about his book. Regardless of whether you buy his book and Butterfly kit, do yourself a favor and google avrfreaks and check out the forum. I found it indespensible in deciphering the mystery that Atmel is.
   
   As a side note, become aquainted with the open source hardware initiative "Arduino". The key attraction here is most of the hardware complexity is shielded by excellent library functions. These functions do things like drive output, read input, PWM, timers and serial work. The downside to Arduino is you are just "holding hands" with the hardware. The Butterfly requires "intimate" contact.
   
   Good luck.
   Steve.
   
   

5 comments about Programming a Multiplayer FPS in DirectX (Game Development Series).

1. This book is terrible! You read through the whole thing, and you don't even learn anything!
   
   I would strongly recommend people not to buy this book.
   
   Otherwise, you just wasted 30 dollars on worthless bs.



2. I've enjoyed reading this book. It effectively shows you how to write a very basic first person shooter in directx. Well done. It briefly introduces rendering, a simple scripting system, peer-to-peer networking, handling user input, scene management, collision detection, sound effects, and more. Not bad. The code is fine, I had no problems compiling it in VS2005 (check the authors website for the latest code though) and I learned a lot from reading the book and going through the code. In short, I am glad to have bought and read this book and I do recommend it to others.
   
   The book does have some drawbacks though. I feel that the actual game that is built in this book is embarrasingly bad. The networking system, rendering system, user interface, and everything else about it are bare-bones functional, but certainly not good enough that you'd want to encorporate them into your own game. I suppose that the thought is that you should first learn to build a Yugo before you learn to build a Ferrari, but personally I'd rather just learn to build the ferrari right off the bat :) Oh, and why must the graphics suck so badly? I realize that it doesn't necessarily impact the goal of learning the various topics, but seriously, how hard would it have been to at least provide a decent character model, or some decent textures and lighting and so forth?
   
   One last thing. The book assumes a familiarity with C++ and to a lesser extent with Directx, so if you are brand new to either of those, the book will be pretty challenging to follow.



3. At my school we used this book for our networking class. (I had been begging our teacher to show us some directPlay stuff... yes, I'm aware that directPlay is ugh in terms of networking, but, it was a lot better than learning some java networking stuff. At least to me).
   
   This book was an invaluable tool for designing my networking system. I basically gutted this networking system and stacked on some variable size packets that I studied from one of the Lamothe (actual author:Todd Baron ) books. (weird book, guy talks about his exploits in ultimate online for like, almost a chapter before he goes on to explain about how you can hack the networking system for exploits.
   
   This book shows you how to implement a peer to peer network and then treat it like a server/client system. It's an interesting (I chose to just go strictly peer-to-peer in my system) approach. And I read in one of the Game Programming Gems a way to bypass some of the connectivity issues with peer to peer networks.
   
   Regardless, this book is an EXCELLENT study of networking for games. I read the networking chapter probably 20x during our project and it took me quite a while to figure out exactly what he was doing with it. In the end, it's a logical system that works fairly decently.
   
   We didn't use the rest of the code in the book too much. Some of the other people in my class modified the FPS game to do other things (made a shooting gallery, other's made some text based games on the networking code, etc).
   
   The source code is useful and there is an update available for it (his precious linked list had a memory leak in it... he really harps on about it).
   
   If you have never designed a game system before. This book is going to be a tremendous help. It teaches a bit about design patterns without all the unnecessary mumbo-jumbo, and how they directly relate to game programming and how they're useful (helloooo singleton).
   
   The code is in visual studio 6 I believe, and you have to set the default project to the actual project and not the engine to get it to run. Also, if your hardware doesn't support hardware vertex buffers (you have integrated graphics, we had a couple people on the team with this issue) you have to change one of the directX intializers to something else to account for this (can't remember the call now, look at some other directX init calls from somewhere else and you can find it).
   
   He goes into quite a bit of detail about each topic and the basics, and then delves down into the design of each system. It's very methodical and well thought out. AND YOU GET SOMETHING WORKING AT THE END!
   
   Do not get this book if:
   You are new to C++(you better have a CRYSTAL clear understanding of pointers and OOP, classes etc).
   
   You are not interested in engine design.
   
   You hate directX, or directPlay.
   
   You hate max; he uses 3dsMax to make the scene files etc.
   
   You are an industry professional that has a basic understanding of how a game engine works. This is definitely a n00b book.
   
   You expect to get your hand completely held at each step. He does skip over some details that are easily discovered if you delve a little into the MSDN or any other online resource.
   
   Get this book if:
   You are incredibly interesting in engine design and want to get your feet wet; as well as learn some engine design in the process.
   
   You're interested in any of the systems this book covers ( I can really only attest to the networking system, and that he uses directPlay, which is in sunset mode).
   
   Interested in basic modular programming and looking to expand the code in the book to meet your needs or to experiment with. It is an incredibly useful base to start with.
   
   Are extremely comfortable in c++/directX and are interested in expanding your knowledge and it's applications into games.
   
   Overall, the book was a good purchase and is an excellent stepping stone into engine design. It has been very useful in my future projects since I've used this book in my course work.



4. In general I'm very pleased with the book "Programming a multiplayer FPS in directX". It provides a very nice introduction on how to approach the task of building a complex 3d application for user with basic knowledge of C(++) and DirectX. Structured programming is important! It is nice that one has such a concrete result at the end of the book. The only drawback is that it could have a little more in depth treatment of certain areas, but hey, it is already almost 500 pages :)



5. To start with, I would say the reader needs to have some basic knowledge of DirectX before reading this book.
   
   This is not a book that "teaches DirectX with the goal of creating a First Person Shooter". It's a book where the author explains how his game engine/framework he built on DirectX works. It's not the type of book that explains to you step by step what is going on and tells you to add this piece of code here, which in my opinion, is the best way of teaching something. Rather, it's a book that lets the reader open up the source code in the CD/DVD and expect him to figure out where the code the author is talking about is located.
   
   Furthermore, the source code won't even compile cleanly in modern versions of visual studio.
   
   Now, if you want to learn how an FPS game engine/framework was created, perhaps you might consider reading this book. I would recommend you look forth to modern game engines and forget about the book, as the end game is not all that good anyways...
   
   So basically what I'm saying here is: 1. This is not a DirectX tutorial for newbies 2. The code/game is rather outdated.
   
   The author knows what he's talking about, though. The actual code is pretty good looking. He's got a great concern for proper memory allocations and memory cleanups. The game loop he designed is pretty consistent too, and very well thought of. My only regret is that, in my opinion, the whole "tutorial" part of the book was disastrously focused, which is a shame.

5 comments about The Joy of C, 3rd Edition.

1. Most books on programming that I have read use 'snippets' of code to demonstrate concepts. This is fine for someone with a grasp of underlying concepts, but useless to novices and students attempting to learn C for the first time. The main problem is lack of context... most of these 'snippets' merely demonstrate _syntax_ Joy of C uses samples that are part of an actual program so that the student may benefit from seeing how 'it all fits together'. The samples are not abstract, they are actually useful. Most of the exercises are extensions of previous programs, demonstrating the iterative process of programming where we take smaller programs that work and slowly add functionality. The authors have a website that provide solutions to many of the exercises, providing guidance when needed. Most of the code compiles and runs. The book covers alot of information, so some of the explanations aren't as detailed or simple as they could be. I believe that some basic grasp of programming concepts would make the book easier to digest, and would recommend it as a second book for students who have never done any programming at all. I highly recommend it to anyone with some programming experience as a means of learning C.



2. I picked up this book as someone with no programming experience to speak of. After working through it for a month, I thoroughly understood all of the major concepts in C. The presentation is thorough and interesting. While this wouldn't be my first choice as a C reference to have around, it is a good read (a feat for a technical book of this nature) which offers tons of examples of actual implementation of concepts. I would recommend it to anyone with an analytical mind, looking to break into the world of programming in C.



3. In passed three years, I have read the book at least five times thoroughly. The most exciting part of the book is the full of completed examples. The completed example means that the example is completed and you could compile it and see the result of execution from your code development tools right away. I.e., you don't have to figure out how a particular C statement or structure can be used in real world. If you prefer "learn by example," it will be definitively one of your best choices.



4. I just bought the book a month ago, but already had 3 other titles previously. The thing that impressed me the most is the authors' style of teaching. So many examples, carefully starting from the basics down to a more complicated version of it, adding little snippets that makes one fully understands why a certain statement do what it does when compiled and run. My only regret is that I should have bought this book while I was in college or before I bought the 3 titles before it. This is a type of book in C that made me think a lot about the logic behind each example's functionality even when I'm not reading it and always makes me compare it with the other titles. Now I'm really excited to finish the book and try all the examples and exercises that goes with it, because honestly, I'm not yet an advanced C programmer, so any help from any book is very well appreciated.

   Thank you Mr. Miller & Mr. Quilici for this wonderfully laid-out book.




5. Greak work on C but it needs fine tuning still. Written in a fearless manner by those who know what they are talking about.If you have no teacher to guide you then after going through this book a few times you should be competent in C programming.Combine this book with the C programming: a modern approach then you are prepared to fly even higher.After reading these two books the C programming language written by K&R should begin to make sense. It appears the authors have completely stopped work on the book.