tumbljack

MVCS

Mon, 20 Feb 2012 15:53:00 -0800

S for Service. A new kind of thing that should also be encapsulated.*

A good service layer is easy to use and has entirely out of the box functionality. I usually do this kind of thing the same every time, using a pattern I’ve seen around that works well. For every service that an app needs to connect to I have a utility class that has an API for requesting specific things from the service. All networking code required to talk to a service is encapsulated inside one of these classes and the class just exposes a nice, handy API to get things done.

A good name for one of these things is usually My<#SERVICENAME#>Client or My<#SERVICENAME#>Service, where ‘My’ is your class prefix and ‘SERVICENAME’ is the actual name of the service the app is requesting things from. I lean towards MySomethingClient because it is more correct, since our app and specifically this utility class is technically the client to the service that it’s hitting.

Watch out for including things like ‘REST’ in a class name, because all things network specific are an implementation detail. I would reconsider names like Fetcher and DownloadManager as well. While we know the class is doing these things, I think this behavior terminology is too specific to include in a class name. Plus Fetcher sounds kind of lame, and Manager is a name I think should only be used wisely, if ever. Also, I personally don’t think Controller makes sense here, because it is something else, and at a project level the behavior of a service class called Controller usually isn’t clear.

So here’s how I do it.

The client API will have methods like…

- (void)requestThingamajigsWithCompletionBlock:(void (^)(NSArray *thingamajigs, NSError *error))block;

and…

- (void)requestThingamajigWithName:(NSString *)name

completionBlock:(void (^)(FOOThingamajig *thingamajig, NSError *error))block;

All API methods call an an internal method like…

- (void)requestValueForEndpoint:(NSString *)endPoint

completionBlock:(void (^)(id result, NSError *error))block;

Each API method’s implementation builds an end-point, calls the request method and handles the result, which usually comes in the form of a JSON or property list object. A handy category for unpacking property list objects is arrayOfClass:forKey:. Once this internal method is set up it’s fast and easy to add more API calls. APIs that create or change things usually call an internal method like sendPOSTValues:toEndPoint:completionBlock:. And optional behavior like canceling and queueing can be added as necessary.

That’s about it. Service is a new layer that should be encapsulated, clean and easy to use, like Cocoa.

Here’s a quick and dirty sample I put together. If you have any opinions, feedback or better designs for this kind of thing, hit me up.

https://github.com/joericioppo/MyThingamajigClient

* Chris Parker’s great post on coding ruthlessly motivated me to finally post this.

http://playswithfire.com/blog/2012/02/19/you-are-not-ruthless-enough/

Earth | Time Lapse View from Space (@rands)

Mon, 14 Nov 2011 00:16:43 -0800

Earth | Time Lapse View from Space

(@rands)

Andy Gilmore

Thu, 11 Aug 2011 15:11:49 -0700

Andy Gilmore

Less code, less effort

Fri, 05 Aug 2011 00:54:42 -0700

Less code, less effort:

Brent Simmons

Sunrise - NASA

Thu, 21 Jul 2011 01:52:30 -0700

Sunrise - NASA

The Art of Drew Struzan

Wed, 27 Apr 2011 22:29:27 -0700

The Art of Drew Struzan

Sunset over South America - NASA

Mon, 25 Apr 2011 21:09:49 -0700

Sunset over South America - NASA

The Mountain - Terje Sorgjerd

Tue, 19 Apr 2011 14:39:09 -0700

The Mountain - Terje Sorgjerd

Slow Company

Wed, 16 Mar 2011 14:20:57 -0700

Slow Company:

Lucius Kwok

Photo

Tue, 01 Mar 2011 01:29:04 -0800

fuckyeahspace: Time-lapse of a whole night at the ALMA Array...

Sat, 19 Feb 2011 13:44:08 -0800

fuckyeahspace:

Time-lapse of a whole night at the ALMA Array Operations Site, located on the Chajnantor plateau, in Chile.

Vintage Future

Thu, 17 Feb 2011 23:27:27 -0800

Vintage Future

Warm Signal - Silke Sieler

Tue, 01 Feb 2011 23:38:27 -0800

Warm Signal - Silke Sieler

if (!fuckingReadable) return;

Tue, 01 Feb 2011 21:38:00 -0800

I got schooled the other day by my much respected and beloved elder. In so many words he said this..

if (![you canFigureThisShitOut]) return toSchoolBitch;

So after pondering the readability of !this and !that for a while, I realized the underlying motivations of my coding style, and why I check explicitly for aFlag == NO || aThing == nil. The thing is, I pretty much stopped caring about how readable code is ages ago. Instead, I’ve found myself editing code, revisiting names, adjusting formatting, changing styles, all based on how enjoyable my code is to read. Because, presumably, if code is enjoyable to read, it’s really fucking readable.

So when I look at code that’s banging nots in front of things all over the place, I realize, you’re saying things backwards. You’re actually speaking in awkward language. When I ponder the existence of self, I think, does self exist. Is this real. Is this empty. Is hope gone.

Is not thing?

David Fuhrer

Mon, 31 Jan 2011 00:38:07 -0800

David Fuhrer

Kilian Eng

Sun, 23 Jan 2011 14:06:59 -0800

Kilian Eng

Alexey Kurbatov

Tue, 18 Jan 2011 14:23:00 -0800

Alexey Kurbatov

MyStyledView

Mon, 17 Jan 2011 00:57:00 -0800

The first time I looked at drawing APIs I thought what the hell. They are generally quite low level, and always procedural. Even Cocoa’s Objective-C drawing APIs are very procedural in nature, because drawing is procedural. There are very few APIs that abstract this up to the styling level. One of my favorite things about CALayer is that it comes with built in styling properties. This is by far the better and more modern API because it abstracts what would be custom drawing code to the controller level where your unique code just becomes values to set.

On iOS it’s really easy to set up a view and use the styling properties of the view’s built in layer to get simple UI elements on screen. You can even set one up to use a CAGradientLayer as its built in backing layer and get all kinds of cool stuff out of it just setting properties. Unfortunately on the desktop the integration with CALayer is not quite as awesome, and layer backed views can sometimes be problematic. I’ve often ended up styling views from scratch with drawing code.

This is a generic styled view class that I use all the time to get quick and dirty graphics on screen during development. The API has changed over time with usage, and I’m pretty happy with its current state for the most part. Styling is exposed through properties on the view. It has support for a fill color and gradient, with the gradient composited on top, and individual properties for top and bottom edges, as well as highlights. The left and right edges have gradient properties instead of colors. It also supports drawing inner shadows thanks to Sean Patrick-O’Brien and his awesome bezier path category. And I recently added support for stretchable background images exposed through a leftCapWidth and topCapHeight property.

Setting one up is just a few lines of code. I put together a simple demo with some goofy graphics I made up on the fly. The result looks like this. The class and categories used are available BSD.

The new Signalnoise Gallery

Tue, 11 Jan 2011 20:19:09 -0800

The new Signalnoise Gallery

jamiepinkham: jeffrock: rvameetups: Some of Tumblr’s staff...

Sat, 08 Jan 2011 01:26:40 -0800

jamiepinkham:

jeffrock:

rvameetups:

Some of Tumblr’s staff members from New York will be in town on Thursday. Please come to Legend Brewing starting at 6 p.m. to help us make them feel welcome and to celebrate the opening of Tumblr’s new office in Richmond. We’ll have free food, drinks, and goodies while they last!

(Image courtesy of Jeff Rock)

This is huge.

Get ready. 2011 is going to be officially awesome for Tumblr mobile apps.

Booyah!