5 comments about Writing Solid Code: Microsoft's Techniques for Developing Bug-Free C Programs (Microsoft Programming Series).

1. This is hands down, my favorite book on software engineering. If you care at all about writing quality code, you should read this book. The examples are in C, but the concepts (defensive programming, code that detects bugs, etc.) apply to any language. I read this book early in my career, and have re-read it nearly every year since. The used copies are 8 bucks, and the book is worth 10 times that in practical knowledge.



2. You may not be impressed when you see that this is a Microsoft book. You may get bored at the beginning when all the examples are C and most about memory management. But it's worth persisting and reading onward, because sooner or later, some of the examples will look familiar. Simple concepts about what kind of coding leads to more defects, and what kinds are "solid" or robust.



3. I would not read this book now but I'm so sorry the author does not write an updated one! This book really changed the way I wrote code.



4. This book has been recently recommended to me by Amazon based on my previous purchase habits and I decided to go take a look at its description. At first, I was little bit skeptic about the value of a book published in 1993 and prepared with Word for Windows 2.0 because software programming has changed a lot since then! However, it was a very low risk purchase because of its very low price tag so I decided to give it a try and I have been pleasantly surprised!
   
   This book is the proof that that there are few things in programming that are timeless. Errors of the past still occur today. The programming language used for the examples is C but what is taught is also applicable to C++ programming as well. Topics discussed in the book are: assertions, integrity checks, stepping through code with a debugger, how to not design interfaces that are error prone, avoid language features that are error prone and finally the author conclude his book by describing the attitude that a programmer should have. Among other things, a programmer should prioritize safe code before micro-optimizations. All these concepts are written in a style easy to understand filled with anecdotes that make this book a pleasant read.
   
   To conclude, I have not been blown away by the content of this book but I have learn one thing or two and I am glad that I have read it especially with its very low price tag.



5. This book quickly reminded me that the "old school" rules to software development will always apply, no matter how many new labels you put on it (e.g. Agile). It was recommended to me by a college professor aside from the regular classroom reading we had to complete. And I was more than happy I purchased it and added it to my bookshelf.

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.

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 Computer Science: A Structured Approach Using C++, Second Edition: A Structured Approach Using C++, 2nd.

