Architecting for the cloud talk

I am doing a talk next week on Architecting for the cloud, with a focus on Windows Azure. Here is the blurb for the talk:

The cloud offers a number of great benefits to organizations such as low upfront & ongoing costs, seemingly infinite resources and elasticity on demand. But how do you design applications to take advantage of what the cloud has to offer? How do you architect applications to work in the cloud? What are the things you need to consider when you are moving your existing application to the cloud? Mahesh Krishnan, Technical Specialist on Windows Azure answers these questions and talks about how you go about architecting applications for the Windows Azure platform

If you are in Melbourne on the 25th of October and would like to come along, please RSVP to janice(dot)itchins(at)robertwalters(dot)com(dot)au.

  • Date and time of event: Thu, 25 Oct, 2012, 5:30pm
  • Location: Level 41, 385 Bourke Street

Refreshments will be provided, but please RSVP ahead of time. I’ll post slides after the talk…


We (John Azariah and Mahesh Krishnan) gave a talk at Tech Ed Australia this year titled Casablanca: C++ on Azure. The talk itself was slotted in at 8:15 am on the last day of Tech.Ed after a long party the night before. The crowd was small, and although we were initially disappointed by the turn out, we took heart in the fact that this was the most viewed online video at Tech.Ed this year Smile – lots of five star ratings, Facebook likes and tweets.  This post gives you an introduction to Casablanca and highlights the things we talked about in the Tech.Ed presentation.

So, what is Casablanca? Casablanca is an incubation effort from Microsoft with the aim of providing an option for people to run C++ on Windows Azure. Until now, if you were a C++ programmer, the easiest option for you to use C++ would be to create a library and then pinvoke it from C# or VB.NET code. Casablanca gives you an option to do away with things like that. If you are a C++ developer and want to move your code to Azure right away, all Iwe can say is “Hold your horses!” It is, like we said, an incubation effort and  not production ready, yet. But you can download it from the Devlabs site, play with it and provide valuable feedback to the product team.

You are also probably thinking, “Why use C++?” The answer to that question is really “Why not?” Microsoft has been providing developers the option to use various other languages/platforms such as java and Node.js to write for Azure, and now they are giving the same option to C++ programmers – use the language of their choice to write applications in Azure. Although there has been a bit of resurgence in C++ in the last couple of years, we are not really trying to sell C++ to you. If we are writing a Web App that talks to a database, then our first choice would probably still be ASP.NET MVC using C#, and maybe Entity Frameworks to talk to the DB. What we are trying to say is that you still need to use the right language and framework that works best for you, and if C# is the language you are comfortable with, then why change.

On the other hand if you are using C++, then you probably already know why you want to continue using it. You may be using it for cross-platform compatibility or better performance or maybe you have lots of existing legacy code that you can’t be bothered porting across. Whatever the reason, Casablanca gives you an option to bring your C++ code to Azure without having to use another language to talk to its libraries.

The Node influence

When you first start to look at Casablanca code, you will notice how some of the code has some resemblance to Node.js. A simple Hello World example in node will look like this –

var http = require('http');

http.createServer(function (request, response) {

                  {'Content-Type': 'text/plain'});
  respose.end('Hello World!');

}).listen(8080, '');

The equivalent Hello World in C++ would look something like this –

using namespace http;

    [](http_request request)    
    	return request.reply(status_codes::OK, 
                      "text/plain", "Hello World!");

Notice the similarity? This isn’t by accident. The Casablanca team has been influenced a fair bit by Node and the simplicity by which you can code in node.

Other inclusions

The proliferation of HTML, Web servers, web pages and the various languages to write web applications based on HTML happened in the 90s. C++ may have been around a lot longer than that, but surprisingly, it didn’t ride the HTML wave. Web servers were probably written in C++, but the applications themselves were written using much simpler languages like PHP. Of course, we did have CGI, which you could write using C++, and there were scores of web applications written in C++ but somehow, it really wasn’t the language of choice for writing them. (It didn’t help that scores of C++ developers moved on to things like Java, C#, and Ruby). What C++ needed was a good library or SDK to work with HTTP requests, and process them.

In addition to this, RESTful applications are becoming common place, and is increasingly becoming the preferred way to write services. So, the ability to easily process GET, PUT, POST and DELETE requests in C++ was also needed.

When we talk about RESTful apps, we also need to talk about the format in which the data is sent to/from the server. JSON seems to be the format of choice these days due to the ease with which it works with Javascript.

The Casablanca team took these things into consideration and added classes into Casablanca to work with the HTTP protocol, easily create RESTful apps and work with JSON.

To process the different HTTP actions and write a simple REST application to do CRUD operations, the code will look something like this:

auto listener = http_listener::create(L"http://localhost:8082/books/");, [=](http_request request)
	//Read records from DB and send data back
});, [=](http_request request)
	//Create record from data sent in Request body
});, [=](http_request request)
	//Update record based on data sent in Request body
});, [=](http_request request)

