Manbolo Blog

Affiliation is a simple way to make extra revenues with your app or with your web site in the iOS/OSX world: it provides a way to link to songs, apps, movies, ebooks, earning you commissions on sales. The good news is that affiliation on iTunes (including App Store, iBooks, and Mac App Store), is really easy to set-up. The bad news is that you will need a lot of audience before making real money. Here’s a quick presentation, since there have been some changes recently.

1. What’s affiliation
2. How to become an iTunes affiliate
3. Linking
4. API and tools
5. Useful links

1. What’s affiliation

1. Assume you’ve released an iOS app. Somewhere in your app, you’re promoting another iOS app; it can be one of your app, or any app available on the App Store. The promoted app can be paid or completely free. The only requirement is that the promoted app is available on the App Store.
2. Your user has tapped a button in your app to download this app, he is redirected to the corresponding page in the App Store. At this point, you’re done: you sole job is to send customers to the App Store, by any means… Whether the user will buy the app that you’ve promoted or not is not relevant. At this moment, you’re the current affiliate on the App Store.
3. Starting from now, and during the next 24 hours, you will earn a 7% commission on each sale done by the user. The user can quit your app, quit the App Store etc, every time he buys something on the store, you will be given a tiny 7% commission for the next 24 hours.

See, seems interesting! I’m using an iOS app in this example but really you can use affiliation with video, book, ringtones, tones, Mac app, podcasts, audiobooks, everything that is sold through iTunes, the App Store, iBooks and Mac App Store. In fact, everything that you can link to is eligible to affiliation.

You will see, it’s all about links. Given a link to the App Store, just add a parameter to this link identifying you (the affiliate token) will suffice to give you revenues.

Things to know:

• There is only one affiliate on the App Store at a given date: your interest is to send users from your app to the store (while not harassing them). That’s why there are a lot of apps that promoted content and uses (and abuses) Push Notifications, to remain the affiliate.
• Really you’ll need a lot of audience to make money.
• Affiliation is not limited to the iOS/OSX world: there is an Amazon affiliation program, but unfortunately no affiliation program for Google Play.

2. How to become an iTunes affiliate

One to rule them all

Until very recently, iTunes Affiliate Program was operated by two or three platforms (Linkshare, Tradedoubler) and you had to register to each program to get affiliation revenues from all over the world.

Starting from 31 March 2014, there is now one and only one affiliation program provider: Performance Horizon Group (aka PHG). To become affiliate, you will have to register to the iTunes Affiliate program with PHG.

Before diving into the account creation, just a word about worldwide support. You will get revenues from customers residing in this 127 countries, but affiliates can be located in any countries:

Sign-in to the iTunes Affiliate Program

Warning : before creating your account, you should insure that you have a live app in the store, or a live web site. Your web site can’t be in beta, or in ’work in progress’ mode. It must be live, with real datas and content, otherwise your affiliation account creation will be rejected.

Now, go to https://phgconsole.performancehorizon.com/login/itunes/, click on Sign-In:

Fill the information:

Some info:

Now, you just have to wait a few days (usually 3 to 5 days) and wait for your account creation confirmation. If your web site / app is live, your account should be validated without problem.

Once you have been notified that your affiliate account have been accepted, you can go sign-in http://affiliate.itunes.apple.com/signin. In the email that you’ve received, you have been given an Affiliated ID (or Affiliate Token): you really just need this token to make money! Affiliated token looks something like 11lqRB (which’s Manbolo’s one).

In case you miss it, you will find yours in your PHG console on the top-right corner:

3. Linking

Now that you’ve your affiliate token, you can start making money. All that you’ve to do is simply adding this token to the end of any iTunes, App Store or iBooks Store links to be eligible for commissions.

On a web site

Inserting an affiliate link in a web page:

<a href="https://itunes.apple.com/us/app/numbers/id361304891?mt=8&uo=4&at=AffiliateTokenHere">Numbers - Apple</a>

Notice the at=AffiliateTokenHere added parameter at the end of the URL. Juste replace AffiliateTokenHere with your PHG affiliate token and that’s it.

In a native app

If we want to promote Meon in one of our app, we could write this:

- (IBAction)buyApp:(id)sender
{
        NSString *urlString = @"https://itunes.apple.com/app/meon/id400274934?mt=8&uo=4&at=11lqRB";
        NSURL *url = [NSURL URLWithString:urlString];
        [[UIApplication sharedApplication] openURL:url];    
}

