Customer Reviews

Learn Objective-C on the Mac (Learn Series)

5 star:		(31)
4 star:		(12)
3 star:		(1)
2 star:		(3)
1 star:		(6)

 

 

I recently started reading this book. I should start by saying I am an experienced Objective-C programmer, but I usually find a useful new tidbit or two in a new book.

I have been enjoying this book immensely, because the tone of the book is much more light-hearted than the normal technical tome. Instead of hundreds of lines of passive voice text, droning on and one with massive repetition of the same stuff to pad the page count enough, this book flows right along. It moves from topic to topic with a nice amount of detail, but without padding and fluff. Examples are written with a slightly humorous touch that makes the reading a pleasure and keeps your interest focused on what is being said.

Explanations of areas such as memory management are nice and straight forward. New items found in Objective-C 2.0 are covered, and a modern version of Xcode is described.

This book presumes (and states upfront) that you are expected to at least know C or similar programing language, so if you don't know how to program already, don't start with this book.

This book is about using Objective-C, but also includes looks at some important parts of Cocoa. Both the writers and the publisher make the assumption that you are intelligent enough to know how to use the internet to find resources instead of listing detailed URLs in the text, which I really liked. It lets me focus on the content being presented, not the mechanics of how to do auxiliary things I already know how to do.

I am definitely recommending this book to anybody new to Objective-C, as well as suggesting that it is a good quick reference to have handy even for experienced programers.

This book provides a really good intro to Objective-C. It also gives some info on Xcode and Cocoa. It is geared towards programmers that have some experience, but want to learn to program for the Mac or iPhone. I think even intermediate and experienced Mac programmers can find some useful information in here. There is enough information here to really get going. The information is also concise enough to not be overwhelming. I wish I'd had this book when I was starting out.

I had high expectations for this book, based on my experience with other books in the Apress series for learning programming on the Macintosh. However, while the authors of this book are obviously knowledgeable about their subject, I don't think they have a handle yet on how to present their knowledge in book form. My impression is that the authors took transcripts of a seminar on Objective-C that they led and then gave it to someone else to put into book form.

Also, the book is full of typos--even in the source code examples! In one case, it is obvious even to a beginner that a source code example could not have produced the sample of program output shown, because the output is in a different order than the print statements in the program. In another case, the text of the book refers to a line of program code that is missing from the code example. This kind of sloppy proofreading is inexcusable in a programming text.

This is a fantastic book for learning Objective-C, the language you need to know if you want to write programs in Cocoa for the Mac or iPhone. Be warned: this is not a book on Cocoa which is a framework built on top of Obj-C. You'll need to know this material to make any sense of the Cocoa or Cocoa Touch frameworks which can be daunting.

If you're brand new to programming, you should probably start with "Learn C on the Mac" because Obj-C is the C programming language with some extra functionality. Confused? If you don't have experience in C, go with this progression: "Learn C on the Mac", then "Learn Objective-C on the Mac", then a full Cocoa book such as Aaron Hillegass' excellent "Cocoa Programming for Mac OS X".

You will learn a little Cocoa in the book, as well as a bit about XCode, the freely available Mac IDE for Cocoa and Objective-C development. Having tried to learn these on my own, I can say this book is a timesaver with tips and tricks for getting things working.

If you are coming from a higher-level language such as Python, Perl, or PHP, be prepared for a little pain while you get used to it. Objective-C will be like having a strict boss after working for yourself for years; you'll need to do things such as declare your variable types, manage your objects memory allocation, and declare the return types for your functions/methods.

The authors definitely had fun writing the material and don't take themselves too seriously, and it comes across well in the material. They have done an excellent job of keeping the material fun to learn.

Note: I recently took the 7-day "Beginning Cocoa" class at the Big Nerd Ranch in Atlanta, and this book was used as the coursework for the first two days.

What more would one want in a book like this? It is clear, logical, concise enough, and comes with a chaser of humor (to keep all that clarity, practicality, efficiency and logic from being too dry to swallow). I especially like the sidebars that summarize and define important terms as the book unfolds. If one followed this book, one would easily go from a beginner to a reasonable Objective-C programmer almost effortlessly... or, as the book says, "In this chapter, you wrote your first two Objective-C programs, and it was fun!"

