Customer Reviews

iPhone for Programmers: An App-Driven Approach (Deitel Developer Series)

5 star:		(20)
4 star:		(4)
3 star:		(0)
2 star:		(2)
1 star:		(1)

 

 

What to say about Deitel books? When I was learning Java, a Deitel book teaches me how to program smoothly, and I did read all that 800 pages. After some frustrations trying to learn iPhone program, I decide to buy a book. First I bought "The iPhone Developer's Cookbook" because a friend of mine told me that this book could be perfect to start. Well, it was completely useless to me. Of course the book is not for
beginners. Then I decide to buy "Beginning iPhone Development" from Dave Mark and Jeff LaMarche. This is a great book, but I couldn't fix the ideas on my mind. I think it is very difficult, especially because I've never saw a Mac before. Although I am a Senior Java Developer, I've never heard about Objective-C or Mac programming before. So, again, the book is great but not for me. Then I bought two more books from Apress: "iPhone Cool Projects" and "iPhone Game Projects". Again, more frustration. I was thinking either I'm so dumb to learn this or I'm not able to do self-study. In a sunny morning I was searching for some news at Amazon and I saw that Deitel was written a new book of how to program in iPhone. I thought maybe was not a good idea to buy another book, since I couldn't learn from the four previous books I had. Thinking in how easy I learned Java from Deitel series, I decided to bet again. I can't describe how amazing this book is. It's very easy. It comes from the real beginning. At first, no delegates, no properties, no memory management. It teaches you using very easy and useful examples. The method is also pretty good. The book introduces you with the example, which works by the way, and after you see what it is then you move to development part. It's very motivational. The codes are clear and well commented. The examples are real, viable, specially the games, and you end each chapter with more hope to become a real iPhone Developer. Congratulations, Deitel. You did it again.

If you already know how to program in a C based language for any other platform the learning curve should be fairly small. The book does a great job of covering to real world things that have to get done. Reading the SDK help does not show you some of these steps for apps in the real world. There were several a-ha moments for me reading through the examples.

Each example is small enough to type it all in, and demonstrates different UI or Cacao features and patterns. These were SO much more helpful than a simple snippet of "this is what you do". How does it integrate into the app as a whole?

This book has many fully developed app programs with source code.
The programs are well commented.
It is right along side of the listing including the why and how the programs work.
This has become one of the must read books for anyone developing for the iPhone.
I reccomend it for the beginner to intermediate programmer.
The source code is available for download from the publishers web site.
A simple registration process is all that is needed to get the source code.
I am hoping a follow up book is in the works.

I am at 7th chapter now. Although I slack a lot, I spent less than a week to come this far. With daily 2-3 hours of effort.

First of all the book is very fast. You learn a lot in a very short time. Chapters evolve. You use what you learnt in previous chapters. Every element is well defined.

The first chapters fill you on about the iPhone business. I set up an iPhone developer account and also ported the applications I created to my iPhone with the instructions of the book. At first I didn't even know that I need a Mac to develop an iPhone application, learned this from the book, bought a Mac mini.

To summarize this is a wonderful book. If you don't know anything about iPhone development and want to become an iPhone developer in a very short time, its a must read.

I am not sure what I am missing that all these other reviewers are getting, but I found this book extremely frustrating. Though I looked at the book in the bookstore and was turned off by it, on the strength of the reviewers I went and bought it anyway. I sorely regret doing so. By the way, I am not a newbie programmer: I've been a strong developer for 30 years, most recently writing J2EE enterprise applications since 1996.

On the plus side, there are (as other reviewers have said) complete examples of applications, all of which you can download from the book publisher's web site. You can - after spending hours poring through the code examples - find many of the details of how to hook up the pieces into real applications.