1. From the back cover: "[...] no matter how powerful the language, it is still far too easy to write poor programs. [...]". The code examples in this book prove exactly this point.

   The authors mention the ISO/ANSI C++ standard and claim to follow it "wherever possible" (sic). However, they make so many false statements that I seriously doubt that they have ever consulted the ISO/ANSI Standard documents, or any of the excellent text books on modern C++ design and coding practice (Cline, Meyers, Sutters.)

   I believe (and I'm not alone) that in a modern C++ course std::vector should be introduced before arrays, and std::string before const char*. Not only are they safer, they are also *a lot* easier to use, and make it possible to come up with more interesting programming exercises than the endless array of meaningless numerical computations. Unfortunately, many instructors and authors consider std::vector and std::string to be "advanced topics", and torture their students and readers with the old stuff they had to learn themselves ten or more years ago. The authors belong to this category, I'm afraid: they learned C, and think that they know C++.

   Let's have the book speak for itself.

   Page 28:

   "While C++ allows declarations and statements to be intermixed, we believe that functions should be organized for readability. Therefore, we continue to follow the C organizational concept that places declarations first in a function, followed by its statements."

   On a related note, on page 40 the authors write:

   "One final point about initializing variables when they are defined: Although the practice is convenient and saves you a line of code, it also can lead to errors. It is better, therefore, to initialize the variable with an assignment statement at the proper place in the body of the code. This may take another statement, but the efficiency of the program is exactly the same, and you will make fewer errors in your code."

   (My comments:) It is commonly accepted by knowledgeable C++ programmers that the practice of declaring variables near the point of their first use in one of the things that makes C++ a better C. It is the old style that leads to errors (forgetting to initialize variables) and maintenance problems (variables that are no longer used, but are still in the declaration section). Furthermore, it is considered good style to prefer initialization ( int sum = 0; ) over subsequent declaration and assignment ( int sum; sum = 0; ). The former is always more efficient, and the difference can be substantial when dealing with large objects for which construction is expensive. You may argue that this is of no concern for beginning C++ programmers, but I disagree; habits, both good and bad, form early.

   --

   From the code example on page 363: bool binarySearch (int list[ ], int end, int target, int &locn){ ... }

   (My comments:) The first argument should be const-qualified: const int list[ ]

   Not only does this protect the programmer from inadvertently changing any of the values stored in the array; it also makes it possible to use the function with const int[] arguments (which would fail to compile with the original code). The const keyword is an important asset of the C++ language, and students should be trained to use it properly from the beginning. Using the Standard Template Library will drive programmers who are not aware of const-correctness issues insane. The book is extremely sloppy in the const-correctness area.

   --

   Page 119:

   "If a function has not been declared or defined before it is used, C++ will assume that you will provide that information when you link the program. Since there are no specifications, C++ will also assume that the return type is integer and that the parameter types correctly match the formal definitions."

   (My comments:) This is not true: in C++, functions have to be declared before they are used, and there is no such thing as 'implicit return type int'. C++ really is different from K&R-style C.

   --

   On page 195, the following insight is highlighted:

   "The else-if is an artificial C++ construct that is only used when

   1. The selection variable is not an integral, and

   2. The same variable is being tested in the expressions."

   (My comments:) No further questions here, your honor.

   --

   It gets really interesting when the authors express their ideas on Object-Oriented programming. They claim that Object-Oriented programming is just a different view, but that the implementation is exactly the same as in structured programming. They are probably misguided by their own example of an elevator simulation program (in the chapter on classes), which is simply a structured program wrapped in a class, and has nothing to do with OO.




2. Great choice for new students to programming.



3. easy to read, helpful excercises, a good book for those who want to learn C++ programing



4. This is the text for my C++ class, so I did not buy it by choice. It's terrible! The people in class who are new to programming are having a hard time. Often the authors use imprecise language. There are many errors of omission: sometimes there is backpedaling or an explanation later. It says a lot that the non-programmers in the class can almost always tell when a statement in the book isn't quite right, even if they don't know why it isn't right. You have to wonder if there was a technical review of this text. And I can't figure out how it got chosen as a text for any class anywhere.

   One, the authors did not mention which compiler they used to compile their program examples. Many of the programs do not compile in MS Visual C++ 6.0 as written in the text. The authors fail to mention you might have to modify the code to get it run on your compiler. For instance,
   cout << fixed;
   may have to be replaced with
   cout.setf(ios::fixed);
   or
   cout.setf(ios::fixed, ios::adjustfield);
   to run right in your compiler.
   They do finally talk about cout.setf in chapter 7 (out of 15). The program example downloads from the website compile; they contain preprocessor directives to make the programs more portable. I guess it never occurred to the authors, while adding those preprocessor directives (which DO NOT appear in the text), that some words about compiler compatibility might be helpful. Fortunately, I have C++ Primer Plus by Mitchell Waite; he addresses the compatibility issues as he teaches the syntax.

   Two, I often disagree with the authors' definitions. My favorite example: the statement
   x = 5;
   changes the value of the variable x to 5. The authors call this a "side effect." Huh? Seems like that's exactly what the programmer intends to do. Usually, I think of side effects as being more subtle than that. More like a function changing the value of a variable parameter to the function because the variable was passed by reference instead of by value (this could catch an unsuspecting programmer by surprise if he/she didn't check the prototype carefully).

   Three, some of the "good programming" tips would cause me to fail code inspections at work. This is a good thing, because they would make verification and maintenance a nightmare. Like not initializing variables when they are declared. I guess the authors have never seen weird things happen as an executing program tries to deal with the garbage in an uninitialized variable. Or maybe they just figure this is a good way for you to discover you forgot to initialize a variable before first use. It just might take a while to figure out that's what's going on since the results can be unpredictable and/or bizarre.

   I could continue, but I think I've more than made my point. I won't be standing in line to get the second edition when it comes out next year.