This is one of the best programming books I've ever read. I emphasize the word read, because instead of using this book as a reference, I actually read it from cover to cover - the book is that readable. How many technology books can you say that about?

The explanations are very succinct and explain things in ways that beginners and long-time programmers will appreciate and understand. The jokes sprinkled throughout the book are actually funny (unlike most other technology authors who try to be funny). This book is not only a pleasure to read, it has greatly increased my ability to read and write Objective-C. The authors have raised the bar on technical writing and I hope this book gets the attention it deserves.

Mark Twain once said that the difference between a word and the right word is like the difference between lightning and a lightning bug. It's clear from reading this book that the authors took a great deal of care in choosing the right words, when they wrote it.

I don't normally write reviews, but this book is so good, I felt compelled to let others know how good it is.

Objective-C is a seriously short-changed language.

Most people think of it as C with a few bits and pieces added to it. Others may view is as inferior, that it lost out to C++ as the object-oriented successor to C.

But Objective-C is a serious language, and seriously powerful. Look at all the applications that Apple has built with it: Pages, Numbers, Keynote, iPhoto, iMovie, iWeb, Garage Band, iDVD, iTunes, Safari, iCal, Apple Mail ... the list goes on. These are all incredibly powerful applications, largely facilitated by Objective-C and the core services and application framework Apple provides with it.

Objective-C combines together the best of many languages. It supports low-level operations and bare-metal speed from C. It supports introspection and high-level operations from languages like Python and Ruby. And it has the pure object-orientation of Smalltalk. Some may think this makes Objective-C a "Franken-language"; I think it means that Objective-C has a varied toolbox from which to pull the perfect tool.

