Customer Reviews

Head First C#

5 star:		(67)
4 star:		(23)
3 star:		(5)
2 star:		(13)
1 star:		(11)

 

 

Head First C# was my first experience with the Head First series, although I have since also purchased the excellent Head First Design Patterns (Head First).

This book is designed to teach you C# from the beginning. Technical books can generally be categorized as either tutorials or reference texts -- and this is absolutely in the tutorial category. It's intended to be read and worked through in order, from start to finish. If you already know C# and are looking for a reference text, look elsewhere. If you're an experienced C++ programmer looking to learn C# but are already very familiar with object oriented programming, consider checking out the excellent and concise Accelerated C# 2008 (Accelerated). If you're an experienced C# programmer and just want to learn the advanced features of C#2 and C#3, you'll again want to look elsewhere, and you couldn't do better than C# in Depth: What you need to master C# 2 and 3.

But if you want to *learn* C# and object-oriented programming, and especially if you have little or no prior programming experience, look no further than this fantastic book. If you're reading reviews of the book, then you probably know two things: it has an unusual style and some quirky humor, and it has a bit more than it's fair share of errors. These two things are true, but there's a lot more about the book that you should know, and that's mostly what I want to talk about in this review. Before I move on, though, let me say two things. First, the conversational style and the humor are sometimes overstated -- this is a book about programming, and it's not a joke a minute or anything. I know that you can't Search Inside here on Amazon to see what the book is like, which I assume is because of the visuals-heavy design and unusual layout of the text, but just do a quick search for the book's website and you can download a full sample chapter and some other excerpts. Judge for yourself before dismissing an excellent book based on its unusual (but effective!) design. Second, the errata *are* extensive, but they don't get in the way of your learning. This book shines for its well-chosen examples, its focus on your learning (you'll be talked to rather than at), and its great overall structure -- and none of the errata interfere with any of that at all. If the extensive errata lists do bother you, I wrote a small free program that can sort through them for you and filter out the types of errors or page ranges you're not interested in. (You can find the link stickied at the web forum for Head First C#.)

There are also some features of the book that I don't see mentioned often enough, and which I want to comment on briefly before getting to the heart of the review. First, I love that the introduction is actually useful, giving you valuable insights on why the authors made the design choices they did (why text is in the pictures, rather than beneath them as captions, for example), and offering advice on how best to approach the book if you want to maximize your learning experience. I highly recommend reading it. Second, it's worth mentioning the way that the book uses the (free) Visual Studio 2008 IDE to make graphical Windows applications throughout, rather than focusing on a text editor and console applications like many other introductory texts. Visual Studio is a powerful IDE, and it *helps* you learn with syntax highlighting and Intellisense -- I'm very glad that the Head First C# authors chose to incorporate its use into the book, because it often allowed me to focus on concepts at first rather than syntax, picking that up gradually through repeated use with the IDE's guidance. Third, you'll be making some genuinely impressive software over the course of the book -- between the use of Visual Studio and the authors' being unafraid to assign projects that take several pages just to *describe*, you'll get a much better feel for what it's like to make real software than you would from the small "toy" examples that are more common in many other introductory books. (But don't worry, there's plenty of guidance, including fully annotated solution code for most of them, and a helpful web forum if you get stuck.) Finally, the book has the advantage of going to print for the first time after C# 3.0 and .NET 3.5 were released, and it fluently combines the various iterations of the language, teaching C# *as it now exists* from the ground up in an order that makes sense for someone learning now from scratch, rather than taking the more common but less sensible route of introducing C#1.0 features before C#2 before C#3. This is great, because it allows the authors to introduce some of the powerful and convenient features of the newer editions of the language and framework -- the stuff that really makes C# appealing as a language -- quite early in the book.

The funny thing about Head First C# is that the conversational tone, the humor, the quirky layout, and the pictures make the book seem completely un-academic. At first glance, it's as far from an academic textbook as you could possibly get! But I've come to realize that reading through the book from the beginning, doing all the exercises, is as close to the structured learning experience of an academic course as you can get in book form. The brilliance of Head First C# isn't in the phrasing of any given sentence or the coding style in a particular snippet -- it's in the overall structure of the book and especially in the examples chosen for exercises, which allow you to build up your knowledge incrementally while still reviewing past material. (Which is why the errata really aren't a big deal.) I've seen some reviews point out the book's "redundancy" as a flaw, and I just shake my head. The book is often repetitious, but never redundant, and always deliberately -- seeing the same material repeatedly from different perspectives and at different times is absolutely key to learning anything, and the repetition is one of the best features of the Head First series in general and this book in particular.

