Customer Reviews

Cocoa and Objective-C: Up and Running: Foundations of Mac, iPhone, and iPod touch programming

5 star:		(7)
4 star:		(2)
3 star:		(3)
2 star:		(1)
1 star:		(1)

 

 

I would agree with the previously-reviewed notion that this book as an absolute beginner's guide is misleading. I happen to be an experienced programmer who works day-to-day in an object-oriented language (but not Objective-C), utilizing design patterns. I found the shorter explanations useful...I learned a few things and some (Objective-) C concepts were made clear, but I didn't have to wade through pages of "this is a loop. This is a function" that gets tiring to one who understands the general programming concepts. But as one who moonlights as a college professor that teaches these very same concepts, I would expect a beginner to get quickly overwhelmed by this book.

I also feel the book's promise to teach iPhone/Pad programming misleading (the subtitle is "Foundations of Mac, iPhone, and iPad Programming"). Stevenson never introduces iPhone-specific programming concepts, or any of the unique aspects of Cocoa Touch and UIKit. There are mentions of such differences (like the discussion on CGImage, NSImage, and UIImage), but the mention is merely that, and no further information is provided. If you're looking to get into iPhone programming specifically, you can do better than this book. However, this book would supplement another iPhone book well, for its basics on C and Objective-C.

My biggest complaint is the Chapter 9 "real" application. Personally, I don't mind that it took that long to get to a practical app. But the chapter was basically one big "type all of this code in" with pages and pages of code on paper. The introductions to MVC and Core Data were pretty cursory, but I was hoping that through the practical example Core Data would be made clearer, and how it fit into MVC. Also, other topics such as drag-and-drop, fetch requests, and sorting were pretty much presented in the code and never discussed. Stevenson would do very well to refactor the chapter and present it in more of a step-by-step fashion. I found myself longing to hit "Build and Run" just to see something working, but knew that it would be pointless, because I just typed in a big, long class, which is supposed to use other classes that I haven't written yet. I just kept typing and typing, just sort of hoping that all would end well, and that I would have a clear understanding of how the app worked once it was done.

It didn't, and I don't.

What was needed were milestones. You know, just stub in a methods and properties, build and run. NSLog a few things, build and run. Flesh out the details of one of the views, build and run. Give the reader some stopping places where they can test the existing functionality against what they're supposed to see, and also just a stopping place in the reading! I couldn't do it all in one go, and it was difficult picking up where I left off the next day.

The funny thing (funny in a relative way) is that in the very next chapter, Stevenson does *exactly this* iterative approach that I'm talking about. We get into drawing into views, and we start with colors and rectangles. We build an app, and draw a colored rectangle. Hey, it works. Great, let's learn about bezier paths, now. Then move on to graidnets, and images, and then text, and then styling text, and finally user interaction. All the while, we build a simple (not very useful, but still cool enough) application that slowly builds up all of the techniques from a simple colored rectangle to an image with a border, shadow, and sheen, that's scaled properly, has a title that's rendered in a bezel below the image (and is optional) that can be dragged around the view and re-centered with a key press. We had so many stops along the way that it was pretty easy to check your work as you went, and I ended up with a working application, not to mention a much better understanding of these particular concepts. Chapter 10 is the model for what Chapter 9 should have been like.

That particular shortcoming is why I gave this book 4 stars instead of 5. If Stevenson addresses this, I'd happily give it 5. However, you need to be comfortable with a certain skill set before being able to harvest information from this book. That itself is not a flaw, although the marketing that implies otherwise is.

My opinion is very different from the previous reviewer. This book is a remarkable publication for all those who want dive into Cocoa development. You should keep in mind that learning Cocoa is not that easy. Cocoa is driven by Objective-C which is a superset of the C programming language. In other words: it is required to know the basics of the C programming language before you start with Cocoa. With that fact in mind, Scott's book is one step beyond it's competitors, because it also gives an introduction to the basics of the C programming language, a unique feature in my eyes. It is written in a very likeable style. The examples are similar to the ones published on Theocacao and Cocoadevcentral, very informal and of course understandable. I recommend it to everyone who is willing to seriously develop for Mac / iPhone / iPad. If I could give 6 Stars, I would.

