Comments about O'Reilly Media Cocoa and Objective-C: Up and Running:

A very straight forward book for learning the basics of getting a project off the ground. It is very useful to point you in direction that you want to go without bogging down in specific details. The only drawback is that it isn't updated for Xcode 4, which makes things difficult to find

Comments about O'Reilly Media Cocoa and Objective-C: Up and Running:

For the first time I read a clear and simple explanation of pointers.

Comments about O'Reilly Media Cocoa and Objective-C: Up and Running:

Scott Stevenson does a good job explaining the principles of Objective-C. It's not as easy to understand as I would expect from a book for beginners, and it's certainly not a book that a total beginner to Objective-C will be able to easily understand.

The main problem is with the editing. It's just plain sloppy. One of the first examples in the book is missing an "include" statement, which prevents the code from compiling. The problem is that at that stage in the book the user doesn't know enough to be able to figure out what the problem is and instead can spend hours making sure what they typed matches what is in the book....all to no avail. Also, there are all sorts of grammatical errors (was this book edited at all?).

The bigger issue with editing, though, is that it is not edited such that it follows a logical progression for a beginner programmer. It jumps from topic to topic erratically instead of slowly building on what has already been covered. I wouldn't expect the author to be able to think like a beginner, but I would expect the editor to catch this and be able to reorganize what the author wrote in such a way that it helps a beginner learn.

I would not recommend this book to anyone who is a Objective-C beginner, not unless a non-technical editor goes through it and fixes it up anyway.

Comments about O'Reilly Media Cocoa and Objective-C: Up and Running:

I was familiar with the MVC design pattern and I knew an object oriented programming language. I assumed that this background would put me in a pretty solid position to easily develop for iPhone. So off I waltzed down the proverbial primrose path wearing rose colored glasses, only to repeatedly find myself sliding off a cliff with Objective C for iOS.

After reading Scott Stevenson's "Cocoa and Objective C: Up and Running", it's clear that most of my problems related to my ignorance about C structs, as well as a misunderstanding of *pointer variables.

If I could rewind time, this is the first book for iOS that I would read, and I recommend it very highly.

I'd read at least five other books, and all of them contained good explanations. But none of them explained the things that I most needed to understand, including:

** What is a *pointer variable, what is its purpose, and how does it work? (Stevenson's explanation is the best one that I've read.)

** What are the differences between a C struct and an object, how do I spot the differences, and why do I care? (This is the first book that explained the implications of what happens when you combine structs and objects in your code, and it is fundamental for writing iOS apps.)

You probably shouldn't expect to get through it in a weekend, but that's only because some sections bear multiple re-reads. It will remain on my bookshelf for reference.

Here is one key area of confusion this book helped me clear up, and I'm explaining in my own terms what I learned in Chpt 4:
-- When you are working on any relatively complex app in Objective C for iOS, you will probably end up combining C structs with Objective C objects in the same code files.
-- This may seem like a trivial point, but imagine that you are setting up an ant farm. An ant can regulate its own temperature, move about, and communicate with other ants -- it can 'get' and 'set' its own temperature, assess its movement, redirect itself, and send and receive messages from other ants. It can do this because it is (in software terms) an 'object'.
-- On the other hand, inside the ant farm you may also have a variety plants. Plants are simpler structures than ants, and you can't expect a plant to behave in the way that an object behaves.
-- A plant (like a C struct) behaves differently than an ant (i.e., an object). If you try to write code that assumes they function in the same way, you will end up in a world of hurt.

(NOTE: Stevenson does not use analogies about ants and plants; this is simply my own interpretation of what I gleaned from his explanations. His explanations helped me visualize key concepts; you'll interpret his explanations in a way that is useful for your own work.)

I would have saved some time and heartburn if I'd read this book first when I started learning about iOS and iPhone. But take your time; you can't race through this book.

Comments about O'Reilly Media Cocoa and Objective-C: Up and Running:

I am a non-professional programmer with some experience in C. I have been trying to wrap my head around Cocoa for awhile, almost always starting back at the Hillegass book that many rave about. This however is the book for me. The explanation of things that are either absent or hurried through in the aforementioned title are thoroughly covered here. This is not a complete reference by any means, but it gets one started in a way that is easy to understand and gentle on the mind. I have gotten far more out of this book than any other I've read on beginning Cocoa.

Comments about O'Reilly Media Cocoa and Objective-C: Up and Running:

This is a book I plan to keep on the shelf as reference. For me, the greatest value is in the numerous code samples. But the treatment of dictionaries is bizarre.

What's in a printed, language dictionary? Word:definition, word:definition, word:definition. Each entry has the same "object" type. The retrieval of each object can be done by key. This is the value of dictionaries over key-less collections.

But the examples of dictionaries in this book use keys of city, state and zip in one example and title, focal length, distance, etc. in the second. Seems to me like the author's missed the point and principle use of dictionaries. It would make more sense to have a dictionary with keys consisting of nothing but zip codes and objects consisting of City:State structs.

The example used in the book does demonstrate that the objects within the dictionary do not have to be of the same class. Which is good to know. But that side-note isn't really being called out.

Comments about O'Reilly Media Cocoa and Objective-C: Up and Running:

It will be short review.
Why it's great book?

1. Because it writes about complicated things in simple way.
2. All materials are ordered in thought manner.
3. Each new concept is described in details.
4. Book is not only about Objective C and Cocoa but has short and effective introduction to C language.
5. Step by step, in dialog with author.

Thank you for your good job Mr Stevenson.

Comments about O'Reilly Media Cocoa and Objective-C: Up and Running:

The back of this book suggests that "basic programming experience is recommended." I have a lot of experience working in scripting languages like PHP, PERL and Javascript. I understand the concepts of objects and MVC. I would define that as "basic programming experience."

Apparently, as far as this book goes, "basic programming experience" means "Have a computer science degree."

By page 50, my head hurt. Difficult concepts like pointers and memory allocation are dealt with like so:

"...if all of your data has to live in global variables and you have thousands of different things to store, you soon have a mess."

WHY? I've built PHP applications with thousands of different things to store. This book has no true explanation of the consequences, no true explanation of the advantages, and not enough examples to demonstrate how to wrap your brain around the concept.

I will admit that a lot of my frustration may be with the language and the concepts themselves. Why do I need to create an accessor to retrieve a value? If the value is there, why can't I just access it directly like I learned to do with variables in Chapter 2? I'm sure it has something to do with memory allocation, but here's what the author has to say about it on page 91:

"Now that I have some instance variables, I'll add accessors to retrieve the values."

Why? On page 86:

"This is partially just because it's better encapsulation, but the other reason is that Cocoa offers some more advanced 'generic programming' features that depend on using accessors properly."

Gee, that was helpful.

I'm sure to those of you reading this with experience are laughing at me for being such a stupid n00b. Go ahead and make fun of me, I don't care. The truth is, this book purports "to be accessible to new programmers," and it's not. It needs more examples and more baby steps through difficult concepts to live up to its promise.