/* Prevent Listen() from returning until user hits 'Enter' */ 
listener.listen([]() { fgetc(stdin); }).wait();

Notice how easy it is to process the individual HTTP actions? So, how does conversion from and to Json objects work? To convert a C++ object to a Json object and send it back as a response, the code will look something like this:

using namespace http::json;

value jsonObj = value::object();
jsonObj[L"Isbn"] = value::string(isbn);
jsonObj[L"Title"] = value::string(title);

request.reply(http::status_codes::OK, jsonObj);

To read json data from the request, the code will look something like this:

using namespace http::json;

value jsonValue = request.extract_json().get();

isbn = jsonValue[L"Isbn"].as_string();

You have a collection? no problem, the following code snippet shows how you can create a Json array

auto elements = http::json::value::element_vector();
for (auto i = mymap.begin(); i != mymap.end(); ++i) 
	T t = *i;

	auto jsonOfT = ...; // Convert t to http::json::value
	elements.insert(elements.end(), jsonOfT);
return http::json::value::array(elements);

Azure storage

If you are running your application in Windows Azure, then chances are you may also want to use Azure storage. Casablanca provides you with the libraries to be able to do this. The usage, again is quite simple, to create the various clients for blobs, queues and tables the usage is as follow:

storage_credentials creds(storageName, storageKey);

cloud_table_client table_client(tableUrl, creds);

cloud_blob_client blob_client(blobUrl, creds);

cloud_queue_client queue_client(queueUrl, creds);

Notice the consistent way of creating the various client objects. Once you have initialized them, then their usage is quite simple too. The following code snippet shows you how to read data from Table storage:

cloud_table table(table_client, tableName);
query_params params;
auto results = table.query_entities(params)

for (auto i =  results.begin(); 
          i != result_vector.end(); ++i) 
	cloud_table_entity entity = *i;
	entity.match_property(L"ISBN", isbn);

Writing to Table storage is not difficult either, as seen in this code snippet:

cloud_table table(table_client, table_name);

cloud_table_entity entity(partitionKey, rowKey);

entity.set(L"ISBN", isbn, cloud_table_entity::String);


Writing to blobs, and queues follow a similar pattern of usage.



Another one of the main inclusions in Casablanca is the ability to do things in an asynchronous fashion. If you’ve looked at the way things are done on Windows Store applications or used Parallel Patterns Library (PPL), then you would already be familiar with the “promise” syntax. In the previous code snippets, we resisted the urge to use it, as we hadn’t introduced it yet Smile

Also, we have been talking mainly about the server side use of Casablanca, but another thing to highlight is the fact that it can also be used to do client side programming. The following code shows the client side use of Casablanca and how promises can be used:

http::client::http_client client(L"http://someurl/");
client.request(methods::GET, L"/foo.html")
      [=](pplx::task task)
         http_response response = task.get();
         //Do something with response

If you need to find out more about ppl and promises, then you should read the article “Asynchronous Programming in C++” written by Artur Laksberg in the MSDN magazine.

Wait, there is more…but first lets get started

Casablanca has also been influenced by Erlang, and the concept of Actors, but let’s talk about it another post. To get started with Casablanca, download it from the DevLabs site. It is available for both VS 2010 and 2012. At the time of writing this post, the version of Casablanca up on the site does not work with Visual Studio 2012 RTM, and a few code snippets shown above do not work (we’ve been working on a private build). But don’t despair, a new version that works on VS 2012 RTM is coming soon…and we’ll have another post to get you started.

Tech Ed videos

I have been rather quiet on the blogging front for a while, but now that I’ve got the book wrapped up, I thought it was time for an update. I had the pleasure of presenting at Tech Ed Australia in the Gold Coast recently, and thought I’d post the videos of my three talks.

Here are the links to my videos:

Casablanca: C++ on Azure

Building Robust Windows Azure Applications with P&P Guidance

.NET 4.5: Just the Good stuff

The "Casablanca" talk has had a lot of views, thanks to some link love from the C++ team, and being featured on the Channel 9

You can look at all Tech Ed videos here:

Book cover

The scheduled date for the book, Introducing .NET 4.5 that Alex Mackey, Bill Tulloch and I have been writing for the last few months is the 26th of September, and here is the picture of the book cover –

Book Cover

Can’t wait for it to come out Smile