read more

If you’ve never heard of perlin noise here’s the wikipedia article and here’s a great explanation of how it’s calculated. Better than that, here are some examples of it’s use:

Natural Textures

Procedural Terrain Generation

Flow Fields

I wanted to have some perlin noise I could use to apply different effects to GPUImage filters. I found a reference to a GPU implementation on stackoverflow.com. The implementation on github here is ready to go. I used the classic 2D implementation provided there. There are also 3D, 4D as well as simplex versions (the simplex noise performs better at higher dimensions).

Here’s that code used to create a filter that generates a texture using perlin noise. The code is just copied from the github implementation:

Header:

#import "GPUImageFilter.h"

@interface GPUImagePerlinNoiseFilter : GPUImageFilter {
    GLint scaleUniform, colorStartUniform, colorFinishUniform;
}

@property (readwrite, nonatomic) GPUVector4 colorStart;
@property (readwrite, nonatomic) GPUVector4 colorFinish;
@property (readwrite, nonatomic) float scale;

@end

And implementation:

#import "GPUImagePerlinNoiseFilter.h"

NSString *const kGPUImagePerlinNoiseFragmentShaderString = SHADER_STRING
(
 precision highp float;
 varying highp vec2 textureCoordinate;
 uniform float scale;

 uniform vec4 colorStart;
 uniform vec4 colorFinish;

 //
 // Description : Array and textureless GLSL 2D/3D/4D simplex
 // noise functions.
 // Author : Ian McEwan, Ashima Arts.
 // Maintainer : ijm
 // Lastmod : 20110822 (ijm)
 // License : Copyright (C) 2011 Ashima Arts. All rights reserved.
 // Distributed under the MIT License. See LICENSE file.
 // https://github.com/ashima/webgl-noise
 //

 vec4 mod289(vec4 x)
{
    return x - floor(x * (1.0 / 289.0)) * 289.0;
}

 vec4 permute(vec4 x)
{
    return mod289(((x*34.0)+1.0)*x);
}

 vec4 taylorInvSqrt(vec4 r)
{
    return 1.79284291400159 - 0.85373472095314 * r;
}

 vec2 fade(vec2 t) {
     return t*t*t*(t*(t*6.0-15.0)+10.0);
 }

 // Classic Perlin noise
 float cnoise(vec2 P)
{
    vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
    vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
    Pi = mod289(Pi); // To avoid truncation effects in permutation
    vec4 ix = Pi.xzxz;
    vec4 iy = Pi.yyww;
    vec4 fx = Pf.xzxz;
    vec4 fy = Pf.yyww;

    vec4 i = permute(permute(ix) + iy);

    vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;
    vec4 gy = abs(gx) - 0.5 ;
    vec4 tx = floor(gx + 0.5);
    gx = gx - tx;

    vec2 g00 = vec2(gx.x,gy.x);
    vec2 g10 = vec2(gx.y,gy.y);
    vec2 g01 = vec2(gx.z,gy.z);
    vec2 g11 = vec2(gx.w,gy.w);

    vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
    g00 *= norm.x;
    g01 *= norm.y;
    g10 *= norm.z;
    g11 *= norm.w;  

    float n00 = dot(g00, vec2(fx.x, fy.x));
    float n10 = dot(g10, vec2(fx.y, fy.y));
    float n01 = dot(g01, vec2(fx.z, fy.z));
    float n11 = dot(g11, vec2(fx.w, fy.w));

    vec2 fade_xy = fade(Pf.xy);
    vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
    float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
    return 2.3 * n_xy;
}

 void main()
 {

     float n1 = (cnoise(textureCoordinate * scale) + 1.0) / 2.0;

     vec4 colorDiff = colorFinish - colorStart;
     vec4 color = colorStart + colorDiff * n1;

     gl_FragColor = color;
 }
 );

@implementation GPUImagePerlinNoiseFilter

@synthesize scale = _scale, colorStart = _colorStart, colorFinish = _colorFinish;

- (id)init;
{
    if (!(self = [super initWithFragmentShaderFromString:kGPUImagePerlinNoiseFragmentShaderString]))
    {
		return nil;
    }

    scaleUniform = [filterProgram uniformIndex:@"scale"];

    colorStartUniform = [filterProgram uniformIndex:@"colorStart"];
    colorFinishUniform = [filterProgram uniformIndex:@"colorFinish"];

    [self setScale:8.0];

    [self setColorStart:(GPUVector4){0.0, 0.0, 0.0, 1.0}];
    [self setColorFinish:(GPUVector4){1.0, 1.0, 1.0, 1.0}];    

    return self;
}

