Product Description
If you liked his first C book "Beginner's Guide to Embedded C Programming" then you will love this one. In this "Volume 2" Chuck takes the reader to the next level by introducing how to drive displays, how to use interrupts, how to use serial communication, how to use the internal hardware peripherals of the PIC16F690 Microcontroller such as SPI, PWM and Timers. He even introduces how to drive a stepper motor for those looking for electromechanical design help. He tackles these topics with his typical down to earth style of writing that makes the reader comfortable as they learn what some consider very difficult topics for the beginner. In addition he continues to use the very powerful HI-TECH C compiler in its free Lite mode so the reader can program along with little or no expense. This is a great companion to the "Beginner's Guide to Embedded C Programming" but also stands well on its own. ... Read more

Customer Reviews (3)

Excellent
Have now going over all experiments in this book and will recommend this book for beginners how wants to learn High Tech C for PIC Microcontrollers.The book is very easy to follow and gives a good start for programming PIC's

A place to start
With a lot of books about microcontrollers on the web sometimes is hard to pick one that fits the needs of starters. And it is harder to find a book that addresses the most important thing; low cost but pro solution to jump to the embedded world. In this book advanced topics are covered, like interrupts timers and communication but always in a practical point of view.

Excellent when combined with Vol 1
This book completes the set. It is the best introduction to C programming for the PIC16 series. It covers all the topics not included in Vol 1, with one glaring exception, keypads and keyboards, but there are plenty of other books that cover keypads. ... Read more

Product Description
Introduces the SPARC assembly language and provides understanding of the complexity and cost of using various data and control structures in high-level languages.Includes the latest material on the new Ultra SPARC architecture. Softcover. DLC: Reduced instruction set computers. ... Read more

Customer Reviews (13)

Straight Forward SPARC
I needed this as backup for an assembly programming course and it was a great help. It's pretty straight forward and basic, but it could go more in-depth and may not serve all that well as your only source for assembly language programming.

Dated but remains an excellent source of reference
This book is excellent considering the time it was produced and definitely an superb piece of work.

But an update is needed as technologies have progressed much over the last 8-9 years; e.g. Sun Microsystems have incorporated the GCC compiler into their latest architectures like the x86-Opteron; to compare and offer new perspectives on the subject maybe advances in compiler technology, if any etc would be terrific.

Confusing
I picked up this book to familiarize myself with the SPARC architecture for an upcoming project and I was extremely disappointed in the presentation of the material, both grammatically and intuitively.

First, when learning assembly language, the last thing a reader or student needs is the code to be obfuscated by a preprocessing tool such as m4. Hiding address offsets and variable alignments in nearly impossible to decipher macros is NOT helpful. This does not make it easier to learn assembly. I found myself learning more about a tool that I'll never use after finishing this book than about SPARC assembly.

Second, whoever edited the manuscript for this book should be fired. I found myself editing the book as I read so I could understand what the author was trying to say. I also found the language to be a bit obtuse in a few, unfortunately important, places.

Third, the diagrams in the book need some serious help as well. They were almost useless. Many of them made the topic being discussed more confusing. I found myself using Wikipedia or the Sparc V8 manual more than once.

All that said, the book does try to cover the important aspects of the SPARC architecture. I did get the needed information from the book, but it could have been organized and presented much better.

The book could be a great SPARC reference and tutorial book if these problems were addressed in a future edition.

Terrible!
I'm sorry, this book is an abomination! It makes a simple thing difficult. Students, prepare to suffer. This is one of the only SPARC books out there.

very clear, down-to-earth style
This is one the best books I've read on computing. The presentation is down to earth, as in "here's how a computer do such and such, it's not thaat difficult, see?' which i like very much. It's a complete contrast to Hennesy & Patterson's 'Computer Architecture', which spends most of its pages surveying grand technologies this and that without really getting down to details. If you like to understand & build things yourself rather than admiring other peoples 'technologies', I think you'd like this book. For me, it's also a great place to learn how to write a compiler, because the approach is clear & simple, not overfed with formal-language theory that's the norm in compiler design texts. ... Read more

Product Description
Provides in-depth coverage for true MFC mastery, Document/Viewarchitecture, object-oriented techniques, bitmap graphics and databaseprocessing. ... Read more

Customer Reviews (54)

Good book for MFC introduction...
I bought this book to find out how to use MFC in Visual Studio. I already know C++, so I only needed to have a guide for MFC. This book starts with creating a MFC program from scratch. Then it goes into using Visual Studio's project creator. I found learning how MFC works under the hood also helped to know what the projet creator had made for me. Doing simple windows programs are easier than ever now.

The right book to start with MFC programming
I have found this introductory book very useful to start with Windows desktop applications development. Although it is quite outdated and uses Visual Studio 98 as build environment, it guides you through the basics of the MFC framework (main classes, dialogs, graphics, document/view architecture) and Win32 programming in general (messaging, maps, data types), leaving room for personal development in the exercises after each chapter, and providing in-depth coverage of advanced topics like bitmap manipulation and database access for the advanced reader. With an additional introductory chapter on COM it would have been perfect.

waist of money
I waisted my money buying this book. It should be sold less than 1 dollar. You don't get far using this book. I recommend the book by Ivor Horton.

good seller, definitely recommend
Shipping is prompt, and the item is in good condition as described.

Excellent Intro Book!!! Best Programming book ever read
This is the best programming book that I read from page 1 to the last page. I hope Jones can write more books on MFC or Visual C#. Not only did I learn MFC concepts and programming skills, but also I found Chapter 1 and 2 are very useful because they are basic and fundamental to C++ that I sometimes forgot. I love the pace and layout of this book. User-defined messaging and modeless are explained in a very nice way. The Appendice are very useful too.

I give this book a full 5 stars. ... Read more

Product Description
Do you want a low cost way to learn C programming for microcontrollers? This book shows you how to use Atmel’s $19.99 AVR Butterfly board and the FREE WinAVR C compiler to make a very inexpensive system for using C to develop microcontroller projects.

Students will find the thorough coverage of C explained in the context of microcontrollers to be an invaluable learning aide. Professionals, even those who already know C, will find many useful tested software and hardware examples that will speed their development work.

In addition to an in-depth coverage of C, the book has projects for:• Port I/O reading switches and blinking LEDs• UART communication with a PC• Using interrupts, timers, and counters• Pulse Width Modulation for LED brightness and motor speed control• Creating a Real Time Clock• Making music• ADC: Analog to Digital Conversion• DAC: Digital to Analog Conversion• Voltage, light, and temperature measurement• Making a slow Function Generator and Digital Oscilloscope• LCD programming• Writing a Finite State Machine

CD contains all the source code, the free WinAVR C compiler, AVRStudio, and lots of other useful things. ... Read more

Customer Reviews (17)

