Product Description

The Pocket Guide to TCP/IP Sockets is a quick and affordable way to gain the knowledge and skills you need to develop sophisticated and powerful networked-based programs using sockets.Written by two experienced networking instructors, this book provides a series of examples that demonstrate basic sockets techniques for clients and servers.

Using plenty of real-world examples, this book is a complete beginner's guide to socket programming and a springboard to more advanced networking topics, including multimedia protocols.

* Concise, no-nonsense explanations of issues often troublesome for beginners, including message construction and parsing.
* Comprehensive example-based coverage of the most important TCP/IP techniques-including iterative and concurrent servers, timeouts, and asynchronous message processing.
* Includes a detailed, easy-to-use reference to the system calls and auxiliary routines that comprise the sockets interface.
* A companion Web site provides source code for all example programs in both C and WinSock versions, as well as guidance on running the code on various platforms.Amazon.com Review
The explosive growth of the Internet in no small part is due to the sockets programming interface. This elegant API allows almost any computer that runs TCP/IP--from palm computers to mainframes--to communicate seamlessly. The Pocket Guide to TCP/IP Sockets provides beginning and intermediate network programmers with a practical tutorial and reference guide. Instead of trying to break new ground, this book establishes modest goals and achieves them splendidly. It is a concise, high-quality resource for students and professionals.

This book targets the accomplished C programmer who wants to learn network programming. You're assumed to have a good working knowledge of basic IP addressing and network configuration--not much time is spent educating you on the fundamentals of networking architecture.

A highlight of this book is the solid sample code. Even for those who already write socket code, a brief refresher is always helpful--this book delivers valuable client and server code for both TCP and UDP sockets. Although the samples are based on a Unix environment, it's a trivial matter to port most of the code to Microsoft Windows and the Windows Sockets interface (ported samples also are available directly from the book's Web site). No longer do you have to paw through a thick reference to find parameter lists for sendto() or accept(). More subtle issues--data alignment, network vs. host byte order, and differing approaches to handling client connections--also are handled with ease.

Chapter 6 contains an under-the-hood discussion on TCP/IP implementation that will be useful to the more advanced user and that explains possible deadlock conditions, discusses the TCP state diagram, and sheds light on how the operating system handles socket resources. These juicy nuggets are reasons enough to keep this book handy--even after the thrill of your first successful network program subsides. --Pete Ostenson ... Read more

Customer Reviews (14)

Excellent Book - Especially for Beginners
I ordered this book because I needed a quick and dirty explanation of how to write socket programs in C.The text was straight to the point and explained to me everything I needed to know.

Great TCP/IP Guide
I bought this guide while in College for one of my programming classes. I could not be more happy with this guide. It told me exactly what I need to know without going on and on. I highly recommend this guide if you want an understanding of TCP/IP sockets.

Possibly THE Perfect Unix TCP/IP Sockets Quick Reference Guide
Having written network code for both Unix and Windows in professional and academic environments, I can say that this book is quite possibly THE perfect TCP/IP sockets programming quick reference guide for the Unix/Linux environment.If you are looking for a good reference guide with many concise code examples, then this is the book for you!

Every example that I tried worked beautifully; it's apparent that the authors took great care in crafting this book.As an aside, I attended an advanced, graduate level networking class taught by one of the authors (Dr. Calvert).It was an amazing class!This author knows his "stuff."

Every computer science book should be so clear
The Pocket Guide to TCP/IP Sockets is a wonderful, hands-on introduction to socket programming. It's small, light, and inexpensive. Perfect!!! I wish that all computer science books were as well-presented and affordable as this one. Definitely a keeper. I know people who refuse even to loan their copy to friends :)

Good, could have been better
I was disappointed in this book, but it is still usually the first of the many on the shelf that I reach for when I need a quick sockets reference. The examples are excellent. The API reference is the biggest disappointment, it is incomplete and occasionally inaccurate. There are many better books for WinSock programmers, but for C/Unix programmers this is a handy book to have on the shelf. Be sure to check out the Stevens _Unix Network Programming_ book for a deeper and more authoritative reference. ... Read more

Product Description
Secure Programming Cookbook for C and C++ is an important new resource for developers serious about writing secure code. It contains a wealth of solutions to problems faced by those who care about the security of their applications. It covers a wide range of topics, including safe initialization, access control, input validation, symmetric and public key cryptography, cryptographic hashes and MACs, authentication and key exchange, PKI, random numbers, and anti-tampering. The rich set of code samples provided in the book's more than 200 recipes will help programmers secure the C and C++ programs they write for both Unix®(including Linux®) and Windows® environments. The book's web site supplements the book by providing a place to post new recipes, including those written in additional languages like Perl, Java, and Python. Monthly prizes will reward the best recipes submitted by readers. The Secure Programming Cookbook for C and C++ is destined to become an essential part of any developer's library, a code companion developers will turn to again and again as they seek to protect their systems from attackers and reduce the risks they face in today's dangerous world. ... Read more

Customer Reviews (13)

Completely useless for PKI programming
The title "Secure Programming Cookbook" is more than a reach, but downright misleading. I bought this book fully expecting to find recipes for using OpenSSL's crypto library to generate CSRs, handle private CA functions such as create Digital ID Certificates, and other functions actually used in writing secure applications. What I found was the author spending more time talking about products and services offered by Verisign, and very little code whatsoever. There is some code for verifying a certificate, and downloading a revocation list, but sadly I've found more useful information reading OpenSSL's lackluster man pages than I have in this book. If you're looking for high level information about "how stuff works", or some simple command-line help, this book will suit you. If you're looking for content living up to the book's title - content that would actually help you implement things like PKI - you'll unfortunately come up short.

Good developer reference
This is a well-written and example oriented book for C/C++ programmers that covers secure programming in all aspects. I had been using this book for last one year now and It helps me as a quick reference and also real source code demonstrating practical approaches that can be incorporated into their software projects.

The book needs a little update but still helps any aspiring C/C++ programmer involved with crypto.

a good reference if you've really got to be secure
If you are not sure that you need this book, then you probably don't. But if there is something it the table of contents that you've got to know, and you've got to get it right, then this would be a good book to have. Chapter 12 on Anti-Tampering was a really enjoyable read, though probably a futile task.

Great book for anyone using C
This is simply a great book for anyone using C or C++.

These guys literally wrote the book on secure code.

Read it!

A task-oriented reference guide
This well-written book covers a lot of topics that I have not read in other books.

Its strengths include:

--Good coverage of cryptography programming
--Task-oriented solutions to specific programming problems
--Easy to navigate "cookbook" style ("with recipes" as the authors call them)

However, some areas of improvement might be:

--Could use more coverage of important subjects (buffer overflows, etc.)
--spends a lot of space on narrower examples (like explaining certain APIs that are documented well online)
--Sometimes jumps into material without much background explanation (which was confusing for me)

It is probably not the first book you should read on the subject. This is more of a recipe guide that is useful if you get stuck on coding a particular topic that happens to be covered. The authors have done a good job of explaining what coverage they do and don't include. ... Read more

Product Description

"The security of information systems has not improved at a rate consistent with the growth and sophistication of the attacks being made against them. To address this problem, we must improve the underlying strategies and techniques used to create our systems. Specifically, we must build security in from the start, rather than append it as an afterthought. That's the point of Secure Coding in C and C++. In careful detail, this book shows software developers how to build high-quality systems that are less vulnerable to costly and even catastrophic attack. It's a book that every developer should read before the start of any serious project."
--Frank Abagnale, author, lecturer, and leading consultant on fraud prevention and secure documents

Customer Reviews (7)

The best how-to security book
This is an important book for people that write computer programs and their managers.
It is also very well organized and well written. Seacord reveals how the bad guys take
advantage of bugs in programs to break into a system or damage it.It is the most
complete list of exploitable bug types that I am aware of.

Many examples are given, naming software that have been exploited by bad guys.Some
may protest that this provides the bad guys with a list of easy targets. All of the
vulnerable software has been updated to fix the bug, and the improved version has been
available for a long time.

Everyone that writes software intended to be used by someone else should read this book.
Every organization that writes software should have a copy.

