These changes may be of use to others as well.

1. Diagonal direction control.
For when you want to slide a view in from the corner of the screen.

2. Enclosing View support.
This is a bit convoluted, but: All animations in FTUtils are assumed to move in and out of the full screen.
When would this be an issue?
If you perform 2 animations at the same time that are enclosed in a view that is less than full screen. Basically, this boils down to the animation curves will be “out of sync”.

On a good note, I have finally uploaded a few snippets for the world to use.

First up is: iPhone Context Views (Codaset) (Github)

This is a very simple view class that will pop up context views/menus for users to interact with. This probably flies in the face of the HIG, but oh well. I must also admit this was heavily inspired by TaskPaper for the iPhone, which is an awesome app for notes/tasks/outlining.

The views use a simple delegate pattern which most Cocoa Devs should find familiar.

For my next trick, I present FJSTransitionController (Codaset) (Github).

“What is this TransitionThingAmaBob,” you ask? Well, FJSTC is a custom “top level view controller” to be used as a replacement for UINavigationControllers and UITabBarControllers. It handles transitions between view controllers, but with more flexibility.

Instead of managing a stack or an array of view controllers, FJSTC manages a Dictionary. You can associate VCs with keys and load them arbitrarily.

“But I want more!” you say. Well instead of giving FJSTC a fully instantiated VC, you can simply provide a class and it will instantiate it on demand. you can provide a nib as well.

Another requirement was the proper calling of viewDidAppear: and friends. This was done using the nice SDNextRunloopProxy class by Steve Degutis.

Just like UITBC and UINC, you can access the transitionController through an instance variable on all UIViewController instances (made possible by a UIViewController category):

[self.transitionController loadViewController:vc forKey:myKey];

And lastly, transition animations. You can set a transition animation type, duration, and direction (if required). The animations were enabled using FTUtils, a fantastic core animation wrapper with several stock animations (you really should check it out, as I said before).

So now you can load arbitrary view controllers with arbitrary animations in just a few lines of code.

These are both relatively new and assuredly have some bugs, BUT I am using them both in applications I am building right now. So, I will find those bugs, yes I will.

If you have a minute, check them out, and break as many rules in the HIG as you can!

One of the most perplexing omissions in the current SDK has been the CalendarStore API. It seemingly goes hand-in-hand with the AddressBook APIs and is every bit as important for contact management on a mobile device.

But alas, here we are on OS 3.1.X without any support for accessing a user’s calendar. Not even the “second-class citizen” readonly kind.

Although I’m sure the iPhone team at Apple has a pretty big todo list, I can’t help but think there is something more to this mystery…

I submit to you, the reader, that the forthcoming Calendar API is intimately linked to a background processes API. Huh?

I know, but let me explain.

When iPhone OS 3 appeared on the scene, Apple bestowed upon us a gift known as Push Notifications. But lets face it, they suck. For one, they only serve a few specific types of applications. And, perhaps even more detrimental, Push Notifications are hard. Hard to implement. Hard to host. Hard to scale.

Now some will disagree regarding degree of difficulty in setting up a Push Notification server, but none can argue that requiring developers to deploy a server just to fake background tasks is ludicrous.

But to my point: If only we had something like Push Notifications, but more flexible with no server requirement. Also, why not let us execute arbitrary snippets of code when our app isn’t running.

Now were getting somewhere. So, lets put it all together.

I have an app, say an alarm clock app (I know easy example). I want to schedule an alarm, so I call the calendar API and schedule an event.

CalAppEvent *newEvent = [CalAppEvent event];
[newEvent setStartDate:someDate];
[newEvent setRecurranceRule:hourly];
CalCalendar* appCalendar = [[CalCalendarStore defaultCalendarStore] sharedAppCalendar];
[newEvent setCalendar:appCalendar];
[[CalCalendarStore defaultCalendarStore] saveEvent:newEvent span:CalSpanFuture error:nil];

But wait, instead of a simple alarm, maybe I want to play a sound file from my app bundle and deliver a context specific message to the user. Maybe I even want to open a network connection.

If only we had an easy way to capture lexical scope and pass off some code to be executed by another process. How about:

[newEvent setAlarmBlock:myBlock];

Now when my event fires, I can run any arbitrary piece of code!

Now you see the possibilities. Is this true background process support? Not quite. But it is close, very close.

It provides nearly all the flexibility we need, while preserving battery life. Not to mention it avoids deploying and maintaining a server. We’ve effectively leveraged existing technologies (albeit 10.6) and since the calendar process is always running, why not exploit it for all of our multitasking needs?

Additionally, this implementation provides users with a familiar, easy to understand UI for managing background apps: the Calendar app. Simply open the special “Background Tasks” calendar to view all upcoming events scheduled tasks all of your apps.

Of course this is all speculation as I can assure you I have no inside information. I am sure that Apple has a much more elegant solution, but I can’t help but think I am on to something…

Thank you for indulging me in my little though experiment.

Below is a list of my subscribed developer feeds along with a link to each home page.

At the end of the post you will also find an OPML file if you are so inclined

Enjoy!

First are the Aggregators:

• [RSS] iPhoneFlow
• [RSS] Planet Cocoa
• [RSS] The MDN Big Blog

All development feeds:

• [RSS] #iPhoneDev
• [RSS] 47 Hats
• [RSS] 6Tringle Blog
• [RSS] 71²
• [RSS] A Smart Bear: Startups and Marketing for Geeks
• [RSS] Alan Quatermain
• [RSS] An Experiment in Bloggery
• [RSS] Arustisha
• [RSS] Basil Shkara
• [RSS] bbum’s weblog-o-mat
• [RSS] benbritten.com
• [RSS] Ben’s Dev Blog
• [RSS] BinaryMethod
• [RSS] BIT-101 Blog
• [RSS] bitquabit
• [RSS] Björn Winckler’s Blog
• [RSS] blog.sallarp.com
• [RSS] Call Me Fishmeal.
• [RSS] Cameron.io
• [RSS] Clickable Bliss Blog
• [RSS] Cocoa Convert
• [RSS] Cocoa Is My Girlfriend
• [RSS] Cocoa Nut
• [RSS] Cocoa Samurai
• [RSS] Cocoa with Love
• [RSS] Cocoaphony
• [RSS] Cocoatoa
• [RSS] Cocoia Blog
• [RSS] coders
• [RSS] Coding Horror
• [RSS] Contrast | The Blog
• [RSS] Dave Dribin’s Blog
• [RSS] Dave Mark’s Blog
• [RSS] Degutis.org
• [RSS] Derek Sivers
• [RSS] developer.casgrain.com
• [RSS] /dev/why!?!
• [RSS] Domain of the Bored
• [RSS] Dubroy.com/blog
• [RSS] Elegant Code
• [RSS] Enormego Developer Blog
• [RSS] Entrepreneurial Seduction
• [RSS] Eric.Weblog()
• [RSS] Eschatology
• [RSS] Espresso Served Here
• [RSS] Fat Cat Software
• [RSS] Fiery Robot!
• [RSS] fill the void
• [RSS] Flyosity: Mike Rundle’s interface design blog
• [RSS] Fraser Speirs
• [RSS] From a remote village
• [RSS] From The Top
• [RSS] furbo.org
• [RSS] Gus’s weblog, adventures in Flying Meat.
• [RSS] Hot Chocolate
• [RSS] How to Make iPhone Apps
• [RSS] Humble Coder
• [RSS] I Love Code
• [RSS] iamleeg
• [RSS] iApps Development Blog
• [RSS] iCodeBlog
• [RSS] ignorethecode.net
• [RSS] inessential.com
• [RSS] iPhone Developer Tips
• [RSS] iPhone Development
• [RSS] iPhone Development Blog
• [RSS] iPhone Development Tutorials and Tips
• [RSS] Iphone Noob
• [RSS] iPhone SDK Articles
• [RSS] iPhone Software Development
• [RSS] iphonedevelopmentbits
• [RSS] Irrational Exuberance
• [RSS] i’m so full of ideas
• [RSS] Jake Behrens
• [RSS] JakeBehrens.com
• [RSS] James Frost
• [RSS] Jayway Team Blog
• [RSS] Joel on Software
• [RSS] Karl Kraft
• [RSS] KATI
• [RSS] Kickingbear
• [RSS] Lap Cat Software Blog
• [RSS] LockFocus
• [RSS] Mac Developer Network
• [RSS] Mac Developer Tips
• [RSS] Mac Fanatic
• [RSS] Manton Reece
• [RSS] Marc Charbonneau’s Blog
• [RSS] Marco.org
• [RSS] Mark Alldritt’s Journal
• [RSS] markjnet
• [RSS] Matt Legend Gemmell
• [RSS] Maxvoltar
• [RSS] memo.tv – iPhone
• [RSS] Michael Tsai’s Weblog
• [RSS] Mike Clark
• [RSS] Mike Lee
• [RSS] Mobile Orchard
• [RSS] Natterings
• [RSS] ninth DIVISION [iphone, mac, web]
• [RSS] Noodlings
• [RSS] Notes From Andy
• [RSS] NotTooBad Blogging
• [RSS] NSBlog
• [RSS] NSCoriolisBlog
• [RSS] ObjColumnist
• [RSS] ObjectGraph Blog
• [RSS] Panic Blog
• [RSS] Pieter Omvlee’s Blog
• [RSS] possible/probable
• [RSS] PrEV
• [RSS] Red Sweater Blog
• [RSS] Release Candidate One
• [RSS] rentzsch.com: Tales from the Red Shed
• [RSS] revetkn.com
• [RSS] Seth’s Blog
• [RSS] shanecrawford.org
• [RSS] Signal vs. Noise
• [RSS] Software by Rob
• [RSS] Space Vatican – Home
• [RSS] Square Signals
• [RSS] stevenf.com
• [RSS] Stormy Productions Blog
• [RSS] Talk Funnel
• [RSS] Tech Thought
• [RSS] Th30z – Coding on the Fly
• [RSS] The Flying Jalapeno Lives
• [RSS] Theobroma Cacao
• [RSS] TobyJoe
• [RSS] toxicsoftware.com
• [RSS] Trails in the Sand
• [RSS] tumbljack
• [RSS] UI and us
• [RSS] Under The Bridge
• [RSS] Waffle
• [RSS] Wandering Mango Weblog
• [RSS] withfoam