5. Spend your money wisely and get another book. This book is poorly written in what seems to be a foreign language. The phrase "it's Greek to me" certainly applies here. This book contains grammatical and spelling errors alike. The coding is incomplete and as a student of C++ I find it outrageous that computer science professors require this book as a textbook. All in all do not buy, try C++ Primer Plus.

2 comments about Data Structures and the Standard Template Library.

1. This may possibly be the worst programming book I've ever seen. The author has a habbit of talking about something, assuming you already have the knowledge, and then explaining it later, sometimes chapters later. Similarly, when using a class, Collins will state what the class is supposed to do, but not include the implementation until later, which would be good, but you've already been bombarded with so much other stuff you forget what the thing did in the first place. There are also no full examples included with several sections of the book, which are definately needed to learn the material.
   
   Finally, when it comes to the data structures (most of the book), Collins explains what they are, and shows pieces of code, but never full implementations. For example, he shows how to adjust a heap, and delete nodes from a heap, but not how to start from scratch. Also, he uses templates containing classes without telling the reader what they mean.
   
   I am currently a sophmore in a data structures class, and have talked with at least 5 students in my class. All of them agree that the book is absolutely worthless, as it only gives partial information that's hard to understand. If you're a professor, please think twice about choosing this book.



2. Paid about $100 dollars for this book only to find more bugs than a rainforest; frustrating since the author teaches at the university level but the code resembles that of a novice programmer.
   Do yourself a favor and go with another book. You're literally better off
   crumpling your cash money and throwing it in the trash rather than buying this disappointment.

5 comments about The Annotated C++ Reference Manual.

1. Well, I know it was out there. But I was referring other books most of the time. I paid for that. Many cannot answer questions like "Why the hell you need a COPY constructor in the first place?" or "Why Copy Constructor always takes a reference to the object as an argument". Here I found the answers. Again this is the BEST reference book available. If you are a serious programmer who wants to know in and out of C++, this is a must. I won't recommend this for those "POOR" souls who just want to be a C++ programmer.

   Again being a reference book, you don't have to read the PREVIOUS chapters to understand a specific topic. You may have to read couple of times to understand certain sections.




2. This book was good when it came out in 1990. It needs to updated to to the newer versions of C++. Other than that it is a good book.



3. This book was fairly complete at the time of its publication, but there have been so many significant improvements and new approaches to the C++ language that the book is outdated. I'd recommend this book only to people who are interested in a historical collection of C++ documents.

   I'd recommend any of the other Stroustrup books. "The C++ Programming Language," (3rd edition) is the closest thing to a bible for the language. (Don't buy the 1st or 2nd edition--they're also outdated. If you want a hard-covered reference, the "Special Edition" is a hardcovered 3rd edition.) I'd recommend "The Design and Evolution of C++," which is slightly outdated but both imformative and instructional to experienced C++ programmers.




4. This was "The" standard for creating C++ 99. Since then the standard libraries were added, a full implementation of templates and exception handleing etc. So while its a good reference for the "core" of C++, i.e. the classes etc, it shouldn't be the first book (or even the 2nd) on C++ you buy. Better to get the Hardcover "The C++ Programming Language (Special 3rd Edition)" which has chapters on all of the language.

   Note: That's not the first book on C++ you should get either, if you are just learning, it is however one you should own if you are going to profressionally write C++.

   On why there isn't a second edition of the ARM, has in part due to the restrictions for republishing the ISO standard. And its also 2003 and now the language looks like it will continue to evolve and thus a second ed. ARM would be soon out of date as well. Maybe we'll be lucky and there will be one for C++2005.