-(void)setScale:(float)scale {
    _scale = scale;

    [GPUImageOpenGLESContext useImageProcessingContext];
    [filterProgram use];
    glUniform1f(scaleUniform, _scale);
}

-(void)setColorStart:(GPUVector4)colorStart {
    _colorStart = colorStart;

    [GPUImageOpenGLESContext useImageProcessingContext];
    [filterProgram use];
    glUniform4f(colorStartUniform, _colorStart.one, _colorStart.two, _colorStart.three, _colorStart.four);
}

-(void)setColorFinish:(GPUVector4)colorFinish {
    _colorFinish = colorFinish;

    [GPUImageOpenGLESContext useImageProcessingContext];
    [filterProgram use];
    glUniform4f(colorFinishUniform, _colorFinish.one, _colorFinish.two, _colorFinish.three, _colorFinish.four);
}

@end

If you read my previous tutorial on how to create a custom GPUImage filter there shouldn’t be any surprises here. I’m not going to go over how the code creates the noise, because I haven’t fully investigated how it works myself. I don’t really care how it works, I’m only really interested in how to use it.

The usage lies in the cnoise(vec2) function. You give it an x and y coordinate, and it returns a number between -1 and 1. In the filter, I’m scaling up the input coordinate (because textureCoordinate is between 0.0 and 1.0 so that won’t give us very interesting noise). Then I’m adding 1 and dividing by 2 to convert from a -1 to 1 range into a 0 to 1 range (which is the range of our color values).

Finally, I use the start and finish color values supplied to the uniforms to create a noise texture that ranges between those two values. Here’s what the result looks like (I’m using white and black as start and finish color values, but you can set it to any two colors):

You can use this filter with a blend filter to create interesting texture. You could, for example, combine it with a brightness filter, and then put a sepia filter on it. This would create a natural faded look, something like this:

However, for me, the more interesting usage of this perlin noise function is to combine it with other functions. You can use this function in any of your shader code to create interesting, natural randomness. A modified Pixellate filter that doesn’t create square pixels, but uses perlin noise to determine the size of the pixel cutoff. Here’s a video of the result:

The code is mostly the pixellate filter. I’ve added a scale uniform and of course the perlin noise function to the shader code:

#import "GPUImageFilter.h"

@interface GPUImagePixellateCrazyFilter : GPUImageFilter

{
    GLint fractionalWidthOfAPixelUniform, scaleUniform;
}

// The fractional width of the image to use as a size for the pixels in the resulting image. Values below one pixel width in the source image are ignored.
@property(readwrite, nonatomic) CGFloat fractionalWidthOfAPixel;
@property(readwrite, nonatomic) CGFloat scale;

@end

Implementation:

#import "GPUImagePixellateCrazyFilter.h"

NSString *const kGPUImagePixellateCrazyFragmentShaderString = SHADER_STRING
(
 precision highp float;
 varying vec2 textureCoordinate;

 uniform sampler2D inputImageTexture;

 uniform float fractionalWidthOfPixel;
 uniform float scale;
 //
 // Description : Array and textureless GLSL 2D/3D/4D simplex
 // noise functions.
 // Author : Ian McEwan, Ashima Arts.
 // Maintainer : ijm
 // Lastmod : 20110822 (ijm)
 // License : Copyright (C) 2011 Ashima Arts. All rights reserved.
 // Distributed under the MIT License. See LICENSE file.
 // https://github.com/ashima/webgl-noise
 //

 vec4 mod289(vec4 x)
{
    return x - floor(x * (1.0 / 289.0)) * 289.0;
}

 vec4 permute(vec4 x)
{
    return mod289(((x*34.0)+1.0)*x);
}

 vec4 taylorInvSqrt(vec4 r)
{
    return 1.79284291400159 - 0.85373472095314 * r;
}

 vec2 fade(vec2 t) {
     return t*t*t*(t*(t*6.0-15.0)+10.0);
 }

 // Classic Perlin noise
 float cnoise(vec2 P)
{
    vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
    vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
    Pi = mod289(Pi); // To avoid truncation effects in permutation
    vec4 ix = Pi.xzxz;
    vec4 iy = Pi.yyww;
    vec4 fx = Pf.xzxz;
    vec4 fy = Pf.yyww;

    vec4 i = permute(permute(ix) + iy);

    vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;
    vec4 gy = abs(gx) - 0.5 ;
    vec4 tx = floor(gx + 0.5);
    gx = gx - tx;

    vec2 g00 = vec2(gx.x,gy.x);
    vec2 g10 = vec2(gx.y,gy.y);
    vec2 g01 = vec2(gx.z,gy.z);
    vec2 g11 = vec2(gx.w,gy.w);

    vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
    g00 *= norm.x;
    g01 *= norm.y;
    g10 *= norm.z;
    g11 *= norm.w;  

    float n00 = dot(g00, vec2(fx.x, fy.x));
    float n10 = dot(g10, vec2(fx.y, fy.y));
    float n01 = dot(g01, vec2(fx.z, fy.z));
    float n11 = dot(g11, vec2(fx.w, fy.w));

    vec2 fade_xy = fade(Pf.xy);
    vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
    float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
    return 2.3 * n_xy;
}

 void main()
 {
     float n = cnoise(textureCoordinate * scale);
     vec2 sampleDivisor = vec2((((n + 1.0) / 2.0) + 0.5) * fractionalWidthOfPixel);

     vec2 samplePos = textureCoordinate - mod(textureCoordinate, sampleDivisor);
     gl_FragColor = texture2D(inputImageTexture, samplePos );
 }
 );