And if you would like to add these straight to your favorite feed reader, here is the OPML file:

google-reader-subscriptions.xml.zip

Lastly, I used this little web app to parse my opml file.

You should be.

FTUtils contains several classes that allow you to easily add semi-complex animations to your app, for “free”.

It’s a nice abstraction of Core Animation (which is a great abstraction of OpenGL + Quartz in it’s own right)

Check out the demo app to see what you can do.

http://boredzo.org/opensourcelinks/byauthor.html

http://cocoaheads.byu.edu/resources/open-source

Originally suggested in this Stackoverflow question.

Sometimes, instead of traditional nib loading, you may want to use the following method:

[[NSBundle mainBundle] loadNibNamed:@"MyViewController" owner:self options:options];

For instance, if you want to provide a runtime replacement for proxy object in your nib (see UINibExternalObjects).

If you do this and you also need to perform setup after the nib loads, you’ll come across an unexpected behavior.

viewDidLoad will not be called (Nor does awakeFromNib).

I wouldn’t classify it as a “bug”, I can see the rationale, but it is dubious and I have (so far) been unable to find any documentation on this behavior.

So if you do need to do some setup, place it in viewWillAppear (You are using a UINavigationController or UITabBarController, aren’t you?).

It’s not quite perfect, as I am sure most developers would like to allow full functionality to users for a timed duration. (Maybe this will be allowed?)

From a consumer side, I hope this isn’t abused to much.

I have a strong feeling that we will see much more of a lash back if users of free apps are constantly bombarded to make in-app purchases.

One of the tools I came across since I began using git is DTerm. It is essentially a free floating terminal that you bring up with a keystroke.

The killer feature (for me) is once you invoke it with a keystroke, DTerm is set to the working directory of the front most document.

The other killer feature is that DTerm (v. 1.x) is free!

NSString *s = [NSString stringWithFormat:@"tell application \"Terminal\" to do script \"cd %@\"", folderPath];
NSAppleScript *as = [[NSAppleScript alloc] initWithSource: s];
[as executeAndReturnError:nil];


The intent is pretty easy to pick up (Also, please feel free to handle the error). The question and answer can be found on StackoverFlow.

To be sure, I have yet to explore some of the more dynamic aspects of Objective-C/Cocoa in my applications.

In fact, as many know, you can move along quite happily though your Cocoa/iPhone programming without directly daling with it. Others might not realize what’s “under the hood”.

If you really want to have some fun, you will need some fundamentals.

To this end, Mobile Orchard last podcast featured Rogue Amoeba’s Mike Ash who gave an overview of the runtime.

MDN also released episode 7 of the MDN Show which goes into more depth in an interview with Jonathan Dann of Sofa.

If these podcasts wet your appetite, Mike Ash has also produced a nice series of blog posts on the subject as well.

I’m sure you will find other great resources in the community as well, but this should give you a good head start.

Almost everything on the iPhone round, glossy and “3Dish”.

Except the standard RoundRect buttons included in UIKit.

Of course we can go off and use one of many drawing apps to crank out some nice glossy buttons, but there a few problems with this approach.

First, you have to be at least competent in using some advanced drawing tool.

Second, any buttons you create are static and must be shipped as a resource in your app. It is acceptable to want to generate multiple colors on the fly.

To solve our dilemma, we can use the work of two other people.

Matt Gallagher posted a great article on generating gloss gradients a while back.

It’s quite informative in explaining and implementing the effect. You can run a OS X app and play around with the setting.

The code didn’t quite work on the iPhone because of the absence of NSColor.

So we have two problems. First, we need to adapt the code to the iPhone. Second, we need to add this code to UIButton as a category.

Good news everyone! It’s already been done.

More than that, you can follow a 5 step tutorial taking you through the process of building the code and some explanation behind it.

The first post of the series can be found here.

I would credit the author, but I think he (or she) has gone through great pains to omit his (or her) name from the blog. (Or maybe I’m just too dense).

Update: Michael Heyeck wrote in to claim his awesome work and updated his “About” page to be a little more forthcoming.

Anyways, try it out. It works good for making glossy buttons pretty quickly and it is tweak-able.

I personally feel that dot syntax serves a worthwhile purpose.
In fact, I have been refactoring old code to conform to this convention.

In the end, I feel these types of debates speak to the health and growth of the Cocoa/Objective-C community.

If you’re not trying to use someone else’s code as much as possible, you’re not doing OOP.

I won’t call this a series, but I would like to showcase some of the great code that is out there waiting to be used. All you have to do is drop it in your project.

This time I’ll point out a framework that I use very frequently:

json-framework (available on Google Code)

It’s drop dead simple to use. You give it data, it gives you a Cocoa Object, end of story.

Here is how I use json-framework in some of my code.

The SBJSON class gives you back a NSArray, NSDictionary, or an NSError (pointer reference).

If you need to parse JSON data, check it out.

A great opportunity for you to hone your iPhone Dev skills is coming up this fall.

Voices That Matter: iPhone Developers Conference is a two day event that will be held in Boston on October 17-18. It will feature talks from some of the most talented and influential iPhone developers, authors, and experts.

Speakers include:

Bill Dudney
Daniel Jalkut
Fraser Speirs
Marcus Zarra
Aaaron Hillegass
Andy Ihnatko
Jon Rentzsch
Steve Kochan
Lee Barney
Daniel Grover
Bill Licea-Kane
August Trometer
Erik Buck
Erica Sadun
and others…

This conference is designed for developers looking for a succinct, easy way to get up to speed on the specific skills needed to build, test and distribute successful applications for the iPhone and iPod touch.

You can attend sessions covering a variety of topics. Choose whatever sessions best fit your individual skill level.

Not only will you learn how to build and ship successful iPhone apps from the great speakers, but also have the chance to meet and network with many other passionate developers like yourself.

Voices That Matter will help you begin developing iPhone apps as quickly and profitably as possible.

I personally am excited to meet the authors who wrote the books from which I learned Cocoa Touch.

If you register before September 12th, you get a $200 discount.

You will get an additional $100 discount, when enter this code: PHBLOG

So if you are thinking about attending, make sure you register while you can still get $300 off.

See you there!

PlaceHolder

PlaceHolder

Full Disclosure: I am attending this conference as non-paying guest.

Billy Gray over at zetetic has done just that with his NSDate+Helper category.

if allows you to completely forget about NSDateFormatter and easily format dates in just about any format you need. it also has some nice convenience methods built in to it.

You can find it on here on GitHub.

They not only save you time, but also help “automate” memory management on the iPhone. They save you from screwing up your accessors.

Another benefit, is the orthogonal relationship with dot notation. Dot notation short hand makes it extremely quick to change the state of an ivar with minimal keystrokes.

There are (too) many debates about whether this syntax is “ugly”, “tacked on”, etc… This post makes a great case for using dot notation to differentiate the intent of your code.

In fact, properties used in concert with dot notation are so convenient that there is little excuse to ever access instance variables directly. Another bonus is the “automatic” memory management. Well as automatic as you can expect in a reference counting situation.

You may be opposed to creating a property for an ivar you want to be private since doing so allows unrestricted access. This creates an encapsulation problem, but one that is easily circumvented with another Cocoa trick: anonymous categories.

By declaring your private property within an anonymous category in the implementation file, you effectively hide it from other classes.

It is still true, that you can peek in the implementation and find these hidden properties. But it will be readily apparent to you, or anyone else, that they should be left alone since they reside within the implementation file.

I use this technique to clean up my interface files (along with placing private methods in the category as well). This gives your classes a nice, neat, and more importantly, easy-to-understand interface.

Another issue is when you need to react to state changes of an ivar. This can be mitigated using KVO. By observing properties, you can react easily such changes.

Do you use dot notation or do stick with brackets? Do you create properties for all of your ivars or do you prefer to handle their memory management in the implementation?

Such ambition, however, can quickly subside after a few snags or if monotony begins to set in.

Unlike those that work in a development shop with several employees, we may have no one to push us but ourselves. As an indy developer, you not only need to be focused and regimented, but also must find ways to maintain your sanity.

