Customer Reviews

iPhone Cool Projects

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

 

 

It's an attractive, slim book with plenty of full color graphics. There are probably enough tips, tricks, and 'from the trenches' stories to justify a place on most iPhone developers' shelves.

I think the book would have been better with a more consistent overall style/structure. Most of the example code is too large and involved to bother inputting yourself, yet there are many, very basic, pictures showing IB connections etc. The code is available for download and I'd expect a book at this level to provide:

- the code itself (yes, on the website)
- class diagrams* or at least some form of architecture diagrams for each project (not really; depends on the chapter)
- detailed discussion of problems encountered, alternatives considered, blocked avenues etc (also hit and miss)
- specific discussion of code snippets (yes, this is covered fairly well)
- a comprehensive appendix of references, or links on the website (no, though you can glean a reasonable amount from the chapters)

[*yes, you can generate class diagrams in Xcode but I'm thinking along the lines of storyboard/whiteboard, "how we got here" views, as well as simply outlining what the demo is and what it does]

Six of the seven chapters deal with real world projects, or working cut-downs. The threading chapter is, for me, the weakest since it uses a toy problem just to illustrate threading, is poorly explained and smacks of 'solution in need of a problem'. Given that it walks the user through the whole setup of IB connections etc I fear that it may be handing a loaded gun to some people who would be well advised to look for ways to avoid threading (or at least not write to common data), rather than dive in with threading. It would have been possible to present a small, real world problem, that legitimately called for a threaded solution without too much effort.

The code I've seen is based on 2.2.1, so you'll probably need to do some tweaking. There is breadth and depth so it's hard to imagine someone coming away without learning something. For $27 or so it's a good deal and a step in the right direction for post-beginner iPhone dev books.

I have to admit I initially overlooked what a great book it is, given its meager 200-page content ;)
When I got the book, I thought: oh nice paper and colorful prints. But maybe it just looks fancy instead of offering real substance.
I was wrong. Once I started reading, I couldn't put the book off. While reading it, it's both satisfying and addictive at the same time.
All the chapter authors have practical real-world experience building successful iPhone apps.
They showed you complete working programs while demonstrating their experience and expertise in their respective fields.

Wolfgang Ante - Designing a Simple, Frenzic-Style Puzzle Game
It shows you how a little game is built from concept to finish, with complete game flow, handling on different logic/paths, and how to use Quartz and Core Animation to build simple animations w/o using Open GL ES. I really liked how he also revealed his thought-processing in designing the game.

Mike Ash - Mike Ash's Deep Dive Into Peer-to-Peer Networking
Peer-to-Peer networking using Bonjour is very interesting. Mike not only showed how Bonjour/CFNetwork works, but also went ahead to build out a simple yet effective network protocol to demonstrate his point. It's very thought-provoking and reminded me poking UNIX networking stuff back in my college days. I'm very eager to try out some p2p trick in my next app after reading this chapter!

Gary Bennett - Doing Several Things at Once: Performance Enhancements with Threading
This chapter is a bit *easy*. It shows you how to work with multiple threads, and showed a simple program to demonstrate different points.
However, I was expecting some more *real-world* app, instead of a toy program.

Matthew "Canis" Rosenfeld - All Fingers and Thumbs: Multitouch Interface Design and Implementation
Matt has done a wonderful job in explaining how to handle gesture events in great details, as well as how to make the decision of what events to use during his design of Stage Hand. This is a great chapter for anyone who wants to design how to capture their own custom gesture events.

Benjamin Jackson - Physics, Sprites, and Animation with the cocos2d-iPhone Framework
Cocos2d is a very popular physics game engine on iPhone. Ben leads us to the door in this chapter. Cocos2d along deserves a whole book for it.
I really would like to have more content on this chapter. 20 pages just don't cut it ;)

Neil Mix - Serious Streaming Audio the Pandora Radio Way
Neil has a great piece in explaining how to design an effective audio streaming algorithm in this chapter. Coming from the Pandora team, I expect nothing but greatness from his experience and expertise. Handling slow network and dropped connection are very interesting to read.

Steven Peterson - Going the Routesy Way with Core Location, XML, and SQLite
This is a good chapter, comparing to others in the book. Probably I've already built apps using CoreLocation, XML Parsing and SQLite, I find it an easy read. But it's still pretty good in showing you how to build an app from start to finish.

Overall, this little book offers more value than many 600-plus-pages of bible-books out there on the market.
I highly recommend it to anyone who's passed the initial iPhone SDK programming newbie stage, and ready to take on more advanced features.
I just wish this book would contain more chapters and more interesting topics. Hopefully APress can come out with a new edition?

iPhone Cool Projects is a very broad and deep iPhone development composition. The book is broken into 7 chapters, which are roughly 20-25 pages in length.

For new iPhone developers, Apress provides the source code for each chapter's project to help those of us that like to learn by seeing the code work, and only then decomposing it into various pieces for learning purposes.

Without going into gross detail, I mainly bought the book to gain some insight into threading, multitouch interface design, audio streaming. For brevity, I'll limit my assessment to threading only. The chapter opens by describing the taxonomy of threading and several keywords such as thread, process, multitasking, synchronization, deadlock, etc. After the description, the chapter walks you through the steps AND color graphics of each of the XCode screens. There are LOTS of diagrams to explain the setup and the arrangement of threads in the example project as well. In the past, when books have very intense globs of code, there is something lost when attempting to explain each line. iPhone Cool Projects actually does a decent job of walking through the connections to UIControl objects and completing tasks such as an event processing loop or implementing a critical section.