So there are errors. So there's a bit of fuzziness in the phrasing sometimes. So it doesn't cover Advanced Language Topic A or B. So what? This book is a teaching tool. It's a full course -- instructor, fellow students, textbook, homework, projects, review sessions, and conversations with peers -- stuffed onto paper, rolled up, printed, and stuck between covers.

I've learned C#, and I've *retained* what I've learned. I've had fun doing it. And if you too want to learn C# and programming, I can't recommend Head First C# highly enough.

As an experienced programmer, I've found this book to be very good at getting me "up and running" and writing my own C# code (I'm about 1/3 of the way through).

However, the book is clearly intended to be appropriate for less experienced programmers as well, and I think it would be very confusing for someone who didn't already have a fair amount of programming experience.

Specifically there are a lot of typos and errors in this book which would, I think, make it very difficult for a beginner to know whether they're doing the right thing or not. In a lot of cases, I find it difficult to tell what I'm supposed to be doing in a given case because, for example, I'll be told to create a particular field or method for an object, and then I won't be told (directly or indirectly) what I'm supposed to use it for. Then, in the exercise "solution", I will see what the field is used for, but that functional requirement was never stated as part of the exercise description.

Sometimes the reader will be told to create a particular field or method as "private" and then, two pages later, the solution will show it as a "public" field. As an experienced programmer, I can usually guess that the book has made an error in a case like this, but I could easily see a beginner wasting a lot of time due to errors like this in the book.

Here are the specific errors I've found just today:

Page 265:
The "Sharpen Your Pencil" exercise shows a line that states:
Bees[6] = Bees[2];
But the solution shows it as
Bees[6] = Bees[0];
Which makes it impossible for the reader to come up with the correct solution.

Page 271:
The user is instructed to create a method called "ScareLittleChildren()" but is not told what it is supposed to do or when to invoke it. The user is also told to have the "Honk()" method pop up a message box that says "Boo! Gotcha!"

On the following page, the solution has the "Boo! Gotcha" functionality moved to the "ScareLittleChildren()" method.

Page 292:
The user is told that the "diningRoom" object needs to implement the "IHasExteriorDoor" interface, when the previous page explicitly stated that the locations with exterior doors are the front yard, the back yard, the living room and the kitchen.

The user is also never told what to do differently with the Locations that have exterior doors (in terms of implementing the form that drives this exercise). Locations can have "exits" and "doors", but we are never explicitly told whether "doors" are considered "exits"; most people would consider those words synonyms in common usage, but it's only by close examination of the data diagram and sample code that the user can guess that it's probable that the two terms should be considered mutually exclusive.

Page 295:
The exercise solution shows an override method for OutsideWithDoor.Description but not for RoomWithDoor.Description.

These are just the errors that I've found today. I noticed a bunch the day before yesterday, too, when I was working through an earlier section of the book. As I said, I would think that such frequent errors would make the book very confusing for a beginner. It's too bad, since I remember a time (the mid-90s) when O'Reilly books were known for their extremely thorough attention to detail. Pity that no longer appears to be the case.

The one thing that most (nearly all) technical books have in common is that they are B-O-R-I-N-G. While this works for many people looking to just get to the meat and potatoes content, if a newbie or beginner wants to be able to LEARN from a book they are at a loss.

That's where the 'Head First' line of books comes in to play.

If you have never read a Head First book you are in for a treat when you sit down and start reading. Nowhere in a HF book will you be bored as these books aren't looking to just teach, but teach in a FUN, interesting way. It's tough to explain a HF book other than it's an experience in itself. Filled with a design, content, and writing that jumps out at you, these books are looking to get you excited to turn to the next page and/or chapter and want to keep reading.

I think that the C# Head First book is one of the best I have had the pleasure to read. With over 700 pages of content spread over 15 chapters, this is a wonderful book for newbies that want to get coding right away. Filled with all the stuff that you would expect from such a book: basic programming constructs and declarations, object oriented discussion, file IO, exception handling, delegates, and even the newest M$ technology LINQ!!