Most of the security flaws are buffer overflows. Secord shows how, from the simple use of
gets() through mistakes triggered by subtle differences in the rules for signed and unsigned
integers of various sizes.There are other ways, and some are quite subtle, but still
preventable.The bad guys are not Jay Leno's "Dumb crooks."

The primary way to frustrate the bad guys is to not have any of the bugs they exploit.
Seacord admits zero bugs is an elusive goal and recommends defense in depth by the use of
various freeware or commercial packages intended to trap or prevent certain errors.
He lists and describes many, with their strengths and weaknesses.

Read this book and make your code better.Read it again, next year.

The following are my opinions, based on over 40 years writing software, but I doubt
Seacord would disagree.Every security bug is also a bug that can cause a crash or a
wrong output from a program.The major cause of fewer bugs is the attitude of the
programmer.Managers can affect the attitude of the programmers by their choice of
questions. Do not ask "Is it done yet?"Instead try approaches like: "Tell me about how
you validated the inputs and how you identified all the inputs.""Who reviewed your test
cases?" "How did you decide you had tested enough?"The fewer bugs of any kind in your
product, the less likely the bad guys are going to target it, other things being equal.

Excellent resource!
This book slipped under my radar, but I recently picked it up and was quite impressed.

This book is fairly unique in that it is accessible and well-written, yet, at the same time, unabashedly technical. It's quite simply a very good book, and it should prove valuable to readers new to software security, as well as experienced security consultants and vulnerability researchers.

I know the problem domain intimately, and was quite impressed at the level of thoroughness and the technical depth of the coverage. This book isn't merely a well-written exploration of known insecure programming idioms and attack techniques; there's actually a considerable amount of original research and material that you won't find elsewhere. Specifically, the coverage of integer issues goes above and beyond what has been previously written, and it's incredibly topical given the current trends in vulnerability research.Seacord's mastery of the C language and his ability to distill the practical rules of thumb out of the somewhat fragmented C standards really results in an excellent resource.

Great Book!
I had the honor of taking a short course at a software security summit from Robert Seacord. I would have to say it was one of the most informative security related courses that I have taken. This book encompasses the course that I took and does a great job of explaining what to watch out for when writing code.

I highly recommend this book for any serious developer.

A book for programmers
There seem to be three categories of computer security books.The first category is books written for system administrators or computer owners, and explains how to protect the computers under their control.The second category is the "true crime" genre that recounts the exploits of black hat hackers or explains the hacker culture (sometimes as "how-to" books for non-programmers).The third, and rarest, category is books for professional programmers that explain the coding idioms that make programs more secure or more insecure.

This book is an excellent contribution to the third category.It explains how certain ways of programming in C and C++ make programs vulnerable to security attacks.There are many code examples throughout the book illustrating the issues.

Although everything is explained in great detail, the treatment is not superficial. (No background in computer security is required, but the reader should be at least a journeyman C or C++ programmer.)Some of the security holes will surprise readers familiar with the basics of computer security.My favorite example: Many programmers know that the gets() function once was involved with compromising 10% of the computers on the Internet in a single day,but did you know that printf can also be a security flaw in some cases?The statement:
printf(s);
can allow an attacker to run any code of his choosing if s is a string provided by the attacker.Even more surprising is the printf attack has been used successfully on popular programs.

This book should be read by any programmer who does I/O across a network, or who writes applications that provide a captive environment for their users (data entry stations, information kiosks), or who writes programs to manipulate sensitive data.Even programmers merely curious about security issues will find this book a readable treatment.I guess the Black Hats can read the book to get more ideas for future attacks.

I can personally vouch for Seacord's expertise.He is a security analyst as the Computer Emergency Response Team/Coordination Center, and I've worked with him on the ANSI/ISO C Programming Language Standards Committee.I've found his information on computer security both educational and valuable.
[...]

disturbing issues
Seacord gives an unsettling walkthrough of vulnerabilities present in much of C and C++ coding. Buffer overflows take up a significantportion of the discussion. Which leads into considering how these can be introduced into unwary code. Consider C. The common string functions of strcpy, strcat, gets, streadd() and others are shown to be very exposed to error or attack. C++ also has similar drawbacks.

The text explains that much of these trace back to some bad usages. Strings are defined to be null terminated. And bounds checking is often not done. While this is often true of code that the programmer writes, it is also true of various common C library functions, like those mentioned above. In fact, Seacord goes so far as to emphatically assert that gets() should never be used in your code. Instead, he suggests fgets() or gets_s().

Seacord also covers other topics, like dynamic memory management,which might have vulnerable heaps. Various 3rd party analysis tools are suggested, to find these errors.

Overall, the book can be quite disturbing, if you are maintaining a large body of C or C++ code. Might make you want to delve in and replace those gets(), at the very least.

While the text doesn't mention this, it turns out that recent languages like Java and C# have far more robust string handling abilities. They were written after the above flaws in C and C++ become apparent. ... Read more

Product Description
*Just months after the introduction of the new generation of 32-bit PIC microcontrollers, a Microchip insider and acclaimed author takes you by hand at the exploration of the PIC32

*Free CD-ROM includes source code in C and the Microchip MPLAB C32 compiler

*Includes handy checklists to help readers perform the most common programming and debugging tasks

The new 32-bit microcontrollers bring the promise of more speed and more performance while offering an unprecedented level of compatibility with existing 8 and 16-bit PIC microcontrollers. In sixteen engaging chapters, using a parallel track to his previous title dedicated to 16-bit programming, the author puts all these claims to test while offering a gradual introduction to the development and debugging of embedded control applications in C.
Author Lucio Di Jasio, a PIC and embedded control expert, offers unique insight into the new 32-bit architecture while developing a number of projects of growing complexity.
Experienced PIC users and newcomers to the field alike will benefit from the text's many thorough examples which demonstrate how to nimbly side-step common obstacles, solve real-world design problems efficiently and optimize code using the new PIC32 features and peripheral set.

You will learn about:
*basic timing and I/O operation
*debugging methods with the MPLAB SIM *simulator and ICD tools
*multitasking using the PIC32 interrupts
*all the new hardware peripherals
*how to control LCD displays
*experimenting with the Explorer16 board and *the PIC32 Starter Kit
*accessing mass-storage media
*generating audio and video signals
*and more!

TABLE OF CONTENTS
Day 1 And the adventure begins
Day 2 Walking in circles
Day 3 Message in a Bottle
Day 4 NUMB3RS
Day 5 Interrupts
Day 6 Memory
Part 2 Experimenting
Day 7 Running
Day 8 Communication
Day 9Links
Day 10 Glass = Bliss
Day 11It's an analog world
Part 3 Expansion
Day 12 Capturing User Inputs
Day 13 UTube
Day 14 Mass Storage
Day 15 File I/O
Day 16 Musica Maestro!

*32-bit microcontrollers are becoming the technology of choice for high performance embedded control applications including portable media players, cell phones, and GPS receivers.
*Learn to use the C programming language for advanced embedded control designs and/or learn to migrate your applications from previous 8 and 16-bit architectures.
*All code examples and software tools required to get acquainted with Microchip's MPLAB development environment, and to complete all the projects described in the book, are offered in the attached CDROM including the MPLAB C32 C Compiler (free Student Edition) and the full source code for more than 15 entertaining projects. ... Read more

Customer Reviews (7)

Best high end Microcontroller book on the market
This is a must have for anyone building sophisticated applications for DsPic or Pic32. I found that most of what I wanted to learn was covered, and in a manner that was to the point coding wise and very easy to understand. I have programmed with Assembly and Basic for most of my Pic projects and yet jumping back into C was very easy with this book. I would highly recommend this to anyone interested in the 16 and 32 bit micros, even if you have limited C programming experience or limited understanding of the new PIC architectures.

This is by far the best out of the top 3 books I have purchased since 1991 when I got involved with industrial controls using micro-controllers. It's clear, concise and to the point. DiJasio does not ramble or go off on tangents as most books in this area do, and makes it very easy to just dive right in and start coding your own custom application based on his ideas.