EDIT: Due to a recent comment on my review I decided to revise it (I did not buy the book here so I can't post a reply to said comment). I understand your concerns but there is no need to worry. It is indeed my first review at Amazon.com but it is not my first Amazon review at all. I come from Germany. Please open my profile and change the URL from .com to .de and you will see some more reviews I posted on Amazon Germany. I'm in no way affiliated with the author. At the time my review was published, it was the first positive, now there are more because it is simply one of the best Cocoa books around. It is also true that I did not buy the book from Amazon, I bought it digital. I think it makes absolutely no difference whether Amazon is the source or not. I bought here countless times and I just felt a need of sharing my experience with other Amazon customers. I think Amazon benefits from reviews that come from non-customers.

Scott Stevenson's tutorials on Cocoa Dev Central have been an invaluable resource for new Cocoa developers for many years, with down to earth descriptions of the essential topics of Cocoa programming and the Objective-C language.

This book brings all that and so much more. It is certainly `the' Cocoa programmer's guide to getting up and running. Starting off with an essential setup guide, chapter two quickly jumps into code, with a great introduction to the C programming language and basic programming concepts that form the foundations of thinking in code. Covering the perfect amount of C, from the ground up the author discusses the basics of variables, functions, conditions and straight forward examples of a procedural application.

Chapter Three dives deeper into C discussing arrays, loops, pointers, primitive types, dynamic memory and more. Scott does a great job of introducing new concepts at a human level, making each new idea tangible. This is where his tutorials have always thrived, and these chapters are definitely where I wish that I could have started my journey into programming.

Chapter Four is where the fun really begins. Thinking in Objects. The author begins to introduce the conceptual foundations of object oriented programming, with clear-cut examples of designing objects. The following two chapters compose the best introduction to Objective-C that I have seen, covering everything from classes, syntax and memory management to dynamic language features like introspection and forwarding messages, interspersed with quintessential thoughts on object-oriented design.

The next chapter discusses the Foundation framework and its value classes, the lower level component of Cocoa. A subject that is often abstract comes through in tangible examples of working with objects and the real life data they represent. This chapter goes into detail discussing many of the value classes that you will use regularly developing Cocoa applications. Styled like a reference, but broken apart by relevant topics, you go through data objects, collection classes, mutability and more, and every class and topic comes with a healthy portion of code. The examples in this section are great.

Chapter Eight is like starting a new book. Titled Basic Controls, it jumps into the user interface level of application development and covers the basics of creating an interface and wiring it up to your code. There are a lot of new topics that go into connecting UI to code, and I think Scott does a great job here of peeling away the layers of the subject, using good examples that help you make sense of things quickly.

The next section was the most helpful to me, as a Cocoa developer with some experience but certainly not expertise, the discussion of Model-View-Controller design and the great sample application were just what I needed to be able to picture the beginning points of real applications in my mind.

I love the chapter on custom drawing, and the amount of coverage it has on the details of creating custom UI programmatically. The sample photo viewer app, with a nice shine drawn on the photo programmatically, cracks open a world of possibilities. And the section on refactoring view code is a true gem; this one part was my favorite.

The final word is a take away guide absolutely worth revisiting.
-

Scott Stevenson has been an active member in the Mac developer community for many years, and has always been respected for his contributions through awesome tutorials on his website, focused on getting new beginners started, and great technical articles on his blog, ranging many topics relevant to writing software with Cocoa. I started with Scott's tutorials years ago, and have followed all of his material since, so I was really excited when this book was announced, and I can honestly say that it did not disappoint. It is the absolute best introduction to Cocoa programming with Objective-C, written by a true expert on the subject and one of the best teachers around.

I read this book on Safari online both the rough cut version and the final version.
I do find the book very easy to read as I always enjoy Scott Stevenson's Theocacao blog and his articles on [...]


One thing is certain that this book is not targeted for non-beginner, as the title suggested. Its content is introductory and far too short with 11 chapters. Compared to other books like Cocoa Programming (Aaron Hillegass) which has 35 chapters, it is obvious that a lot of topics are left out. Don't expect advanced topics like Core Animation, Grand Central etc.

Now for up-and-coming Cocoa programmer, is it a good book?
I felt that on this regard, the author is too ambitious.
It is tough to cover Cocoa and Foundation Framework, let alone having to cram C, Objective-C, object-oriented principles and design pattern into it, it ends up only touching the surface on most topics.
And if the newcomer want to know what's the iPhone or iPad app all about, sorry there is none mentioned.
It seems that the author fails on meeting both ends that, either lets the reader to build a solid foundation or having them a tastes of Mac, iPhone programming on Cocoa.

Honestly I wonder why publishing companies in general don't release computer programming books in a series.
If I think of this book as Volume I out of Volume 5, it is a pretty good book. And progressing with the series gives the readers a sense of achievement too.

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. You won't learn everything from a single book, but for me this book has been extremely useful.

I got this book in hopes of learning the objective-c language so that I could move on to developing iPod apps. Now this book is not so bad however I had a hard time remembering everything because there was hardly any examples in the first chapters. This was really a stumbling block for me because I seem to learn best by writing code, which there was no good examples in the beginning of the book to follow. I am new to objective-c, however I am not new to programming. I know several programming languages such as c/c++, perl, java, php,ect.. so I thought that any into book to the objective-c language would suffice, and i was incorrect. I would not really recommend this book to anybody because it would likely be hard to follow for a beginner in programming, and it seems to be too basic for advanced users.. I guess this book will sit in a stack with my other reference books on programming..

I purchased this book based on the excellent reviews written by professional programmers (my own background.) I've been a commercial software engineer for 8 years, and have written hundreds of thousands of lines of code in C, C++, Perl, Python, and C#. With the latter, I didn't bother to buy a book, because of the similarity to Java (which I had learned in college course) and the plethora of literature now available online. I was hoping that this book would provide a detailed explanation of the nuances of syntax, memory management, efficiency and style. I wanted to understand the why behind the constructs, and the Objective-C way of doing things as compared to all of the other languages that clutter my brain. However, this book moves at a lethargic pace, and concepts are explained without any technical panache.

In the author's attempt to reach both technical and non-technical audiences, neither is well served; the pace is simply too fast for the novice, and too slow for the expert. Initial chapters present an acceptable introduction to programming fundamentals. Beginner-intermediate programmers will find the material accessible, with plenty of real-world analogies. Latter chapters present concepts that will not be easily grasped by the novice, but for which the skilled programmer with a background similar to my own should already be well-acquainted (mostly conventional object oriented programming techniques that are sprinkled here and there with Small-Talk syntax sugar.) These concepts are presented in a plodding, non-technical style; the technical reader will wonder why the author doesn't just get on with it, while the novice will find that concepts are not presented with enough detail and rigor to be readily grasped.

As Malcom Gladwell observed, it takes 10,000 hours to gain expertise in any subject. When learning to play a musical instrument for the first time, the introductory text doesn't typically assume that the reader will be playing Paganini by the last chapter. I would never discourage a novice programmer, but there are no shortcuts. Having a big idea is wonderful, but (continuing with the musical analogy) it's important to learn to play the scales smoothly, keep time, and mimic the style of those who have already gained mastery before you try to compose your own symphony. It probably won't take you 10,000 hours, but it will take several books on different subjects, a lot of hard work, and practice. Just as non-professional musicians can create startling compositions, non-professional programmers can craft useful and elegant software; but it takes time, passion and dedication to make it happen.

If you are a novice, you should start with an introductory programming book that teaches the fundamental concepts in a very through and detailed way. Once you understand the fundamentals, you are ready to begin learning about data-structures, and object oriented programming. Again, we aren't ready to move into graphics, networking, or other advanced topics. Only when you have mastered data-structures, are you ready to begin learning about domain specific topics. Each topic, deserves it's own book. If you wish to write a graphics program, you should take the time to learn graphics programming (an entire subject on it's own.) If your big idea involves networking, you should invest the time to learn about that subject. Finally, you are ready to learn about the system specific topics of the target platform. Depending on how much time you have to invest, and your individual learning style, it's going to take you at least a year to really get your application off the ground, but in all likely-hood it's going to take you a lot longer.

I also purchased "iPhone Programming: The Big Nerd Ranch Guide," which provides adequate treatment of the fundamentals of Objective-C, and is much more inline with expectations. If you already understand the fundamentals of object oriented programming and poses a working knowledge of C but you find that you have to learn yet another (somewhat kludgy) programming language (let's face it, Objective-C isn't the prettiest baby out there) just to write iPhone Apps then "iPhone Programming" is probably for you. You'll get through the language basics and the fundamentals of memory management in a few hours, and be writing apps on day-1.

I really liked many things about this book. I started in at chapter 5, and from there through chapter 8 found it extremely helpful and pleasantly concise. But I'd have to agree with those who have said that chapter 9 is a shocker. This is a real shame, because the topic of multiple windows/nibs is badly covered, if at all, in every other Cocoa book I've looked at, and the material in this chapter could have been really useful. However, as other people have said, it's pretty discouraging to be asked to type in great masses of unexplained code, and not being able to build an intermediate version until the whole lot is in. So, only four stars from me, but look forward to giving the next version 5.

This book is written for the C programmer who is new to Cocoa. The book is very slow to cover the basics, which explains why after 10 chapters you have only begun to scratch the surface of Cocoa. But for me, a non-professional, that was ok. After attempting to muddle through the Hillegass book multiple times, which left me with more questions than answers, this book was a relief. In the early chapters, you can easily read each one without entering the code and yet understand the output generated. There's no doubt that this is an entry level book and you'll need another to springboard onto, but for those of us befuddled by Cocoa and in need of a true beginning, this is the best book I've read so far.

this book is written in very good language [not too hi-tech, and is not treating people like dummies] and offer loads of examples i recommend this book to every objective C programmer with some programming experience -no matter huge or tiny