If you are new to using C# and want to learn in my opinion possibly the best way possible, pick up this book FIRST and use all other guides as references. If you want boring books that are full of drab info and light on the enjoyment, this isn't for you (highly unlikely).

A pleasure to read and easy to learn from, this is one great book on C#.

***** HIGHLY RECOMMENDED

There are over 43 pages of corrections (errata) to the first edition (11/07) of this text. It is inexcusable. You can go to O'Reilly's site and print the errata lists, three of them, to use as cliff notes to decode this book. I have purchased three other titles in the Head First series that are excellent. The quality of this one is horrible. Not only do some of the programming examples have minor syntax mistakes, but entire sections of code are incorrect. In one case the errata recommends downloading a pdf because the text has been substantially revised "to enhance clarity and quality of learning".

If you want to purchase this book, make sure you get the latest edition.

Kevin

First, please understand this is my first review and I am still just a programming student and this is my first experience with C# but not the C language. I've taken two classes in C++ and one in Visual Basic, so I'm not a newbie but at the same time I still wouldn't consider myself intermediate.

I'm writing this review having only read the first 100 pages of the book because I wanted to state that, as of this writing, the current edition of this book that Amazon.com is selling (Pub: May 2010, 2nd ed) there have been NO errors. If you are considering purchasing this book, please be aware that (again as of this writing) there have only been 2 reviews of the newest edition (2nd ed, May 2010). All previous reviews are of the November 2007 edition which was apparently filled with errors. If only Amazon.com would list them separately we wouldn't have this problem.

Now, a brief review of the content. The first impressive thing about this book is that it takes into consideration how our brain works and learns and it explains this to you a bit before getting into the subject of the book. It uses a lot of pictures and repetition (repetition via text and program exercises) to help you remember things which studies have shown makes a big difference in the way our brain stores data. (I know this from reading 'Brain Rules' by John Medina).

Anyway, so far in the first 100 pages, we've lightly covered the basics; variables, if statements, loops and program structure (namespace, class, method, statements). When I say lightly, I mean it doesn't go into every type of variable or all the details of a method. I feel this is a good approach for a first time coder because trying to remember everything a method can do in one chapter just isn't going to happen. I should also mention that in the first chapter you go through a simple program to help you get the feel of the IDE (Visual Studio 2010).

That about summarizes my experience in the first 100 pages (mid chapter 3), I will add more to the review as I progress through the book.

Update 7/11/2010: Been busy, I've only got to the end of Chapter 4 since my last post. So far great except for a few steps left out of the program you build on p. 162. However these steps and a reason why they aren't there are posted on the front page of the Head First C# webpage.

For those interested, here is the Table of Contents (Summary):
Intro
1 Get productive with C#: Visual Applications, in 10 minutes or less
2 It's All Just Code: Under the hood
3 Objects: Get Oriented: Making code make sense
4 Types and References: It's 10:00. Do you know where your data is?
C# Lab 1: A Day at the races
5 Encapsulation: Keep your privates... private
6 Inheritance: Your object's family tree
7 Interfaces and abstract classes: Making classes keep their promises
8 Enums and collections: Storing lots of data
C# Lab 2: The Quest
9 Reading and Writing Files: Save the byte array, save the world
10 Exception Handling: Putting out fires gets old
11 Events and Delegates: What your code does when you're not looking
12 Review and Preview: Knowledge, power, and building cool stuff
13 Controls and Graphics: Make it pretty
14 Captain Amazing: The Death of the Object
15 LINQ: Get control of your data
C# Lab 3: Invaders
i Leftovers: The top 11 things we wanted to include in this book

I have been out of coding for almost 10 years and decided to get back into it recently. Since I'm focusing on .Net technologies I thought jumping into C# would be the right step. I read most of the reviews for this book and the gist I got was: it was good for beginners, well written, but full of errors.

I have found only two of those to be true: The second edition of this book seems to be mostly error free. I'm about half way through and I *think* I've found only one error so far (this was very minor too). All of my code has compiled and I haven't had any issues at all. The book is very beginner oriented but moves at a good pace. The concepts come fast and things like class diagramming and coding styles are seamlessly worked in to the lessons.

The book teaches C# and object oriented programming from the beginning and I can't recommend it enough for someone who is starting out or has been out of the game for too long (like me). Make sure you get the second edition and you wont be disappointed.