A common solution adopted my man developers is to work on more than one project at a time. Starting a new project can feel like a mini-vacation. You get to solve new and interesting problems making work less like work (the way it should be).

Unfortunately, many of us go on “permanent vacations” (Aerosmith pun intended). It is a seductive trap to fall into. The path to indy success is littered with the many carcasses of unfinished projects.

It is a fine balance. On one hand, you need to focus and work hard to push out a product. On the other, burning yourself out can be difficult, if not impossible to recover from, emotionally and financially. It is far better to distract yourself for a few days with a side project than to open yourself to mental and financial ruin .

Like everything else you do as a micro-ISV, you need to police yourself (you are “independent” after all). Use iCal and schedule yourself a “2 day break” to work on another project.

Try to prevent boredom from setting in, in the first place. Make sure you outline discrete tasks and complete them one at a time. Completion is a reward that does not receive enough credit.

One tool I like to use is Scrumy. It is very easy to visualize your progress on individual tasks (Note: this is a scrum web service, but you don’t need to be completely versed in scrum to use it)

Another great tip from Matt Gemmell (via the MDN Show) is to create new components in a blank Xcode project. This allows you to focus on the task at hand and not let the rest of the project to “weigh” you down. There are other benefits as well which you can get from listening here.

What tips do you have for staying focused? How many projects can you successfully juggle and still make concrete progress? Let me know down below (I like cheap rhymes as well as puns).

Edited: To correct Matt Gemmell’s last name. How I spelled that wrong after hearing his theme song, I’ll never know.

I currently work on a 13″ MacBook, so the 15″ would definitely be a step up. Extra screen space is not just welcome, it is needed. Although my MacBook is ultra-mobile, I could not handle the 13″ MacBook Pro anymore for development.

Instantly I realized that the MacBook Pro 15″ is a great balance between productivity and mobility.

The 17″ model is a different planet however. Xcode wasn’t installed on the demo machine, but I opened many application windows to help imagine my workflow.

The extra 2″ PLUS increased resolution makes the 17″ screen enormous by comparison. Where the 15″ feels like a laptop with a bigger LED, the 17″ is a workspace (to quote someone on some forum, I can’t remember quite where).

I couldn’t resist. I finally settled on the 17″ model.

I use Spaces heavily in my typical workflow. My workspace divided into 4 spaces, which really optimizes my screen real estate. I think I may be able to cut that down to just 2 Spaces with the 17″ (possibly just 1).

I’m not terribly concerned about the weight. it really isn’t that much bigger or heavier than the 15″ model. Both models are significantly bigger than my current MacBook and will require a new “wardrobe” regardless.

I did think long and hard about getting the 15″ and an external monitor. However, my work patterns aren’t set enough. I work mostly at home, but also coffee shops. I never know where I’ll be. I may also begin renting a workspace rather soon (indy hall).

My thinking is the 17″ machine best fits my unpredictability right now. I can worry about later when it comes. Maybe that is short sighted, but work only ever gets done NOW, nothing ever gets done later (but thats another post in itself).

Now if my shipment can ever make it out of Shanghai Anchorage.

However, making table views work smoothly with anything but a small, simple, static data set can be trying, to say the least.

Many Cocoa developers have come up with solutions to cope with scrolling performance issues, abstracting cell content, creating preference views, adding network awareness, etc…

Ideally much of this functionality should have been included in the Apple frameworks. Alas, this is not the case. We must use third party solutions to fill the gaps or “roll our own” solutions. Sometimes we need to combine the work of several developers into one class.

Recently, I had to create a network aware table view that also supported filtering with animation. Already having setup a UITableViewController for receiving network data, all that was needed was to filter my data and animate the change. Simple.

Well, not really. If you want to perform that nifty animation that Apple uses when viewing missed calls in the phone app, you will most likely need to make some changes to your current design.

To analyze the problem, lets look at the major components: data model, presentation model, view. We will stay away from code, and look more at the design to accomplish this.

For my typical table views, Matt Gallagher’s solution works fantastic.

The diagram is a bit simplistic, but illustrative (In reality, we have nested arrays representing sections within the table). There are two arrays, one to hold our model data and one to hold our presentation data. Also note, the structure of the data model does NOT necessarily need to reflect that of the table, but it seems logical to organize this particular set of data in this manner.

We have created a “Cell Controller” to manage individual UITableViewCell logic. The UITableViewController now only has the responsibility of creating and destroying these Cell Controllers. This moves the UITableViewController one step closer to adhering to SRP.

One undesirable aspect of this methodology is the requirement to instantiate every Cell Controller and link it to its model data upfront. In return you receive better flexibility and encapsulation without a noticeable performance loss (at least with the moderate sized data sets I have so far worked with).

So, lets look at our basic algorithm for creating our Cell Controllers:

1. Loop through each dictionary in the model data array.
2. Create a cell controller.
3. Add a pointer to the dictionary in the cell controller.
4. Add the cell controller to the array of cell controllers.

This approach works well for static tables and it is easily adapted for network aware tables. For static tables, you set up your relationships once, and your done. For a networked table, you must add a new object to handle network activity. Then they can communicate through any combination of notifications, KVO, and delegate methods.

This is pretty basic, but it is nice to see the relationships laid out.

Now we need to modify our approach to handle filtering. We need a way to represent the full data set and any subsets. Two methods of accomplishing this task are:

1. Create separate arrays for each set. One for the full data set and one for the filtered set.
2. Use a flag to mark filtered results.

Flagging is preferable for a two reasons. In reality, the data didn’t change, we just want to update the presentation. In this case we don’t want to actually modify our data. Additionally, it is more difficult to track several arrays and which one is the “real” data.

As we stated earlier, the presentation model needs changed to display the filtered results. In our previous design, the view controller “looked” at the model and created the cell controllers based on the structure of the data. Not much has changed, but now we just need an additional check. So our algorithm could be:

1. Loop through each dictionary in the data model.
2. If a dictionary has the flag set,
   • Create a cell controller,
   • Add a pointer to the dictionary in the cell controller,
   • Add the cell controller to the array of cell controllers.
3. Finally, replace the old (unfiltered) array of cell controllers with the new (filtered) one.

As we connect the Cell Controllers to their corresponding model data, we check our flag. If we did not want to animate our deleted cells collapsing, we would be finished. We need to devise a method tell our table view which cells have been removed (as well as sections).

There are a few ways to accomplish this. In place of the previous algorithm we could do the following:

1. In our view controller, loop through each cell controller in the array.
2. If a cell controller’s model dictionary does not have the flag set,
   • Add the cell controller’s index to an indexPathSet to removed from the array
   • Add the cell’s index path to the array of cell paths to be removed from the table.
3. Remove the cell controllers from the array of cell controllers.
4. Remove the table view cells from the UITableView.

Not too bad, but we have completely changed our algorithm. Instead of creating an entire new array of cell controllers, we now remove the ones . The motivation behind this, is that we need to give the table view a list of cells to delete. If we had used our previous algorithm, it would have been difficult to produce this list.

We have just one more issue, but you will not discover it until you try to update a remove all the cells in a section and you app crashes. UITableViews do not like empty sections after deletions. So make sure you remove any empty sections as you remove UITableViewCells.

Hopefully this helps some of you get a head start on your table views. We mostly went over design and algorithms which should help you produce your own code and cut down on much of the trial and error that goes into this problem. In a future post, I will include some code as well.

Let me know if you have already coded your own solution to this or are using open source code.

http://www.karppinen.fi/analysistool/

Not that the scan-build CLI is that intimidating, but if you have any problems getting reports (I just had an issue with a static library), it may help

You can be sure that all iPhones will be running OS 3.0, but we now have 5 devices to deal with, each with 5 different sets of capabilities.

If you are like me and bought an original iPhone on day one, you may have some older devices laying around. You may have even received a free iPod touch with a Mac purchase.

The major problem for us now is not whether voice command or a video camera is present, but the speed and memory of each device. We now develop for the sluggish first-gen iPod touch, as well as for the speedy 3G s. That is a huge performance gap.

Without the ability to test on a few of these, you may not be able to predict how you apps will function for your customers.

With 40 M devices out there, you can’t ignore the older hardware. There are still millions of original iPhones and iPod touches in the wild.

How will you cope? Maybe you shouldn’t sell your old iPhone to get a 3G s. Maybe you should search ebay for an extra testing device as others upgrade.

What do you plan on doing to ensure your apps have the highest compatibility?

I’ll first get my AT&T hatred out of the way. This isn’t exactly developer related, but it is annoying enough that I feel compelled to address it.

I usually have few complaints about AT&T. My reception as been good where I live, customer service has been tolerable, and usually don’t have billing issues. I am not happy with how they gouge for text messaging and internet, but prices aren’t “outrageous”.

But for the first and largest iPhone wireless carrier to be lagging behind the rest of the world is absolutely ridiculous. Their rationale for the MMS delay is like an excuse from a student who didn’t do his homework. The non-answer on tethering is almost better by comparison.

The real reasoning is likely two-fold. First, I am sure they are contemplating how much they can charge us. The other stems from holding a monopoly on iPhone service. They have no motivation to provide good service to retain their iPhone customers. We would never give up our perfect phones and they know it.

