I’m a big fan of AWS, and every year I get super excited about a new technology/service they release. Last year, I spent too much time marvelling about the simplicity and beauty of AWS Kinesis. And in the meantime, I’ve been applying the same principle on a smaller project I’m working on.

But this year I was stoked about AWS Lambda. AWS Lambda is a “compute service that runs your code in response to events and automatically manages the compute resources for you, making it easy to build applications that respond quickly to new information”. This is a perfect match for the event-driven and micro services way of thinking that I’ve been learning to love more and more.

But after skimming through the documentation, I’ve realised that the only supported runtime is Javascript (via Node.JS). I’m sure they will expand this support in the future, but I wanted to use it right now. Since in the meantime I’ve also been experimenting with Go lang, I wanted to find a way to run Go code on AWS Lambda right now.

Fortunately, it’s well known that you can statically cross compile your Go binary. This means I could generate a x86_64 Linux binary on my OS X system, and include it in the Lambda function distribution.

Just uploaded a cross compiled Golang binary to AWS Lambda and called it from the node.js function: it works flawlessly #happy #hack

— Ruben Fonseca (@rubenfonseca) November 21, 2014

So first of all, cross compile your Go app:

1
2
3
4
5
6
7
8
9
10

package main

import (
  "fmt"
  "os"
)

func main() {
  fmt.Printf("HELLO FROM GOLANG WITH ARGS %v", os.Args)
}

1

$ GOOS=linux GOARCH=amd64 go build test.go

This will generate a test binary compatible with AWS servers. The only supported way of running AWS Lambda functions is still Node.JS. That means we still have to write a quick Javascript module to fork to our binary:

1
2
3
4
5
6
7
8
9
10
11
12
13

var child_process = require('child_process');

exports.handler = function(event, context) {
  var proc = child_process.spawn('./test', [ JSON.stringify(event) ], { stdio: 'inherit' });

  proc.on('close', function(code) {
    if(code !== 0) {
      return context.done(new Error("Process exited with non-zero status code"));
    }

    context.done(null);
  });
}

Now you can follow AWS Lambda instructions, create a .zip file with both the Go binary and the JS file, upload and invoke it. At the end, you can see something like this on Cloudwatch:

So while you wait for AWS to add more runtimes, have fun with Go today :-)

Dropbox Sync for iOS

I can’t count how many people requested this module. It seems that syncing files between devices is very common problem that people want to solve. When I saw the Dropbox Sync had come out with a new SDK for doing that, I decided to start working on it.

The module allows you to have your own private Dropbox inside your iOS application. The Sync module takes care of syncing all your data with Dropbox through a familiar, file system-like interface. It’s like giving your app its own, private Dropbox client.

The Sync module handles all the caching, retrying, and file change notifications. Writes are local so changes are immediate. The Sync API syncs to Dropbox behind the scenes. The Sync module lets your app work great even when offline and automatically syncs when it’s back online.

The module starts with a free 15 days trial . If you’re still undecided to try it, look at what the people are saying about my other modules :)

Urban Airship

There’s already an Urban Airship module on the Marketplace. However, I client got in contact with me because it was not happy with the existing module. It mainly lacked usefull features like Location management, In-App-Purchases and Subscriptions!

The new module is available here. It’s also my first monthly subscription module.

iOS6 Social Framework

After the success of my iOS5 Twitter module, I’ve released the new Social.framework module for iOS6 or later devices! You can now directly post to Twitter, Facebook and Sina Weibo. Also, you can integrate with their APIs and not worry about signing requests and parsing responses.

The new module is available here

If you like the new modules, please don’t forget to rate them :)

You will find the forum here. Thank you for participating!

Warning: I will assume you are using Ruby on Rails as the server backend.

Integrating backbone.js libraries

Backbone.js is often used with underscore.js, and I actually use the later a lot. So the first thing I do is to install backbone and underscore under Resources/lib directory, and import it on my main.coffee file.

Now the thing is, Backbone is pure Javascript and by default has no idea on how to make a HTTP call, besides using jQuery for AJAX. So I dug a little on the internet and found a Titanium compatible Backbone.Sync module that you can see on this gist. This version uses Ti.Network.HTTPClient to proper transmit the HTTP requests.

Making Rails accept the HTTP POST data

Now that my Titanium App knows how to make proper HTTP requests, I have another problem. During my tests I couldn’t make Titanium send the model’s attributes in the correct format for Rails to recognize them. Somehow Rails is supposed to accept the body encoded as JSON but I never got it to work. Also, I found no way of sending Files (TiBlob) to Rails without using my custom solution (how do you encode binary data on JSON?).