https://itunes.apple.com/app/meon/id400274934?mt=8&uo=4 is the unaffiliated link, while https://itunes.apple.com/app/meon/id400274934?mt=8&uo=4&at=11lqRB is the affiliated ones, using our affiliate token 11lqRB.

Starting from iOS 6, you have the possibility to show, inside your app, an "iTunes controller": SKStoreProductViewController. The big advantage over the previous approach is that you user is not redirected to the App Store, he can buy apps (and other iTunes content) directly inside you app, and never quit it. Note that you can also write reviews without quitting the app.

Unfortunately, as of iOS 7.0.6, there is no way to pass an affiliate token to a SKStoreProductViewController. It’s rather surprising because the APIs use to initialise this view controller (just a dictionary) will be well fitted to add an affiliate token. That’s said, if you still want to use SKStoreProductViewController, here is how you would do it:

- (IBAction)buyApp:(id)sender
{
    // The store id of the product that you want to promote.
    NSString *storeId = @"417817520";
    NSDictionary *parameters = @{SKStoreProductParameterITunesItemIdentifier: storeId};

    SKStoreProductViewController *controller = [[SKStoreProductViewController alloc] init];
    [controller loadProductWithParameters:parameters completionBlock:nil];
    [self presentViewController:controller animated:YES completion:nil];
}

With a Smart App Banner

If you plan to use Smart App Banners, be sure to read http://blog.manbolo.com/2012/10/19/invasion-of-the-smart-app-banners. You can use your affiliate token in a Smart App Banner:

<meta name="apple-itunes-app"
        content="app-id=400274934, 
        affiliate-data=at=11lqRB">

Campaigns

You can also use another parameter ct, the campaign text, that you can optionally add to any link in order to track sales from a specific marketing campaign. For example, the link below has added a campaign tracking parameter for a blog link. You can name the campaigns anything you choose, but the ct value may not be longer than 40 characters:

https://itunes.apple.com/app/meon/id400274934?mt=8&uo=4&at=11lqRB&ct=blog

Then, you will see the performance of this campaign in your PHG console dashboard.

You can get more informations on linking here: Basic Affiliate Link Guidelines for the PHG Network.

4. API and tools

If you want to build a service base on affiliation, you will need to find links to useful content on iTunes. There are some tools and APIs to help you:

Search API

http://www.apple.com/itunes/affiliates/resources/blog/introduction---search-api.html

The lookup API is really useful: given an app id, you will get the description, URL of app icons, screenshots, price, average rating, user rating count etc… More information on the lookup API in Useful iTunes Web Services.

Enterprise Partner Feed

Apple gives you also a much more powerful tool: a direct access to the entire App Store metadata database, called Enterprise Partner Feed, or simply EPF. EPF provides a daily access to the iTunes content entire database (apps, movies song) and you can use this tool to build your killer app: it’s much more powerful than iTunes Search API but need more work.

EPF is daily updated, so you can use it to extract useful content and add affiliation. Note that any links extracted from the database must be used with an affiliate token.

Access on the database requires login credentials and an active partnership with the affiliate program. You can apply to get access by filling a request at http://itunesaffiliate.phgsupport.com/anonymous_requests/new (don’t send request to EPFrequest@apple.com, the mail is no longer in use). You will receive an answer in a few days.

5. Useful links

WWDC 2012 - Session 603: Tools, Services, and APIs for iTunes Affiliate Program Marketing

WWDC 2010 - Session 133: Using iTunes and App Store Affiliate Tools and Technologies

http://david-smith.org/blog/2013/08/19/itunes-affiliate-linking/

http://www.apple.com/itunes/affiliates/resources/

http://www.apple.com/itunes/affiliates/resources/documentation/itunes-enterprise-partner-feed.html

From jc.

Daniel Greenfeld and Audrey Roy have just released a revised edition of Two Scoops of Django, Best Pratices for Django 1.6.

I’ve been a huge fan of the first edition (targeted to Django 1.5), it has been (and still is) an invaluable companion in learning how to develop with Django. The first edition contains a lot of tips, tricks, patterns, code snippets, techniques and more important best practices: how to organize your settings, how to design your models, how to test your Django app etc…

In my opinion, this is not a book for starting to learn Django: it’s value is really in the knowlegde and experiences that Daniel and Audrey have learned over the years, it’s about best practices. If you’re new to Django, this book will be challenging, you should at least have gone through the Django tutorial.