Sadly, Apple is also to blame for creating this type of environment. They may have needed to commit to a single carrier in 2 years ago, to obtain certain network guaranties, but those reasons no longer exist.

Just having Verizon, Sprint, or T-Mobile as potential competitors would scare AT&T enough to force better service and competitive prices. From the sound of things, Apple is more than savvy to this fact. I am optimistic that the AT&T’s exclusivity contract will soon be coming to a close.

Once you get to that point, most or your journey still lies ahead. If you were like me, you probably learned a lot about iPhone programming from online tutorials and books. Then one day, after your 16th tutorial and 3rd book, you looked around and said, “Now what?”

The truth is that technologies like Core Animation, Core Data, and Core Graphics are just tools. They are only a means to an end.

A full toolbox does not make a carpenter good. You still need experience, planning, and vision.

With this in mind, I want to talk about Key-Value Observing. This won’t be a full coding example, per se, but a discussion of how you may use this tool in your code.

Many readers may know the gist of KVO, as well as KVC and bindings. Although bindings are beyond the scope of this post, we will give a quick definition of keys and Key-Value Coding.

KVC is a technology that allows you to access an instance variable by using a string referred to as a key. So using an example:

To access are aptly named dictionary, we can type the two equivalent statements:

They do exactly the same thing, but in KVC we use supply keys using the “valueForKey:” method available to all NSObject subclasses.

To set this property we can use either of the following statements:

This can get more complicated with key paths and some other things. If you would like more information, there are some great tutorials available here and here.

Now to KVO. For those who don’t know, KVO provides a mechanism to receive notifications that an instance variable, has been modified. Of course you know now we will be using keys to do this. First you register as an observer for the key:

(Note: I won’t engage in any “self=[super init]” talk here)

We simply registered the class to receive notifications about its own instance variable, but we could have easily selected an ivar of another object.

We also have set some options and a context here, but nothing that need be delved into for our discussion.

To receive the notification, we need to implement one method:

Every time the instance variable is changed, this method will be called automagically.

Now that we have a very, very rudimentary understanding of what KVO (and KVC) are, we can begin to talk about how to use them.

One very common use of KVO is model observation. On stack overflow, I see many questions like: “If I have a variable in view controller A, how do I pass it to view controller B?” Of course the real problem is that we are asking the wrong question.

The right question is: “How can I get two view controllers to know about changes of a single variable?”

We know now that we can use KVO. What we want to do is make our views observe our models. By registering view controllers as observers to the model, we can have an unlimited of views showing and/or using the same data. This also gives us well defined MVC boundaries. What’s more, is that we will write almost no code to accomplish this feat.

As you will read elsewhere, KVO has some (few) disadvantages. The one that sticks out, is that it may make your code harder to debug. This is because it is hard to sometimes tell who is observing who. Otherwise this is a very elegant solution that will eliminate some of your glue code.

If you want to go deeper into Key-Value Observing you can read more here, here, here, and of course you can use Apple’s documentation.

What are some uses and patterns of KVO and KVC in your programming?

In retrospect, I can see these classes represent some of the fundamental design patterns used in Cocoa (touch): delegation, composition, protocols, MVC, nibs, memory management, etc… Once I understood how to use a UITableViewController, I was able to dissect and comprehend the interactions and use of other classes much more easily.

There were many “ah ha” moments when learning those concepts. Previous to iPhone programming, I mainly wrote C and machine level code. It wasn’t my first foray into OOP, but it has been my deepest and most comprehensive.

Learning to write methods that you never actually call yourself was a huge mental hurdle. Splitting class responsibilities according to MVC was logical, but hard to do right (I know, a discussion in itself) the first few times.

Similar to MVC, was memory management. It’s so easy: alloc(or new or copy)+retain = release+autorelease. But when do you actually release? When should you just set to nil? Should you use the accessor or not? Maybe it is best to just use the assign property. Should I create an autorelease pool? Is it best to just “leave the object around” and just handle it if a memory warning pops up. You have a lot of design decisions to make even though the basic premise is simple.

Nibs were simply awesome to layout my views, but learning to hook up the right things and how to use them effectively was no simple task. The outlets and actions themselves weren’t that confusing. The “things you don’t quite have to know until there is a problem” were hard to get my head around. For example: how to load nibs from other nibs, load UINavigationControllers in UITabBarControllers, what the proxy objects actually are, which controller classes to include in the nib, what “really” happens when objects are unarchived, realizing that “initWithCoder:” is called on classes that are defrosted from a nib, how to load UITableViewCells from nibs, etc…  There are many intricacies, most of which you never think about until your app doesn’t work.

After I had some time to think over these problems and Scott’s question, I came to realize (at least for me), Cocoa just took time to learn. Everyone comes from a different background with a different skill set. Add to that, the size and breadth of Cocoa. It should come as no surprise that everyone has to take there knocks when moving to Cocoa and Objective-C, no matter where there coming from (save Next developers).

So, how to wrap this up? To all of the beginner iPhone and Mac developers: know that you have a mountain to climb. Find information where ever you can. The Cocoa development community is great and there is no shortage of resources. Eventually you will reach the “critical mass” of information when you can begin to solve your own problems much more effectively. You will always have more to learn, but will develop an instinct to find what is wrong and begin to ask the right questions.

Is there anything that you think is missing from Scott’s list or that I glossed over? Let me know.

For the past few weeks, my routine has been quite the opposite. I answer as many questions as time allows. To better keep up on the latest questions, I keep a RSS feed of Stack Overflow tags “iPhone” and “iPhone SDK” in Safari’s bookmark bar.

I was reluctant to answer questions because of my (perceived) lack of knowledge. I have since discovered that I am able to help much more often than I thought. It feels good to contribute to the community that has helped me so much.

Even better, answering questions helps me more than asking them. Thinking through the problems of others allows me evaluate my skill set and identify any non-obvious holes in my knowledge.

I highly encourage everyone to get involved in the community. Even if you’re a beginner, you will find you know more than you think. It will only help you improve your problem solving skills and make a few friends in the process.

I originally decided to try Xcode after some experience with Versions.app, my first SCM experience. Versions is a collaboration between Pico and Sofa. I used Versions during it’s beta. At this time, I was painfully inexperienced with version control. I frequently went back and forth between Versions and Terminal, picking up what I needed along the way.

Eventually, when Versions went 1.0, I made the decision to not purchase it. I could never get Versions to display all of the change logs of a working copy if it hadn’t existed locally since the creation of the repository. As I said, I wasn’t the best with svn at this time. I probably just couldn’t find the control to download the logs from the repository, but it shouldn’t have been that difficult nonetheless. This was something that should have happened “automagically”.  This and a few other quirks didn’t make a good value (for me) over Xcode and the command line.

Flash forward to last week when my repository host, beanstalk, sent a notice they were upgrading all repositories to subversion 1.5. This influenced me to look into upgrading my client side software to use 1.5 as well. At first, I figured I would just patch Xcode to use 1.5, but that seemed unnecessarily complicated. So once again, I decided to try an external solution, but armed with a much better understanding of my work flow and subversion itself.

I downloaded new demos of both Versions and Cornerstone. I had briefly looked at Zennaware‘s offering before, but this time I was able to examine it much more thoroughly. I setup Cornerstone first, and to be honest, I haven’t looked back.

Before I move on, this seems like a good place to get 2 (related) points of contention out of the way: DVCS (Git and Mercurial) and SCM GUIs.

I’ll address my need for a GUI first: I want a seamless and easy way to perform my version control. I already perform enough tasks extraneous to actual programming. I want this part of my workflow to be “point and click”, allowing me to focus more on delivering code.

As far as DVCS: I realize that Git is the new “hotness”. At this time, I operate primarily as a solo shop. Additionally, I now know how to get around svn just fine. For me there is no overwhelming advantage that switching to Git would provide at this time. I am almost never working out of internet range and I don’t collaborate very often. Moreover, there is no “great” GUI for Git yet. I am sure one is eminent, taking in account GitHub as an example of Git’s growth in both marketshare and mindshare.

Back to Cornerstone.

I really like its layout. It matches up extremely well with my “mental” picture version control.

The side bar is split: working copies up top, and repositories on the bottom. This is in contrast to Versions where the repositories are like “folders” and the working copies are subfolders.

The main window contains a file browser for the selected repository or working copy. When I pressed the space bar, I got a nice surprise: Quick Look. Located along the top of the main window are quick filters for “changed”, “modified”, “unversioned”, etc… These make it super easy to filter a long list of files.

When you make a commit, Cornerstone automatically asks if you want to begin versioning any files not added to the repository. Sweet.

By clicking a checkbox, you can automatically setup your repository with the default trunk, branches, and tags folders. You can also set ignore files just as easy.

Corenerstone has an entirely different window devoted to file history. Simply select one or more files within the file browser and click the history button. You are then presented with a graphical timeline with a “node” for each past revision. Select any 2 nodes and they are opened for file comparison.

This presentation does have some drawbacks. Primarily, it just doesn’t scale well. Each file has its own timeline at the top of the window. This works well for a few files, as you can see. View many, though, can be cumbersome. It is possible to view a timeline for just the root folder of the repository which cleans it up a bit, but this wasn’t an immediately obvious solution.