excellent overview
This is a well written, enjoyable introduction to both the hardware and programming of PIC32's.It is written at an introductory to intermediate level and has broad coverage.If you are brand new to PICs, you may find it throws a lot at you fast, but you will be able to follow with a little work.If you are a veteran PIC user, but not necessarily a PIC32 veteran, you will get a lot out of this book.One thing to note:this book makes little use of the PIC32 peripheral library code in favor of developing its own mini-libraries.The good thing about this is that you learn more about the details of the peripheral hardware and the Special Function Registers.The drawback is that you are unlikely to program the PIC32 this way; you will probably use the peripheral libraries.

A Good Book For Those New To The PIC32/MIPS
A Good Book For Those New To The PIC32/MIPS

Lucio Di Jasio, Senior Applications Engineer, follows on his book, Programming 16-Bit PIC Microcontrollers in C: Learning to Fly the PIC 24 (Embedded Technology), with a similar look yet specific to the PIC32/MIPS 32-bit architecture. The style of this book departs from the previous in that the aeronautical theme "flying" has been nearly removed (there is still a debriefing section at the end of each chapter or "Day" as well as "checklists"). Other than those differences, the books are very much the same. So, if you enjoyed Lucio's first book, you will also enjoy this book. The "Tips & Tricks", "Notes for the C Experts", "Notes for the MIPS Experts" and "Notes for 8/16-bit PIC Microcontroller Experts" are similar to the previous book and are very useful.

That said, this book will not teach you the MIPS architecture, but will teach you the PIC32 with mention of how the PIC32 designers adapted prior PIC innovations to the PIC architecture. To learn MIPS (Specifically, the MIPS 4K core) as well as the PIC32, you should also consider the book See MIPS Run, Second Edition (The Morgan Kaufmann Series in Computer Architecture and Design) and, to a lessor extent MIPS Assembly Language Programming (for the hard core assembly enthusiasts). If your goal is simply to learn the PIC32, this book will get you started.

There are many interesting basic projects in the book including those dealing with the usual; interrupts, LCD, RS232, etc. The project ("Day 6: Memory") is of particular note as the MIPS memory architecture is unlike the classic PIC architecture (it is not a Harvard architecture). Nearly all aspects of the PIC32 are covered including the PMP, A/D converter, and timers/comparators. The final "Days" of the book include projects on File IO, Mass Storage, PWM playback of WAV files and even a simply video generation project.

The book is slightly out of date due to updates in the C32 compiler (clearly the author cannot be held accountable for such changes), and a few missing mentions of defines required for some projects, and there are some rough spots where you really need to pay attention to the entire book to get a project to run (specifically the chapter or "Day 10: Glass = Bliss"). The project is well worth learning, but I found that in order to make sense of the code presented I needed to refer to the author's code (I generally like to type code and debug it as I go - your mileage may vary). The required files were a bit confusing. There are a few errors in the book, none that are serious, however, they is no mention on the errata page. Perhaps this is not an issue though as it does make you learn more about the PIC32 since you must refer to the data sheet and compiler include files to remedy the errors.

So, to summarize, I'd recommend this book in an instant to the individual that wants a guided tour of the new PIC32, does not want to begin by reading the data sheet (you should definitely read the data sheet at some point including the PIC32 Family reference manual) and wants to have some fun learning along the way. If you are a hard core PIC programmer to start with, you may get some use of the book specifically when it comes to the MIPS specific material but I suspect you will know by simply reading the contents.

Nothing like it, but it sometimes isn't quite clear
A good book, nothing else out there like it on programming PIC32 in C.

You should come to this with some experience in C, but it isn't absolutely necessary. I'm learning to program in C at the same time I'm going through this book.

I'd give this five stars except it is sometimes lacking in explanations of new concepts. I'd give it 4.5 stars if that were possible.

The chapter sample code on the CD isn't well commented. On the other hand, if you copy the chapter sample code to your hard drive to use it, you can comment it yourself as you learn.

Very nice resource
I just finished reading through this book and found it to be an excellent learning guide. I've never played with microcontrollers before and wanted a book that would help me learn the basics and understand both practical and theoretical issues in working with them. While the book is written around a specific microcontroller, I felt like it did a great job of presenting the material in a sufficiently general fashion that you could easily apply the principles to devices from other families or even manufacturers. I also think that using a book that was focused on a specific device was helpful, because it can then show you exactly how to do things while you're first learning rather than having to use overly general descriptions that might leave you wondering how you apply the concepts in real life.

There are some typos here and there, but nothing that was terribly confusing. My only real complaint is that sometimes variables or constants used in the author's code snippets are not defined or described in the text or code comments and it can be a little cryptic trying to figure out what he's doing with them (he's a big fan of highly abbreviated variable names). Fortunately, I felt like the underlying concepts were explained well enough that I could still understand what was going on at a high level even if was difficult to figure out some of the specifics of his code. This mostly happened in the later chapters where he deliberately passes over some of the nitty gritty details in order to focus on how to effectively use some of the more advanced microcontroller features. I thought the presentation was very effective in that regard.

Overall, an excellent read from a raw beginner's standpoint. ... Read more

Product Description
Discusses fundamental notions, data types and objects,expressions, statements, declarations, function and program structure,the preprocessor, and the standard library. ... Read more

Product Description
Runnion makes extensive use of examples to teach assembly language programming to studentspossessing a wide range of skills. The text motivates concepts with applications, presenting a thorough, yet accessible approach to an inherently detailed and complex subject. ... Read more

Customer Reviews (2)

Very informative.
We used this book in our college assembly language class.(If you have trouble finding this book, get it at a junior college bookstore.)I found it very useful, but might be difficult for a person who hasn't programmed in assembly language before.(For the rank beginner, Robert Lafore's Assembly Language Primer for the IBM PC and XT, circa 1984, is very easy reading - find it at a library, it may be out of print now.)Runnion's book has information on 32-bit instructions, as well as BCD (big integer) algorithms.The appendices give the syntax for most of the Intel x86 instructions (16-bit as well as 32-bit).Nothing on Windows programming though - all examples run in a DOS window.

I have not read this book
I have not actually read this this book, but it is probably good or no one would publish it ... Read more

Product Description
Another gem from Herb Schildt--best-selling programming author with more than 2.5 million books sold! C: The Complete Reference, Fourth Edition gives you full details on C99, the New ANSI/ISO Standard for C. You'll get in-depth coverage of the C language and function libraries as well as all the newest C features, including restricted pointers, inline functions,variable-length arrays, and complex math. This jam-packed resource includes hundreds of examples and sample applications. ... Read more

Customer Reviews (40)

It's worse than I remember.
I once wrote a fairly negative web page about the 3rd edition of this book.The 4th edition corrects some of the errors, but many more remain.Schildt's writing is very friendly, but he frankly does not know C well enough to be writing about it.His example code is full of errors.Some might prevent things from working immediately; others would be more subtle, and might not show up until you tried to run stuff in production.

All the people dismissing this as nitpicking have missed the point.*THE C LANGUAGE IS VERY PICKY*.If you want a friendly language that doesn't care whether you know what you're doing, don't program in C.C doesn't just let you shoot yourself in the foot, it helpfully picks the gun back up, reloads it, and hands it back to you, already pointed at your other foot.

Newbies who learn from Schildt's books either stay clueless or spend years overcoming the various misunderstandings they acquired from them.