@implementation GPUImagePixellateCrazyFilter

@synthesize fractionalWidthOfAPixel = _fractionalWidthOfAPixel, scale = _scale;

#pragma mark -
#pragma mark Initialization and teardown

- (id)init;
{
    if (!(self = [super initWithFragmentShaderFromString:kGPUImagePixellateCrazyFragmentShaderString]))
    {
		return nil;
    }

    fractionalWidthOfAPixelUniform = [filterProgram uniformIndex:@"fractionalWidthOfPixel"];
    scaleUniform = [filterProgram uniformIndex:@"scale"];

    self.fractionalWidthOfAPixel = 0.05;
    self.scale = 4.0;

    return self;
}

#pragma mark -
#pragma mark Accessors

- (void)setFractionalWidthOfAPixel:(CGFloat)newValue;
{

    _fractionalWidthOfAPixel = newValue;

    [GPUImageOpenGLESContext useImageProcessingContext];
    [filterProgram use];
    glUniform1f(fractionalWidthOfAPixelUniform, _fractionalWidthOfAPixel);
}

-(void)setScale:(CGFloat)scale {
    _scale = scale;
    [GPUImageOpenGLESContext useImageProcessingContext];
    [filterProgram use];
    glUniform1f(scaleUniform, _scale);
}

@end

The applications of perlin noise are endless. I just wanted to throw a couple things out there to spark some imagination. Here is another great creative coding applications (by @inspirit) that uses perlin noise to guide a particle system to paint an image with ‘strings’, this stuff is awesome:

Click on the above to go to the site and play with the demo.

With WWDC and presumably iOS 6 approaching, John Gruber looks for obvious gaps in iOS to fill, and in Low-Hanging Fruit, he doesn’t report many. Following on reports that Apple will switch from Google to an in-house Map provider, he writes that while controlling such an essential functionality is crucial, the switch has to be flawless:

This is a high-pressure switch for Apple. Regressions will not be acceptable. The purported whiz-bang 3D view stuff might be great, but users are going to have pitchforks and torches in hand if practical stuff like driving and walking directions are less accurate than they were with Google’s data. Keep in mind too, that Android phones ship with turn-by-turn navigation.

This was an interesting graf to me, because Gruber usually gets the details right, and this time he’s pretty far off.

Start with “users are going to have pitchforks and torches in hand if practical stuff like driving and walking directions are less accurate than they were with Google’s data.” That’s a fundamental misunderstanding of what the iOS SDK provides. Neither Map Kit, nor any other part of the SDK, provides directions. Map Kit only provides map tile images, and a “reverse geocoder” that may be able to correlate a given location to a street address or at least a political region (city, state/province, country). There’s nothing in Map Kit that knows that a yellow line is a road, a blue polygon is a lake, a dashed line is a state or country border, etc. More details in my write-up of writing Road Tip and my Bringing Your Own Maps talk from 2010, but the long-and-short is that any app that provides directions has to be getting its data from some source other than Map Kit, probably a web service hosted by Google, MapQuest, Bing, etc.

I also did a little research to see what the Android API for this stuff looks like, assuming it was easier, and was quite surprised to see that it’s not. A DrivingDirections class was apparently removed after Android 1.0, presumably due to the fact that implementing it required third-party data (TeleAtlas, NAVTEQ) that Google wasn’t in a position to redistribute for free. The suggested workarounds I’ve seen are all to either license a third-party directions API (embedded or webservice), or to make a specific request to maps.google.com and scrape the result as JSON… in other words, to use Google as the directions webservice and not worry about the terms of service. I only spent about 15 minutes looking, but it didn’t appear to me that getting directions is any easier for Android developers than it is on iOS. So while Gruber notes that “Android phones ship with turn-by-turn navigation”, that seems to be a user feature, not a developer feature.