Corenerstone has a decent comaparison engine built into the app. Versions performs its comparisons by using an external app of your choosing. I know many users love this because it enables them to use their favorite comparison tool. Personally, I prefer the speed of Cornerstone’s implementation. With a single click, I can compare any local changes to the latest revision.

When packing a large amount of information in to a GUI, some items will become focal points, while others will move to the periphery. For me, it appears as if commit messages and change sets are presented as second class citizens in this Corenerstone’s UI. They are regulated to a small info pane whose purpose wasn’t readily apparent. Versions, on the other hand, has the change sets and commit messages beautifully laid out in a seperate view.

I imagine that when I stop working on a 13″ Macbook and have a larger 24″ desktop, it won’t matter so much. This will also allow me to evaluate Cornerstone’s ability to switch froma an all-in-one mode to a multi-window mode, ala Xcode. With a large and/or multi-monitor setup, these issues will likely disappear. My interface complaints are mostly my fault for developing on a contrained consumer laptop.

Speaking of hardware limitations, Cornerstone did not seem to be bothered by the specs of my development machine. Not that you would expect a subversion application to give a modern Mac any such issues. All the same, I haven’t noticed any interface delays, network hangs, excessive disk access, or any other performance problems. This clearly demonstrates the skill, care, and time investment of the developer, who from my understanding operates a single-man shop.

Cornerstone’s interpretation of the svn domain is the most solid out of the apps I have seen (although I admit to not diving as deeply into all other solutions). I am currently running Cornerstone in its demo period and plan to purchase it soon. It has definitely made subversion painless to use while packing a fair amount of power into its interface. If you are seeking a powerful GUI for subversion, Cornerstone is the best you can get.

First, is an excellent series on cocos2d for the iPhone by Keith Peters at BIT-101:

cocos2d Tutorials – TOC

Second, is an in depth look at at OpenGL ES for the iPhone at Jeff LaMarche’s (of “Beginning iPhone Development” fame) aptly named iPhone Development Blog:

OpenGL ES From the Ground Up, Part 1: Basic Concepts

Enjoy!

When you have a question, it is easy to type it into a search engine and find an answer. Sometimes, though, you don’t know what question to ask.

Enter development blogs. A steady stream of information, tips, tricks, tutorials and great open discussion. I subscribe to over 50 feeds from development blogs using Google Reader as my RSS reader of choice.

Besides “doing”, this is the best learning tool I have. I consistently read articles addressing problems I haven’t thought of yet. I find sample code I can stock pile now and use later. The Cocoa community is extremely helpful and talented.

Most developers carry their tedious attention to detail into their blog writing. This leads to infrequent, yet highly polished and information rich posts which are easily scoured in your feed reader.

So, what feeds do I read?

Below is the list of web sites of who I keep in Google Reader (in no particular order).

I’m sure I left out some, so let me know if you have any good blogs that should be on my list.

Cocoa Samurai »

Cocoa Convert »

NotTooBad Blogging »

revetkn.com »

Manton Reece »

71² »

Jayway Team Blog »

toxicsoftware.com »

UI and us »

47 Hats »

Software by Rob »

markjnet »

Joel on Software »

iPhone Development Blog »

inessential.com »

BIT-101 Blog »

Mac Fanatic »

Coding Horror »

Fraser Speirs »

Theobroma Cacao »

Cocoia Blog »

Mac Developer Tips »

iPhone Development »

How to Make iPhone Apps »

Cocoa with Love »

iPhone Developer Tips »

Cocoa Is My Girlfriend »

iphonedevelopmentbits »

iPhone SDK Articles »

iPhone Software Development »

Fiery Robot! »

iCodeBlog »

PrEV »

Trails in the Sand »

Mobile Orchard »

Red Sweater Blog »

NSCoriolisBlog »

Ben’s Dev Blog »

Hot Chocolate »

iApps Development Blog »

memo.tv – iPhone »

Ninth Division LLC »

coders »

Iphone Noob »

shanecrawford.org »

bbum’s weblog-o-mat »

BinaryMethod »

NSBlog »

Pieter Omvlee’s Blog »

Dubroy.com/blog »

Kickingbear »

Degutis.org »

Tech Thought »

Domain of the Bored »

Waffle »

Gus’s weblog, adventures in Flying Meat. »

stevenf.com »

Dave Dribin’s Blog »

Clickable Bliss Blog »

From a remote village »

rentzsch.com: Tales from the Red Shed »

Marc Charbonneau’s Blog »

Call Me Fishmeal. »

Lap Cat Software Blog »

Matt Legend Gemmell »

Michael Tsai’s Weblog »

Enter Three20. Three20 is a framework written by Joe Hewitt that abstracts much of the functionality of UITableViews, UITableViewCells, and networking away from the programmer. The way the components are abstracted is clearly MVC, but done in a more “web application” way. I believe Joe commented in his recent interview on the Mobile Orchard podcast.

When you download Three20, there is a nice sample app included with just about everything you can create. This provides a great overview of what is included within the framework.

The functionality of the UIKit classes has been abstracted to the point that you never really touch the usual delegate and datasource methods. You create view and controller objects through a completely different programmatic interface.

You can create tableviews and photo galleries very easily by just adding creating a data source array and the view classes basically take care of themselves. This was very cleanly done. For instance, to determine the type of cell that will appear in your table, you populate your datasource with a specific type of *Field object. A TTTextTableField produces a text cell, a TTSwitchTableField yields a cell with a switch, etc…

To create a Photo Browser View and/or a Photo Thumb View is slightly more difficult. You will need to define your own Photo Datasource class. In the example code, there is a mock photosource class setup that provides a good starting framework.

Unfortunately, the requirements for my current project didn’t allow me to use the Three20 classes as is. I had to dig a little deeper into the framework and modify it to suit my needs.

When you dive into the code, you quickly find all the Cocoa classes have not been merely subclassed, but have had there behaviors completely altered. I could use the basic, high-level classes, but I could not understand exactly how they worked behind the scenes. I needed to subclass the TTThumbViewController and I had to understand what I needed change to make it work for me.

To be frank, it is complicated. So complicated, I considered giving up subclassing it several times during my adventure. As I began to decipher the interconnections and roles of different objects, some design patterns began to fall out. An interesting note is Three20′s use of delegates. There are many delegates and controllers and controller delegates and datasource delegates, etc…  This was one of the main reasons it was hard for me to fully comprehend the framework. I literally had to pull a notebook out and start drawing the connections between the classes.

After a few hours,  I felt I had a decent understanding of the underpinnings of the relevant classes which I needed to alter. I began to make my construct my classes and finally accomplished my goal of customizing the thumbs view to the following:

I know, not very impressive on the surface. What I managed to do was add section support to the TTThumbsViewController. The stock class only supports a single section with no division between the rows of photos. Also, it only supports one photo source per view. I have changed it to allow a photo source per section (Even though it looks like one source, it’s actually 2 sources with the same data).

It’s not bug free yet, and [redacted] betas are a little picky. When I get a little more solid, I’ll see if I can get a fork going on GitHub and upload my additions there.

In the end, I think it was worth getting intimate with Three20 to get all of the networking and photo browsing goodness for free.

I encourage everyone to check out Three20. It works great for just about anything you want to do. If it was my decision, I would have just changed my design to accommodate the framework and save myself a weekend.

Let me know if any of you have used Three20 and what your experiences were.

You will find a variety of questions from novice to advanced. Stack Overflow has a policy of “no stupid questions”. Which means you won’t get attacked for asking a “easy” question. Jeff Atwood and Joel Spolsky stated on their podcast (which is also phenomenal by the way) that they want to be like a programming “Wikipedia”. That is why the like and encourage all levels of questions.

Go to Stack Overflow and start posting, commenting, browsing, and, of course, as answering many questions as you can.

http://majicjungle.com/blog/?p=115

If you submit an update to iTunes Connect, do NOT change the available date of the update to a future time. It will remove the current version from the App Store.

I did this because I wanted to make sure my update didn’t get buried in the new releases list. Instead, my app Compounds, was delisted AND removed from the “New and Notable” section for the larger part of a day before I noticed.

After I got it re-listed, I immediately checked the New and Notable section to find that Compounds was not back in its place. I understandably panicked, but was more than relieved when it was back the next day. I estimate about a 70% loss in sales fo the day, however.

To make sure you get the best placement for your update:
The day your update passes review, simply log into ITC and change it’s available date to today. This will ensure that you’re app will be near the top of the new releases list.

Lesson learned.

We need to track cash from sales of iPhone apps and/or iPhone contracting. I assume most of those reading my blog need both. (Side note: if you’re not in the iPhone contracting market, get there, another article…)

We have many contenders fighting for mindshare, loyalty, and sales, from the big boys to the indys. So how do we decide? What is important to us as iPhone developers, software vendors, and contractors?

Like good little programmers, we’ll logically split our problem into bite size pieces.  Here is what we need:

1. Invoicing
2. Job Tracking
3. Project Tracking
4. Bank Transaction Download or Import
5. Double Entry Accounting (for tax purposes)