This book provides an introduction to Objective-C for a wide variety of programmers, from beginner to advanced. It starts off gently for programmers who have some programming experience but not a whole lot, beginning with the canonical "Hello, world" application and building up from there. In the middle, you learn about memory management, object initialization, properties, categories, and protocols. Towards the end, you delve into loading and saving those ubiquitous "plist" files, key-value pairs, and predicates. At appropriate points, the book ties in discussion of Xcode (Apple's application development system), Core Services, and the Application Toolkit -- but only enough to continue the focus on Objective-C itself.

All along the way, the authors show the skills for which they are noted. Mark (the penciler) brings his vast experience and specific knowledge of programming. Scott (the inker) provides his unique touch in explaining the material clearly, succinctly, and pleasantly.

This is _the_ book for learning and mastering Objective-C. Great writing, very easy to understand, and excellent as both a tutorial and reference. The authors assume you already know a little C syntax (from C, C++, Java, etc), so this is the key text for switchers. Still not figured out memory management retain counts and auto-release pools? Protocols, categories and inheritance a mystery? It's all in this book. Recommended for all iPhone developers.

Over the past three decades I've collected about fifty programming books, most of which deal with Unix, C and C++. I have read them all, and there are only two or three among them that I regard as poorly written. "Learn Objective-C on the Mac" is the very worst programming book I've ever encountered.

The best programming books are distinguished partly by the fact that the authors are meticulous with each and every sentence. This book is littered with sentences that do not quite make sense or that imply something contrary to the facts. On page 46, where they are discussing method declarations in the @interface section, they write, "The type of the argument is specified ... The name that follows, fillColor, is the parameter name. You use this name to refer to the parameter in the body of the method." This is incorrect. The name given to the parameter in the method definition, in the @implementation section, is used within the method to refer to the parameter, and this name is not required to match the name given to the parameter in the declaration in the @interface. Here's another example: "Although the draw method doesn't do anything, we define it anyway so that all of Shape's subclasses can implement their versions." This implies that you are not permitted to define a method in a subclass except for when that method overrides a method in the parent class. How about this pearl of wisdom: "You can make your code easier to read by choosing meaningful parameter names, rather than naming them after your pets or favorite superheroes."

The final five pages of Chapter 2 are spent discussing the type BOOL, which is implemented in a familiar way, using the C preprocessor. Several worthwhile things are covered in this discussion, the most pertinent of which is that it is generally a bad idea to perform a Boolean test via explicit comparison to 1, or equivalently, to a defined constant such as YES, which equates to 1. This is a worthwhile thing to discuss, but to spend as much as one full page on this is superfluous and tedious.

Chapter 3, which is titled "Introduction to Object-Oriented Programming", begins by asserting that indirection is a key concept of OOP. They spend several pages on an utterly sophomoric and incoherent discussion of indirection, after which they spend several more pages lecturing on how it is best not to embed, directly within a program, the data that a program operates on. Ten pages into the chapter, the large bold heading "Using Indirection in Object-Oriented Programming" appears. Two very short paragraphs into this section, the sub-heading "Procedural Programming" appears. Under this sub-heading, they devote no fewer than seven pages to the presentation of some C code for operating with graphical shapes. This C implementation is not realistic, because it avoids the use of pointers entirely, which contrasts with the normal practice in C of embedding function pointers within structures and passing around pointers to the structures. They then spend several pages on a parallel implementation in Objective-C, and at the very end of the chapter, they revisit the C implementation.

The premise of all this is that by contrasting the Objective-C implementation with the C implementation, they will demonstrate how indirection is a pivotal difference between procedural programming and OOP. The entire discussion amounts to a muddled contrivance. It does not remotely give a useful perspective on the difference between procedural programming and OOP. Indirection plays a role in OOP, but the notion that you could expose the essential difference by focusing on indirection is ludicrous. Their C implementation is contrived to facilitate their point of view. Their parallel implementation in Objective-C does not reflect a proper OOP implementation, because even though the various shape-specific classes have a great deal in common, they each descend immediately from NSObject. This is distracting, because if you have the slightest clue about OOP, you are aware that there is something inherently wrong with this implementation. They do it correctly in the next chapter, but in this chapter that is supposed to introduce OOP, the code they present confounds the true essence of object-oriented programming, under the guise of demonstrating that indirection is a key concept in OOP. The whole chapter is horrifically contrived and sophomoric.

Chapter 4 commences their discussion on inheritance. The diagrams they use to explain how methods are found at run-time are sophomoric. In the highlighted box on page 69 they talk about the memory layout of an object: "These offsets are now hard-coded into the program generated by the compiler. Even if Apple's engineers wanted to add another instance variable to NSObject, they couldn't, because that would change all the instance variable offsets. This is called the fragile base class problem." The problem to which they allude is nothing but the familiar and mundane requirement that if the base class changes, you have to recompile everything. The "fragile base class problem" is more fundamental. The trite example is what can occur if a derived class bypasses accessors to access instance variables defined in the base class. The cost of avoiding this is lots of run-time overhead, especially for Objective-C. The non-trite case is when a method, call it method A, invokes another method, call it method B. If a class that derives from the class where method A is defined extends method B, then the correctness of the behavior of this derived class is predicated on the assumption that when method A is invoked, the enhanced version of method B will be invoked. But if method A is subsequently modified such that it no longer relies on method B to do what it has done all along, the enhanced version of method B is no longer invoked when method A is invoked against the derived class, and the derived class is broken.

Chapter 5 deals with composition, i.e., using other classes as instance variables within a class. They discuss accessors in a cursory fashion toward the end of this chapter, but they do not delve into the semantics of dynamic allocation and deallocation of memory for the contained objects. The more significant problem with this chapter is that they switch to programming examples that are contrived and sophomoric, using cars, wheels and engines. This is so artificial that it is difficult to translate and apply what you the see in the example to real programming.

The book starts to improve with chapter 6, which begins on page 87. But the first five chapters take up more than one-fourth of a book that is just barely 300 pages, and even if what remains after page 87 were enough to justify a book, it would not make up for the dreadful way that the first five chapters are written.

As the title says; The book is good but it does not cover a lot of mac specifics. This is a decent read and I read the book from start to end without referencing code too often on the mac.

The book does have some drawbacks, mainly that a couple of times they dont include all the code in the text which forces you to fall back to the source code files (which have to be downloaded and is not supplied on a disc).

Overall i found the book to be usable but not extremely in depth.