If you are a skeptic and want to see more before committing to purchasing this book, the publisher has generously provided a sample chapter (Chapter 5) to entice you to buy.

When reading introductory books in any language, it is easy to learn the language elements and concepts, but it is hard to see how everything fits together. What is great about the cool projects series from Apress is being able to see the elements and concepts in practice with projects from professionals who are active in the field.

Each chapter is written by a different author, so every project covers a different experience and topic. These range from touch interfaces to streaming audio over the network. Some of the projects presented are based on the author's live applications that are currently available through the App Store. A wide range of the topics are covered in the book with practical examples of the concepts.

This book is definitely not an introduction to Cocoa or iPhone programming. It is more geared toward the intermediate reader who has learned the basics and needs practical, real-life examples. It can also be of use to a more experienced iPhone programmer who wants to explore some of the topics in the book without having to dig through the documentation.

I would highly recommend this book because it is easy to read and does not get bogged down with basic concepts. Code is provided on the book's site and is easy to follow the code with the explanations in the book. As a beginning iPhone programmer, I found this book to be a lot of help to work out some of the concepts I was having trouble with.

I bought this after seeing the high reviews from others on this site. Unfortunately, the content doesn't quite live up to the hype for me. I got this in particular wanting more details about threading having come from the Windows world where I have implemented very robust networking applications that require UI responsiveness while results are cached in the background. I was hoping this book would shed some light on how to go about doing this in the iPhone paradigm, but the example is so rudimentary that it almost isn't even worth putting into the book. Plus, the instructions for building the app are incorrect and contain glaring omissions as well as references to code objects that don't even exist. What's worse is the code itself as listed in the book doesn't even run when built! It causes an unhandled exception due to objects created in the header file not being instantiated or initialized in the implementation file. And no where in the chapter does it say you must download the source code for the example. It walks you through it as if it has been checked and is guaranteed to work as printed. Once you download the source code, it becomes apparent how rushed or poorly thought through this portion of the book was. Whole sections of the header and implementation files are glaringly omitted from the book. Did Bennett even bother proofreading this part of the book, and if so, where were the editors in this process? It's shameful for a book that is marketed as a technical tome to increase a developer's proficiency on the platform.

I'll admit that I haven't delved into other parts of the book in great detail, but the game portion did look pretty interesting at first glance. However, the hands on experience I had with the threading chapter left a very bad first impression and does not leave me all too optimistic on either the usefulness or accuracy of the additional content in the book.

I thought Chapter 7 was good and thorough unfortunately not all of them are. If you are expecting something that walks you through like the Dave Mark book this is not it. This is more like a collection of articles that provide a topic overview and then it's up to you to download the code and do a deep dive.

Overall, a very interesting read. Each of the chapters contains very useful information that I found to be quite valuable to as up and coming iPhone developer.

I bought this book because I wanted to see code that successful iPhone developers had written. I guess I was looking for "best practices" sort of information and I was hoping that I might get insight on how to tackle some problems I have run into when developing my own applications.

Book Flow

The biggest disappointment in this book is that developers wrote it (I am assuming). The book lacks the continuity you would normally find when one or two people collaborate on an entire book. When a different person writes each chapter, you get seven different styles in this book. I found a couple of the chapters very well written, but the rest I found to be, well, written by developers. I'm not saying that developers are inherently bad at writing, but it takes a certain something to relay information to other developers effectively. Most of the writers of this book just do not have it.

Code Samples

I got very frustrated reading chapters with code snippets from applications the various authors had written. If a working application had been available to provide context to the snippets, then I would have been less frustrated. For example, in Chapter 5, the first 12 pages of the chapter provide code snippets with very brief explanations of what the code is supposed to do. No working example is provided for context. I couldn't even play with the code to see what was going on. It was almost like I was expected just to know the context because I was on the team that wrote the application. The last 10 pages actually create a working sample. I would have rather spent the entire chapter creating the application with better explanations of each step and theory behind the code.

Proofreading

I wish I had a dollar for all the typos I've seen in this book. Again, in chapter 5, page 118 there is a screen shot of the application the author wrote. The caption says it's a screen shot of the application that you will be writing at the end of the chapter. Sloppy.

Conclusion

I feel like I did get some useful information from this book. Was it worth the frustration of reading poorly written text, no context for code snippets, and numerous errors? Not in my opinion.

If you're like me--learning Cocoa, know some C from way back in college, but otherwise a beginner--and you've gone through Mark and LaMarche's Beginning iPhone Development, then this is your next book. Whereas the Beginning iPhone book goes into detail on the basics, this book shows how to stitch those basics together to solve more complex, more "real world" iPhone problems. Another value to beginners like me is that this book introduces various, generic programming concepts (such as threading, sockets programming, transferring audio data over a network, game timing, etc) that experienced programmers take for granted.

For example, the first chapter does not only show you how to make a simple Quartz-based game, but also addresses issues such as synchronizing game timing with program timing. The second chapter (Peer to Peer Networking) combines the sockets API with Apple's NSNetService networking framework. Before reading this, I didn't know a socket from Shinola.

What I like about this book is that each chapter is self contained, so you can jump around and read the stuff that is more immediately important to you.

I have enjoyed this series of books from Apress, this one in particular was good for the depth it provided and the views from developers of actual products. Often when trying to solve problems it is nice to see examples from code that has been successfully used. It was a quick read and I certainly would have enjoyed having a book twice as large so that I had more examples and ideas to look through.

If you've read the other books in this series (in particular the Beginning iPhone 3 SDK book) and enjoyed it, you will probably find some value here.