Build solid applications for Mac OS X, iPhone, and iPod Touch, regardless of whether you have basic programming skills or years of programming experience. With this book, you'll learn how to use Apple's Cocoa framework and the Objective-C language through step-by-step tutorials, hands-on exercises, clear examples, and sound advice from a Cocoa expert.

Cocoa and Objective-C: Up and Running offers just enough theory to ground you, then shows you how to use Apple's rapid development tools -- Xcode and Interface Builder -- to develop Cocoa applications, manage user interaction, create great UIs, and more. You'll quickly gain the experience you need to develop sophisticated Apple software, whether you're somewhat new to programming or just new to this platform.

Get a quick hands-on tour of basic programming skills with the C language

Learn how to use Interface Builder to quickly design and prototype your application's user interface

Start using Objective-C by creating objects and learning memory management

Learn about the Model-View-Controller (MVC) method of sharing data between objects

The animal on the cover of Cocoa and Objective-C: Up andRunning is a Pampas cat (Leopardus pajeros).Named for the Pampas region of South America, the Pampas cat is relativelysmall for a wild cat and resembles domestic cats in size and stature: adultsgrow to only about two feet high and weigh between three and four kilograms.Individuals display varying combinations of stripes and spots on theircoats, and vary in color depending on geographical location; dominant colorsinclude grey, yellow-brown, rust, and black.

The Pampas cat exists only in western central South America, butenjoys a wide distribution therein.The species has shown that it can thrive not only in the open grasslandswith which it is most often associated, but also in the woodlands of GranChaco and central Brazil, the low-lying swampy areas of Uruguay, thesemiarid desert of Patagonia, and the elevations of the Andes. In fact, theonly significant South American habitat in which it cannot be found is therain forest, either temperate or tropical.

Scientific classification for the Pampas cat has become a complicatedissue over the past two decades. Formerly, the Pampas cat was consideredonly a subspecies of the Colocolo (Leopardus colocolo),which itself previously belonged to the separate, now defunct genusOncifelis. The Pampas cat was distinguished as its ownspecies in 2005, along with the Pantanal cat (Leopardusbraccatus), but taxonomists still disagree about whether there isenough biological difference to validate the move. Despite their wide range,relatively few specimens are captured for genetic testing.

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

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.

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.

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.

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.

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.

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.