5. Yes it is outdated as it does not cover the latest features added to the standard. However it does describe in great details the core language and it is still the most detailed book about C++ to my knowledge after the C++ standard document text itself. Even the latest edition of 'The C++ programming language' book does not provide as much details about the language itself.

1 comments about Just Enough C/C++ Programming.

1. Are you a beginner or intermediate C and C++ programmer? If you are, this book is for you! Author Guy W. Lecky-Thompson, has done an outstanding job of writing a great book that provides you with just enough information on the subject of C/C++ in hand to be useful in the real world.
   
   Lecky-Thompson, begins by showing you what the tools of the trade really are, some of the basic concepts related to the programming process. Next, the author focuses on the programming primer. Then, he covers some of the various concepts that make up the typical C program. The author continues by showing you how information is stored in a program. In addition, the author introduces you to Console I/O--showing you ways to get information from the user and display it on the screen. He also shows you how to selectively perform tasks based on the outcome of preceding tasks, which is vital in programming. Next, the author covers mechanisms that are available for task repetition. Then, he covers standard libraries. The author continues by providing you with a detailed explanation of how programs process incoming arguments; and, how you can create functions within your programs. In addition, he deals with file I/O--which deals with ways to process files and perform external data storage. The author also shows you how you can create your own templates for storing information. Next, he looks at pointers--which is an advanced programming topic, but necessary for understanding the bridge into C++. Then, the author looks at pre-processor directives--which detail how you communicate with the program charged with taking your code and turning it into an application. He continues by discussing the extensions to C that make C++ a useful language. In addition, the author gives you some direction as to how you can go about using all of this information. Finally, he provides a list of all the various useful Web references.
   
   This most excellent book provides vast amounts of reference material. What's most important though, is to use the source code from the companion Web site, and click on the Downsload button.

5 comments about Data Structures in C++: Using the Standard Template Library (STL).

1. We have used this book at our University, but it doesn't provide any answers, actually it gives more bugs than answers ! I advise NOT to buy this book, there are other books out there which are a lot better !



2. I used this book in a Data Structures course, and it turned out to go pretty well. It covers all of the data structures in the STL (vectors, queues, strings, lists, etc.) in addition to some things not implemented (trees, hashes, etc.).

   The nice thing about this book is for each data structure, it broke it up into two sections. A look at how it was implemented in the STL and also a look at the interface and how to use it, along with examples. In our course, we focused on how to use it (why reinvent the wheel), but it was nice to know how it works as well.

   Budd also provides a nice quick sheet for each structure so when you are writing programs, you can refer to it and know immediately how to use that structure.

   Be forewarned, some of his code has errors. You can download fixes for some at his website (listed in the book). Not all code has fixes on his website, but you should be able to fix them yourself after reading the book.

   One final note, I was able to use most of the code in this book with both MS Visual C++ 5 and Borland C++ 5 with only minor modifications.




3. Actually this book is nice. This is the only book I use to learn STL C++ beside the Stroustrup's book. But, the only reason I bought this book was that this was the only STL book available in my local bookshop...;-)

   I am really irritating in the way the author targets the readers. If you have programmed using C++ before, this book is NOT for you. This is really for second year Computer Science student who learns Basic Data Structures (List, Tree, etc.). It would be too slow for you and not give you much information. Sorting algorithm, binary tree implementation, and other data stuctures and algorithms are covered too much for an STL book, but too little for a data structures book. And finally, the price is too high. My suggestion is if you really love data structures and algorithm , buy other data structures and algorithm book (not this one), if you really want to dive deeply to STL C++ , buy other C++ books. If you would like to do both, maybe this book is for you.

   I do not give this book 2 stars because this book has also useful information and I put this book on my shelf too, just beside the Stroustrup book.I do refer to this book more than the other one because I could only access to the French version of the Stroustrup book...;-)