So I needed to invent a way of formatting the model’s attributes using Rails’ standards. You’ve probably noticed that on line 28 I call model.toParams() if I’m sending a POST body. So I hacked a quick way of generating Rails compatible attributes, and extracted into a class called QueryStringBuilder:

This class uses underscore calls to detect variable types, and should handle most of the basic types on your application. It should handle nested attributes too, and notice that when an attribute is a file (TiBlob) it just passes the object down the stack, because later, the Titanium HTTP module will handle it and encode on the POST body.

Defining a Backbone model

So armed with the previous tool, I could for instance write a Backbone module to handle blog posts like this:

Binding to Titanium Views

So with the previous mechanism, it’s very easy to tie Backbone Models to Titanium Views. Remember the way I did ViewControllers on part 1? Let’s build one that manages blog posts using a TableView:

So a simple fetch and massage the data to fit the tableview. Nothing fancy so far right? Now the best part comes when you’re showing a Post model:

Notice line 16 and 17. We are literally binding the model attributes to a view (in our case, a row). So imagine that for some reason, you change the title of the post (by doing @post.set({title:"foo"})), Backbone would trigger the change, and the table view row would automatically display the new value! For instance, imagine an Edit button that shows a drill down view controller to edit the post. As soon as you change a value on the model, the parent view will be updated! That for me was plain awesome when it worked for the first time.

So by using this method, all I have to do is to bind model attributes to Titanium views, and all changes are automatically propagated to the correct places! Using this setup saved me a lot of time and code writing REST applications with iOS and Titanium.

Now this blog post is getting big and there are some things I didn’t talk, like how to save models on our Rails backend, and how this setup works on Android (hint: it does work!). Maybe I’ll leave that and a few tricks for part 3? :-)

I’ve just published a new iOS Titanium Module on the Appcelerator’s Marketplace: Sincerely for 9.99 USD. It integrates with the Sincerely SDK and allows you to send greeting cards to the people you care about most.

The Sincerely Ship Library for iOS makes adding photo printing and postcard functionality to your app as easy as including a library. Sincerely will handle printing, delivery, billing and customer support. Your users will get a physical product they’ll love & you’ll extend your brand and monetize your app.

Main features

• Add print & ship functionality to your app in under 1 hour.
• Monetize your app; earn 70% of purchase price above 99 cents.
• Leverage Sincerely Inc.’s global printing and user network
• Spread your brand; each printed postcard has developer branding area.

Sponsored by Jim Carter III

I also want to publicly thank Jim Carter III for sponsoring the development of this module. Thank you!

This is part 1 of this post. I will cover how I use CoffeeScript with Titanium and automate stuff. On part 2 I will talk about how Backbone.js was the best thing I could add to my Titanium project… yet :)

CoffeeScript

I personally dislike the Javascript syntax, and although I don’t think CoffeeScript is the holy grail, I think it does a pretty good job of hiding the pieces I hate. I really feel 2 or 3 times more productive when writing CoffeeScript. So I had to integrate it with my Titanium projects.

OTOH, I only use Titanium Studio when I really have to. Otherwise, I do my daily code on the CLI with Vim and tmux. That meant I had to come up with a solution to run Titanium projects from the CLI. I quickly found some random Gist with the instructions to do that. (some weeks ago, Matt Apperson launched his MakeTi tool too, it is worth checking out).

So I wrote a Rakefile. You’ll notice it’s a very lazy one, because most of the values I hardcoded could be derived by inspecting the XML files on the project. But it does the basic job.

Wiring it

So you’ve noticed the coffee command on line 19? That’s where the magic happen. So let me quickly explain how I organize the skeleton of an app. I useually create an empty Titanium project, add the Rakefile, and then create the following structure:

Let me break files 1 and 2 individually:

1 - app.js

This will be the only Javascript file I will need to write. The contents? Just create the main namespace for the app (more on that later) and include the generated main.js file!

The Resources/js/main.js file is derived from the coffee/main.coffee fill we will now write.

2 - main.coffee

On this CoffeeScript file, I start by including other classes that I will need, and bootstrap the application. Example:

So the final question is, how do I create and manage a “view controller”?

Building View Controllers

I love to use CoffeeScript classes to build “view controllers” around a window. I usually build a class for each window, and some times one class for each specialized view. A typical view controller class would be like this:

So notice how I encapsulate the logic into one class, and then store a reference to the class on the global app scope. This is probably bad practice because of CommonJS and stuff, but I found it is the best compromise for me, and it makes me really focus on the code itself.