Seriously, stay away.It's a huge book, it's full of text, but the text is full of errors, and if you try to learn C from this book, you'll end up disadvantaged.There are many better books, and few I'd call worse.(Some are less well-written, but that at least means that you don't pick up their mistakes.)

I opened this book to a random page (page 259), and found a program which had at least six errors in it, some fairly serious.The net result is that the program does not illustrate anything, may not work on some systems, and that it is completely obvious that the author never, ever, ran the program to see what it did.(You can tell, because if he had, he would have noticed that it never displays the output prompt he prints.)

Note source of complaints about this book, please
This book is in common use by C developers, especially on Microsoft platforms. It has some flaws, mostly due to Microsoft centricity, but I shall give it five stars.

This is because all of the complaints about this books seem to me, after researching this issue, to date by way of viral replication from a single document ("C: the Complete Nonsense": use Google to find). I have discovered that the author of this document, one Peter Seebach, is without qualifications or standing in either practical real-world programming (especially on Microsoft platforms) or academic training, whereas Herb Schildt has a Master's in computer science and extensive real-world experience especially but not exclusively on Microsoft platforms, where C programmers need extensive guidance.

Based on this single document it has become a fashion statement amongst non-Microsoft developers to "hate Schildt".

If you Google and examine the single source of the Schildt canard you find a list of about twenty random objections, some of which are genuine errata (of the sort that appear all the time in published newspapers, magazines and books despite the best efforts of authors and editors), some of which stem from Seebach's hatred of Microsoft (a fashion statement), and some of which are trite.

For example, because Seebach believes that it is logically possible to implement C without using a stack for small values and a heap for larger data structures, Seebach takes Schildt to task for existentially talking about "the" stack and "the" heap. Because of Seebach's limitations, he fails to see that Herb's discussion was no different from the way a high school teacher of geometry must perforce draw a specific right triangle (with a specific size) to illustrate a general Pythagorean truth about such triangles.

Seebach himself makes errors in his document which in turn may be "laughed at", where the campaign against Schildt, although conducted by chronological adults, is conducted by way of the childish laughter of fourteen year olds; very often, arguments against Schildt as seen on comp.lang.c reduce to "agree with me that Schildt sucks or I will laugh at you".

For example, Seebach tells us at one point that "the 'heap' is a DOS term". Which of course, it is not; heaps were invented to store variable-length data structures without cluttering the stack.

Charitably, that is with a charity Seebach is incapable of showing, one could say that Herb's presentation was, according to Seebach, overly specific, and tied towards an MS-DOS runtime architecture in which the stack grew in one direction and the heap another in a common, and at the time (the time of the first edition of this book) small storage. But this means that the high-school teacher of geometry who does not warn his students that what he claims is true of all possible triangles, and who does not warn his students that the dimension of the line he draws in chalk is not (or is) to be included in the calculation of the area of the triangle, is a "bad" teacher.

Focusing on the conduct of the teacher and not ideas is a Fascist gesture, since Seebach was both incapable of and unwilling to talk about what happened to C as a result of its own deficiencies: the creation of dialects and the preservation of mistakes (such as the semantics of C's for loop and the pre and post increment operators). To talk about ideas in an industry dominated by vectors of vendor greed, a Matrix of unknown forces, is somewhat dangerous. How much easier it is to attack powerless individuals!

The behavior of the author of "C: The Complete Nonsense" was an example of a new childishness in putatively learned professions, as in the famous Sokal hoax, justified by a supposedly egalitarian or libertarian spirit which discounts certification and which mines individual texts for nuggets: which specialises in giving offense and causing pain as ersatz logic through magnified canards and Sokal-style pranks. Since theory formation (such as theorizing why there are Two Cultures in programming) might anger anti-intellectual programmer employers by giving accidental offense somewhere in the money network, it's actually safer to regress to the nightmare of childhood: Fascism.

Content OK, but it's in a hundred pieces.
This is a reference book, and not a bad one. I would have given it 4 stars, but the quality of the binding is terrible.

I think a few pages fell out, the first time I opened this book. After some mild usage, I've just got a big ole pile of papers, with a bunch of missing pages.

Good learning book
This was a requirement for college.I have the kept the book after college though because I think it is good reference.

The most updated C book on the market.
First of all, it shoud be said that the C language is so widely used it's a shame that good and updated books no longer appears on the market. This book is an exception. To my knowledge, it's the only book that covers the latest additions from the last ISO/IEC 9899:1999 standard.
This book covers (in addition to the traditional C89 standard):
1) restrict pointers.
2) the inline reserved word.
3) The new _Bool and bool types.
4) The new _Complex and _Imaginary reserved words.
5) The new "long long" integers for 64 bit integer arithmetic.
6) Variable lenght arrays.
7) Type qualifiers in array definitions.
8) Single line comments.
9) Mixed code / declaration style.
10) Variable arguments to macros.
11) The _Pragma operator.
12) Variable declaration inside for() cycles.
13) The new compound literals.
14) Flexible arrays inside struct members.
15) Delegate initializers.
16) Various additions and differences from the past standard.

and, most importantly, it always underline when a concept apply to C99 only, when it apply to C89 and when it is usable in both standards. It also underline when something get in contrast with the C++ programming language. The difference between the two standards will be always clear.
And, to my opinion, this is a *very good thing*.
What matters the most is: this book will teach you C. It's not an advanced book nor a beginner book. It's intermediate. So, if you're looking for an updated book about the C programming language and you have programmed something before, get this book now and leave complaints to others. If you're searching for a pedantic syntax/semantic analysis for the C language, just buy the specifications. The last section of the book is fantastic to gain confidence with the language. While not C related, it teaches you how to solve common problems by using C in practice:
a) Search and sorting.
b) Queues, stacks, linked lists and trees.
c) Sparse arrays with hash tables.
d) Syntax analysis and expression evaluation.
e) Some techniques used in artificial intelligence.

An additional section covers the implementation of a small C subset interpreter!!!

This book is not intended to be the most complete and advanced C book of the planet, but reading it surely it will contribute to your C knowledge and technical skills with it. Buy it without hesitation as a first book for this language. And don't skip more advanced books like "Expert C Programming" by Peter Van Der Linden, "C Traps and Pitfalls" by Andrew Koenig and "Memory as a Programming Concept" by Frantisek Franek. ... Read more

Product Description
Get the preeminent guide to programming application for Windows with C++. Programming Applications for Microsoft Windows is a classic book (formerly titled Advanced Windows, Third Edition) and is now fully updated for Windows Vista, including the latest information about Windows XP. In-depth and comprehensive, this essential reference covers the Windows operating system and how to program at the API level. Recognized experts provide an inside view of how Windows works and how to use its features in Visual C++ development tasks. Topics covered include processes, thread pooling, virtual memory, DLLs, file I/O, and message crackers. For systems-level programmers, this is a must-have title. Includes code samples in Visual C++.

Features coverage of classic topics such as thread pooling, heaps, and advanced DLL techniques

Provides expert guidance fully updated for Windows Vista

Provides extensive sample code in Visual C++ 2005 ... Read more

Customer Reviews (16)

More information than most would care to know.
This book is awesome. I'm reading it along with Windows Internals, and this is my favorite of the two. I'm still reading it, and the knowledge keeps coming at a steady pace. This book is heavy on information and code. If you plan on developing for Windows in any serious capacity, this book is a must-read.

Great book
One of the greatest programming book I have ever read. Although topics it covers are rather advanced, Jeffrey's style makes everything so easy to follow. The greatest thing about book is that authors don't follow 'how-to', but 'why' approach. After reading each chapter you know the subject not becasue you know how-to do it, but because you understand how is it (threads, kernel objects, virtual memory) working. This approach is essential when you want to master technology, find hard-to-find bugs and design better SW.

12-13 years ago I read previous edition of this book. That time I was just inexperienced student, but I was able to understand nearly everything.
Today after 10 years of professional career this book was like piece of (delicious) cake.

For every server-side native Windows programmer this book is 'must'. I also recommend Joe Duffy's Concurrent Programming on Windows which gives you some other ideas about multithreading development.

By the way Richter also wrote CLR via C# (Pro-Developer) which is absolutely 'must' for every .NET developer. Also highly recommended.

Great Book for Windows Vista 32-Bit and Up...
This book is great, it doesn't hold your hand.You have to dissect the authors' programs yourself to relate them to the conceptual material in the chapters.Like all good teachers, they only explain difficult or misleading areas of the examples in detail, providing conceptual but not step-by-step explainations of the more easily deciphered (or otherwise just review material related) points in the code.

Don't buy this book for more than a joy-read without buying Windows Vista 32-Bit or Windows 7, however, because most of the programs will not work.(I tried out the code from the website (NoCD library book :( ).A simple trip to MSDN to look up the function that fails to execute in over half the example programs confirms this fact.)