So, on the one hand, third-party apps probably won’t change right away, because they haven’t counted on iOS for their directions anyways. But maybe that’s an opportunity: if Apple controls its own data, maybe it could offer an easy-to-use directions API, consisting of easy Objective-C calls rather than JSON or XML parsing like webservice clients have to do now.

There might be a licensing snag too: using Map Kit today means that developers are implicitly accepting the Google Maps terms of service. If iOS 6 switches providers, the terms presumably change as well, and I wonder how that would be handled. Would creating a MKMapView magically default to the new Apple maps in iOS 6 (and thereby inherit new Apple terms of service), or would developers maybe have to resubmit or add a credential to their apps to get the new maps?

And taking maps in-house has other interesting side-effects. The other day when I was out with my kids, I searched for “Arby’s” in Jackson, MI and the result appeared on the map as a “Sponsored Link” (I can’t re-create it here at home… maybe it’s only an ad when you’re physically nearby?). The money for that ad presumably goes to Google, a revenue stream that will start to dry up if Apple provides its own business location data when searching maps. We’ve also heard that Siri could hurt Google search if people start performing speech-based searches rather than keying terms into google.com via the mobile browser.

And isn’t this exactly what Google was afraid of, and why they felt the need to create Android? With iOS, Apple is in a position to disintermediate Google. And with Apple’s wrath towards Android, the company may be more interested and willing to do so than it might otherwise have been. Smooth move, Andy.

I’m sure this has been asked a million times, but why are there so many goddamn bootleg manga apps on the iOS store?

And then a follow-up from social-media expert and publisher Erica Friedman of Yuricon:

@ANNZac I’ve tried to write Apple/Google about the links to bootleg sites. Neither has a reasonable way for reasonable people to complain

So let me back up a second… what we’re talking about are dedicated apps that read “scanlations”, which are comics (usually Japanese manga) that have been scanned, translated by fans into English, and posted for free to various websites or made available through channels like BitTorrent.

Zac righly calls this “bootlegging” because there is no question that copyright violation is involved. Entire works are being digitally redistributed with zero compensation to the original authors or publishers. What can make this a gray area is a question of whether or not any actual harm is done: if the work is unavailable in English, nor likely to ever be, then how can a scanlation eliminate a sale that could never be made? This is a fairly bogus defense because (as we’ll see), the untranslated works are just a minor part of the story. Moreover, we could apply the established tests of “Fair Use” under US copyright law, such as:

• Is the new work “transformative”? In other words, are we using the original to create a fundamentally different thing?
• How much of the original is being used?
• Does the copying impede future sale of the original work? Does it harm the creator?
• etc.

Guidelines like this permit use like, say, presenting few pages of a comic in the context of a critical review or an academic paper: fundamentally new work, small amount of copying, doesn’t replace the original (and might actually drive new interest and sales). And obviously, a scanlation fails every one of these tests: it’s a full-on copy that changes only the language, and fully replaces a translation the original publisher might provide. It’s also been pointed out that scanlations are harming the development of a legal digital manga industry in the US. Scanlations would have zero chance of surviving a legal challenge.

So why the hell is Apple in the business of distributing them on iOS?

Search for manga on the App Store and you’ll get dozens of hits. Most of them are apps for downloading and reading scanlations on your iPad or iPhone. For the purpose of this blog, I tried the free versions of:

• Manga Storm
• Manga Rock
• Manga Rock 2
• “Manga Browser, Downloader, and Reader
• MangaX3 Lite – didn’t use, crashes when loading title database
• eManga – didn’t use, hangs on sync
• Komik Connect – didn’t use, since it requires a login to do anything

Note: these are not affiliate links. I wouldn’t want a cut of their sales, since I consider them illegal and illicit.

Most of these apps get their contents from three scanlation websites: MangaFox, Mangareader.net, and MangaEden. Some of these sites play at supporting the source of their titles by slapping in pseudo-legal disclaimers and vague admonishments to somehow support artists as seen on this page of The Rose of Versailles:

This image is hosted at mangafox.com. We take no credit for the creation or editing of this image. All rights belong tot he original publisher and mangaka. While we hosted this for free at mangafox.com, please don’t forget to support the mangaka in any way that you can once his/her work becomes available for retail sale in your region!

Some of these sites also adhere to an ethic that they don’t host scanlations of titles that have been licensed in the US. In this screenshot, Manga BDR (which awkwardly makes you browse MangaFox rather than scraping its index) shows an notice that Fullmetal Alchemist is unavailable from MangaFox because it has been licensed in the US:

Does this mean there’s honor among thieves? Hardly. The sites are still violating the original Japanese copyright of the titles they do offer. And they’re not living up to the implicit promise to make obscure titles available to a wider audience — the Rose of Versailles manga cited above has not been completely translated, despite being more than 30 years old. And wherever Manga Rock gets its data from, it has no compunction about offering up titles that have US publishers. Here’s Manga Rock 2 offering Fullmetal Alchemist in its entirety:

Not only is this stuff illicit bootlegs, these apps are popular because they allow access to pirated manga. Every single one of these apps advertises itself on the App Store with screenshots of browsing popular titles that have US publishers: Manga Storm shows Fairy Tail, Manga Rock shows Fairy Tail, Air Gear, and Negima!, and Komik Connect shows Bleach and Naruto. And the users use these apps precisely because of their illegal nature: the one-star reviews on Manga Storm don’t complain about it ripping off artists, but because it lacks US-licensed titles (due to its dependence on MangaFox and friends), and because it’s a paid app.

And speaking of the paid versions…

Apple gets a 30% cut of every sale of the full versions of these apps. That makes Apple a direct beneficiary of copyright piracy.

Everyone who stood up to say Apple does more to support creators than Google and its cavalier attitude towards IP rights, you can sit down now. So long as these apps are available on the App Store, Apple is complicit in piracy.

It’s fair game to criticize Apple for these, when the company has such a stringent review process. When it’s so careful to consider what it will and won’t sell, approval of an app has to be considered an explicit endorsement, particularly considering Apple gets a cut of the sales.

And that’s what makes it all the more galling:

• Apple has started rejecting apps for largely hypothetical privacy concerns, but is OK with pirating manga.
• Apple won’t allow BitTorrent clients, despite significant non-infringing uses, but is OK with pirating manga.
• Apple won’t let third parties sell gay- or lesbian-themed comics, but is OK with pirating manga.

The last of these may be the most galling. Erica Friedman again:

I went on a rant about why is it okay with the those of you who like shiny things that Apple just told DMP to take their BL off the iPad app? WHY?!? If the TV hardware manufacturers told you what TV stations you could receive, you’d be enraged. When your work blocks sites, you find ways around it. So why the hell is it okay will all you Apple fans that Apple censors content? I cannot understand why you are not screaming at all, much less loudly? APPLE CENSORS CONTENT. Especially LGBTQ content. Why are you still giving money to a company like that? People boycott BP and Chik-Fil-A and Target…but are absolute sheep about Apple’s censorship of content. ARGGGGGHHHH.

It’s as if Apple is saying “we won’t let anyone sell you gay manga for your iPad, but we will sell you tools to help you steal the stuff.”

This has to stop.

If nothing else, these apps are in obvious violation of section 22.4 of the iOS App Store Review Guidelines:

22.4 Apps that enable illegal file sharing will be rejected

Apple apparently won’t listen to third-party criticism (people have been calling attention to these bootlegging apps since at least 2010: 1, 2, 3), but there are channels that aggrieved parties can use. Viz and Yen Press have legitimate iOS apps for their manga titles. Since Manga Rock 2 makes bootlegs of those titles available (I saw Viz’s Fullmetal Alchemist and Yen’s High School of the Dead), these companies could use Apple’s dispute policies to at least have Manga Rock 2 taken down.

Beyond this, it’s hard to see what will work. Via Twitter, Erica noted yesterday that most US manga publishers are too small and operating on margins too thin to follow up with DMCA takedowns, and Apple may be technically in the clear on DMCA because they’re not themselves hosting the offending content.

However, since Apple’s making money off the sale of the apps used to pirate this content — in clear and obvious violation of their own policy — another option is that the Japanese publishers might want to sue Apple directly. They would presumably have more legal resources to stick with a lawsuit, and with Apple deaf to criticism, maybe it would take a few subpoenas to call their attention to the fact that making money off piracy is an awfully dirty business for one of the world’s largest and most prestigious companies to be involved in.

For the sake of Apple and the creative community, these apps need to disappear forever.

While blocks are a powerful tool, if you’re not careful they can start to degrade the quality of your app by introducing retain cycles.  Retain cycles occur when two objects in your application keep strong references to one another.  Take the common table view for example.  Ordinarily, the view controller containing (owning) the table view acts as the datasource and delegate for table, providing the necessary information for displaying the number of rows and supplying cell objects.  If you look closely at the properties on UITableView for datasource and delegate, you’ll see that both properties are declared as “assign” or “weak” in ARC.  This is critical particularly in the case where the view controller is also the datasource/delegate.  If the properties were “strong” or “retain” you could easily wind up in a retain cycle where neither your UITableView nor your view controller would ever be destroyed, thereby leaking memory.