So what about modules, Backbone.js and network operations? Stay tuned for part 2 of this module where I talk how I use Backbone.js for REST operations and view bindings.

UPDATE: Part 2 is online

OTOH, you may be noticing there is a new section on the top of this blog called Hire me. Since sometimes I have free time on my freelance work, I created that central point where potential clients could contact me and see my status.

Since for now there isn’t any type of notification system, please bookmark that page if you’re interested on working with me.

This is the full Dropbox SDK module for Titanium Mobile applications. This is ONLY FOR iOS DEVICES (iPhone/iPad). It implements the full Dropbox SDK API in a clean JavaScript way.

Included with the file there is documentation and two different Titanium applications where the API is exercised. One of them is a clone of DBRoulete found on the Dropbox SDK, but implemented on top of Titanium Mobile.

I’m using this module in production on two iOS applications, so the module will be maintained.

Recently I found an old but very efficient way of doing that using vim and ctags. The following is a simple screencast where I show how to use ctags to solve that type of problems.

Vim + ctags demo from Ruben Fonseca on Vimeo.

It’s called Map Crowd Reduce and it’s available on github.

This project made into the final SAPO Codebits 2010 programming contest, but unfortunately didn’t win :)

The project consists of a node.js server that starts a HTTP server on port 3000. To start a new computation, you must supply some javascript functions: a split/segmenter function that generates jobs, a map function, and a reduce function.

After that, the system gives you an URL that you can share with anyone wanting to contribute with CPU to the computation. The client side functions are run inside a WebWorker so it never blocks the main UI thread.

With the code there are 2 prewritten examples:

• find the number of primes between 0 and 60000 (brute force)

this uses a brute-force method of testing if each number is a prime, from 0 to 60000. it runs very fast and can be used to debug.

• find a MD5 collision with the MD5 on all words with 5 or less alfa words

this lasts 15 minutes on a single machine. when I tested it on the main stage, 50 people connected their browsers at it lasted like 20 seconds (#win).

We are currently trying to write a parallel Mandelbrot fractal using map reduce :) it will be awesome.

Finally, I couldn’t have built this project without the help of some friends.

TwitterRSSLinks is a Twitter (OAuth) service that filter all your timeline tweets that contain HTTP links, so you can aggregate and watch them later and so on. The website outputs the tweets in a variety of formats including JSON, RSS and ATOM.

Version 1 was shutdown because I had no plan for monetizing the service, and at the time, there was a good alternative. Now the alternative is dead and Twitter UserStreams is in Beta.

There’s a good excuse to learn node.js. :)

Without further ado, here’s version 2 architecture (sorry for the quality, I am definitly not a drawing guy…):

The site is completely free, and now beneficts from the real-time user-stream feeds. Also, I’m using pusherapp for the first time, just in case you are on the browser and a new tweet arrives :)

The live website runs on a EC2 Micro instance, and I will definitly open the source in the near future. Happy tweets :)

Gowalla spots Google Maps Mashup [http://gowallamaps.heroku.com]

It tries to use HTML5 geo location to get a position on the map (defaults to somewhere on USA). Probably best used on the iphone (tried on a friend’s Android and it failed :S). Screenshot:

Simple hack, and a reminder for Gowalla to open up their API :) Thnks @pengwynn for the awesome gem :)

The protocol originally targeted the Atom XML Standard, via an extension. Later, some work has been done on standardizing a JSON format too.

With that in mind, I’ve tried to implement a Ruby parser that defines a common API to access both the Atom and the JSON specification. Is is now available on github and also as a Ruby gem.

Here’s a simple demonstration on how it works. We take the excellent Cliqset feed proxy and get an activity streams annotated Twitter Atom feed:

The JSON API is very similar. Some documentation is up on rdoc.info and it is worth checking the spec too. Have fun :)

• it is my first Ruby C extension ever
• it is my first OpenCL approach ever
• it is my first MacRuby hack (ever)

With this in mind, don’t expect real world usage from this code, nor that it will get merged into upstream: it was just written for fun!

The MacRuby branch with the changes is located here

Example

The hello world on OpenCL is probably “calculate each element’s square on a given array”. The code below shows how this can be done in MacRuby:

This code runs the same computation on all available OpenCL devices on your hardware. The results on my hardware (2 GPUs, 1CPU) are:

It was fun, and maybe it can inspire someone :) The OpenCL API is kinda complex and I’m not sure if there’s a good way of making it Rubyish enough. Suggestions are welcome! Have fun :)