When I say project management, I don’t actually mean how we as developers track our project progress (scrum, agile, issue trackers, etc…). I am referring to a means to group jobs and invoices under a common “umbrella”, not only by customer.

It would seem to me, and to most of the financial software venders that we have three distinct problem sets. The products I have been demoing specialize in a some combination of invoicing, accounting, and/or banking.

This separation of responsibility leads to an additional requirement: exporting and importing data between apps.

I won’t be doing full blown reviews, there are many available on the interwebs written by better reviewers than I. Instead, I will give a quick impression, some key points, and links.

Without further adieu, a look at the products:

Invoicing, Accounting, and Banking

Quickbooks

Lets get the elephant out of the room first. For me, Intuit’s offering is overkill. It does everything, with all the flair a professional accountant could ask for. As developers in the digital age, we are not tracking inventory and tend to have few employees and a little office overhead. Our needs are small and I don’t feel such comprehensive tool is required for most ISVs.

AccountEdge

MYOB has two relevant products. AccountEdge is poised to compete with Quickbooks. Suffice to say, it is not exactly on my radar.

FirstEdge

MYOB’s slimmed down, small business oriented product is much closer to what I am looking for in an accounting app. If you are looking for a solid accounting app with more features than you will ever need, while remaining as simple and Mac like as possible, look no further. FirstEdge gets high marks from the usual review sites. It’s not as complicated as AccountEdge or Quickbooks, but it’s still very “formal” in the way it handles your data. I know many consider this a feature, but with my limited knowledge of accounting, I think we can go even leaner.

Money

This app by Jumsoft is really nice. It has that familiar iTunes / Mail.app feel. It’s a nice one window interface with a sidebar used for selecting and presenting relevant data. It has decent reporting as well.

It has a template editor for invoices to make you look more professional. One strange quirk of Money is splitting invoice templates between “Styles” and “Layouts”. Styles are non-editable preloaded templates and Layouts are templates you can edit. The downside? You can’t use Money’s professional Styles as a starting point for your own templates. Just weird.

Importing bank data is also not automatic. It does include a “Web Bank” option which launches your bank’s website (in Webkit) within the app, but when I tried downloading transactions this way, it didn’t work. This may have something to do with the Safari 4 beta or not. Bank connectivity is a definite sticking point in an otherwise great app.

Accounting & Banking

iBank

Sure it has a cliché OS X name, but it is a great app. It is similar to Money, minus invoices, plus direct bank downloads. Additionally, IGG Software built in automatic connectivity with their Accounting/Invoice app, iBiz.  This is a great selling point.

IGG  has positioned iBank as accounting and banking with iBiz handling invoicing (with a bit of Accounts Receivable). This puts your Accounts Receivable (money coming in) within a separate app from your actual bank accounts and Accounts Payable (bills). This presents an interesting division of responsibility some may like and some may not. A downside is it may be a few more steps to see your total financial picture.

You can, however, create an asset account representing Accounts Receivable in iBank to which you can then transfer your invoices from iBiz. This works, but is slightly clunky. First my invoices sometime are imported as a withdrawal, instead of a deposit. This seems odd so I may be doing something wrong here. Second, moving a transaction from Accounts Receivable to a real account (on payment) is not automatic. I have to add the transaction to the bank (or download) and then deduct the amount in Accounts Receivable. As you can see from all of my words, this is not the workflow that IGG intended and is involves much extra work.

Invoicing

A note: there are many invoicing apps available for OS X. I probably missed some, or just didn’t include them.

iBiz

I’ll cover this first to keep it close to iBank. As I mentioned briefly, iBiz is attempting a bit of double duty. It has full Accounts Receivable capabilities. It can track open invoices, and send payments to iBank. This workflow is pretty nice. I think the interface is a little lacking, especially standing next iBank, but it isn’t the worst I’ve seen. Also it has reporting, but it’s not dead simple an maybe expects iBank to perform the “heavy lifting”.

It has an invoice editor, but invoices are created using HTML. My job revolves around coding, I really don’t want to mucking around in HTML just to make an invoice. I really feel that any invoice editor should be WYSISWG. iBiz’s users aren’t necessarily coders. I have to think overly complex template editing alienates some potential users.

Profit Train (formerly Billable)

A great, dead simple, invoicing app. It doesn’t waste a single button or window. It allows you to have multiple businesses that you can invoice from. More importantly, switching from one to another is scary easy. It also tracks expenses, and you can bill clients for expenses. Profit Train is still in beta and not feature complete, so I can’t be give a definitive ruling as of yet. Even in beta, Profit Train is extremely solid, with what I feel is the best interface of all of the invoicing apps.

Billings

Market Circle has a great app that many swear by. It clearly divides the interface between work and billing. I think this is good, but I don’t quite like the implementation of slips. They seem needlessly complex. Not that I am saying reduce the functionality of slips, it’s just that the default slip UI should be simple. Billings does allow you to group slips by project and invoice multiple slips. Billings also has many, many reports. Another great plus is that Billings will soon launch a companion iPhone app. Billings also has one of the best invoice designers. Billings also has export ability, but I did not test it.

GrandTotal

GrandTotal is an interesting entry. It fills most of my invoicing requirements and has export capability. It’s interface is pretty nice, but something is a slightly off. I think the structure has layout has something great going for it, but just needs some polish. Not “bling”, which it uses effectively, just some shuffling around of controls. The invoice editor/designer is good, probably second to Billings. GrandTotal has a free iPhone companion app with MobileMe syncing. This is a solid all around pick.

On The Job

Another solid pick. Very simple, very Mac like. I think it has a great invoice designer except for the fact there is no “save”. Don’t mess up, because all changes are permanent! I think the straightforward thought interface goes a long way in this app. It’s hard to write much more about it, you just have to use it to understand what it brings to the table.

Involver, Invoices, Invoice, etc..

I’m not delving into these products for one reason or another. Most do somethings well, but may be unpolished or don’t differentiate themselves from the pack.

SAAS

I’m not really evaluating these, I don’t see a need to keep this data in the cloud. However these are viable options with many in the link provided.

(Long) Conclusion

Overall, I find that none of the solutions are ideal. I’m sure that this is most view their accounting software. I am probably being a little picky and will likely be told so in the comments, but I don’t think I am being too demanding. However, I am self-aware enough to realize I am a UI snob which is heavily infuences my software decision.

I applaud the developers of all these products for creating complex software that is expected to perform perfectly or it is deemed a failure. Customers have (understandably) high expectations when it comes to safeguarding their financial data. With that said, I think that small business accounting and invoicing apps are still going through major maturation.  As a Mac user, you and I have insist on a great user experience. Couple that with the complexity that is accounting, and it gives these developers a tough UI problem to solve. I think several of these apps are on a great trajectory with a lot of room for growth and polish.

So what will I do?

Well, I’ll have to settle on an invoicing app soon. I can’t keep bouncing back and forth.

I like the simplicity of Profit Train, but want to see it in it’s 1.0 (really 2.0) form.

On The Job has much of the simplicity of Profit Train, with a WYSISYG invoice editor.

GrandTotal is solid. It’s a little crashy (Safari 4 beta problems, I believe), but it has promise.

Billings has everything the above three do, a better invoice template editor, but a a lesser UI.

For a one stop shop, I think Money is really close. I want this to be the app. It just seems so odd not have automatic transaction downloads in 2009.

I’ll have to pick one of the above invoicing apps and hope I can export my data to an accounting application I select in the future.

In conclusion, I  have a lot of thinking to do… (And most likely a second post).

After your considerable time investment in reading this post:

Don’t forget to tell us what you use!

I need a new Mac. I’ve needed one for a while.

I do all my developing on a Late 2006 white MacBook. Not a bad machine, but i’m a little hard on it. What’s worse? My logic board has been bad for a while, leaving me only 2 hours of battery life. I have Apple Care, but sadly I haven’t been able to spare a week to have it repaired.

I’d love to hear what everyone else is rocking for their dev setup.

I see two options:

1. Desktop (+ External Monitor) + Light Duty Laptop
2. Heavy Duty Laptop + External Monitor

I wouldn’t say my budget is unlimited, but I am an extremely practical person. If someone has a compelling argument for a Mac Pro, I’d get it.

Desktop Laptop combo:

iMac or Mac Pro

I’m leaning towards a high-end iMac. I think it is powerful enough for my needs. If needed, I can get an external monitor to augment the screen space. My biggest gripe right now is the lack of an LED screen (One of the reasons I am holding out for WWDC and a possible hardware announcement). I can’t imagine buying the LED Cinema Display and only having the LCD for the main monitor.

The Mac Pro feels like overkill. I know I am buying compile time, but is the saved time significant enough considering the size of my projects? The upgradability woul be awesome, and I wouldn’t need another machine for 4-5 years.

Macbook Air or Aluminum Macbook

Since the laptop would be almost exclusively for recreation, I think an Air would be perfect. I could do some light coding if the mood struck me. Of course, I think hardware update is eminent, maybe not this summer, but possibly in the fall. I can’t imagine buying one before Apple brings some of the battery tech over from the 17″ MacBook Pro. And you know the black trim is coming.