However, for me, this advantage was completely wiped out by providing very little explanation of what is going on. Beyond the first chapter or two, explanation of what's going on in the Interface Builder is non-existent. When the application (which there was also no explanation for) doesn't work, you're left trying to figure out what you didn't hook up in the Interface Builder (which wasn't explained). Also, there is no categorized explanation of what you're dealing with - just code examples. If an interface method is not in a particular code example, you have no idea that the method exists. Just page after page of code, with textual explanations that are very little better than the code comments themselves. I could never imagine using this book beyond the initial learning curve - there's nothing you could call a "reference." Finally, the page after page of method listings are not in any way connected together: you have to keep flipping back and forth to figure out what class a given method belongs to. And at least one sample app (the Address Book) does not build for me.

I think the Interface Builder problems point out the overall weakness of this book. Code examples might be ok for a purely code-based system, but developing iPhone apps is not - at least, the way it's presented in the book - a code-driven approach: it all starts in the Interface Builder. More coverage of that tool might have pulled the pieces together.

All in all, good context of its examples, but did not at all work for me to learn iPhone programming. I've been much more impressed with iPhone App Development: The Missing Manual.

After buying several rather unimpressive iPhone development texts, I finally purchased this one via Amazon. This book is a SPECTACULAR example of what a programming book should be. Apple has done a terrific job with Xcode, Obj-C and Cocoa but these are very complex technologies. There are countless APIs and frameworks available to the developer which can result in even experienced programmers feeling lost and confused. This text does a great job of helping a new iPhone developer get started making apps. The book does several things well which deserve special mention:

1) It guides you through writing code that basically amounts to skeletal apps that, when fleshed out, would be quite suitable for inclusion in the App store. So many books provide code examples that are useless fragments. With some programming languages this is fine. However, with Obj-C, Xcode and Interface Builder it is ESSENTIAL to understand the overall structure of your program. The authors of this text have done a great job with communicating how these complex structures work.

2) Even though the focus is on programming, the book still takes time to discuss in detail the process for getting an app accepted into the App store. Most books either neglect this business aspect of the app development process entirely... or focus on it excessively. This book deals with the business aspect of development thoroughly without neglecting its main objective of teaching programmers how to write apps for iPhone.

3) The code examples in this text are commented amazingly well. This is quite possibly the strongest feature of the book. In many cases I have been able to understand entire, lengthy sections of code using the comments alone. The fact that line numbers accompany the code is also a very handy feature that used to be standard in programming texts.

4) If the comments aren't enough, you'll find the actual follow-up explanation of the code to be very useful. The authors are brief and to the point but always thorough.

The above points highlight the positive aspects of this book. What about the negative? Well, I have not found anything in the text particularly troubling or annoying but I offer the following advice to would-be buyers of this text:

1) Understand the title of this text is: "iPhone for PROGRAMMERS". That is not a joke. If you have never programmed in your life and have recently decided "I want to make iPhone apps!", this book is NOT the place to start. You at LEAST need a basic understanding of a C-based language in order to easily follow this text.

2) This book REQUIRES that you PAY ATTENTION TO WHAT YOU ARE READING. This is crucial. Each chapter builds on the previous one and you are expected to retain what you learn in previous chapters. These authors are very efficient. You will not find comments such as: "How do you feel now? You deserve a break!" or any other such nonsense which has unfortunately contaminated so many instructional texts on the market today. This is by no means a negative and I quite appreciate the authors taking me serious as a reader. Still, if you insist on having your hand held through every detail and lots of redundant material, you might prefer to look elsewhere.

In summary, this book is outstanding. If you are serious about developing apps and have even an elementary grasp on the basics of software design you'll greatly enjoy "iPhone for Programmers: An App-Driven Approach". The text is thorough, concise and clear. Remarkably, these authors have written a book that is enormously helpful and instructive... WITHOUT insulting your intelligence. HIGHLY recommended.

As a former programmer who hadn't done any significant programming in several years -- and that largely in COBOL, to boot -- when I decided to start looking into creating apps for the iPhone/iPod, this was the first book I bought. That turned out to be a mostly-good, slightly-bad decision.