This can happen with blocks as well and it’s not always so obvious.  Let’s say we have a view for which we define a block to handle the user tapping it.  The code might look something like this:

#import <UIKit/UIKit.h>

typedef void(^TapBlock)(void);

@interface TapBlockView : UIView
{
   TapBlock tapBlock;
}

@property (nonatomic, copy) TapBlock tapBlock;
@end

@implementation TapBlockView
@synthesize tapBlock;
- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
{
   tapBlock();
}

- (void)dealloc
{
   [tapBlock release];
   [super dealloc];
}

@end

This is a very convenient way of setting up delegate style behavior without having to litter your code with lots of protocol definitions. Now an example of using the view in a view controller:

- (void)viewDidLoad
{
    [super viewDidLoad];
    tapBlockView = [[TapBlockView alloc] initWithFrame:CGRectZero];
    [tapBlockView setTapBlock:^(void) {
        self.someLabel.text = @"You tapped it!";
    }];
}

Everything seems fine right? Nice and convenient.

Not so fast.

Blocks automatically scope capture and retain any object types you use in the block. In this case that variable is “self”. Now we have a retain cycle since self owns the tap view which owns the block which now owns self.

According to Mike Ash, the correct way to handle this is to use a weak pointer (assign) in the block like this:

- (void)viewDidLoad
{
    [super viewDidLoad];
    tapBlockView = [[TapBlockView alloc] initWithFrame:CGRectZero];
    __block typeof (self) weakself = self;
    [tapBlockView setTapBlock:^(void) {
        weakself.someLabel.text = @"You tapped it!";
    }];
}

By using a weak, nonretained pointer along with the __block modifier we’ve broken the retain cycle. For ARC code you should use __weak instead of __block.

There’s two important lessons to be pulled from this. The first is that you always have to be aware of the code you’re writing and look for subtle retain cycles like this one. No amount of automatic reference counting magic can help you in some of these scenarios. The second is that it’s always good to look at code written by others on your team because there’s nearly always something new to learn to refresh on, even if you’re one of the more seasoned developers and the code you’re reading is from a junior dev.

For more information check out these two articles on Mike Ash’s Friday Q&A Site:
9/30/2011 – Automatic Reference Counting
4/30/2010 – Dealing With Retain Cycles

I am relatively new to git, compared to the number of years I’ve been using source code control systems. That said, I’ve been using git now for about 18 months. And I’ll admit that it has taken some time to really “get” it. I find that I am learning new things about it all the time, still.

We all know how easy it is to get started with git:

% mkdir myproject
% cd myproject
% git init
% <write fabulous code>
% git add .
% git commit -m "Fabulous code!"

Presto! A local repository with all your code and commits and history. Easy peasy.

Getting this to a server requires adding something called a remote, which is simply the address of a server that is prepared to receive your commits. (I will not go into how to setup a git server. I use gitolite, which is easy to setup and easy to manage.)

% git remote add origin git@git.myserver.com:myproject.git

Now you can push your local repository to this remote, which here has been named “origin”, but you could name it anything meaningful to you (as we’ll see later).

% git push origin master

The reference to “master” here is the name of the branch, on the remote “origin”, to which you want your commits pushed. You could use another name here too (e.g. trunk), but the convention generally is to have a remote named “origin” and a main branch named “master”.

Ok, great. Everyone knows this stuff, and there are any number of online tutorials about it. What is not necessarily “out there” already is how to scale this for yourself.

Did you know you could have any number of remotes defined for a single working directory (local repository)?

I first ran into this when I had changes I wanted to make to a Ruby gem I had found on github. We needed to use this gem in our project, but it also made sense to push the changes back to github on a branch of my own forked copy. So I forked the project, and cloned the repo:

% git clone git@github.com:granoff/apnd.git

This automatically gave me one remote:

% git remote -v
origin	git@github.com:granoff/apnd.git (fetch)
origin	git@github.com:granoff/apnd.git (push)

When I had completed my work, and pushed back to github, I also wanted to push the code to our internal gem server. I simply had to add another remote:

% git remote add scm git@scm.company.com/apnd.git

I named this second remote “scm” to distinguish it from “origin” (which I knew was github). Then all I had to do was push (again), but this time to “scm”:

% git push scm master

Pretty cool. And, all in one working directory.

Ninja Challenge

Now for the fun part. I recently became the primary developer on the Ruby on Rails portion of a project for which I am the primary iOS developer. Luckily, the Rails project is in pretty good shape, and I have not had to wade too deeply into it. At least, until recently. A few issues have popped up and ultimately, I have had to face a challenge I knew was coming. But more on that in a bit.