I also reccommend Programming Windows by Charles Petzold and Windows Internals by Mark Russinovich/David Solomon as parallel companions to this book (that means keep them next to you, ready to reference...also don't forget to load up MSDN on your notebook!).

This is a very very involved read, which I like.Like I said before, you can't just sit there and watch the text go by on this one, so get your brain working!I will be ordering my own copy as soon as I upgrade to Vista or 7.

An update to a classic
I recently updated my previous century's copy of "Advanced Windows" to this one. This book adds a few details about Windows Vista although as a programmer I wouldn't want to do anything Vista specific. It dicusses not just how you would, say, use virtual memory, but also why. The discussion on architecture mkaes the book more or less complete. The chapter on DLL hooking will save you a lot of researching the Microsoft web site. A well written book that will be of use to a Windows C/C++ programmer. Christophe Nasarre is an author to watch out for.

Good reference book, but
As in many other books, this book also contains erroneous programs. And, what is even worse, one program which one of the authors claims he has solved a deadlock situation does not work the way he says it should, which means that program is NOT the solution.

The program is at page 569, where the function DisableThreadLibraryCalls does not solve the deadlock situation described on the previous page. Even more, the thread created is NOT run in any of two situations. I have tried the program on Windows 2003 Server x64, Windows Server 2008 x86 and Windows Server 2008 x64 and does NOT work the way described in the book.

If a program which is supposed to be THE solution does NOT solve the issue and DOES NOT work the way it is described, what about "normal" programs, which are not THE solution of anything?

I am wondering if any of the previous reviewers who claimed the beauty of DLL advanced techniques have ever tried any of the beauty of these techniques to see if they work the way this book claims they should. ... Read more

Product Description

Customer Reviews (7)

Possibly a good book if updated
I purchased this book in an effort to learn how to program embedded systems. When I opened the book I quickly realized that the true strength of this book's potential lies in it's ability to pattern it's teaching off of an embedded development kit that I would need to purchase separately.
I was okay with this and called the dev kit manufacturer from the appendix - arcom and tried to purchase the hardware development kit so I could follow along with the book.

The Arcom distributor for my area indicated that the kit used by this book for this second edition was not only obsoleted but end of lifed and not available for purchase.

This made me quite sad since without the hardware development environment this book becomes practically useless. That is a real shame. Perhaps the authors simply need to locate a dev kit that is available to their readers and do an update?

As a previous embedded developer and hardware engineer I could probably go through the text and learn a handful of techniques, but embedded programming for me has always required some hardware platform.
This is such a shame....

After being a loyal Seattle Amazon customer for so many years, I felt so strongly that this is my very first review after literally dozens and dozens of Amazon purchases. This is the very first time I felt my money was unfortunately wasted.

Good Introductory Book to 32-bit Embedded Programming
Embedded system requires very diversified skillsets and I don't believe all of them can be covered in one book. In my opinion, the skilset of embedded system programming can be loosely grouped into two categories which are 8-bit and 32-bit. Engineers writing software for 8-bit microcontroller would usually be more involved in hardware details such as keypad debouncing, soft I2C etc. On the other hand, their 32-bit counterpart would spend more time designing more complex software that may includes bootloader, structured programming and RTOS. This book is more appropriate for those who intend to use 32-bit processor i.e. ARM rather than 8-bit microcontrollers i.e. 8051 and PIC.

I had quite some years of experience developing PIC/8051 firmware on Windwos platform, but did not had any experience on Unix. I found the book is particular useful in introducing building project on Unix platform, it is brief, but that's exactly what I wanted - short and simple.

Chapters on hardware, tool chain, memory, interrupts and RTOS are quite fundamental but could come handy to beginner in embedded world despite there are many other books that excel in these areas. However, I found Chapter 7 "Peripherals" is well written to teach you how to write a device driver. I believe this is something new to learn for engineers with either software or hardware background. Hardware engineers tend to access the hardware registers directly. On the other hand, softawre guys may not be familiar with low-level hardware. The authors talked about the device driver philosophy and elaborate on how to use struct and bitfield to provide hardware abstraction. Finally, a serial port device driver is presented as an example.

As a conclusion, this is a very good introductory book to 32-bit embedded programming, or better still if you use Unix/Linux/eCOS. For those who want to learn deeper about RTOS and hardware (say, how to write soft I2C, keypad/button debounce, LCD driver), you wouldn't gain much from this book.

Good book, bad development kit
Presents a good introduction to embedded system programming; no complaints there. However, their choice of development kit is poor. The Arcom (now EuroTech) kit is $600, rather than the $300 stated in the book. And it took almost 3 weeks for them to respond to a quote request. Fortunately, there are kits available from other vendors (BiPom, Olimex, etc.) which can be substituted for less than $300. However, the impracticality of using the Arcom kit robs the book of its purpose of being a hands-on, guided tutorial.

Learning Tool for a Foundation Course
If you are just getting into embedded systems and you want to understand the myriad of interacting concepts, this book is a good start.You will get a solid overview of the basic elements, such as hardware, software tools and techniques, memory and peripherals, processing controls and design strategies.

As with any embedded systems book, there has to be some alignment with specific hardware and application examples.The author uses these examples to tie together embedded elements, but the integration is a bit choppy.

The book is organized as a general introduction to embedded systems.About half the book describes the system elements and about half provides full system examples.A single book cannot cover all topologies and development platforms, so I wouldn't recommend it for someone who is trying to solve a specific problem on his/her embedded application.For cases like that, your vendors and FAEs are probably your best bet.

So if you are trying to learn embedded systems development, this is a great resource. If you intend to use it to guide a current project or debug an embedded problem, it may become more of a distraction.

Great Introduction to Embedded Systems Programming.
This book gives an excellent overview of programming embedded systems. It provides numerous examples of real-world hands-on embedded programming. I'd recommend that you have experience in C. Experience with operating systems concepts (such as interrupt service routines) would also be helpful.

Unlike usual programming books, you won't be able to pick up the book, download something, and start working. You'll need to have an embedded system that you can use. The authors use a system from Arcom that will run you about $300. I've not used it and was very wary about it when I first started reading, but as I read through the various examples I gained a great appreciation for the system. It looks like a great way to gain hands-on experience with embedded programming.

Before getting this book I read through the Lego Mindstorm NXT documentation and felt very lost. I didn't understand the symbols on the schematics and they used strange acronyms (like I2C and PWM). I also have an Iguanaworks USB infrared transceiver. I bought it to use in a MythTV system I am building. This book has enabled me to understand the schematics of both the Mindstorm and the transceiver as well as the documentation of both systems. I now feel ready to do my own embedded systems programming.

That said, I did not like everything in this book. They gloss over areas that I felt would have helped me (such as how to use a JTAG adapter and how to create an interrupt service routine under Linux). There are areas where the writing does not flow well and is redundant. The book switched from using an embedded x86 processor in the first edition to using an ARM processor in the second and there are still references to the old processor.

Even with its faults I am glad I got this book. It filled in many of the gaps that I have as a software engineer who is wanting to learn about embedded systems programming. I feel a whole new world has just been opened up to me and I can't wait to jump in.
... Read more

Product Description
Programming with C++, Second Edition, is an update of the highly successful first edition­­a bestseller in Schaum's computer science line­­and reflects the new ISO standard for C++, rendering previous C++ guides obsolete. Essential for programmers, 280,000 computer science students taking first-level classes, and thousands of advanced placement students, this book is the perfect supplement to the leading textbooks in introductory and higher-level programming courses. ... Read more

Customer Reviews (28)

Don't waste your money!
Simply not enough info in to few pages.This was not a "traditional" Schaum's Outline that I have come to know and depend upon.
Spend a few dollars more and get a more comprehensive Schaum's on the same subject.If you're uncertain of how to do that, simply review the indexes of a few books; The more comprehensive the index the more comprehensive the author treats the subject.
This was a waste of my money!

Good for review
I read this book because I'm going back to C++ programming after having been away for awhile and felt the review would be helpful.

This book generally does a good job reviewing the basics, although it might be a bit difficult to follow in places if you weren't familiar with the concepts to begin with. Thus, if you're looking for a book to review the basics of C++ (like I was) or something to supplement a college textbook, this is a great book for you.

With that said, this book covers only the BASICS of C++. Reading it instead of a full-length treatment of C++ is like reading the CliffNotes version of "Les Miserables" instead of the real thing and thinking you fully grasp the book. Obviously such a short book can't cover everything, and the things it does cover aren't covered in nearly as much detail as a full-length book. There are several topics, such as templates, that get little or no coverage. Also, while this book has abundant examples, it lacks things that would be found in a longer textbook like exercises.

In conclusion, I strongly recommend this book for review or for a supplement to a college textbook but not instead of a full-length book.

Covers basic C++, far out of date.
This book will give you a basic grasp of C++ at a good price. Unfortunately, the information in the book is dated and does not follow current C++ standards.

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

Gut strukturiert, viel Info zu einem sehr guten Preis
Dieses outlet bietet eine sehr gute Zusammenfassung der meissten Aspekte von C++. Es ist kein Anfängertutorial und auch kein Referenzbuch, eignet sich aber sehr gut zum Nachschlagen.

Die Erklärungen sind, im Vergleich mit anderen Büchern, kurz und sehr gut ausgeführt, zusätzlich bietet es noch viele Beispiele zur Vertiefung. Es ist in einfachem, leicht verständlichem Englisch geschrieben. Durch das praktische Format kann man es auch leichter mitnehmen als 1000 seitige Wälzer.

Besonders für die guten Erklärungen und den Preis vergebe ich die vollen Punkte. ... Read more

Product Description
Why is Accelerated C++ so effective? Because it

*Starts with the most useful concepts rather than the most primitive ones: You can begin writing programs immediately.
*Describes real problems and solutions, not just language features: You see not only what each feature is, but also how to use it.
*Covers the language and standard library together: You can use the library right from the start.

The authors proved this approach in their professional-education course at Stanford University, where students learned how to write substantial programs on their first day in the classroom.Amazon.com Review
If you don't have a lot of time, but still want to learn the latest in C++, you don't have to learn C first. You might learn more by digging into current language features and classes from the very beginning. That's the approach that's offered by Accelerated C++, a text that delves into more advanced C++ features like templates and Standard Template Library (STL) collection classes early on. This book arguably can get a motivated beginning programmer into C++ more quickly than other available tutorials.

What separates this title from the rest of the pack is that it jumps right in with samples that take advantage of the Standard C++ of today--from streams to built-in container classes, such as vectors and linked lists. Early examples are more complex than in other books, but the thoroughness and relaxed pace of the explanations will bring the novice up to speed. (Although it ships at a slender 350 pages, Accelerated C++ is packed with samples, tips, and example problems; about 10 per chapter.)

After a tour of basic C++, the book looks at more advanced C++ features, such as templates, including built-in support for containers. Besides tapping the strength of Standard C++, you also will learn to design with your own templates. (Other tutorials would defer this material until later on.) The authors have tested the approach in the book in their own teaching, and honed a set of worthwhile examples that will help anyone get familiar with these powerful language features. All examples make use of the command line and console (without GUI programs), but the advantage is that this code should run on any of today's operating systems and compilers. Later sections cover the basics of class design, which include good coverage of operator overloading and inheritance.

With its innovative approach to teaching the language, Accelerated C++ will challenge readers in the right way. It suggests that you don't need to learn C to be productive in C++. Written in an approachable style, it deserves a close look from any C++ novice. --Richard Dragan

Topics covered:

• Introduction to C++
• Console I/O with stream classes
• Basic string handling
• Loop and flow-control statements
• Arrays
• Using functions and methods
• Using Standard Template Library (STL) containers (vectors, linked lists, and maps)
• Iterators
• Sorting and generic functions
• Basic class design
• Pointers and arrays
• File I/O
• Memory-management techniques, including statically and dynamically allocated memory
• Adding stream support to custom classes
• Conversion operators
• Operator overloading
• Friend functions
• Inheritance
• Polymorphism and virtual functions
• Handle idioms for classes, including reference counting
• Quick reference to the C++ language

Customer Reviews (91)

Not for noobs
I'm on chapter 3 and I don't know but it doesn't seem that this book is good for beginners. I have some background in perl and I've written software for customers in VB. I'm not a complete noob but this book gives you exercises on code that it really doesn't cover and I'm finding that to do exercise 3-5 I'm having to read ahead to chapter 4. I've used disorganized books like this before and it's very discouraging to force yourself to go through exercises they don't cover well. I don't mean to just hand over code to the student but at least give some idea of how to go through the exercise without being on the internet the entire day looking for help and examples. I have 2 jobs and I'm trying to use this book. I don't have time to struggle through this. This book may be ok for someone that has gone through a basic beginner book first but not a C++ noob.

Great Little Book
It is a great little book that has helped me get a handle on C++ right away.I would however not recommend it for someone completely new to programming. Also it does not cover everything about C++, but if you have programed in another language before it will get you right into the C++ without wasting time going through loads of stuff you already know (what a string is, what an array is etc etc)
The negative I have found is sometimes I find I really need to read a head before I can do the exercises, but in my experience I have found that true with most programming books, so its like you need to read it more than once and then go back to it.I found the first few chapters to be easy for me, but then it got harder.

Simple

This is the best book on C++ ... but for beginners.

Can not be used as a Cookbook or Reference and misses alot on OOP.

Can be used only as a learning tool if you have less than 6 month experience in C++.

A nearly perfect book for those new to C++ (but not new to programming)
The authors are widely considered to be among the world's foremost authorities on C++. What is perhaps even more important for the purposes of this review is that the authors are not only knowledgeable, but are also great teachers: they have used the material in this book for their professional-education course at Stanford University, and their pedagogic skills show on every page. It comes as no surprise, then, that "Accelerated C++" is consistently recommended to programmers who wish to learn C++.

The Good: This book does not talk down to the reader. It assumes that you are intelligent and implicitly expects you to have previously come into contact with either procedural or object-oriented programming. Many different topics are covered in a short space (around 300 pages in total), but the text is highly readable owing to the authors's relaxed tone, as well as their many cross-references and their detailed explanations of the examples (after all, the book's subtitle is "practical programming by example"). Equally important, the authors have provided on their website the source code for all the examples in the book (and more), packaged for different platforms. As should be obvious, modifying, compiling, and running the code in parallel to reading the text is integral to understanding the concepts being introduced. In contradistinction to many other popular volumes, this book teaches real C++, not "C with classes". To illustrate this point, let me note that pointers and arrays are only introduced in Chapter 10 (of 16). "Accelerated C++" jumps right in and describes a variety of topics that are of use to professional C++ programmers, such as standard library algorithms, templates, allocators, dynamic binding, and more.