4. This book did provide some usefull expamples of C++ STL, but overall it is the worst C++ book I have ever read! I only have it because it was the required text for my Data Structures class. The Index is worthless! Many poor explanitions! There are fare better books out there for STL.



5. Provides a well thought-out and organized overview of fundamental data-structures in the STL. Most frequently used member functions are clearly described and summarized at the end of each chapter. One of the few books on the subject that strikes a balance between showing how data-structures are implemented while still providing practical information so you can use the STL in your own code.

5 comments about C++ Coach: Essentials for Introductory Programming.

1. Very little of the code in this book is written according to the ISO C++ Standard. The author seems to have learned by experimentation, and makes basic mistakes. Fundamental parts of contemporary C++ (such as namespaces) are not covered (well, the one allusion to namespaces dismisses them as an annoying quirk of modern compilers).

   Your money would be best spend elsewhere.




2. This book clearly is aimed at non-technical programmers--that is, people who will work in IT, not CS, for a living. The drills were a cool way to master language concepts. The author presented the language details in a way that I could grasp. For example, functions is broken into a series of small, more predictible functions that were understandable. If you want a non-intimidating book to learn C++, this is a good one to have.



3. My tech school teacher is using this book to "teach" us C++. I already know C++ myself, and this book is HORRIBLE. ALMOST EVERY SINGLE PROGRAM HAS ERRORS!!! If I'm exaggerating, it's not by much. If I could give this book a custom number of stars, I would RATE IT A NEGATIVE NUMBER!! A majority of the programs DON'T COMPILE without MODIFICATION TO THE CODE. If you don't know C++, you WON'T HAVE THE KNOW-HOW TO MAKE CHANGES THAT ARE NEEDED TO COMPILE ANY OF THE PROGRAMS. One exercise looks like the author thought he was programming in BASIC: there are no semi-colons to end the statements, and the if else statements looked like BASIC. I apologize for my annoying caps review, but I want to make sure that NOBODY BUYS THIS BOOK. WHATEVER YOU DO, FOR GOODNESS' SAKES, DON'T BUY THIS BOOK!!!! I don't care what the other readers say, listen to the negative reviews: they know what they're talking about. Oh, and DON'T BUY THIS BOOK!!!!



4. I know the author myself, because he is one of my teachers.The book is horrible, don't waste your money. Every program he give as example has mistake. Spend your money somewhere else, and don't let the stupid Salvage guy get your money.



5. We used this book for my introductory computer science class. Going into my computer science class, I already had four years experience of C++ programming and asked the instructor whether or not I needed to purchase the book. Since I was so experienced, he told me that I would probably only need it for the additional exercises and programming assignments that are in it. So I decided that I would just borrow someone else's book for the assignments and I'm glad that I did. In just about _every_ additional exercise there is at _minimum_ two syntax errors. Sometimes the function prototypes wouldn't have the data type in them or sometimes they'd call functions with nonexistant parameters! It was just horrible to look at. Even worse, I don't see how the students that didn't know C++ could actually learn it from this book since just about every example in there is so errant. The only reason I rated this book as one star is because there is no zero or negative star option. If you are taking a class and you plan to use this book, do yourself a favor and purchase a half-decent C++ book that has examples that will actually compile. This book is evil, avoid it like you would the black plague. DON'T GO NEAR IT! You have been warned!

5 comments about Embedded C.

1. I believe the real title of this book is more like "Introduction to embedded systems programming and software design with 8051 using C". Most of the C and C++ programmers will not find anything more about the C language they do not already know. The author claims that the target audience is desktop developers with C++ and Java programming. Probably this involves a portion of this programming crowd, who have not done any low level programming and are relying on existing libraries or have very little experience. One obvious advantage of the book is its clear style. The touch of many important topics and well selected examples from very small to a decent size projects is another plus. Selecting a well known microcontroller flavor (Intel 8051) is a plus, for the specific points that could be illustrated when one has to use such a cheap and not very powerful device for a project. The choice to demonstrate the examples with the Keil development environment makes it very convenient for the reader to follow the text. For the experienced embedded programmer most topics are pretty well known and they may find the style very easy and not so rich in new information. For example interrupts are not discussed until chapter 7 and the book has 4 more chapters. The users of bigger microcontrollers ,16 and 32 bit, may find that the code does not cover some of the more complex issues they have to face in their software designs. I am mostly refering to the developers creating code for Motorola 32 bit and the ARM family. Looking forward for the forthcoming book "Embedded Operating Systems" from the same author due for publication Jan, 2004.