My wife has a new Aluminum MacBook (yes, a better machine than me). It is nice and light. I think it would be a more than serviceable laptop. I know the battery life is great, its just not as light as the Air.

Powerhouse Laptop:

MacBook Pro 17″

There is only one choice here. My 8-hour seductress. This is an awesome machine, I just picked one up yesterday and it is surprisingly light. I would have to lug it back and forth to work and I absolutely need the 24″ cinema display. I know I would be sacrificing some speed and screen space, but I could work anywhere.

So, what’s your pick?

If not, this snippet may save you 15 minutes. Set the keyboard type to phone pad and add these 2 methods to the delegate of your text field. This code does rely on a UITextField category method: fullRange. You can implement this yourself, it just returns an NSRange representing the entire string.

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string{

    NSMutableString *localText;

    if(range.length>0){

        localText = [[textField text] mutableCopy];

        NSRange deletionRange = [localText fullRange];
        deletionRange.location = ([localText length]-1);
        deletionRange.length = 1;
        [localText deleteCharactersInRange:deletionRange];

        phoneNumber.text = localText;
        [localText release];

    } else if([[textField text] length]<13){

        if([[textField text] length]>0){

            localText = [[textField text] mutableCopy];

            [localText replaceOccurrencesOfString:openParentheses withString:@"" options:NSCaseInsensitiveSearch range:[localText fullRange]];
            [localText replaceOccurrencesOfString:closeParentheses withString:@"" options:NSCaseInsensitiveSearch range:[localText fullRange]];
            [localText replaceOccurrencesOfString:dash withString:@"" options:NSCaseInsensitiveSearch range:[localText fullRange]];

            [localText appendString:string];
            self.phoneNumberString = [[localText copy] autorelease];

            [localText insertString:openParentheses atIndex:0];

            if([localText length]>3)
                [localText insertString:closeParentheses atIndex:4];

            if([localText length]>7)
                [localText insertString:dash atIndex:8];

        } else{

            localText = [openParentheses mutableCopy];
            [localText appendString:string];

        }

        phoneNumber.text = localText;
        [localText release];

    }

    return NO;

}

- (BOOL)textFieldShouldClear:(UITextField *)textField{

    phoneNumber.text = @"";
    return NO;
}

What tools are most important to you?

Here is a quick looksy at my home screen:

In the Dock: Nothing special here, I have alternated Remember the Milk and Things Touch down here. I am currently deciding on my task management workflow, and will probably move the iPod back out when I make a decision. In the mean time, iPod has made a comeback. I find myself listening to many, many podcasts

Top Row: I like having my camera and photos handy. I use maps about every 5 minutes and weather almost daily (I like AccuWeather the best).

2nd Row: My internet row. These are the things I am using the most online. I think Google is a little better in the app that in Safari, but it’s debatable.

3rd Row: Gettin’ social. This is how I stay connected. I still use Twitterriffic (free) for my main Twitter app, but I am looking at going for Tweetie (I’m loving the desktop version) and Birdhouse when I get a little more active. Since I started blogging, I constantly use the WordPress app. The Facebook app has made me ever so slightly more active in Facebook land.

Bottom Row: On this row I track my vital stats, Analytics App (Google Analytics) , Mint for my money, and App Sales for more money. Last is Notes, which I use a lot. This may change when I get my task management in order.

So, what are you packing?

So, how can you make it in?

That’s not exactly an easy question, nor are all cases the same. I swear I’m not trying to get out of the answer! What I can do is go over some data and see if it can give you and me any advantages.

I have been tracking the sales of Compounds comparative to it’s ranking within the Productivity category. Additionally, I have also been probing other categories to give me some insight into how our app sales measure up.

My first discovery was that the gaming and entertainment are by far the best selling categories. This isn’t exactly news, but it is relevant to figuring out how well you app must perform within it’s category to reach the top 100.

Here is Compounds’ ranking changed with sales:

Compounds achieved it’s highest ranking on Sunday, Apr 19, when it reached the number 3 spot in Productivity. Unfortunately, this was NOT enough to make it in to the Top 100. It was close: the number 1 and 2 app in productivity are both in the Top 100. Even more, the previous number 3 app, was briefly in the Top 100.

For perspective: In the Entertainment category, the 11th ranked app can be found within the Top 100. An even crazier comparison is with the Games category.  The 63rd ranked game is just barely in the Top 100.

All these facts confirm what we already know, games and entertainment apps sell, a lot. If you release a productivity app, you are not going for the gold rush, you are going for a steady yet consistent climb. At least that’s what you should be thinking.

Productivity is a long term investment, with long term users. Some top selling entertainment apps won’t produce any revenue next month, but many productivity apps will still be chugging along. Each strategy has it’s merits and pitfalls. You must to decide what your goals are.

Now, back to the top 100, what can you do to make it in?

Here are some ideas that have I’ve read, came up with, heard, or just dreamed. Take what you will.

1. Get noticed! Pick something and have an interesting take. Sure it may have been done before, but you can explore a different metaphor. Stand out.
2. Get noticed, by Apple! Ahh, the easiest way. Well, not really. But if you follow my previous advice, you’ll have a fighting chance.
3. Get noticed, again! Your icon is your face on the App Store and you need to give it the same treatment as your code. I recommend getting it designed. If you can’t, go to iStock Photo and learn some photoshop.
4. Frequent updates. Get your releases out often to drive some sales. You’ll get a brief moment on the front of your app’s category page. Additionally, (more importantly) it looks good to potential customers to see frequent updates.
5. Demos. Give them to any website or person that will have them. You need to do a lot of leg work, maybe more than you did to write your app.
6. Review sites. Try and hit the big boys, but even a little buzz will land you some traffic.
7. Get a real website. You need to pimp your app elsewhere, not just on the App Store.  To a customer: A solid website = A solid app.
8. Do some research. Know the other apps you with who you will compete. How many reviews do they have? What’s there ranking? It may not e worth it ot enter the space without a great idea. You’ll need to look at data and make an informed guess.

You might not make it to the Top 100 with these strategies, but you don’t need to. Many apps make a respectable, stable income without ever sniffing the top 100.  If you a apply the concepts above, you can’t go wrong. You will have a rock solid app with more of a marketing strategy than 80% of the apps available.

The truth is, as much as you and I want to charge more for our apps, we are constrained. We didn’t take VC capital. We have bills. We have angry significant others who have supported us and sacrificed, letting us sit and stare at our computer screens for unimaginable amounts of time.

Most of us just don’t have the luxury of picking our price point on principle. Even still, I did price Compounds at double the going rate, $1.99, though not exactly a princely sum.

Since Compounds is a very, very niche app (how big is the market of iPhone users that perform mole calculations?). My pricing strategy must reflect that. “But, Mr. Jalapeno, your app is now $0.99. Are enough people are going to buy it?” Well, thats a tradeoff we made. When we had the luck of being featured on the front of the App Store, our pricing strategy HAD to change.

This wasn’t clear at first, and our sales are probably slightly less than if we had reduced the price quicker. If you look at the graph from my last post, you can see how are sales had definite downward trend.

If we hadn’t reduced our price for the weekend, we would have left even more money on the table.  How much is hard to say.

Our current price is still $0.99. Do we raise the price, do we let it stay at this level indefinitely? Thats a hard question I am constantly thinking about. The answer of course is, it depends.  I don’t remember where I read it, but someone said “Don’t mess with your price during a positive trend”, and I believe that.

If sales drop to a certain point, I will most likely raise the price to recoup revenue for the lost volume. For now, I am happy with the consistent sales of Compounds.

So with this data in mind what are my thoughts on pricing new apps?

Niche Apps:

1. I will price them according to what I THINK I need to be profitable. Most likely this will be above $0.99. This is just good business sense.
2. I will ensure my niche apps are of high quality. No one pays for crap.
3. I will release a “lite” version to help drive sales.

Wide Appeal Apps

1. It is highly likely I will release these at $0.99. My market is so large, if I have decent idea, I should make it up in volume.
2. I still will make a great effort on these apps, but depending on the time investment, I need to weigh tthey amount of polish against the amount of risk.
3. If I do price this app at $0.99 AND it is an app that promotes repeated use, a “lite” version is in the cards.

Every situation is different and you have to evaluate for them for your self . The first time will be hard because you have no data, so my experience may be of use to you.  This is the methodology I will be using until the data steers me otherwise. If you have other thoughts, let me know.

I’ve used Numbers to graph our sales for the import range of data. These figures are AFTER Apple’s 30% rake. I’ve also placed some significant markers that properly scope the data.

April 11th and 12th were a Saturday and Sunday, which are traditionally poor performing days for our work-oriented Chemistry app. We did have a few sales, but they were, in fact, our worst 2 sales days since we launched Compounds.  For reference, are sales were normally a modest 5-15 units a day. (Edited)

Tuesday, April 14th was an awesome and welcome surprise.  I honestly was a little down about out app until this happened.

You can see another significant jump on the day we decided to reduce the price of Compounds to $0.99. The effect of dropping the price just $1.00 was astounding.  In retrospect, I probably should have reduced the price earlier to make it into the top 100. Ahh, hindsight…

Lastly, is next Tuesday, when we moved to the second page. What a difference a single click makes.  You can see we approaching a asymptote near $100 a day, which I would be extremely satisfied with.  For our first released app, I am extremely pleased.