When I took over the Rails project, I had the then primary developer push his git repo to a new repo I setup on my own server. That repo on my server is my origin for the project. Our Rails app is hosted on Heroku. But instead of just one instance, we have 3: production, beta, and test. Each of those is effectively a copy of our repo, but we only push to these repos when we want to deploy something. But they are all just git repos! That means locally, I can define them as remotes in my working directory!

% git remote add prod git@heroku.com:instance-three.git
% git remote add beta git@heroku.com:instance-one.git
% git remote add test git@heroku.com:instance-two.git
% git remote -v
beta	git@heroku.com:instance-one.git (push)
beta	git@heroku.com:instance-one.git (fetch)
origin	git@git.myserver.com:the-project.git (fetch)
origin	git@git.myserver.com:the-project.git (push)
prod	git@heroku.com:instance-two.git (push)
prod	git@heroku.com:instance-two.git (fetch)
test	git@heroku.com:instance-three.git (fetch)
test	git@heroku.com:instance-three.git (push)

The first challenge I had was to push what we had on beta, to production. (This also involved a Heroku stack change, which seemed daunting, but in the end was painless. Thanks Heroku!)

Now, I am pretty comfortable at the command line; there are just some things that are done more easily from a shell prompt than by using a GUI. And sometimes, what you want to do cannot be done easily with a GUI simply because the task is non-trivial. That being said, being able to visualize a git repository graphically is priceless. There are at least a couple good tools for this. One is GitX, the source code for which is on github, and has been forked numerous times. The one I had been using, GitX(L), seems to be the one in active development, and works pretty well. But semi-recently, Atlassian released a free tool, aptly named SourceTree, that I have been using. It’s a little more full-featured than GitX, in my opinion.

Anyway, using a visual tool, I could see prod was tracking prod/master, and beta was tracking beta/master. My local repo was tracking origin/devo (an active development branch), and test was tracking test/master. (On Heroku, it is the master branch from which your app runs. If you had just one Heroku instance, it might make sense to have other branches that you work with locally, and then when it’s time to deploy, you push master.)

To push what I could see was actually on beta (beta/master) to prod, all I had to do was the following:

% git push prod beta:master

This command is effectively the same as

% git push prod beta/master:prod/master

What it is doing is pushing to prod what is locally in beta/master to the remote prod/master. Easy peasy, again!

But, it wasn’t before I spent a lot of time understanding this, with a colleague in tow, before I actually executed the command!

The point is that with commands like this you can push almost anything to anywhere. Very powerful.

The next challenge I had to face was applying a couple hot fixes, made locally on a development branch, to production.

My workflow included committing my specific fixes on my development branch, and then cherry picking those commits over to my (local) production master branch. For the cherry pick, I used SourceTree’s UI. Just easier, as that is a fairly common thing to do, and the UI handles it nicely. After testing locally, I pushed it easily:

<I had prod checked out at this point>
% git push prod prod:master

Specifying prod:master was probably redundant, but I wanted to be specific about what I wanted from git. The command “git push prod” would have been sufficient, I think.

The Lesson

Git is a tool for both novices and ninjas alike. For the beginner (with git) it is easy to get started, and the basic concepts are fairly easy to grasp. For the experienced, it is extremely powerful, if unleashed.

Unleash your git ninja today.

I did combo this drill down with a sorta complex core data model and assumed this was setup before handing off objects to each subsequent class. I’m going to nix the core data in favor of a simple input, but we are going to keep music on the table!

Lets start here : UIStoryBoardDrill.zip

This Xcode project will start you out with some plist data that is a nested list of music genre, artist, album, song. At the same time not to complicate the ViewControllers on how it handles these different tiers the data is only nested as a “NSString name” , “NSArray items” pair. This way we constrain straight on the loopback of the table segue.

First take a look at the “Auto” side of this app, this table view controller uses the cells prototype push outlet to auto loopback to the controller again. Because this dose not utilize the didSelectRowAtIndexPath: (or to be clear) this does call but, performs the segue regardless. This practice will make use of the sender value in the prepareForSegue: to identify which cell was clicked on. Realize we are not making a decision where to go next, thats already happening via the segue, we are only deciding what to take with us. We send some values to the next view controller that is another instance of this current one, but is not this exact one. And the view controller is then stacked in the navcontroller and is now only aware of the sub-array we handed down to it.
This auto drilling can be a little limited because of the way we always drill into the same view controller class type. But! if you want to explore here, I suggest you make another cell prototype with a different identifier and a different segue outlet, and use it at your desired tier.