2. This is a good introduction to Keil's C51 compiler. I have 1 year experience writing PIC code using CCS C compiler. My latest project is to develope 8051 microcontroller firmware using Keil's C Compiler. The documentation provided by Keil is limited and confusing, not a good one to beginner.

   "Embedded C" is definitely a rather good introductory book to Keil's C51 compiler. It is suitable to reader who already has knowledge of C programming. In this book, some special features and instructions are explained, such as sbit and the I/0 pin (which bother me the most in the beginning stage, as 8051 I/O is different from PIC and Motorola).

   Furthermore, the author also introduce the Real Time Concept, RS232 etc which differ the Embedded C with the desktop C. This is especially useful to beginner of embedded programming.




3. As a desktop applications programmer this was a good introduction to the embedded world for me. Whenever I try to learn some new technology, there always tends to be a knowledge gap that needs bridged. Once it has been, I am able to start using whatever that technology is. I feel this book is my bridge for learning to write code for embedded systems.
   
   When I first bought the book, I would just try to read it from chapter to chaper starting with chapter one. I've started to read it several times. This method, I now realize, was a mistake as there is some terminology that doesn't make sense even to a seasoned programmer such as myself. Embedded systems are quite different from building applications for an operating system running on a robust microprocessor.
   
   I found that what I should have done from the start was to install the demo compiler from Keil and the project examples. Once I did this, the book really started to come to life as I could step through the code with the debugger and see what was really going on. I got through the first four chapters with a strong understanding in the very first evening I did this.
   
   The book seems to do a good job of covering all of the main topics you would want to know about. It is not short on examples which is a great feature. I, do, however, have a single complaint. In chapter 5, Pont talks about code organization. Now, while I feel that this is a reasonable things to learn, for someone who is just getting started with embedded programming it would have been better to save that as a bonus chapter at the end and instead let all of the preceeding chapters contain everything in a single file. I'm not suggesting that it's a bad idea to organize your code. I'm simply stating that I was able to understand the first four chapters much quicker because I didn't have to jump around from file to file to figure out where a certain function or variable had been declared. Some might complain that keeping all of the code in a single file would create "spaghetti" code, however, for learning purposes, I feel this is a reasonable trade-off. Not to mention, the code examples are not terribly long.
   
   In the end this book has been really great. The prose Pont uses is very approachable and he does a good job (especially at the beginning) to explain what is happening in the code. I definitely recommend this book and the 8051 is a great choice of processor. There is a lot of sample code on the web and it is a very well documented MCU. Plus the tools for development using this chip are very inexpensive as are the chips themselves.



4. This may be the best technical book that I've ever read, and I've read a bunch. I can't say enough about Dr. Pont's accomplishment with this book.
   He clearly and concisely takes the reader/student through the basics of programming embedded devices. He uses the 8051 with the Keil compiler as an example platform and provides adequate code listing examples. If you're an embedded guru with decades of experience in microcontroller programming this book may not be for you. However, if you're one of us, from a computer science background, whose embedded experience comes from programming at the application level, then I highly recommend "Embedded C" without reservation.



5. This book covers the basics of embedded programming on an 8051 microcontroller. It is very easy to read and understand and comes with an evaluation version of the keil compiler. Simulation software is built into the compiler so you can test your code on a simulated 8051 device. This is a good book for a beginner to embedded programming.