In another post, I’ll also compare this data to our popularity within the Productivity category.

For me, this was accelerated by the iPhone SDK. It is a simple sandbox that allows beginner programmers to have a chance to focus on a well defined set of functionality and features.  Moreover, it provides UIKit classes that do the visual heavy lifting. In my opinion, it is the perfect environment for a fledgling programmer.

The ecosystem created by Xcode, the SDK, iPhone Simulator, Instruments, etc… has allowed many programmers to not only write, but also distribute apps with an ease that has never before been seen in world of software publishing (at least not in my limited knowledge of this area). Of course, the downside has been the flood of $0.99 apps that are negatively impacting the App Store.  Additionally, developers have given up a large amount of control, but many of us new to the game didn’t know we lost.  In regards to bringing new programmers to the platform, the overall effect seems positive.

Just being a curious Mac user has afforded me a great opportunity. Mostly, I’m just grateful I have a chance to be create my own company and be my own boss. Which, while not impossible, would have been much more difficult without the iPhone.

Several months ago, Apple began allowing quick ratings during app deletion. However, the ratings received from this process tend to be negatively biased. This makes sense of course, users will typically delete apps they don’t like, or are bored with. You and I, being awesomely objective, logical software developers, possess the incredible ability to rate an application based on its merits, regardless if we choose to delete it from our phones. Unfortunately, most of our customers aren’t as deliberate in there rating process. Moreover, Apple provides no comparably easy rating mechanism for a customer who actually likes your app and decides not to delete it.

Of course, there’s always iTunes, but on device rating is much more convenient for users. I’m not saying people won’t go to iTunes to post a rating. As with many things on the internet, those with the strongest opinions, good or bad, will be attracted to rate your app in this manner.

Using the above thought process, we can categorize several types of customers that constitute the bulk of our ratings and their most likely rating (in order of occurrence):

1. Feels very strongly about your app, in a negative manner (1 star)
2. Feels very strongly about your app, in a positive manner (5 star)
3. Recently purchased your app, and deleting it because it adds no value (1 star)
4. Feels your app is ok, but is critical of its flaws (3 star)
5. Feels your app adds value, and does not mind taking the time to tell others (4 star)
6. Feels your app is subpar, rates it poorly, but is keeping thinking it will get better (2 star)

Now, you almost definitely won’t agree with my categories, or their frequency and possibly think I have a negative view of the world. Regardless of whether or not I had a tormented childhood, people on the internet find it much more natural to express negative feelings.

Moreover, many of your happy customers are just too busy. They enjoyed the 60 seconds or so they used your app today, but don’t have any inclination to express this feeling in the form of a rating. This is why most of your reviews will come from the extremists, good or bad.

So, with this knowledge (and rampant speculation) in hand, lets look at some of the patterns that arise out of customer ratings and what they could mean about our apps.

The Ski Slope Ahh, the worst for first. You apparently have alienated the majority of your customers. The discussion of this pattern is brief. It reflects the presence of several glaring defects within your application, which you should have no problem finding.

The Cylon Raider Now here is one we can sink our analytical, pattern oriented minds on. Somehow, you have managed to completely polarize your customer base. As usual, you’ll have a few on the fence.  With the exception of a political application, how did you accomplish such a feat? (Full dislosure: this is what Compounds is looking like)

A five star rating means that your app has filled a need, and the customer is able to use it effectively. A one star rating, means exactly the opposite. Lets think about that. A certain percentage of your customers will know exactly what to do with your app in spite of what you tell them. Many others will be lost without a clear interface, clear instructions, and a clear description.  These customers aren’t idiots, you are.  many of your customers don’t understand how to use your app, or it doesn’t work how they thought it should.  The ones who gave you the five star ratings are probably technical people, or at least people with a significant amount of computer experience.  You can’t assume that of all you customers.  Make you app design and description clear, and you will attract the customers you want, and they will appreciate (and rate) your app accordingly.

The Shop Teacher This one is close to the Cylon Raider, but a step better in the right direction. You have cut down on those bad reviews by addressing some of the problems stated above.  Some of the polarization still exists, however. Your learning, but you need to think critically and honestly about your app.  The advice is trite yet needs to be said.  Read your reviews, email your customers (if you have any on file), and pass your app around to strangers and get their reactions. You need objective information to improve your app.

The Hand Gun We finish with the best, your goal. You please most of your customers. Those that you can’t, are few in number. You have been marketing your app to the right crowd, and have designed an interface that your mother could be proud of.  As with the Ski Slope, their isn’t much to say, but it seems you know a lot more than me anyways.

These aren’t all the patterns of course, but these seem to be the most common and, I think, provide some great landmarks for customer acceptance of your app. I feel that these mental exercises can really help you get a handle on where you need to go next with your app. It also highlights that everything is your fault. There are no stupid customers, just bad directions and clunky interfaces.

In the next week I will release some figures in the spirit of other bloggers here, here, here, here, and here.

When were getting ready to release Compounds, it was really hard for us to get a handle on the answers to questions like:

What is our price point?

Do I offer a lite version?

Do start at a low introductory price?

What is the effect of a review/top 100/staff favorites/etc…?

There is a lot of mystery still surounding these questions and those I linked to above (and many others) really helped us make better guesses at the answers to these questions.  Notice I didn’t say, THE ANSWERS, because frankly, they don’t exist.  There is no “one” strategy.  We are just riding this wave and hoping we can sustain this momentum after we are off the front page.  But this isn’t just about marketing, it means we must continually improve and make Compounds a compelling option for all our potential customers.  Time will tell.

When a user enters a search term in the iTunes Store, they are presented with a grid of the top items from several categories. Two items for “podcasts”, four items for “albums”, two items for “movies”, etc… What we care about , obviously, is the “Application” section. The top two apps for that search term are displayed in that section along with two additional links: “see all” and “Applications”.

If you follow the links you get a long list of every app matching the search. Where this gets interesting is how they determine the ranking. Well, here’s what I have found out using the progress of Compounds.

When I search iTunes for “chemistry” and look at the list of apps, Compounds has steadily crept the list. Now it seems stuck at #8. Oddly, if I look at top paid apps under “Productivity”, Compounds is the only chemistry app in the top 20, so what gives?

It appears the following is happening:

iTunes first displays apps with names containing the search term. These apps are displayed in order of sales rank (last 24 hours, or a cumulative over the past week, I’m not exactly sure)

Next, iTunes displays apps with descriptions containing the search term.  These apps are also displayed in order of sales rank.  Here’s another gotcha, the search term must be near the top of the description or the app will NOT be displayed in the search.  I am not sure how close it must be, or if it gets worse the further down the search term resides.  I do, however, know there is a limit.

Good news, if you didn’t know, the name of your app on the store does not have to match the name of your app displayed on the home screen.  So, you can manipulate these search terms a little.

I hope this helps some of you with your naming strategy.

Philly CocoaHeads and Indy Hall

Local chapter of CocoaHeads hosted at the more than generous Indy Hall in center city Philadelphia. Great people, advice, motivation, and networking. What more can I say?

Matt Campbell

Of App Shop.  An iPhone developer who writes a very helpful dev blog and has provided me personal advice regarding App Store Econ 101.

Ricardo Vidal

A Biotech specific blogger who gave us our first review.

MacResearch

Gave us a great opportunity to write and post a comprehensive showcase review on Compounds.

stackoverflow

A very active question and answer site, especially for iPhone developers

Bill Dudney

Author of a great Core Animation book, iPhone book, and a great blog. We specifically used some nice “exploding” Core Animation code from his book.

Jeff LaMarche

Author of another great iPhone book and a very frequently updated development blog.

MDN

Scotty of the Mac Developer Network produces so many great podcasts, worth every penny of the membership. They are really eating into my Jim Rome time.

iPhone Tech Talk, Toronto

Not to suck up, but these guys really helped us turn a mediocre app with a poor interface into something worth using.  John Geleynse, Matt Drance, Michael Jurewitz and crew provided great design information and even better motivation.  I’m deeply saddened I will not be able to attend WWDC.

Of course, as always, there are many others, but this list can get anybody moving in iPhone Development.

WordPress is nice, so nice, look for my company site to be moved over to WordPress, too.

Now, maybe I can start posting things of value…

I had intended to post about my own app, but in light of yesterday’s news…

After combing through the API differences between 2.2.1 and 3.0, which I can’t discuss openly, I am really excited.

What I haven’t written about yet, is that Compounds was my first Objective-C app, Cocoa app, and iPhone app. To be honest, the 2.x sandbox I learned to develop i was warm and secure. I clearly saw the boundaries and I became comfortable very with them.

With 3.0, that all changes. I am suddenly in the Gobi, with endless possibilities. In some ways this is great, I can do what I want, but to continue the analogy, I have to keep moving, exploring, and avoiding quicksand.

I think there is much to be said about being creative under restrictions. For one, at least for me, it is seems easier. Now I feel like I am scrambling all over again. Admittedly much better prepared, but working overtime to learn the new APIs, nonetheless.

Of course, the new possibilities outweighs any of my trepidations, and, like every other Phone developer, I am already heard at work.