C Programming for Microcontrollers Featuring ATMEL's AVR Butterfly and the free WinAVR Compiler
Very poorly written book.Just a headache to get started.Many mistakes in the book that the author pays little attention to.Don't buy this book to learn AVR.Just get CodeVision AVR for $220 and free AVR design Studio4 from the AVR website and learn the way you would be doing things in real life.Some of the stuff is ok in the book but it is not the way to break into the AVR microprocessor world. Working with makefile etc is real cumbersome and you must have some prior exposure to the micro-controllers to follow the author of this book.Best way to learn AVR is, in my opinion, to get codevision, get one board with a AVR micro from ebay that will come with a LCD and a few programs to play with.Check ebay for premade boards with AVR ATmega16, 32 etc.That would put you in real learning mode on a fly.The author of this book must be an unemployed person just looking to make a quick buck. I am an experienced designer and i have had nothing but a headache reading this book.Everyone shouldn't write books.When you open the CD that comes with this book the first thing that you will notice is the corrections file.And that means that now first thing you have to do is to go to each page with mistakes and correct those mistakes before you even begin the learning and exploration process.This author will take you around the corner and spank you and then bring you back dazed and confused.You want to learn AVR from this guy?Forget about it.Just follow what I said and you will learn the right way.No, shortcuts that the author proposes in this book will get you working in the real world of microprocessors.

Best wishes and a happy learning.

Felix Khan
Tucson, Arizona.

Great tutorial and project book!
I got started in C and AVR with this book. I found other texts harder to understand. But Joe broke it down and made it easy to learn and I was very grateful for having this book. The projects were fun and useful and I ended up immediately using code and ideas from the book to create more advanced projects with the Butterfly (Turns counters, resonant frequency tuners, etc). You should be able to get up to speed and writing your own advanced functions after following this book within one week. If you are already adept at C then this book will show you some fun project ideas and get you running fast.

Advice for the prospective buyer
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.

Not very helpful at all
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.

wealth of info - even without background
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. ... Read more

Product Description
Written by a master teacher and author of the highly acclaimed The Art and Science of C, this new book helps students master the fundamentals of data structures while encouraging them to develop strong software engineering skills. By emphasizing modern programming concepts such as interfaces, abstraction, and encapsulation, the text provides an ideal foundation for further study of programming. With his clear explanations and engaging writing style, Professor Roberts leads students through the CS2 curriculum in a way that captures and holds their interest throughout. ... Read more

Customer Reviews (13)

angry
just got this book havnt read
but angry with amazon
just bcz its 10dollar cheaper if i bought from sweden, so i decided to buy it from amazon
but the book is really broken when i got it.
and the most angry thing is i even doubt that wether this book is a right copy one
since i also have another book The art & sience of java which i got in sweden.
i compare those two books, just found this book is really bad print quality, so i really doubt what happened to this book.

Programming Abstractions in C / review
haven't gone through all the material yet- but have browsed through the book and related syllabus.

For starters- this is a book that was [and may still be] used at Stanford.You can even get course videos and handouts etc... from Stanford Engineering Everywhere web site-

[...]

This book is for the CS106B class- and at a quick glance- it looks like there are a set of libraries that are used [similar to the intro CS106a java class] that provide the amateur student with a framework to make simple gui programs- stuff that looks more intuitive than the traditional intro CS class while delving into some pretty meaty topics.

The main reason to get this book is because the corresponding lectures are available online from a respected university along with applicable lecture notes and assignments.

Expected better
I was really disappointed by the purchased item. I expected a regularly printed book and I got something that looked like a photocopied version of the original. Quality if paper is marginal, designs are in black and white instead of the very nice green-blue of the introductory book by the same author.

In any case, Amazon's website should reflect the quality of the interior, and clearly state what you buy for your money: $91.20 is way too much for what I got (i.e., not a real book). I really need the book, otherwise I would have returned it.

Precise, yet gentle intro to Abstract Data Types (ADT)
This is the best book I can recommend on abstract data types to beginners and refreshers alike. Written from somewhat academic perspective, it does a great job in instilling the concepts of abstraction and encapsulation. These are the basic principles behind Object Oriented programming. The author uses C, its a remarkable text on how to write "Object Oriented" like programs in C, but without relying on OO features of C++. Unless you know the underlying principles as explained in this book, it is just as "easy" to write bad OO programs in C++ as it is in C. Personally, I found the chapter on recursion the best. Explanations on recursion are simply the best I have yet seen. Now, I can do magic myself with recursion! Great job. I wish I could sit in his class. Is he planning to write more books for us ordinary mortals?

Great book! The "SICP of C ?"
Haven't worked through the whole book yet, but I will say that I have other C or imperative-paradigm data structures book.
The topics are very meaningful: thorough emphasis on recursion (usually misunderstood by C programmers), backtracking (in games - yes, fun!), graphs, trees, that is, the standard gammut of topics, but all written amidst a very interesting text that makes a person who loves programming to never let the book down, because of all the /usefull/ stuff that's in it. For instance, he uses an editor as the common thread to discuss buffers, then implents it using arrays, stack, and linked lists. You end up having a /practical/ introduction to those issues and the implications therein. This is not "practical" in the sense that it's "dumb". This is "real" as in "real GOOD, USEFUL, WELL WRITTEN, WELL DESIGNED" code. C hacking as it should be done.
The code is written in crystal clear style (which is amazing for a C book), the author is keen on abstraction and library reuse. The excercises are great, and not dumb and mechanic.
There isn't any book like this one for C out of the several that I've seen.
If you want to learn C, after you learn the basics, this is THE book. I guess the other reviewer is right when he says that this must be the "SICP for C." And if you know anything about programming, you know that this is a big compliment.
The author is an Applied Mathematics graduate from Harvard and a professor at Stanford.
An excellent, excellent text! Addictive reading! ... Read more

Product Description
Your ultimate guide to building graphical Linux UNIX applications with Gtk+ 1.2. Includes comprehensive coverage on Gtk+ 1.2, GLIB, and GDK. Softcover. ... Read more

Customer Reviews (4)

Sensible Reference for Gtk+-1.2 outside of GNOME
This book has a fairly clean layout. The index is a bit tepid, but Ok. So far, for content, the book is slightly better than the other two books I have seen. Donna Martin's doorstop for SAMs is pretty good, but a bit winded. Eric Harlow's book is also good, but too lean. I see a Jack Sprat pattern there.

I consider this book a good reference, not a tutorial. I like a book that does not waste too much time on the ubiquitous 'Hello World', crawling its way up to an excruciating sample application. I do not have an affinity to that style; Even for tutorials. Usually open source is replete with examples anyway.

I often judge a book by seeing if it can quickly answer a specific question, which did not immediately leap to my attention, from the standard Web docs. How do I change the text label on a button? What do the arguments really look like? Having figured it out already, I noticed this book answers the question right out of the contents page and on page 179, with an example of the proper object property arg "GtkButton::label". It is more pleasant to learn from brief working examples, than syntax diagrams and source code.

Another feature that jumped out was the "API Synopsis" sections. Fast, single sentence descriptions followed by the API call, on a class by class basis. Nice touch.

An IMPORTANT note on ergonomics, which you cannot possibly experience by clicking 'What's inside':This book is fabricated with the same lightweight, semi-gloss, low-acid paper that another one of my favorite books, Stroustrup's C++ opus, is published with. This means the book is thinner, taking up less shelve space. More importantly, the pages turn easily, indexed by finger, and when browsing the inner meat of the book, it stays open without coaxing. This means I don't have to constantly interrupt my browsing both machine and book to crack the binding. This kind of babysitting quickly vectors toward the intolerable, in particular, with the big, cheap doorstops. Good reference books need to be browseable in random fashion, right out of the shrink wrap.

