Table of Contents for

Programming for PaaS

A familiar activity involves taking a structure that has a username and a password, plus a list of friends encapsulating this data; you want to be able to send this data from a server to a client to be consumed by the end user. There are many ways to accomplish tasks like this.

XML is one common method that is prevalent within Java; it’s still a vital tool within many enterprise applications. JSON is a bit newer to the market; it’s a JavaScript representation of objects. JSON’s relationship to JavaScript is key in understanding why this format has taken off.

One of the most common ways that JSON is consumed is through a JavaScript client on the web frontend. Because of that attribute, it is very easy to turn JSON into JavaScript objects through the web client. Since the point of origin of many mobile applications is the Web, these JavaScript representations have transferred with them. They are much easier for humans to read and much less verbose. They also take up less data, another reason these types of objects have proliferated within mobile devices.

XML is very verbose, which can be good when dealing with complicated data. However, it will add significant bulk to your data packets, and in mobile development, where you have limited bandwidth and you have to deal with slow connections, transferring as little data as possible becomes ever more important. This is why many mobile applications have chosen JSON for encoding and transferring data.

For reference, JSON has the following basic data types available:

Native iOS applications in Objective-C can get data quickly and easily from metaservices. There are various ways you can approach this process, from building it yourself to leveraging open source or proprietary frameworks to help you.

The first step to writing the code yourself is leveraging iOS’s asynchronous network operations:

Here is an example of what that Objective-C code might look like in practice:

- (void)load {
  NSURL *myURL = [NSURL
     URLWithString:@"http://example.com/users"];
  NSMutableURLRequest *request = [NSMutableURLRequest
    requestWithURL:myURL
       cachePolicy:NSURLRequestReloadIgnoringLocalCacheData
   timeoutInterval:120];
  [[NSURLConnection alloc] initWithRequest:request
                                  delegate:self];
}

- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data {
    [mutableData appendData:data];
}

- (void)connection:(NSURLConnection *)connection
  didReceiveResponse:(NSURLResponse *)response {
    mutableData = [[NSMutableData alloc] init];
}

- (void)connection:(NSURLConnection *)connection
  didFailWithError:(NSError *)error {
    [mutableData release];
    [connection release];
    NSLog(@"Unable to fetch data");
}

- (void)connectionDidFinishLoading:
                   (NSURLConnection *)connection
{
    NSLog(@"Succeeded! Received %d bytes of data",
                                    [mutableData length]);
    NSString *jsonResponse = [[[NSString alloc]
                       initWithData: mutableData
                           encoding: NSASCIIStringEncoding]
                    autorelease];
    // Parse the jsonResponse and feed it to the UI
}

As of iOS 5, Apple added native parsing of JSON through the NSJSONSerialization class; however, there are some open source libraries that can parse JSON even faster in iOS, like JSONKit.

Once the data is grabbed and parsed, there are a number of ways to serve that data to the frontend user experience:

Apple’s Core Data framework is Apple’s standard way for iOS apps to persist data on phones. It is used widely for filling the UI components quickly and easily through many parts of the iOS experience.

// User.h
@interface User : NSObject
@property (strong, nonatomic) NSString *name;
@end

// User.m
@implementation User
@synthesize name;
@end

// MasterViewController.m

#import <RestKit/RestKit.h>
#import "User.h"

...

- (void)viewDidLoad
{
    [super viewDidLoad];

    RKURL *baseURL = [RKURL URLWithBaseURLString:@"http://example.com/users"];
    RKObjectManager *objectManager = [RKObjectManager
    objectManagerWithBaseURL:baseURL];
    objectManager.client.baseURL = baseURL;

    RKObjectMapping *userMapping = [RKObjectMapping mappingForClass:[User class]];
    [userMapping mapKeyPathsToAttributes:@"name", @"name", nil];
    [objectManager.mappingProvider setMapping:venueMapping
    forKeyPath:@"response.users"];

    [self sendRequest];
}

Android native applications use Java and can also get data quickly and easily from metaservices. As with iOS, there are various ways you can approach this process, from building it yourself to leveraging open source or proprietary frameworks to help you.

The first step to writing the code yourself is leveraging Android’s asynchronous network operations:

Here is an example of what that Java code might look like in practice:

// executed in a Service via new GetRESTData().execute();
// http://developer.android.com/reference/android/app/Service.html
private class GetRESTData extends AsyncTask <Void, Void, String> {

   @Override
   protected String doInBackground(Void... params) {
     URL url = new URL("http://example.com/users");

     URLConnection urlConnection = url.openConnection();
     InputStream in = new
       BufferedInputStream(urlConnection.getInputStream());
     BufferedReader reader = new
       BufferedReader(new InputStreamReader(in));
     String result, line = reader.readLine();
     result = line;
     while((line = reader.readLine())!=null){
        result += line;
     }
     in.close();

     return result;
   }

   protected void onPostExecute(String restResult) {
     // process the JSON string into a Java object
     // and persist it into a SQLite database
   }
}

Note that you should not implement Android REST methods inside activities. Activities are for user interface and user experience functionality. The code should always start long-running operations from a service; Android services were meant to run this kind of code.

Android has a native parser for JSON through the org.json.JSONObject class; there are also some open source libraries that can parse JSON in Android, like JSONLib, FlexJSON, and Gson.

Once the data is grabbed and parsed, it needs to be persisted immediately. SQLite is your best friend in Android. You should also use a sync adapter to execute regular checks for new data from your REST services. The sync adapter can change your data-grabbing process from a pull into a push architecture, which will save a ton of battery life.

public interface UserResource {
    @Get
    public User retrieve();

    @Put
    public void store(User user);

    @Delete
    public void remove();
}

ClientResource cr = new ClientResource("http://example.com/users/123");
// Get the User object
UserResource resource = cr.wrap(UserResource.class);
User user = resource.retrieve();

As seen in Chapter 5, building metaservices, which can power mobile or web frontends, is easy to do in Platform-as-a-Service. In fact, building applications in PaaS this way from the beginning is actually a best practice. These services have less code, are easier to maintain, and are easier to scale.

When you use a PaaS to build metaservices, deploying large N-tier clustered servers and managing them takes seconds, not weeks or months.

PaaS makes building and running metaservices faster and easier than ever before.

Scaling metaservices in PaaS is easy. If your app is modular and does not require constant disk access, you can very quickly and easily add more instances, which increases the concurrency levels dramatically. As thousands (or hopefully millions) of people start using your mobile applications, adding capacity is no longer a chore but an API call.

Many PaaS providers even have REST APIs, which you can use to automate the process of scaling.

You might only have 1,000 users, but those users might upload 100,000,000 pictures. Your PaaS provider can make it easy to manage and run the proper scalable backend service to handle both kinds of services fast and effectively.

Once you build your metaservices and launch them on a PaaS, they can be accessed through your iOS, Android, or Windows Phone smartphones and tablets. They can even power your web presence. This is a powerful way to maximize the efficiency of the resources you have when building applications.