But if you plan to use Django in your projects, Two Scoops of Django, Best Pratices for Django 1.6 is simply a must-to-read.

You can buy it on Amazon or on Daniel and Audrey’s online shop.

Did I say I love Django?

I love Django.

I love Python.

From jc.

In a word: cntlm!

If you work in a big company, chances are good that you’be been fighting your proxies IT guys, in particular if your proxy is a NTLM one.

You should configure your login/password proxy in the System configuration of OSX. That way, every OSX application can read your proxy settings and use it.

While this method is really simple, I’ve found a lot of applications that doesn’t work well with my company’s NTLM proxy, even if I’ve configured it in the System Preferences:

• the iOS Simulator: doesn’t use the System proxy configuration (Xcode 5.0.2 /Mavericks),
• Jenkins: can’t upgrade / download plugins through the web interface,
• A lot of curl based tools: git clone https://github.com/AFNetworking/AFNetworking.git etc…,
• brew (if you don’t know it, you should!)

cntlm is a simple command line that stands between your applications and the corporate proxy, adding NTLM authentication on-the-fly. Your OSX system uses a local proxy (by default localhost:3128) provided by cntlm and cntlm does the hard work of always adding the NTLM authentification. You can use cntlm in interactive mode i.e. in a shell that you launch and stop on demand, or install it to be started at launch with your session.

Installing and configuring cntlm is a matter of minute and, after, you will say goodbye to your proxy issues.

The best tutorial I’ve found on cntlm is from _oho: Howto Set Cntlm on Mac OS X. Installation and overview are simply described and there are some really good tip and tricks. If you work behind a corporate proxy, be sure to read it, your life will change!

From jc.

Here is what I’m waiting for iOS 8:

Courtesy of John Siracusa

There are a lot of little annoyances in iOS 7 that should be fixed. I dream of a Snow Leopard 0 new features release for iOS 8 with a lot of bug fixes. This time, @_wolfover_ has found a rather serious bug in the Apple Reachability Sample.

If you download the reachability sample, and launch it on an iPhone 5s, with an active cellular connection, you will see this result:

Everything looks OK, the cellular connection is well recognized.

Now, if you modify the sample build settings to take advantage of 64-bit architectures (Target > Build Settings > Architectures) from "Standard Architectures (armv7, armv7s)" to "Standard Architectures (including 64-bit) (armv7, armv7s, armv64)"

and run the sample, you should see this:

Reachability thinks that there is no active cellular connection! I think it’s a serious bug, I’ve certainly missed something but just recompiling Reachability for 64-bit shouldn’t produce a different result. I hope I’m wrong, but in the meantime I’ve filled a bug report (rdar://15880397) and you should too!

From jc.

Introducing ack

ack is a powerful grep replacement, I use it everyday to search for patterns in files. For instance, if I want to search for occurrences of CMBitmapNumberView in my source project, I just type:

ack CMBitmapNumberView 

and instantaneously, I can see where this string is used. The good thing about ack is that ack defaults to only searching source code. In case of iOS projects, it means that it will search inside *.h, *.m, *.xib, *.plist etc… It just works and if you’re not already convinced, read the Top 10 reasons to use ack for source code.

Installing ack on OSX (piece of cake)

On OSX, you can install ack with homebrew:

brew install ack

Find unused images in Xcode project

As ack is searching through source code files and xib files, you can use it to search for images usage.

For instance, if I want to know where is used the image ’BigButton.png’, I just type:

ack BigButton

and ack will look though .m, .h and .xib files. Thanks to this Stack Overflow thread, I use ack to find unused images in my Xcode project, with this litte script:

#!/bin/bash

for i in `find . -name "*.png" -o -name "*.jpg"`; do 
    file=`basename -s .jpg "$i" | xargs basename -s .png | xargs basename -s @2x`
    result=`ack -i "$file"`
    if [ -z "$result" ]; then
        echo "$i"
    fi
done

So usefull if you like to have a clean project!

From jc.

iOS Auto Layout Demystified by Erica Sadun is an excellent book on Auto Layout.

From the preface:

You’ll explore many of the strengths of Auto Layout as well. It’s a technoloy that has a lot going for it:

• Auto Layout is declarative. You express the interface behavior without worrying about how those rules get implemented. Just describe the layout; let Auto Layout calculate the frame.
• Auto Layout is descriptive and relational. You describe how items relate to each other onscreen. Forget about sizes and positions. What matters is the relationships.
• Auto Layout is centralized. Whether in IB or a layout section in your own code, Auto Layout rules tend to migrate to a single nexus, making it easier to inspect and debug.
• Auto Layout is dynamic. Your interface updates as needed to respond to user- and application-sourced changes.
• Auto Layout is localizable. Conquer the world with Auto Layout. It’s built to adapt to varying word and phrase lengths while maintaining interface integrity.
• Auto Layout is expressive. You can describe many more relationships than you could in the older springs-and-struts system. Go beyond "hug this edge" or "resize along this axis" and express the way a view relates to other views, not just its superview.
• Auto Layout is incremental. Adopt it on your own timescale. Add it to just parts of your apps and parts of your interfaces, or jump in feet first for a full Auto Layout experience. Auto Layout offers backward compatibility, enabling you to build your interfaces using all springs-and-struts, all constraints, or a bit ob both.

What I love about Auto Layout is that the system is declarative: you just tell what you want and the system computes the frames for you, sometimes better than you could do by hand, see Cocoa Auto Layout Release Notes:

The benefits of this approach are most clear for localization and resolution independence. With this architecture, your localization effort is typically confined to translating strings. You don’t have to specify new layout, even for right-to-left languages such as Hebrew and Arabic (in which the left-to-right ordering of elements in the window should generally be reversed). For resolution independence, this system allows for pixel-perfect layout at nonintegral scale factors for interfaces designed in Interface Builder. Neither was previously possible.

Erica Sadun’s iOS Auto Layout Demystified does a very good job at explaining the system’s motivations and gives a lot of tips & tricks on Auto Layout. The second edition have been revised for iOS 7 and Xcode 5, and I’ve particularly appreciated the parts explaing Interface Builder.

Highly recommended.

If you’re looking for other Auto Layout pointers, the WWDC conferences are a good start:

WWDC 2012:

• Introduction to Auto Layout for iOS and OS X - Session 202
• Auto Layout by Example - Session 232
• Best Practices for Mastering Auto Layout - Session 228

WWDC 2013:

• Taking Control of Auto Layout in Xcode 5 - Session 406
• Interface Builder Core Concepts - Session 405

We don’t know what will be iOS in 5 years, but I bet we will have more resolutions and more screen forms factors. Auto Layout is designed to help you build interfaces, it’s the future, so adopt it.

From jc.

LightPaper is a simple, beautiful, powerful and free text editor for OSX. I’ve just test it a few minutes but I already love it. It works especially well if you’re writing in Markdown.

Under the cover, blog.manbolo.com is a static generated blog. It uses a small PHP script to generate the entire blog each time we add new articles (the generation of the entire blog lasts less than 1s). Each article is a Markdown file (you can see the original Markdown file by appending .md at the end of an article url like this http://blog.manbolo.com/2013/12/04/uialertview-bug-on-ios-7.md).

Writing a new article with LightPaper is a real pleasure. The killer features for me:

• live HTML rendering of your text,
• can open a bunch of Markdown files folder,
• really fast, light, and feel modern OSX.

I used to write with the venerable BBEdit but LightPaper has become my favorite tool for Markdown writing. Well down Clockwork Engine!

LightPaper is free but I wouldn’t mind to pay a few bucks for such a great editor. There is also an Android version, can’t wait for the iOS one.

From jc.

If you need a human readable description of an iOS device, check out UIDevice+Hardware category on GitHub. Previously, I was using Erica Sadun’s various categories on UIDevice but the last commit happened a year ago. UIDevice+Hardware seems simpler and more up to date.

The core of the code relies on Apple’s internal naming:

- (NSString*)hardwareString
{
    size_t size = 100;
    char *hw_machine = malloc(size);
    int name[] = {CTL_HW,HW_MACHINE};
    sysctl(name, 2, hw_machine, &size, NULL, 0);
    NSString *hardware = [NSString stringWithUTF8String:hw_machine];
    free(hw_machine);
    return hardware;
}

The code is straightforward but could be a lot simpler by using a lookup table. Instead of this:

- (NSString*)hardwareSimpleDescription
{
    NSString *hardware = [self hardwareString];
    if ([hardware isEqualToString:@"iPhone1,1"])    return @"iPhone 2G";
    if ([hardware isEqualToString:@"iPhone1,2"])    return @"iPhone 3G";
    if ([hardware isEqualToString:@"iPhone2,1"])    return @"iPhone 3GS";
    if ([hardware isEqualToString:@"iPhone3,1"])    return @"iPhone 4";
    if ([hardware isEqualToString:@"iPhone3,2"])    return @"iPhone 4";
    if ([hardware isEqualToString:@"iPhone3,3"])    return @"iPhone 4";
    if ([hardware isEqualToString:@"iPhone4,1"])    return @"iPhone 4S";
    if ([hardware isEqualToString:@"iPhone5,1"])    return @"iPhone 5";

    …
    return nil;
}

Why not simply use dictionary literals?

- (NSString*)hardwareSimpleDescription
{
    NSString *hardware = [self hardwareString];
    if (!hardware) return nil;

    NSDictionary *hardwareToSimple = @{
                                        @"iPhone1,1": @"iPhone 2G",
                                        @"iPhone1,2": @"iPhone 3G", 
                                        @"iPhone2,1": @"iPhone 3GS",
                                        @"iPhone3,1": @"iPhone 4", 
                                        …
                                      }
    return hardwareToSimple[hardware];
}

For the record, the current list of iOS devices is:

From jc.

You like that UIAlertView contentView property have been removed from iOS 7? You will love this!

In iOS 7, tint color plays a major role in your app. With the abandon of button’s borders, tint color indicates strongly (if not exclusively) that a control is interactive.

From the iOS 7 UI Transition Guide:

When an alert or action sheet appears, iOS 7 automatically dims the tint color of the views behind it. To respond to this color change, a custom view subclass that uses tintColor in its rendering should override tintColorDidChange to refresh the rendering when appropriate.

When an UIAlertView is shown, all controls under the UIAlertView are greyed to emphasise the alert and re-colored on the UIAlertView dismiss. I find this default behaviour kind of cool and like it.

A best practice very often advertised by Apple with UIAlertView is to dismiss an UIAlertView when your app goes into background. This is to insure not to present an UIALertView out-of-context the next time a user launch your app.

Doing this, from iOS 4 to iOS 6 has been really simple and straightforward. Given a view controller that has a IBAction showing an UIAlertView:

- (IBAction)tap:(id)sender
{
    self.alertView = [[UIAlertView alloc] initWithTitle:@"Hello"
        message:@"A standard UIAlertView"
        delegate:nil
        cancelButtonTitle:@"OK"
        otherButtonTitles:nil];

    [self.alertView show];
}

One has just register to UIApplicationDidEnterBackgroundNotification in viewDidLoad :

- (void)viewDidLoad
{
    [super viewDidLoad];

    [[NSNotificationCenter defaultCenter] addObserver:self
        selector:@selector(applicationDidEnterBackground:)
        name:UIApplicationDidEnterBackgroundNotification
            object:nil];

}

and dismiss the UIAlertView when handling UIApplicationDidEnterBackgroundNotification:

- (void)applicationDidEnterBackground:(NSNotification *)theNotification
{
    NSInteger cancelButtonIndex = self.alertView.cancelButtonIndex;
    [self.alertView dismissWithClickedButtonIndex:cancelButtonIndex
                                         animated:NO];
}

On iOS 7, this code should have worked flawlessly. The alert view is dismissed when the app goes into background. But when the app is activated again into foreground, all controls that have been automatically dimmed by the system while the alert view was shown are still dimmed. Not only are they dimmed but they are also active and enable!

The code is so simple that I’m pretty sure this is a bug of iOS 7 (or at least 7.0 to 7.0.4). You can download the sample code for this bug here and I’ve filled a bug rdar://15582862 for it.

Let’s hope it will be fixed soon!

From jc.

In Automating Terminal Tasks on OSX, I was describing how I used a combination of iTerm 2, AppleScript and Automator to launch a batch of shell commands in iTerm 2 tabs.

This solution was useful but not very configurable: if I wanted another set of commands or another configuration, I had to duplicate my Automator application, modify the AppleScript, and save the application. Not a big deal, but quite tedious.

Introducing panes

So now, let me present you panes!

panes.py is a Python 2.7+ script to configure an iTerm 2 window. panes.py reads a configuration file at ~/.panesrc and creates a new iTerm 2 window.

Based on the configuration file, panes.py creates additional horizontal or vertical split panes inside this window and can launch additional commands at the startup of the shell pane.

The configuration file uses Microsoft Windows INI files format. All configurations are described in one only file, ~/.panesrc, and each configuration is a section in this file.

For instance, the default config file is:

[Default]

panes: [
    {
    "name": "Pane 1",
    "split": "v",
    "cmds": [
        "echo pane 1",
        "ls -ltr",
        ],
    },
    {
    "name": "Pane 2",
    "split": "h",
    "cmds": [
        "echo pane 2",
        "ls -ltr",
        ],
    },
    {
    "name": "Pane 3",
    "split": "h",
    "cmds": [
        "echo pane 3",
        "ls -ltr",
        ],
    },
]

To launch this config, simply type panes.py default or panes.py. This will create a new iTerm 2 window with three panes labeled ’Pane 1’, ’Pane 2’ and ’Pane 3’. Each pane will launch an echo command followed by a ls -ltr command. For instance, you can use it to ssh to your server and output some logs in a pane.

You can add another configuration by adding a section to ~/.panesrc:

[default]

…

[prod]

panes: [
    {
    "name": "Pane 1",
    "split": "v",
    "cmds": [
        "ssh prod.example.com",
        "tail -f /var/log/example.log",
        ],
    }
    ]

[preprod]

…

And launch your prod environment like this: panes.py prod.

I now use panes to setup my various Django projects, or connect to a server and watch some logs. If at any point I need to reboot my Mac, or if one of my shell session is broken-pipe, I just have to relaunch my panes session.

It’s a kind of very very simple tmux or Screen, but it is completely sufficient for my needs. And it can be perfectly integrated with Alfred for instance…

How does it work?

panes.py works by creating a temporary AppleScript script to pilot iTerm 2. This script is totally based on Luis Martin Gil iTerm 2 scripts that you can have at https://github.com/luismartingil/per.scripts/blob/master/iterm_launcher02.applescript. Kudos to Luis for mastering AppleScript which I have not the courage to do! Without Luis’ work, I wouldn’t be able to do what I wanted.

The Python script does the following:

• reads the configuration file in ~/.panesrc,
• constructs a temporary AppleScript script for piloting iTerm 2,
• executes this AppleScript with the OSX built-in command osascript.

I’ve chosen to do this because I wanted to have my configuration described in a simple text file and I didn’t want to spend time doing this in AppleScript. Moreover, I find it rather cool to script an OSX app in Python. Seriously, who likes AppleScript? Imagine you could script all your OSX apps in a decent language, like Python, Ruby or Javascript… Wouldn’t it be super cool?

panes is available on GitHub! If it can be useful to someone else, I would be happy. In the meantime, I’m ready for the pull requests!

Thanks _oho for the debugging !

From jc.

When I installed few days ago the iOS 7 revamp version of Apple podcast app, it made me remember how much I dislike the iOS 7 new design. From the first version of iPhone OS to iOS 6, I believe one of the key strength of the platform was achieving a consistency in the UI, while having some freedom with color, textures, animations etc… The transitions between views were strongly coherent from apps to apps, buttons were instantaneously recognisable as tappable element, interactions were or intuitive either easily learnable, always enjoyable. With every developer/designer gaining experience, apps become a field of UI innovation, while remaining coherent and consistent.

With iOS 7 new design principles, I feel this consistency has become too strong, and now we have uniformity.

Quoting Matt Gemmell’s iOS 7 first impressions

Breathable whitespace is everywhere, and is used to unify and homogenise previously disparate interface styles

Here is a batch of (not randomly choosen) iOS 7 Apple and third parties apps screenshots. Yes the interface is homogeneous. In fact, everything is white! Everything is dull, identical, uniform.

In a word, boring.

New iOS 7 version of Podcast app

Mail and Calendar

Contacts

Music and Notes

Alarm and Maps

Phone and Game Center

This white plague has also spread through third parties apps:

Tweetbot and Nike

Kickstarter and Ted

Frankly, I miss the days were differences between apps were not limited to some tint color, or bold font.

Of course, we are just at the beginning of a new area, designers and developers need to learn the new UI paradigms and invent new designs. But, I’m already fed-up with this white, flat minimalism: if you’re updating your app for iOS 7, at least don’t go with the stock white appearance like a tons of others apps.

Frankly, do you think Apple is going to wait this time 6 years before introducing a new radical change?

From jc.