A note to Logan: Nice job. On the second edition, put a bigger index in the book. It might be nice to see your "Synopsis" block style description of the most popular signals for widgets (table 4.2)and containers (table 10.1) in the signal chapter, as well as the classes. It saves flipping.

Good Reference for "Real World" Programming
My first impression after I purchased this book was that it would have limited usefulness.However, after about two weeks on my first GTK+ project it became clear that it was actually the most useful of three books I had purchased.After having this book for more than a year, it is what I turn to about 85% of the time when I have a GTK+ question.If this book has a weakness it would be that it doesn't mention much about the GNOME desktop.However, for "real world" programming on a GTK+ based project that will last more than a couple of weeks or go beyond the basics, this book is a timesaver.I also have the book by Peter Wright that covers GNOME and is a fairly useful supplement to this book.

overly tedious with no real target audience
First off, I'd like to explain why I'm judging this book so negatively. I gauge all computer texts against one of the best instructional books I've come across in my 12 years of programming; "C Programming: A Modern Approach" -- by K. N. King. This book explains the c language with out using too much jargon....

"GTK+ programming C" on the other hand is so jargon laden, it becomes tiresome before the first chapter is even complete, and what's worse, no "target audience" is ever addressed. This book is not for a novice in any way shape or form (though the back cover would lead you to believe otherwise). I'm not a novice, but I'd rather spend my time reading an instructional book with a little personality rather than one that seems straight from a man page, but enough of my opinion laden book bashing let me back up some of my accusations:

--Jargon (this is straight from the book BTW)--
"Gtk+ (via Glib) allows applications to load shared library code at runtime and execute routines that the shared library exports." say that three times fast. Again I'm being a little more critical of writing such as this because no target audience is ever specified. A novice programmer might find a sentence such as this a little confusing.

Another point of contention I have is the lack of GOOD example code. The book is seeded with function definitions, and code snippets throughout, but has very few actual examples to drive the new information home. As an example lets look at chapter 3 (Signals, events, objects and types). This chapter is about 50 pages long and is devoted to the functions that allow a Gtk+ program to interact with the OS, but this entire chapter (Very important subject matter) only included 2 (that's right TWO) working examples. Oh, the example code isn't commented either!!!

A) That is a poor programming technique in general, and
B) Comments in the code help those trying to learn the language to understand the what's, and why's, as they read the code (or type it in)

Anyway, I could go on like this for some time, but I think I've made my point. Novices and maybe Intermediate programmers stay away. Strong intermediate programmers, or better, looking for a REFERENCE, not an instructional manual, this book might be for you.

Great GTK reference
When it came time for me to make the transition from the nice and cozy world of Windows/MFC to X Windows, I started to scrounge for an X toolkit to develop applications on.As a result, I searched for decent documentation.

This book tries to be a primer and a reference, but it really only succeeds as a reference.This book covers the straight GTK code from a C perspective, and documents most of the basic widgets.

With only this book, you will find it difficult and tedious to produce usable applications.

However, armed with glade, a glade tutorial, and this book, you can be as productive in designing X GUIs as a Visual Basic programmer.

Highly recommended. ... Read more

Product Description

Considered a classic by an entire generation of Mac programmers, this popular guide has been completely updated for Mac OS X. Don’t know anything about programming? No problem! Acclaimed author Dave Mark starts out with the basics and takes you through a complete course in programming C using Apple’s free Xcode tools. This book is perfect for beginners learning to program. It includes all–new Mac OS X examples!

• Provides best practices for programming newbies
• Written by the expert on C–programming for the Mac
• Presents all the basics with a pragmatic, Mac OS X-flavored approach

Customer Reviews (23)

Good up-to-date C primer
This isn't quite the caliber of Greg Perry's "Absolute Beginner's Guide to C," but it is a worthy effort and does quite well in teaching C basics.There are some inconsistencies in difficulty level, however.For example, some topics are presented in a very beginner-friendly way, while other topics that are difficult to understand are quickly or not thoroughly covered, though you're expected to understand them.

All-in-all I think it's a good primer for someone getting ready to learn Objective-C.

Zero Interaction
I'm on chapter 5 of this book right now and I'm having trouble mustering the will to contuine.

I have taken it upon myself to teach myself computer programming. Most reviews for this book touted it as excellent for beginners. However, I am finding it to be contrary.

The book has conveyed a lot of key ideas very well, but instead of having you write out the code you're learning and then testing it, the book provides complete examples of mini-programs.

This is a terrible way to learn this material.

The book should be formatted such that it explains what the basic parameters of a C program look like.

Like:

#include

int main () {
}

Then they should explain what each of those parts do and mean. Then the student should add small chunks at a time, altering the previous code. Instead, it gives you full code and hopes that you can remember everything that was taught without having practiced it yourself.

This book MIGHT be good if you remember everything you do without having to interact with it first, but for the normal human being who can socially interact with others, this book falls short of its potential.

A Good Foundation for Programming in C based languages
I actually did this sort of backwards. I got halfway through "Beginning iPhone Development" and realized that I needed to learn more about the basics of Objective-C. Therefore, I went back and read through "Learn Objective-C on the Mac". With that I was able to get some working prototypes of apps on the iPhone. However, whenever I'd look at some bits of code, there were things I knew to do because I saw other code do it, but didn't really understand why I was doing it.It was then that I realized I needed to stop playing around and get serious about learning the C language.

I came to this book thinking, "Alright, I'll learn a thing or two, but I know most of this because I'm actually making apps already." Boy was I wrong. Sure this book went over a lot of programming stuff that I knew (if statements, expressions, etc) but it also pointed out a lot of stuff I didn't realize about C.

The main reason I came to this book was to answer some pretty basic questions about pointers.

I see the snippets of code below and wonder, what's the difference?

int* myVarName
int * myVarName
int *myVarName

How come I see the ampersand sometimes?
myVarName = &myInt

What does this arrow thing mean?
myVar->someElement

Therefore, I was very grateful when I realized that there was an entire chapter just on pointers alone. It's been over 10 years since I've used a language that supports pointers, so I definitely needed the refresher. The book answered all my questions and some I didn't even realize I had yet. If you're having problem understanding pointers, get this book for that reason alone.

This was also my first tech book on the Kindle. While the source code snippets was a bit small in a few instances, most of the time there was nothing I missed about the physical book. In fact, I liked being able to review the pointer chapter again and again throughout the day on my iPod Touch. If I had bought the physical book, that simply would not have happened.

Excellent Book
I am already a programmer but new to C. I recommend this book. It explains code and the initial set up in detail. Some people may think it has too much detail but I'd rather have more than not enough. I find C tedious compared to the high-level languages I have been working with (COBOL and Natural). This book does a great job explaining the concepts and the codes so it has helped. The author is thorough and uses a bit of humor and keeps the reader engaged. He doesn't use too much humor and that's good. I don't like books that appear to be 'childish'. Anyway, this is a wonderful book and I enjoyed reading it and learning C.