There are several reviews for this book that cite the poor editing of the first edition of this book. As I have found that the confirmed errata on the O'Reilly web site seems to be fixed in my copy, I can only assume I have the second edition.

This book isn't perfect; there are still some errors, BUT if you are really trying to learn C# and you've paid attention to what you've read in the book, the errors are not serious and you should be able to tell what was intended.

I suppose I should say that this book is just over 700 pages and I am currently on page 348. That means two things. First, I can't claim that there won't be problems with the text later in the book (but I doubt there will be), and two...

When I say I'm on page 348, I mean I've read every page preceding, followed every exercise and finished the first lab without 'cheating'. I haven't done that with a 'computer book' since Datamost published a guide to Applesoft Basic back in the early 1980's.

What do I really like about this book? Two main things. First, everything is explained, then repeated several times in plain language. If at first I don't understand, I only need to keep reading to have the explanation come at me again from a slightly different angle, and usually with a new code example or exercise. Second, I love (LOVE!) the labs. After learning and reinforcing several key bits of C#, you'll eventually reach a lab wher you are given the specs for a program. There are usually some details on what sort of approach you might take but otherwise you are on your own to use what you've learned to build the application. If you are serious about learning anything (including C#), nothing beats practice, practice, practice.

The forum for this book on the O'Reilly site is populated by helpful people who seem to be good at sharing information and helping clarify if and when you get stuck on something.

I would totally recommend this book, especially if you are a beginner.

I don't know how to program, I'm not a professional in the computer industry. I'm just a guy who wants to make a game, and is willing to put in some work toward making that happen. I have tried to read several books on C++, but I always get bored. I wish this book were about C++. It pulls me right through the pages with interesting text and easy to follow pacing. In most book, by chapter three, if your lucky, you've made a "Hello World" program. In Head First C#, you've made programs that could actually be useful, even if they aren't that great. It is much more engaging than other programing books that I've read, and I have no reservations recommending it to anyone interested in learning C#.

Overall, I can say that I love this book. It makes learning a programming language fun. This book focuses on C#, but you'll also learn about object-oriented programming, the .Net framework, the Visual Studio IDE, and the .Net GUI tool set. The presentation is great for retention. This book gets you involved from the first page. Some of the programming examples are somewhat nonsensical, but I think the humor helps keep you involved. There are a lot of places where the book asks you to stop and write things down and following the book's guidelines helps to solidify the concepts that were discussed. When I say discussed, I mean the book feels more like a conversation than a lecture. The conversational aspect is another tool to keep you involved in the book. The material builds upon itself nicely and takes breaks in 3 different spots for lab work, which are decent sized applications that reinforce the concepts taught up to that point. You also build interesting programs as you work through the book's examples, like a random excuse generator and a bee-hive simulation. These aren't the boring "build an order form with a button that calculates shipping and tax rate information" programs that you'll see in lifeless textbooks. At the end of this book, you will have to learn more about the advanced areas of C# and .Net, but you will have a very strong foundation to build upon.

There are a fair amount of typo's and minor errors in the book. It's definitely a candidate for a revision or a second edition. However, the minor errors won't get in the way of the actual learning experience. You just have to overlook the minor flaws.

I would not recommend this book for people who already have solid programming experience and are looking to learn C# to round out their repertoire. I imagine they would be better suited with a language reference style book. This book is not suited for serious reference material.

I plan on purchasing more Head First books. I have learned much in a short period of time and actually enjoyed doing it. I've dabbled in teaching myself programming before, but all the self-teaching books I've previously read have left quite a bit to be desired. This one feels like I have an instructor working with me through the book.

This book is absolutely incredible. This was my "switch from VB to C#" book. After reading this entire book I feel and think like a professional C# developer, a true object oriented programer. So what it has a few typos or even sections of slight confusion. But the way this book is written teaches you how to think outside the box, not provide you with a quick Copy-Paste code example to use in your app.

Because of this book and my implementations, I've increased my salary substantially (because our development social rate C# programmers higher than VB programmers). Moreover, this book makes coding C# fun. You can't tell me applying base class and interface schemes to create a cool role-playing-game wasn't exciting.

So if you're not an english major/teacher/editor and think a few mistypes or spellings don't matter, you will definately want to get a copy of this book. I liked it so much that I purchased the Java book as well. Who would have ever thought programming was so fun!!!