The Bad: Some readers may find the student-grading and character-pictures examples a little boring (though what simple example isn't somewhat boring?). Also, the difficulty level of the exercises is not consistent (e.g. some have already been worked out in the provided source code). This book isn't really great as a reference: new concepts are introduced when they are needed for the purposes of the examples. This means that the chapters cannot really be read out of order. Futhermore, certain things like bitsets, switches, enums, and multiple inheritance are either relegated to the Appendices or are not mentioned at all. In a similar vein, object-oriented programming is not thoroughly discussed (as can be expected from such a short book): e.g., inheritance is introduced in chapter 13 (of 16). Finally, this book was published in 2000 and quite a bit has changed in the meantime. Most notably, we are now expecting a new standard to come out (still known as C++0x). Unfortunately, this book doesn't talk about TR1 (a specification for functionality being added to C++'s standard library) or boost (a collection of libraries offering TR1 implementations and much more), or threading in C++. A new edition of "Accelerated C++" apparently is in the works.

Lest the reader feel that I am being too negative, I note that it is impossible for one book to please everyone and cover everything, while being always up-to-date and still remaining short. In a nutshell, this book is great at what it intends to be: a fast-paced, authoritative, and pedagogically sound introduction to (1998/2003) standard C++ . This book definitely deserves 5 stars.

----------------

My two cents on recommended follow-ups:

* C++ Primer, 4th edition, by Stanley B. Lippman, Josee Lajoie, Barbara E. Moo

A great second book which can be used to solidify and expand your understanding. The "C++ Primer" is over 800 pages long, but it is so well written that it can either be read cover-to-cover or used as a reference (see also my review of it on amazon).

* Effective C++, 3rd edition, by Scott Meyers