Elementary, brief and little to do with Mac OS
Recently I downloaded Kindle for the Mac, and out of interest I chose the Kindle version of Learn C on the Mac to experience Kindle in action. The Kindle version did not display any book page numbers which was immensely frustrating since it was hard to gauge where I was in the book without referring back to the table of contents. Not a satisfying user experience.

The book itself is a little higher in quality than complete drek but by a narrow call. Most of the code is built around creating a DVD library - using the terminal for all input and output - a very historical if not dated approach more suited to a 386 PC from the 80s. It is a very simple project, too simple in my opinion for what the Mac has to offer. Code slices are available from the book's website. A long list of bugs are reported by readers on the website along with author responses. Some of the bugs are just down to bad proof reading, but others are more serious. e.g. operator confusion. Towards the end of the book, a short piece on binary trees and searching is preceded by an even shorter piece on recursion (using factorial as exemplar). The author professes himself a fan of Knuth's work so surely something more substantial could have been presented.

In summary the book takes one straightforward terminal focused I/O application and uses it deliver brief illustrations of C constructs and mechanisms. Apart from a couple of screen-shots from XCode at the beginning, a reader could be forgiven for thinking they had stumbled into a time warp of C presentation from 20 or more years ago. Objective-C and Cocoa get mentions that are so brief as to be useless. The 'Mac' component in the book in my opinion is irrelevant.There are better C texts, more substantial and more challenging. ... Read more

Product Description
This new book is carefully designed to teach C language programming as it applies to embedded microcontrollers and to fuel knowledge in the application of the Microchip® family of PIC® microcontrollers.Coverage begins with a step-by-step exploration of the C language showing readers how to create C language programs to solve problems.PIC processors are then studied, from basic architecture to all of the standard peripheral devices included in the microcontrollers. Numerous worked-out example programs demonstrate common uses for each of the peripherals.Readers are subsequently introduced to the built-in functions available in C, to help speed their programming and problem solving.Finally, readers are taken through use of the C Compiler, and learn to efficiently develop custom projects. ... Read more

Customer Reviews (5)

Not quite what I had hoped
I had high expectations for this book and unfortunately it didn't deliver like I had hoped.I was trying to learn how to program PICs in C and this book starts its tutorials with the classic printf("Hello World"); example.This isn't useful for an embedded design since my PIC doesn't have a printer or monitor attached to it yet, so I read the rest of the book and did the exercises in text without actually doing any programming.The final chapter assumes that you have C programming down by that point so it is dedicated to the fundamentals of how to organize a project, which is a huge system design of an electronic scooter using the CAN bus.Overall this whole chapter/project wasn't all that useful or interesting to me, so I skipped it.Though I read all of the text and did the exercises, at the end of the day, I still couldn't program my PIC in C.I had a decent understanding of syntax and such when I got done, but it wasn't until I read Martin P. Bates book Programming 8-bit PIC Microcontrollers in C: with Interactive Hardware Simulation that I was able to actually get anything written in C to load into my processor.

That said, this book does what it says it does and addresses C programming for the PICs and not a computer.I have found it useful for giving more in depth explanations of what is in the CCS users guide.

I am giving this book 3 stars because it is quite expensive and has turned out to essentially just be a supplement to the CCS documentation, which is already really good, so I doubt that I will be using this book that much.

A rare tutorial for using C on the PIC
Unlike most PIC books which focus on coding in assembler, this book uses the CCS C compiler for all of its examples.It provides simple solid C examples that show what needs to be done.An embedded C tutorial in the front of the book reviews the language.Excercises (With some solutions in an appendix) at chapter end help you know what you understood and where you need more work.The appendix of library functions repeats what is available in the CCS help so I did not find it useful.Maybe it would be to someone who didn't have the compiler.Overall, this book helped me find how to do what I needed to with a minimum of reading irrelevant information and that's really the highest praise I can give to an instructional book.I recomend this book to any experienced programmer who wants to get started with PIC development.

Doesnt worth its price
Provided you have NO knowledge on C programming and microcontroller, otherwise you dont really need this book. I personally think that big portion of contents could be found in CCS's manual and sample code FREE.

Anyway, this book is more readable than the manual as it is more well-arranged, together with some explanation and diagram. This could be helpful to beginner with NO prior knowledge on embedded C programming.

Excelent book for a Newbie!
For a Newbie on PIC C programming like me, this is really an excellent book. It teaches C language programming, helping the reader to create an entire program (step-by-step). Also, the reader can understand the PIC architecture and learn how use a C compiler (like CCS C). Finally, the reader can learn and try to implement a complete project using microcontrollers. I recommend this book to anyone who is thinking to make a travel through the field of microcontrollers and embedded programming.

A very good Text Book
A very good textbook for undergraduate learning MCU programming. This book is based on CCS C complier, a step-by-step guide from basic C programming to project planning. ... Read more

Product Description
Sams Teach Yourself C for Linux Programming in 21 Days presents C programming techniques in a logical and easy-to-follow sequence that helps you understand the principles involved in developing C programs. You'll begin the basics of writing a program, then move on to arrays, pointers, disk input/output, functions, and more. Learn the basics of C, including variables, constants, conditional statements, loops, pointers, data structures, input/output, and functions. This book presents C in the most logical and easy-to-learn sequence, and is geared towards programmers learning the C language for Linux. Also included will be additional material needed to develop and execute programs for Linux. ... Read more

Customer Reviews (15)

A well rounded, decent introduction to C
I came to this book after struggling to learn C++.I found this book to be well written and understandable given that it is a programming book. The book breaks down the programs in a step by step manner which made it each smaller piece easier to understand.Although, the author avoids explaining some things early on, it is so that the reader isn't overwhelmed.

I was able to learn C from this book when I was a 10th grader in high school with only a background in BASIC. Although, there may be better books out there, this book is good to fair.

I am now a software engineer who owes some of his early education to this book.

Bad Choice
The Book: C for Linux Programming in 21 Days by Sam's is published in 2000. It is either so out of date, or inaccurate that even the first example (Hello World!), coding doesn't work. Even after following the instructions multiple times and double checking everything over. Warning their is a number of different downloads that have to be done to apply the information in these kinds of books that never get mentioned it is questionable if books like these serve any purpose other than coffee table decorations. Space too small to give lessons here. Buy only up to the minute beginning books. May things go well with you.

With out a doubt, the BEST intro to C book on the market!
Going into my first year as a computer science student, I had never programmed before in any language. After realizing how tough it was, I picked up this book that was luckily in a local book store and read the entire book cover to cover. I'm now in my final year preparing to do a Masters in computer science thanks largely in part to this book. Even though it's not a complete C reference, it definatly gets you going in the write direction. From making simple to advanced makefiles in a clear and understandable manner, to structured software development with debugging information and proper coding techniques. It is missing important information like database programming and socket programming, but the things that are missing could be picked up in a more indepth and advanced book on C programming like "Beginning Linux Programming" (big red book with the 2 guys on the cover laughing at eachother). I'd never part with my copy of Teach Yourself C in 21 Days because its a good reference for little things you may forget along the way.