I was tired of hearing about one of the new innovation in HTML5: the WebSocket API.

After reading the excelent blog post about WebSockets and Ruby by Ilya Grigorik I got inspired by this experiment which is a simple example of a twitter-to-browser usage of websockets.

Since the excelent em-websocket was available on github, I decided to write my own “from twitter to the browser” real time updates, with no polling.

You can check the final result on my github repo.

General overview

Twitter Stream API → Filter → RabbitMQ → AMQP → Eventmachine → WebSocket → HTML5 Brwser

Too much buzzwords? Lets look at some code.

Filter

The filter is responsible for eating the Twitter Stream API and puting the tweets on a queue (RabbitMQ in my case) using AMQP:

Pretty easy right? Notice I am using a fanout exchange, which will allow me to broadcast the same message to all queues (clients) latter on.

Server

Now we just need to build a server that accepts websocket connections, and for each client deliver each message that arrives on the fanout exchange. The code will make this clear:

So simple, yet so awesome!

Client

The client just have to connect the websocket, and for each JSON piece that arrives on the socket, present them on the screen:

It seems we’ve ended writing almost more JS than Ruby :P Note that I’ve only tested this on Webkit nightly and latest Google Chrome beta for Mac.

Overall it was a great and easy experience building this simple system, but it allowed me to realize how simple we can build scalable push systems with the WebSocket API!

update: seems like Ilya Grigorik liked it :)

Well, fell no more! Enter the VoIP world!

Betamax created lots of providers specialized in VoIP. Although almost all of them offer free calls to Portuguese landline numbers, I never realized how competitive they were on the mobile side.

So I dig a little, and found some pretty competitive Betamax VoIP providers:

• 12voip.com – 4.5 cent/min

• voipraider.com – 5.0 cent/min

• webcalldirect.com – 6.0 cent/min

The best thing about these providers is

• No required monthly payment

• You can use your own phone number as Caller ID (so people still answer your calls).

• They all support the SIP protocol (great for non-windows users like me)

• Same price for all the mobile operators (so you can jump the wall garden)

I hope that this information helps you lowering your phone bill. Spread the word, and maybe your mobile operator starts lowering the prices too!

Recently, I discovered they have a softphone like system called Webphone (Windows only), that allows you to place and receive calls, SMS, MMS, and other stuff, right from your computer.

My first thought was “this must use some kind of SIP service”. Since the SIP settings are not posted anywhere on the internet, and I don’t want to use Windows to use their client, I decided to dig deeper and try to find the SIP configurations so it can work on any regular softphone.

Although it was easier than I thought (Wireshark, I love you), there is one serious limitation that I couldn’t solve without hacking some open source code. Anyway here’s the main settings:

Optimus Tag SIP settings (to use with a SIP softphone)

• server address: sip.optimus.pt
• username: 351 your number@sip.optimus.pt
• password: your webphone password
• SIP proxy: asbg.sip.optimus.pt
• User Agent: Optimus-SoftPhone/7.0.1.4124

Now, the last item is the worst part. If you don’t specify a User-Agent that starts with Optimus-SoftPhone, you’ll receive a “403 Forbidden User Agent” message. I tried to find a SIP softphone that allowed me to change the UserAgent but didn’t found one (I didn’t try hard).

So I decided to take the Twinkle open source SIP client, changed the hard coded User Agent, and got surprised when it worked flawlessly from the first time! I tried placing and receiving calls and it worked perfectly :)

If you’re interested on the trivial patch (I used Twinkle version 1.4.2) you can find it here.

If you know a SIP client for OS X or Linux that allows me to change the User Agent, don’t hesitate to comment bellow!

Ruby library to whit.me service API

whit.me is a wonderful service to shorten URLs. They have a public API, and I wrote this library that allows you to use the service in the middle of any Ruby script.

The project is available here. It is compatible with Ruby 1.9 and JRuby, and contains a full RSpec test suite.

newzbin XMPP search agent

After spending some time learning XMPP, I decided to try it and build something useful. So I hacked a simple search agent for the newzbin website to be used by me and my friends. It is poorly written, but it works.

Maybe you can learn something from the simple example. In case you’re interested, the code is available again on github. It uses the XMPP4R gem and CouchDB (overkill, I know).

Feel free to comment on any of the code and send me suggestions on how to improve it.

“The designer of this algorithm built a backdoor into the code. Decryption is a piece of cake if you know the override codes.”

Five seconds later, the file is decrypted :)

I guess Bruce Scheier, the author of the original cipher, should not be happy to hear this on a TV show :P