This assumes you have already come across all of the material contained in "Accelerated C++" and in the "C++ Primer". It offers solid advice on numerous aspects of effective C++ development. Meyers also describes a few design patterns as well as more modern topics like TR1.

Alexandros Gezerlis

Worth its weight in gold
In less than 300 pages, the authors cover *more* than most c++ books do in 800+ pages. The explanations are clear, and the authors are clearly experts that know exactly what every feature does. Luckily for us, they are also very good at imparting their knowledge. This book will teach you to write C++ instead of just C, which is what most other C++ books seem to teach (even the best ones, like C++ Primer Plus). In short, this is definitely the C++ book to buy. My one caveat is: if you have never programmed, this book will confuse you; but to be fair, C++ is not a good first language if you have never programmed before. Python is the best choice there (its certainly my favorite language). ... Read more

Product Description
Be sharp. Learn C#. Programming in Visual C# 2008 gives you a fresh and easily accessible approach to learning programming concepts using Visual C# for 2008, one of the most pervasive programming languages in the job market today. Best-selling authors Bradley and Millspaugh apply their proven pedagogy, incorporating basic concepts of programming, problem solving, and programming logic and design techniques to teach a mastery of Visual C# at anintroductory level. A hands-on approach, Programming in Visual C# 2008 lets you begin programming in the very first chapter. Thought-provoking feedback questions and in-chapter tips are dispersed throughout so students can reflect on a topic introduced and evaluate their understanding of the details. Comprehensive Hands-On Programming Examples found in each chapter reinforce the programming logic and techniques learned in the chapter. ... Read more

Customer Reviews (1)

Average Book for beginners
I bought this book for my C# course in community college. Its an average book and have some mistakes too. Personally I won't recommend this book as there are tons of other books on C#.Price is expensive too. ... Read more

Customer Reviews (4)

Nice Book
Well, this is an excellent book for the new learners but i couldn't find enough high information for my satisfaction. Anyway, It is a nice book.

said to be the bible of the C
i havent read the book yet but what i know is that this book is said to be the bible of the C

this book is said to be baybl(incil) of C
I havent read the book but what i know is that this book is said to be baybl(incil) of C programming.

one of the best books around on C
You probably want to learn C so that you can learn C++, right?While this is a more difficult book compared with others, it covers the necessary background for you to tackle C++ (and Java subsequently).Kochan's book is easier, but you need a solid foundation in C to move on to OOP in C++ and Java ... Read more

Product Description

Customer Reviews (5)

Good Book.
Cocoa Programming in my opinion is an extremely well written book.I have been through a lot of Cocoa books, Objective-C books and the like, this one is the best.Yes, it does assume you have some basic programming abilities, but his writing is clear and the programming is such that you realize how simple and powerful X-Code and Objective C is.The author never loses you, and when you think that you made a mistake, just read on.The next paragraph will have the solution.Very well done.Excellent Job.Gets Five Stars from me.:)I had the book at a 5 star level, but chapter 10 started to assume that you know exactly what to do.Guess what?We DON'T...That's why we got the book!I am going to continue to read the book and I hope Chapter 10 was an exception because it is still a good book.

So far, So good.
As a web developer, I was a little worried about picking up a compiled language to add to my toolbelt, since the paradigm is so much different from the normal scripting and object oriented programming I'm used to, but so far "Cocoa Programming: A quick start guide for developers" has been an excellent introduction. I am a big fan of PragProg books in general and this book is no exception. Written in a clear and conversation tone, this book is helping me get up to speed with the Cocoa framework from the very practical point-of-view of the XCode/InterfaceBuilder workflow and introducing Objective-C concepts in a way that is illuminating and not intimidating.

Its not a deep resource manual, there are other books that do that, but if you're looking to see what is like to build OS X applications, this is a great first step.

Well thought out and not rushed
Pragmatic has done it again.They once more found an author to truly tackle this ever growing important subject.Cocoa Programming, and not just on the Mac but touches on the iPhone and iPad a bit.Everything is clear and concise and easy to follow.Objective-C can be a bit daunting, but not at the fault of the author just the nature of the beast.But once you get familiar with the language idioms.Things start to fall into place and you just start to get it.

Great modern introduction to Cocoa
This is a great modern introduction to Cocoa Programming.It covers a lot of topics and really helps you get the idea behind the design decisions of the apis. It is a great overview of the many important aspects of programming for the Mac desktop.

Great Starter Book for Cocoa
In my opinion this is a great book for beginners in Cocoa. The author conceptually explains the framework for Cocoa Programming (that is to me more useful then just a programming recipe book).Yes, there are a lot of recipe like books out there for iPhone and Mac programming, but if you really want to learn how things work, this book actually will help fill in the details for you. For example this book really explains 'delegates' and 'first responder' concepts in more plain language to me then other sources I used .Also, in the recent update to the book, the author covers new and important concepts with 'blocks' and 'grand central dispatch' which are new to snow leopard.The book is a big time saver and the price was very affordable (the last I checked) . ... Read more

Product Description
B> This book presents introductory programming and software development concepts to engineers using a disciplined approach. It provides numerous case studies and programming projects based on real-world examples from a wide range of engineering areas, making the material relevant to what engineers will encounter in their careers; the authors introduce implementations of basic numerical and statistical methods commonly used by engineers. Another feature is the addition of a chapter entitled "On to C++" that prepares readers for a transition to object-oriented programming.The book focuses on many aspects of software engineering, establishing early the connection between good problem-solving skills and effective software development. A five-phase software development method is presented in Chapter 1 and applied in every subsequent case study throughout. The book presents material in an order that meets the needs of a beginning programmer, rather than by the structure of the C programming language. This approach makes it possible to present fundamental concepts using traditional high-level terminology--output parameter, array, array subscript, string--and makes it easier for readers without a prior assembly-language background to master the many facets of pointer usage.This book is designed to introduce C programming to engineers in a way that is relevant to their engineering practice. ... Read more

Customer Reviews (5)

Not even helpful
As a sophomore in electrical and computer engineering major at Auburn University, I can safely say that this is the worst book I have ever *attempted* to read as well as spent seventy dollars on. The book came with faded text, a poor introduction, and horrible examples that does not appeal to the beginning programmer. This book is now a coffee coaster in the living room of my apartment (as no one would buy it back). Do not waste your time with this book. Instead, try the Absolute Beginner's guide to C by Greg Perry or any other book if you want to learn C.
Not this book.

Who printed this thing?!?
Although this book does cover the material okay, I was extremely disappointed in the printing and binding quality. For starters almost everything is blurry, except straight text. The programming examples are blurry and the whole book looks like it was scanned in. Even the front and back cover is blurry. The binding quality is terrible. My book fell apart after almost no use(like literally a couple hundred pages came out of the middle of the book in a block). Opening the book requires bending it slightly to keep it open, but as you do, you can see the binding material come apart with. I was careful with this book and rarely used it, but my dollars basically are down the drain in this book.

The content is okay, but there are better books that won't fall apart on you and can easily be read because they haven't been scanned from what looks like newspaper print.

If you have to buy this book for a class, you probably don't actually need it for that class. If you are a serious programmer and want to build your professional library, don't buy this book; get a better one. Reference someone else's book who bought it if you have to.

C Program Design for Engineers
Book trys to be good at explaining programming, but it's not exactly something you can explain in a book.

Well done book
I will have to disagree with theguy that said the book " NOT THE BEST ".
First he said that he was a C++ programmer and that the book was not good for him. Well, i'am not sure if that guy is blind or half stupid ,but the title of the book clearly says " C PROGRAM FOR ENGINEERS " not for morons.

Not the best
I am a c++ programmer and tried to brush up on C using this book. I had to buy a new book. Maybe an engineer can get some use for their $55 some bucks but I didn't. ... Read more

Product Description
Written by the originator of the USENET C FAQ, this book addresses the real-world problems on C programming that are asked, again and again, on the "comp.lang.c" newsgroup. The book is aimed at C programmers who need quick, concise answers to the stubborn questions which invariably arise when programming in C. It provides accurate answers, insightful explanations, and extensive code examples.Amazon.com Review
C Programming FAQs contains more than 400 frequentlyasked questions about C, accompanied by definitive answers. Althoughthis resource contains lots of useful information, it is more of agrab bag of questions and answers than a comprehensive reference. ... Read more