Great book! Nice introduction to C in the Linux environment.
This book helped me get back with programming in C (one of the most powerful languages out there), and they did a nice job of explaining the Linux environment and how the GNU C compiler (GCC) works. I am pretty new to Linux but had no trouble getting up and running with the book.

Full of goodies, plenty of reference-
This book is beyond as good as i said in my last review, well this is an update. After finishing this book, i have an entirely new outlook on why this book is so good! I always find myself looking back for a reminder; if there's something i need a refresh or rescale on, it's got it. it teaches compiling all the way to deployment. This book is desirably the best in my GNU/Linux stash. There are so many extras in this book, you would b surprised why they priced it so low!

COVERED- Pointers (in depth), functions, all forms of data structures, GTK/GTK+, and more-

If you the reader are taking any introductory courses in programming, for goodness and gpa get this book! Especially if you have a[bad]teacher as i once did ;)

Hope this was helpful ... Read more

Product Description

In just 21 days, you'll have all the skills you need to get started with C.With this complete tutorial, you'll master the basics and them move on to the more advanced features and concepts.

• Understand the fundamentals of C.
• Master all the new and advanced features that C offers.
• Learn how to effectively use the latest tools and features of C, by following practical, real-world examples.
• Get expert tips from a leading authority on implementing C in the corporate environment.

Sams Teach Yourself C in 21 Days is designed for the way you learn.Go chapter by chapter through the step-by-step lessons, or just choose those lessons that interest you the most.

Customer Reviews (44)

Very satisfied with this book
Sams Teach Yourself C in 21 Days (6th Edition)
A very good book for absolute beginners and those who have very modest experience with programming. I have been using it for about a month.

The book uses plain easy to understand English language. It has notes and tips which alert the user to points that need attention.
The "Do--Do not" section help you avoid falling in programming pitfalls that can result in unexpected results.
Each topic has a sample code followed by explanation of the code's lines.

The Q&A, quizzes, and exercises at the end of each chapter (i.e. day) provide additional ways to understand the topics covered in a particular chapter.

The most valuable thing for me is the program that follows the end of each week. After every 7 chapters (1 week) there is a "Review of Week" section. This is a comprehensive program that contains codes that use what you have learned over a week. Even the code lines have reference to the chapters that cover the keywords, and syntax of C language.

At the end of the book, there are bonus chapters about Java, C++ languages. Although they cover a small part of those Programming languages, the chapters are worth reading.

If you are not sure where to start with C language, buy this book. It contains a lot of useful and practical examples as well as "C" compiler/editor which works on Windows (You can type and modify code lines, and with a click of button you get the .exe file that can run on every Windows PC even if the PC has no "C/C++" compiler).

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

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

Get a different book
I decided (perhaps foolishly) to dive into the world of computer science with the book. I mean a book that teaches me a whole programming language in 3 weeks? I was sold.

What the book does well is that it can quickly teach you the fundamentals of C, right up to pointers. The book does well in borrowing material from a far better book, "The C prgramming language" by kernighan and ritchie. The book also provides a wealth of coding examples for you to disseminate at you leisure. There are also quizes at the end of each chapter.

Not counting the innumerable typos and editing mistakes (even an example code that doesnt compile properly, even when copied from the CD the book came with), the book has many, many acheilies heels.

For one, at an attempt to provide simple explanations and answers, the author merely succeeds in glancing over important information and causing confusion. I was really frustrated over the lack of descriptive explanations for many important topics, most notably typedefs, unions, casts, and void type pointers. Oh and the "bonus" topic on linked lists may as well not even be in the book since its almost completely impossible to follow unless you know what a linked list is already. Another problem is the coding examples. All to frequently you will see alibrary function that has not yet been covered, and you will have to thumb through the book to figure out what it is. Additionally, at several points in the book, you will need to skip ahead several chapters just to understand what is being said in an earlier one. An example of this is having to learn chapter 8 before 6, chapter 16 before 14 and chapter 20 and 21 before 18, and 19.

By not providing enough explanation, this book teeters on the line between being comprehendable and not. Also, dont expect to learn how the library functions work until much later on (incredibly useful to know). the difference between knowing "char *gets(char *)" and "gets()" early on is huge. Id say its analogous to knowing to put in bread into a toaster and knowing toast will come out versus knowing you have to put 'something' into a toaster and relying on magic for something to happen, respectively.

There are quizes at the ensd of each chapter which are pretty easy, if you were able to parse the confusing chapter before it that is.

OVERALL
This book teaches you the basics in an oversimplified and brief manner. As a result topics that would otherwise be easily explained, are unnecessarily difficult. However if you can piece apart the explanations, this book is actually helpful. I HIGHLY recommend getting "The C Programming Language" with this as a reference and supplement. The latter is fairly difficult and the SAMS books helps out to understand it.

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

Product Description
A source for advanced PC graphics topics currently being used in a wide variety of fields. Stresses a hands-on approach, providing numerous program examples written in C and applicable to any C compiler with correct, ready-to-use and well-described code. Covers ray tracing, used to create realistic 3-D graphics. Includes information on graphical file formats and manipulating digital images. Also focuses on printing screens and images. ... Read more

Product Description
During the past few years of tech sector economic decline,which has touchedthe EDA/semiconductor industries, two companies have had consistentdouble digit growth. They are Xilinx and Altera. Their business is FPGAdesign. Advances in FPGA technologies have made FPGA design a low costalternative to very expensive unreconfigurable ASIC design. ... Read more

Customer Reviews (3)

Don't be fooled by the title
A more appropriate title of the book should include Impulse C!Without Impulse C, one can forget about FPGA programming in C.Had I read the review by "Wiredweird", I would have not bought this book.This is a useless book without Impulse C.I wonder if this is a clever way to advertise the product Impulse C.

Clarification of previous review
As a reader of this book and a user of Impulse C I feel that I should clarify some of the previous reviewer's comments.While "weirdweird" is clearly knowledgeable about FPGAs, he (or she) is confused about the programming and execution model used by Impulse C.

Impulse C is an extension to the traditional ANSI C programming language that permits development of FPGA hardware by writing C.Like any C-to-gates development tool, the resulting hardware design is inferior to what an experienced hardware designer could produce.However, many feel that the greatly reduced development time and effort of a C development environment is worth the performance trade-off.In many cases the resulting hardware runs significantly faster than software programs on a PC.

The CoDeveloper tools that come with Impulse C (they are not included with the book) compile C to FPGA hardware and, in the process, extract multiple types of parallelism.Contrary to what "weirdweird" says, the resulting designs do not suffer from traditional processor bottlenecks as the resulting designs are nothing like a processor.Hardware synthesized from Impulse C programs consists of a datapath controlled by a Finite State Machine, the same structure used in most hardware designs and one that is not found in processors.

In addition to any parallelism the user specifies through stream declarations, the Impulse C compiler can also perform loop unrolling and other optimizations to perform multiple operations in parallel.The tools also permit the simultaneous use of multiple memories internal to the FPGA, eliminating the "memory wall" to which the previous reviewer refers.

"weirdweird" is correct that this book focuses solely on Impulse C, so readers without potential access to the Impulse C tools might want to consider other choices.