The “Manual” side takes on calling segues from code and needs the fake UIBarButtonItem to create the loopback segue. This little trick will let you define segue identifiers and then let you decide with directing to take with the call to performSegueWithIdentifier: The other important thing is to know what object you want to send along here as the sender. The cell is no longer the sender that is triggering the segue, didSelectRowAtIndexPath is and we could likewise send the UITableViewCell or filter it down to the object we are after. This is the place I test for the data nesting and chose to end the drill down. Calling the different segue will push over to the details view, but the stack of drills downs is still managed by the navcontroller.

Good luck and happy storyboarding.

The game is called Muster my Monsters (MmM). It is a two-player fighting monsters action game. It is a casual game, so game mechanics need to be simple and art appealing to most of people. Here you have a gameplay video.

Problem statement

The problem statement for MmM has some unusual restrictions due to unusual circumstances. First, I wanted to submit it to the first CELL APP Awards. As you can see at the official website, the deadline has been extended, but the original deadline was April 30. By the way, you can help Muster my Monsters win the contest by voting for it here

I also needed a game that could start simple enough to be ready in two weeks but with potential to grow naturally, in case I want to keep working on it after the contest.

So, the problem statement is:

I need to design and develop a cross-platform game using CELL·SDK in two weeks. It needs to be simple but with potential to grow and appealing for casual audience. No level design involved.

Why CELL·SDK? Well, because it is mandatory to participate to the contest But also because it is a promising cross-platform development tool. In this post you have more details about my reasoning around cross-platform development on mobile devices.

Why only two weeks? Well, due to some personal and technical problems, I started to work on this game only two weeks before the contest’s deadline. That’s why I needed a simple game without level design involved. Level design and balance is very time consuming.

Game Design

The core gameplay of Muster my Monsters is rock-paper-scissors. Yes, it is essentially a rock-paper-scissors game with a nice dress However, upon this extremely simple game mechanic you can build up a very solid video-game.

The available actions in Muster my Monsters are: Attack, Dodge and Mock.

• Attack wins Mock
• Mock wins Dodge
• Dodge wins Attack

The current version of Muster my Monsters has two game modes:

• Single Player. You play against the COM. Currently it is like a slot machine game because the COM selects the action randomly.
• Two Players. This is the fun part Here I take advantage of the intrinsic gameplay richness of rock-paper-scissors. I have put my main effort on calibrating correctly the timings and phases of every round and match of the game to make the players feel the rock-paper-scissors tension.

But MmM is also a fighting game, so I can naturally add game modes such as: tournament, arcade, survival, time attack…

MmM is also about monsters. Do you like collecting monsters? Both casual and hardcore players love to collect things. But collecting monsters is the best! Moreover, this is an interesting feature for monetization.

Maybe I could break a little bit the rock-paper-scissors balance. What about a very strong monster that gets some advantage after winning a throw using the Attack action? Would that player use Attack at first round? Or would avoid it because it’s too obvious? Nice dilemma :)

So, as you can see, this little game may easily grow up.

CELL·SDK

CELL·SDK is a promising cross-platform development tool that supports iOS, Android and Windows Phone with the same code base. They are still working on it, but it already offers some very interesting features such as a modern physics engine, support for sprite based animations, key-frame based animations, integration of various advertising platforms, analytics…

The main drawback is the cost. CELL·SDK is built upon MonoTouch and Mono for Android, so you will need the corresponding licenses to publish games and apps for iOS and Android, apart from the CELL·SDK license.

Art

For all the art of Muster my Monsters I talked with Javi Sanz, from Ravalmatic. Menu screens, game HUD, character design, sprite animations, background… Everything.

It is amazing how he could manage to do everything taking into account that I first talked to him about the game two weeks before the deadline. Great work Javi!! Thanks!!

Music & SFX

The music and, specially, the SFX are very important for this game. The background music builds tension and the SFX help the player to understand the action and being aware of the current game state.

It is important that the payer can easily know how many rounds has win/loose so far and the number of matches played so far. But the most important thing is that the player could internalize the timings and phases of the game, as well as the history of actions delivered both by himself and the opponent. And for achieving this, the SFX are as important as the visuals. The sequences of sounds are easily retained unconsciously by players.

Conclusion

The most important conclusion I get from this stressful experience is that it is possible to create a playable and fun game within two weeks. It still needs some polish, but the main part is already developed.

It also has allowed me to introduce myself to the Windows Phone platform. Microsoft technologies are really great: C#, XNA, Silverlight, etc. All of them are modern and robust tools that make your life easier as a developer. In the future I will see if it happens to be the same with the Marketplace and the publication and distribution phase.

So, let me remember you again that you can help Muster my Monsters win the first CELL APP Awards voting for it here. Wish me luck! Thanks!

This post is part of iDevBlogADay, a group of indie iOS development blogs. You can keep up with iDevBlogADay through the web site, RSS feed, or Twitter.