Customer Reviews (9)

A 'real' gem
Have you ever had one of those C language questions that nobody quite knows the answer of?Well, this book should help.

I have seen a lot of good books on C++ on the market but there are very few good C books and this is one of them.I will bet that fewer than 5% of the C developers out there will be able to answer some the FAQs in this book.

It's too bad that not that many people know about this book but it is a real gem.

quick nutshell
this is good companion to C in nutshell. answering your c question quickly and effectively.

references to MSDOS are long in the tooth
Summit gives us an extensive test of our C knowledge. While C has a simple syntax, and lacks object oriented complexity in notation, there are many nuances that catch out unwary programmers.

A lot of the questions revolve around the assembly language-like constructs in C, for pointer arithmetic. Very easy to trip up here. And also in the related area of memory (buffer) allocation.

If that is not enough to keep you busy, Summit also talks about issues of portability across different operating systems or across different versions of the same operating system. At least you usually don't have to worry about the version of C itself. For system dependencies, Summit covers both unix and MSDOS. While C and unix grew up together, a reality is that much C programming goes on under Microsoft.

The references to MSDOS in the text reflect that the book was written in 95. Though even then, Microsft was deprecating DOS in favour of its newer Windows offerings. A newer version of this book might be overdue. Where Summit would no doubt discuss C under XP.

A C programmer's must read
Simply put, this book does a good job of condensing years of FAQs from the comp.lang.c new group. Some of the questions really get down into the nitty gritty of C. The answers are easy to read and understand.

One of the best programming books
This is an essential book for any programmer. I remember buying it when it first came out in Fall 1995. I was an undergraduate senior at the time and thought I was a hotshot C programmer. How mistaken I was! Reading through this book was a humbling experience, as each page showed me fine details of C that I did not already know.

This is an excellent book. It is organised into chapters on different aspects of C, and in each chapter are dozens of FAQs that range from rather common to extremely fine-detailed. Three chapters which I particularly liked were Chapter 1 (declarations and initalisations), 3 (expressions and evaluation order), and 6 (arrays and pointers). Later chapters introduced new (at the time) concepts to me, including getopt, variable-length argument lists, and preprocessor tricks. The level of detail provided in each answer is extraordinary.

Other things I liked about the book: The index is excellent. There is a lot of discussion (spread across the FAQs) on the differences between K&R and ANSI C. (This was relevant to me because at the time, I was splitting my work between gcc and the proprietary cc compilers on DEC Ultrix and SunOS.) The style of writing is friendly and does not talk down to you. This is not a beginners' book!

Note that there is an online version, but it does not have nearly as many questions as in this book. ... Read more

Product Description
B> C by Dissection presents a thorough introduction to the programming process by carefully developing working programs to illuminate key features of the C programming language. This book presents the concepts of the programming process using the "dissection" method. Dissection is a unique tool first developed by the authors to point out key features of program code. It is similar to a structured walk-through of the code, with the intention of explaining newly encountered programming elements and idioms as found in working code.Each chapter presents a number of carefully explained programs, which lead the reader in a holistic manner to ever-improving programming skills. Right from the start, the reader is introduced to complete programs, and at an early point in the book is introduced to writing functions as a major feature of structured programming. This edition features expanded treatment of pointers, memory management, and recursion. It also takes into account the fact that many people are learning Java as a first language and then going to C, or vice-versa, and calls out those topics that present a challenge when making such transitions (e.g. i/o, data types).This book assumes no programming background and can be used by first-time computer users or by experienced programmers who are transitioning to C. ... Read more

Customer Reviews (28)

Great Reference
Anybody trying to learn C, this is the best and probably the only book you will need.

Probably need some experience...
I am a complete newcomer to programming, and am still taking my Programming in C class. Although the book claims to be for beginners, I found it a pretty difficult read. My professor's lecture only makes things foggier, so I THOUGHT I could rely on the book to clear things up, but it only does vaguely.

The books gives you an example of a program, then walks through each line of the code and explains what it does. The only problem is that it explains in jargon, which is to say, geek speak. I had trouble following along, and eventually hired a tutor to explain everything to me.

This book would be great if I already had some fundamental knowledge of the language, so if you do, go for it.

C by Dissection: The Essentials of C Programming
What a horrible book! Right in the Preface, the author writes "NO BACKGROUND ASSUMED", then continues in the first sentence following; "This book assumes no programming background and can be used by students and first-time computer users."

WHAT A JOKE....

I consider myself to be a reasonably smart person.I excell in engineering, and electronics and have a desire to learn the programming.Although the author (even in reviews here!) proclaims this to be for "first-time computer users", it is not.It is bland, unintresting reading.Examples and illustrations require knowledge not previously mentioned in the book for understanding.OFTEN, the book says something like --- This is covered later in Chapter 12.... --- but its understanding is needed at that moment and in the example currently being discussed in Chapter 2 or Chapter 1 or wherever.

Then agin, It could be used by a student or first-time computer user.It could be used to keep papers from flying away or to prop a good book up on.

I wish I had my money back!

Chuck

Not for the beginner
I needed this book for a programming class and thankfully I had a good teacher.This book starts to describe a point and then says something similar to "(See chapter 14.2)" or "Later discussed in 8.4"Can you not just tell me how to use the printf function now?The books examples are thorough and most of the programs written are dissected and explained, but they miss the part of actually teaching and explaining the function in the first place.The book also contains exercises at the end of each chapter to help reinforce what you should have learned in the chapter which can be helpful, but some are too complicated if you're just starting out.The book also has a section at the end of each section that explains how to move on to C++, along with a section of common programming errors, and an additional section for programming style.This book would be good for reference, but if you're just starting out, you should look for something different.

A great book
This is really one of the best C books. It is easy to read and follow. The examples are top notch. It is a must to any one interested in C. ... Read more

Product Description
With its ever-expanding installed base, C continues to be one of the most popular programming languages on the market. This fact, along with the Teach Yourself series' reputation as the most popular way to learn programming languages, guarantee that Teach Yourself C in 21 Days, Fourth Edition is clearly headed for the bestseller lists. ... Read more

Customer Reviews (9)

Not Bad!
I've searched through the most popular books on C and C++ trying to find something on how to determine how much memory is available for your data.I was looking for something comparable to the "memavail" command in Turbo Pascal.A programmer wants this information if he plans on putting most or all of his computer's available memory to best use.Finally I found something, and it was in this book.(I am amazed that other books on C offer nothing by way of advice or anything else in this area.)It was an example of how to use the memory allocation function (malloc()), and it also provided an excellent example of what you can do with C pointers.My compliments to the author(s) of this book.

Nice book
This book is nice one, I'm sure that it could make you understand the language. I'm a C++ programmer, but somehow I have to read/analyze C code very often (since C is more popular than C++ in Japan). This book iswell-done in many aspects. However, there are still something/functionsthat shouldn't be use. For example, the author used "gets()"function, which is dangerous.

Anyway, overall this is a nice book on Ctutorial. Note for noive/beginner don't hope to finish it within 21 Days,remember that learning any language, not just programming language, taketimes.

Fun to frustrating
This book starts off excellent, giving the user the belief that C is easy, etc.In fact, it is not easy and you need to have some programming experience before attempting this book.For the first 5 days no experienceis necessary, but this changes quickly

An Excellent Tutorial!!!
This is the first C programming book I read. I still recall the excitementI felt when I run the first code example in the book and saw "HelloWorld" displayed on the screen.

1) The authors present the keyconcepts in C language, such as pointers and arrays, in a concise andeasy-to-understand manner.

2) The many code examples (with analysis) inthe book enable the readers to better understand the language features.More importantly, they can get a feel on when and how to use thesefeatures.

3) The programs are fun to run, and the pace of the book iseasy to follow. I finished the book (including most of the exercises) in 21days.

I highly recommend it to everyone who wants to learn C.

Very comprehensive but too complicated
This book is good and will teach you a lot. But at many points i felt likegiving up because it is easy to get lost as it is too complicated. ... Read more