Very mixed
Let's start on the positive side. This book is very current - it mentions the recent Cray and SGI FPGA accelerators as part of the reason for programmers to learn about FPGAs. It goes through some interesting and practical examples, showing how a C program can be used to specify the synthesizable logic for triple DES, including time/space tradeoffs. It gives some hardware awareness, without trying to turn a programmer into an EE. Best of all, it shows practical use of Impulse C, an ANSI C extension that supports pragma-driven pipelining and parallelism. Impulse C, by the way, seems to have an exceptional pedigree. It seems to descend from Maya Gokhale's work at Los Alamos, and there isn't much better parentage for such a product to claim.

There are some problems with this book, however. It relies overwhelmingly on the Impulse C product, to the exclusion of Handel C and a flock of other products - it's really an Impulse C how-to. That's not necessarily a bad thing, but it's not what I assumed from the title. It emphasizes streaming data, like radar input, video, audio, or all the other traditional DSP applications of FPGAs. Streaming is good, but a poor match to the Cray and SGI coprocessors.

The biggest problems in this book come from the basic approach of trying to turn an FPGA into a CPU. Back when iron was first introduced for bridge-building, iron beams were built to imitate wooden ones. The result was a wooden bridge made of iron. It worked, but used far more material than was needed for the job, and got relatively poor performance from the material. Ditto what happens when FPGA logic goes into a soft CPU. The result is a little like the classic "Fortran program written in C," only worse. Andre deHon, in his FCCM `04 talk on hardware design patterns, identified the FPGA CPU as one of the biggest anti-patterns in his lexicon (though he didn't use the word anti-pattern). Creating a CPU makes the FPGA look familiar to a C programmer, but is a great way to turn the FPGA's inherent parallelism into serial execution, and far slower than the host CPU's at that.

The FPGA CPU re-introduces the "memory wall." A big Xilinx FPGA has 300-400 on-chip memories that can be accessed independently and concurrently. You can (I did) build a dual-ported RAM with 1000-bit words. You can (I did) create a 64-way interleave, so all data for a 3D tricubic interpolation can be accessed in one cycle. You can (I did) create scratch buffers for hundreds of concurrent computations. You can create all kinds of wild structures with massive performance - or you can reinvent the 16-bit von Neumann bottleneck. (Soft CPUs aren't inherently evil, there are good uses for them. Mostly, I'd rather use the same logic for 100 parallel, dedicated processing elements instead of one serial PE.)

If you need to use Impulse C, there's probably no other book around. If you're a programmer trying to learn about hardware, I suggest Wirth's aging "Digital Circuit Design for Computer Science Students." I recommend this book only to people with product-specific needs.

//wiredweird ... Read more

Product Description
Learn through play! Each chapter of C Programming for the Absolute Beginner includes a project designed around simple games as a fun approach to learning programming. This book sticks to the basics so you won't get in over your head. Plus it uses the free CYGWIN software that allows you to easily read, study, and implement chapter contents from any background. The CD even includes CYGWIN and games you can cut and paste right into your own Web sites! ... Read more

Customer Reviews (5)

Adequate
This is heavily focused on C programming in the Windows environment. The information is decent, but if you want to use Unix or Linux, etc., you will need something else to supplement.

blurry screen captures
If you have never programmed before, then this gentle introduction to C might be suitable for you. It explains the syntax. And how to code in a procedural, top-down manner. It also points out the advantages of designing for code reusability. Something that is probably not high on the awareness of a new programmer.

You can learn the importance of flow charting. Why you should do this before coding. Time well spent, that can really help your program, instead of just winging it and pounding away at the keyboard.

The book does have a drawback. The figures which are screen captures of terminal windows are blurry. A little offputting.

Pretty Well Done
I think C Programming for the absolute beginner is fairly well written and contains some good examples. The challenges aren't all games, and some of them will probably be uninteresting to the reader. It is the best book I've read so far for learning C, and would certainly recommend it to others who want to learn it as well.

Easy to use, but not technically correct
The book is easy to follow, and can help a non-programmer pick up the basics.The problem is in the code examples.The code examples in this book all compile, and the binaries run, but if you enable warnings on your ANSI-compliant compiler before compiling any of this code, you will see a whole host of warnings and error messages.Don't think that you will learn C from this book and then go get a job somewhere as a C programmer.Your code will be as non-ANSI compliant as it could possibly be while still working.This makes it even more difficult if you progress to a more advanced C text after this, as you will likely have to go back and relearn quite a bit.I give it 5 stars for ease of use, but it loses 3 stars for not "teaching good programming practices" as it claims to on the cover.

For anyone wanting to learn C Programming from scratch
Deftly written by software engineer and applications developer Michael Vine, C Programming For The Absolute Beginner truly lives up to its title. No previous familiarity with the art of computer programming is required to understand and learn from the lessons provided, all of which revolve around simple game creation in a learn-through-doing process. Basic C Programming tasks such as initializing variables, creating two-dimensional arrays, manipulating strings, and using compound if structures, are among the many core building block abilities taught by this superbly written and presented introductory guide. An accompanying CD contains a gcc C compiler and the Cygwin free UNIX shell makes Michael Vine's C Programming For The Absolute Beginner and absolute "must" for anyone wanting to learn C Programming from scratch. ... Read more

Product Description

TCP/IP Sockets in C: Practical Guide for Programmers, 2^nd Edition is a quick and affordable way to gain the knowledge and skills needed to develop sophisticated and powerful web-based applications. The book's focused, tutorial-based approach enables the reader to master the tasks and techniques essential to virtually all client-server projects using sockets in C. This edition has been expanded to include new advancements such as support for IPv6 as well as detailed defensive programming strategies.

Customer Reviews (2)

This book gets you a jump start.
This book includes enough easy to read explanations of actual working code that you can within a few hours have a client/server socket connection up and working.Both the text and the code are well written and easy to follow.Advanced information about non-blocking I/O allowed me to quickly implement background socket reads without tying up a foreground process.The annoying occurrences of "address already in use" errors is explained clearly, and how to get around them by the use of socket options. I had literally zero problems compiling and executing the examples with the gcc compiler and Ubuntu Linux.
As the title says, it's a book for C programmers about sockets, not for other languages.There is a chapter on C++ use, which I have not needed yet.

A Waste of Money if Help with Windows is Wanted
the publicity is careful not to mention Windows.unfortunately, neither does the book."basic" means "unix only". ... Read more

Product Description
com/~bs/) have been added. The result is complete, authoritative coverage of the C++ language, its standard library, and key design techniques. Based on the ANSI/ISO C++ standard, The C++ Programming Language provides current and comprehensive coverage of all C++ language features and standard library components.

For example:

abstract classes as interfaces class hierarchies for object-oriented programming templates as the basis for type-safe generic software exceptions for regular error handling namespaces for modularity in large-scale software run-time type identification for loosely coupled systems the C subset of C++ for C compatibility and system-level work standard containers and algorithms standard strings, I/O streams, and numerics C compatibility, internationalization, and exception safety

Bjarne Stroustrup makes C++ even more accessible to those new to the language, while adding advanced information and techniques that even expert C++ programmers will find invaluable.Amazon.com Review
This classic work shows a care and understanding of C++ thatonly Bjarne Stroustrup, the designer of the language, can achieve. Italso conveys the punctilious and sometimes suffocating detail thatonly Stroustrup would desire to communicate. The novice programmerwill have difficulty distinguishing between the essential and thedispensable material. However, experienced C++ programmers willappreciate the reference manual portion of the book, which contains anexact definition of C++ that even numerous examples cannotexpress. Stroustrup's book has several chapters on classes and thereference manual component of the book contains the complete grammarof classes. This is a book that every experienced C++ programmer needsto own. ... Read more

Customer Reviews (284)

The right c++ book
Being a java programmer, I was searching for a book giving me more insight in the c++ programming language. Before reading this book, I had good conceptual knowledge and practical experience of object oriented programming in java and c++.

This was not my first c++ book and I also successfully followed, during my bachelor studies, courses on data structure and algorithms based on "Algorithm in Java 1-5" by Robert Sedgewick (Addison Wesley books). However, the STL was quite new for me.

This book was definitively the right book to purchase. Yes, it is not an easy read: every sentence seems to contain important information and so it has to be read slowly to get the maximum benefit of it.

Bjarne-Stroustrup makes a magnificent job at explaining the c++ language from a compiler perspective, language design perspective and software design perspective. He helps you understand that the design of c++ is based on a series of choices and carefully taken decisions.

I have although very much liked the structure of the book which supports well its difficulty: every chapter start with a list of concept to be explained and end with advices and exercises. I found the advice section very useful to test the understanding of what you read. Moreover, every time the author makes a reference to an example - particular topic (already seen or to be seen), there is a paragraph reference. This is of a great help!

Finally I found the part on the Standard Library very understandable despite the fact that my knowledge of it before reading the book was limited.

Many thanks to Bjarne-Stroustrup for this book!

C++ is not what it should be
C is Unix and C++ is just another Multics in the programming language world.
I would consisder C++ a testbed for language design and implementation, but
not a successful language.

It has lots of features, and most of programmers would be misled and get confused(
this culminates in c++0x)
Bajarne told people to focus on techniques not features, it's really hard
to follow in the real world though. I think a good programming language should
be simple and elegant, and won't cause confusion for any level of programers.
C does a better job, and Java is ok. If I have other choices of OO programming
languages, I would give it a try. C++ is really a dilemma for me.

Pretty good.
Good book.He did write the language.Perhaps a bit of a personality would make learning more enjoyable.
No offense to the author.All the information is in the book, just so darn hard to stay awake.

Sorry.Buy it if you have lots of coffee!

This is the definitive reference
Great book, and I believe an absolute must for any serious C++ programmer. Great as a reference, and a very informative (if a little involved) read. Nothing beats the thoughts of the language designer/creator when it comes to understanding how C++ works.

C++ by the Man Himself
There is nothing to review about this product. This is THE reference for C++ programming by the man who is behind the development of the language. His insight into the process of programming and what developers need is astounding. This book is the only book you need for C++ programming. ... Read more

Product Description

Customer Reviews (5)

Explains a difficult topic
I bought this book as an experiment because I really wanted to teach my students to use Java on their NXTs. I was surprised by how well the book explains C programming on the NXT and delighted by the many excellent examples. We were able to get a program running on the first day. We did not use but I was impressed by the many excellent, illustrated examples of construction.

C programming is hard for students to grasp and they eventually gave up but this was not the book's fault.

NXT Power Programming
This is an excellent book written by someone who was involved in-depth with NXT programming as the NXT product evolved.Lots of good examples of C code will speed your learning curve.

Real programming power for the NXT
If you are interested in programming your NXT beyond what NXT-G can do (the environment that comes with the retail kit) this is the book for you. You don't have to change out the firmware as you do for other text based programming languages, so you can continue to use NXT-G. In fact both types of programs can reside on the NXT at the same time.

There is a great chapter giving details on the Bricx integrated development environment and all the tools that come with it. It is very complete.

The versa bot that is detailed in the book is a great platform to add to and make your own modifications to. I have already made several of my own modules for it and wrote programs to take advantage of them with NXC.
There are several other bots to be built in the book that I have yet to get built, as I am still adding to the versa bot, but I definitely will though. The etch a sketch one looks really cool and I am sure programming it will teach me a lot.

Thanks should go out to John Hansen (the author) for all the contributions he has made, and continues to make to the Mindstorms Robotic community. The Mindstorms is a great platform to aid the young in learning and teaching the old to stay young.

Getting More from this Powerful Robot Kit
Summary: An excellent'next step' for getting the most from this powerful computer system

Mindstorms NXT is robot building tool from Lego. The centrepiece is a large "brick" containing a 32-bitARM7 computer - the kind of computer you might find in a PDA or a Smartphone. The kit includes a graphical programming environment capable of quite complex programs as well as being accessible to beginners and youngsters. The kit also includes motors and sensors, wheels, gears, and a whole lot of technic-style Lego to hold them together.

John Hansen's book takes all of these components and organises them in a coherent and easily understandable fashion. He describes how to use the various components and explains the sensors (that range from a simple contact switch to a sophisticated ultrasonic distance sensor). However, the real strength of the book is in its approach to programming of the system.

Power Programming describes how to maximise the capability of the kit by programming it using a conventional, textual programming language that is close to standard C. This is both more natural to anyone who already has a smattering of programming knowledge and, ultimately, capable of more complex and much faster programs for the NXT. Best of all, the system that Hansen describes is a free, open-source toolkit usable on Mac, PC and Linux; just download it from the WWW and you're ready to roll.

NXC (Not eXactly C) and the complementary assembler, NBC (NeXT Byte Code) are explained in a clear and authoritative way (Hansen is the author of the compilers too) before the book explores the rest of the system. Each item is introduced in the context of a real robot (you can build these from the step by step instructions) but in a style that explains how it actually works; so the reader is left understanding how to apply each item in their own programs. Later chapters dig deeply into advanced programming of the sensors and communication between several robots without ever becoming inaccessible. And, lest I have made it all sound too dry and worthy, there are detours to examine such things as playing Space Invaders on the NXT and producing a Bedroom security system and remote controlled car.

This is a well-written, clearly presented and very well produced book from an acknowledged expert. It's not for young children but anyone with a little programming knowledge and an interest in computers and robots will find it entirely indispensable. Just beware that, while the tools it describes are free, it could well convince non-owners that they need to buy a NXT!

Empowering resource for NXT fans
While the official NXT-G programming language included in the LEGO Mindstorms NXT set works well for many people, what if you want to increase your programming potential or simply prefer a text-based language rather than a graphical one? John C. Hansen's book provides the answer to both of these questions by teaching you how to program the NXT in NeXT Byte Codes (NBC) and Not eXactly C (NXC).

The book begins with an introduction to some basic programming concepts and then shows you how to set up NBC/NXC. Since these unofficial languages are based on the standard firmware, you don't have to download custom firmware to your microcomputer, making setup a breeze. Chapters 2 through 4 discuss the NXT hardware, NXT firmware, and basic construction concepts, respectively. If you're new to the NXT set, you'll find these chapters helpful.

Chapter 5 covers the BricxCC IDE, which supports NBC, NXC, and a number of other languages. This is definitely one of my favorite chapters. BricxCC is an incredibly powerful but user-friendly program, and this chapter shows how to effectively use and customize BricxCC. Perhaps the most interesting chapter in the book is Chapter 6, which discusses free NXT utilities that perform miscellaneous functions.

The real power programming begins in Chapters 7 and 8, which cover NXC and NBC. If, like me, you've programmed the RCX microcomputer in Not Quite C (NQC), you'll be glad to see that Hansen created NXC with a lot of the same features and same "feel." Naturally, these chapters are most easily understood if you have a background in C or programming in general, but such knowledge is not required. The book assumes you are a beginner and explains fundamental programming concepts. If you need more information about a basic concept that the book doesn't discuss in great detail (for example, using arrays), you could easily consult an online resource.

Chapters 9 through 16 teach you how to build a basic robot (Versa), program basic and advanced NXT outputs, program basic and advanced NXT inputs, create an intruder alert robot, explore "games that people play" on the NXT, and control an NXT robot remotely. It is through these chapters that you get practical experience in using NBC/NXC.

In conclusion, if you're looking for an effective and user-friendly text-based programming language for the NXT, then this book is for you. NBC, NXC, and the BricxCC IDE are outstanding resources, and this book teaches not only the basics but also quite advanced concepts (which will be of interest to expert users out there). Bear in mind, however, that this isn't primarily a book of building instructions. Its purpose is to teach you how to effectively program robots--and it accomplishes that purpose very well.
... Read more

Product Description
This book is intended for anyone who is learning programming for the first time. The main goal is to teach fundamental programming principles using C, a popular language used in schools and industry. However, the book is more about teaching programming basics than it is about teaching C.Basic programming proficiency requires that you know, at least, the following: the primitive data types of the language (integer, floating-point, character); how to write input/output statements; how to write conditional statements (if, if...else); how to write looping statements (while, for); how to write functions and how to declare and use arrays. But, more importantly, you need to be able to write programs to solve problems using these features. This book explains all of the above in an easy, conversational style.To learn programming well you must write programs. The exercises are a very rich source of problems, a result of the author's more than 30 years in the teaching of programming. ... Read more

Customer Reviews (2)

Great book for new programmers
This is a great book for anyone new to programming (or in my case new to C programming). Each chapter ends with 20-30 exercises ranging from very simple to challenging. It covers a lot of ideas and concepts that are left out of the other beginner books I've read. It focuses on using a small amount of info to solve a wide variety of problems. I've almost completed the exercises in the book and am excited about reading Kalicharan's next two books in the series, Advanced C Programming and Data Structures in C.

A gem
Clear, simple and to the point. The perfect place to begin. The clearest explanation of sorting and searching algorithms I've read. A gem, the best kept secret on the internet.

Actually, this book is the first of a serie of three books, all of them are clear simple and to the point, where other books are too wordy, clear as mud and expensive.

From beginner to beginner, you want to begin programming the right way, do yourself a favour, buy "C programming - A beginner's course".

You want to learn more, do yourself a favour, buy "C Programming - An Advanced Course" and "Data Structures in C" by professor Kalicharan.

Hubert Dupont, France. ... Read more

Product Description
This practical guide contains a detailed set of C standards and UNIX system comparisons for the construction of highly portable software. Professionals will learn the underlying causes of portability problems as well as the techniques for creating portable UNIX system software. It shortens the software development and test cycle and enables the user to reduce the cost of long-term support. ... Read more

Customer Reviews (3)

Clarification on authorship
Cowan's only half-right. The "E" in "J.E.Lapin" is for "Eric" (as in "Eric Raymond"). The "J" is for "Jon" (as in
"Jon Tulk").The book was actually a team effort undertaken by several software engineers working at Rabbit Software in the 80s.

This book should be far better known
In addition to being everything the previous reviewer said it was, its true author is Eric S. Raymond, rather better known in the community now than he was then. ("Lapin" is French for "rabbit", as in Rabbit Software, the publishers.)So it should really be filed along with "The Cathedral and the Bazaar" and "The New Hacker's Dictionary".

Somewhat dated now, but still very worthy ideas.
First off, the composite authors name is Lapin, not Laping.

I used this book back around 1990 to develop a large software suite.The first 5 chapters are an excellent intro to portable C coding.We used the beginning chapters to design and develop our common platform headers, libraries and Make system.We did not take their examples unchanged, but used them as starting points for a our needs, which was a somewhat more comprehensive system.My team gives the book credit for helping us get us some of our 10x improvements.Still have not seen the likes of this book even today, in terms of the quality of data to use.

The last half of the book is a summary of different API calls and /bin functions available on different Unixes of the day. Interesting now, from a historical perspective. ... Read more

Product Description
B.E.S.T (Basic Engineering Series and Tools) consists of modularized textbooks offering virtually every topic and specially likely to be covered in an introductory engineering course. All the texts boast distinguished authors and the most currant content. These inexpensive BEST modules are easily combined with each other to construct the ideal intro to Engineering course. The goal of this series is to provide the educational community with material that is timely, affordable, of high quality, and flexible in how it is used. ... Read more

Customer Reviews (1)

textbook_critic
This computer programming text will serve students well both as as a text or as a quick authoritative desk reference.

The authors'focus on answering the most common questions asked by beginning students in C computer programming is great. They also spend quite a bit of effort showing the differences among subtle symbology.

Note I think the people who invented C language did a huge injustice to all students of C by being very sloppy with their chosen set of symbols especially for "Pointers" -- which is often used in solving most intermediate and advanced programming problems.

This book tries to get to the root of all the confusion and sloppiness of the orignal inventors and thus end up greatly helping beginning students. Once students overcome all the sloppy terms and symbols carelessly adopted by the original designers then they can begin to enjoy the C langauge and make it do some wonderful things.But the learning curve is typically long and tedious to slowly overcome all the nuances in the language.

Sometimes I even feel that C language should be phased out completely and allow C++ to be the sole langauge for all beginning student computer programmers.But people are reluctant to change anything -- just like the '80's attempt trying to phase out English dimensional sytem with the Metric system.

Again this text understands all the areas of sloppiness that lead often to confusion and then goes to work at clearly explaining them all.

Normally it's a tough job to clear up others confusion but these 2 authors apparently were highly motivated and committed at trying to take a good stab at all inherent problems incommunication -- which, in my view, most technical people don't pay enough attention to. They seem to think that after they design some complex system it's someone elses problem to figure out what they designed.

The original designers of C language certainly have caused a lot of unnecessary headaches for many beginning students trying to learn C; and this book focuses on being a Bridge to understanding this shadowy language which, in my view, again should be phased out altogether, or the designers should fix the confusing symbology and often unnecessary cryptic shorthand for almost everything in their C language.Note C was designed when computer memory was [more money] and limited, and the designers got very creative at working under this environment. But did they think about future students trying to learn this often confusing and thus, difficult langauge?

The only suggestion for the book is that the publisher should have used larger font for titles and subtitles and theoretically should have aimed for new page for each subsection.I could never undestand publisher's use of the bottom of a page for major subsection.

G. Jerry Sagliocca, P.E.
Schenectady, New York ... Read more