First, the bad:
The "bad" in this case has not so much to do with the book as with the way I used it. This book was my first-ever introduction to Objective-C, Xcode, Interface Builder, and iPhone programming in general. My only exposure to that entire world was in using an iPod Touch my wife got me for my birthday. You can use this book that way, but if, like me, you are a complete novice in the Apple world, you might want to consider taking advantage of some of the free education you can find on the web before you dive into "iPhone for Programmers." At least get a sense of how the SDK components fit together and what is meant by outlets, connections, and so on. It might not be a bad idea to order the book from Amazon and start learning from the web while you're waiting for it to arrive.

Now, the good:
Most programming books illustrate the concepts with which they are concerned by using trivial, totally useless examples and out-of-context code snippets. That may work sometimes with very basic stuff, but it doesn't do a lot for trying to put everything into context. This book is not like that.
Here you get actual usable -- and useful -- apps, along with step-by-step instructions as to how to put them together and get them to run. You get to see how to add components in Interface Builder and how to add them programmatically. You get explanations of developer conventions. You get downloadable code you can check against the code you type in when you have problems. In short, you get code with a point.

Organization of the book is fairly straightforward. It begins with explanations of how to register as a developer and acquire the SDK. You then get a very handy walkthrough of how the App Store and submissions to it work. Then you switch over to coding. That too is presented in a logical progression; you start with fairly simple but complete apps and work your way up to more complex ones. The authors do a decent job of tying the "what" of how you code with the "why" of how it all fits together.

If you thrive on examples as opposed to simply exposition, this is the book for you.

Great book -- The apps are well thought-out and provide the reader with enough insight and inspiration to create their own apps for the iPhone. The authors include comments about coding approaches they tried and then changed -- and why they changed them -- very useful! Attention is given to details such as retain counts, also very useful to anyone not familiar with memory management. The source code for all projects is conveniently available for download.

In the process of learning a new computer language or software development environment, I have found that multiple books are needed, each with a different focus: a good intro book with simple examples (Beginning iPhone 3 Development), a great language reference book (Programming in Objective-C), and a first-class advanced applications/topics book. This book, iPhone for Programmers: An App-Driven Approach, is the first-class advanced applications/topics book in my set.

Chapter 2 describes the process that follows the design step for an app: testing the app on an iPhone/Touch device, preparation for submission, pricing, managing, and marketing your newly created app. Chapter 2 lists common characteristics of great iPhone/Touch apps. Some of the reasons that may cause an app to be rejected by Apple are also described. Chapter 2 is a much appreciated chapter and a rare topic for an application programming book.

For the next fourteen chapters, example apps are provided; one per chapter. The apps look good enough to be listed on the app store. Each of the chapters follows a consistent organizational structure: Introduction, Test-driving the App, Overview of the Technologies, Building the App, and Wrap-up.

On the page just before the Table of Contents is a listing of the topics available at the resource center on the authors' website. The resource center is an extensive collection of well-organized current information about computer languages, internet business, open source, programming, and web2.0. This is definitely not your typical book-support website.

Although I am still working my way through the last few chapters, I am pleased with the depth of technical material and the variety of real application examples. After learning the basics, nothing beats further learning than developing, compiling and debugging your own code to create your own software application. It is also the most humbling part of the learning process. Dare to dream...

This is not a book for beginners - there isn't much about C-programming, or even about cocoa programming as such. You are expected to have a reasonable grasp of OOP, dot-notation and square brackets and all. What there is is very detailed annotated code for applications that you might actually use. Perhaps the code is over-annotated for some, but I found it very helpful to have a detailed, line-by-line description for those "what's going on here" moments. And in the body of the text, there is a further description of what and why.
A great book that seems to have given me enough "Aha!" moments to make me feel confident of producing something useful.
My only quibble would be that some flow diagrams would have helped. However, given the "style" of the code, which doesn't use interface builder very much, if at all, it's fairly straightforward to build your own diagrams. It is a matter of personal preference as to whether interface builder should be used or whether it's better to wire an application up in code - both may "break" with Apple upgrades/changes, so it is important to understand both approaches. And you can always get a diagram in Xcode.
Strongly recommended.