Jordi Romero

Radical startup

2013-07-17T10:00:00+00:00

This talk was presented in the context of Radical Benasque, a conference to explore the limits of your mind and body, where we discussed subjects such as Radical Brain (neurobiology), Radical Food (innovation in cuisine, evolution of food), Radical Science (quantum physics), etc.

Control your life

2013-05-06T10:00:00+00:00

This video was recorded during the presentation at itnig’s fridays in May 2013.

Metrics for Pirates!

2013-02-15T10:00:00+00:00

Lean Startup & Science

Defining a strategy for a product startup is both exciting and hard to do objectively. Most of the times the founders are guided by instinct and passion, and that’s great, but can lead to follow false hypothesis.

The Lean Startup is this whole movement and set of best practices that can reduce uncertainty by making the founders validate their hypothesis one after the other. It’s all about validated learning, which means applying science to decide if the company is going in the right direction.

And by science I mean metrics.

The video

This week I gave a presentation in the Barcelona Lean Startup Circle titled Metrics for Pirates. Itnig was kind enough to record and upload a video, so if you don’t feel like reading you can watch it here. Not even half an hour.

But moving on our subject, we were talking metrics…

Actionable metrics

The secret to make smart and fast decisions in a startup is having metrics for everything. Actionable metrics. An actionable metric is one that tells you that some relevant business indicator (revenue, I’m looking at you) will increase by a known factor if some strengh is applied. This means that if you have a 2.0% conversion rate and you can increase that by 20%, your revenue will be affected proportionally. Of course there are variables that affect this formula because the whole process is not rigid, but you get the point.

Customer Acquisition Funnel

Another concept to talk about before going to the actual metrics is the Customer Acquisition Funnel. We’re talking business here. And specifically we want people to pay money for stuff. Let’s call these people customers. I wish there was a tree that grew customers, but as far as I know, there’s no such thing. So we have to go get them. Out in the wild.

There are many kinds of customers and many ways of finding them and converting them into paying customers or any kind of revenue-generating users. We’ll not get dirty discussing them, though I’d love to hear from you if you want to discuss any specific case.

Here’s where I say: AARRR! Acquisition, Activation, Retention, Referral and Revenue. That’s what you do to your customers in order to make your business work.

I hope the image next to this paragraph is clear enough, but in case it’s not:

Acquisition is where you get the attention from somebody in your customer segment. Let’s say you get him to visit your landing page.
Activation is when you make this user not regret his visit. She likes what she sees. She’s happy. She clicks through your links (if you know what I mean). She signs up for a newsletter, free trial, WHATEVER.
Retention is when this user shows repeated interested in your product. Either by coming back to your website a couple of times a month or by keep using your free trial, opening the newsletter, reading the RSS feed, …
Referral is a little bit out of the loop, because that’s when you get your best users (the promoters) to recommend your product to other users. This one is a sexy one.
Revenue is when you generate money out of a user/lead/visitor or however you call the people in your funnel. If referral is sexy, this is getting laid.

So there’s your funnel, pirate. Go make money with it. I’ll warn you: this funnel is leaky. And your job (as a CEO, founder, or whatever kids call themselves this days) is to patch the leaks and oil the machine. You want big volume at the beginning of the funnel and high conversion through it.

Acquisition

Acquisition is the first step in this process. It means feeding the funnel so you can afterwards convert these people into revenue (paying customers, revenue-generating users, …).

How to get people into the funnel? Ask your marketing guy. A few concepts that should ring a bell: SEO, SEM, PR, E-mail marketing, Social Media, Affiliation platforms…

How to measure each of these channels? Try to segment well and go deep in the funnel, then measure the revenue each of them is generating. That’s the best way to set the dollars per user for each channel. Also, keep in mind that good channel is one that can give high volume, high conversion and low cost.

Activation

Once you get someone’s attention, you better keep it. So create killer landing pages for a product with killer features. You need to make the user happy about finding you.

How do you measure this happiness? Depends on the business, but bounce rate (or the lack of it), visit duration, usage feature, newsletter subscription, free trial signup, etc. are a few examples of activated users behavior. Tools like A/B test are really valuable in this step. Don’t abuse them, remember to look at statistical significance, use it in conjunction with your common sense and do short cycles. My favorite tool here is Visual Website Optimizer.

Also, remember tagging your users (via URL, via your own custom system, whatever) so you can then look deep down in the funnel and see what version of the split test is working better, etc. Most of the analytics systems that we’re going to use understand Google’s way of tagging links.

Retention

They say it’s cheaper to keep a customer than to get a new one, and they both generate the same amount of revenue. And, true story, most people often forget to take care of their own user/customer base. How do you measure people using your product or staying as a lead for a long period of time? Repeated visits (% of users that come 3 times a month to your website), active usage of your software-as-a-service, open-rate in the weekly newsletter, RSS feed view-rate, …

If you can get your user’s e-mail, do it! Then use some e-mail marketing software such as Mailchimp. With Mailchimp you can nourish a user database that you can use for your weekly/monthly newsletter but most importantly you can setup Autoresponders that will let you automate e-mails given user behavior patterns such as: days of inactivity (one after 3d, 7d, 1m, …), key feature usage (or the lack of), and many other creative ways of ensuring your users are doing what you want them to do.

If you don’t get our user’s e-mail, then you can try with Google AdWords remarketing/retargeting campaigns. You should of course track all this activity through Google Analytics or KissMetrics.

Referral

Who doesn’t want their product to go viral? This is in itself a science or an art, I’m not sure, but we’re not going deep in this subject here. Maybe it deserves its own article. Quick tips: don’t try to go viral unnaturally. If your product rocks, it will go viral organically. If your product has some kind of virality in its nature, then try to enhance it by offering your promoter users (people who would vote your product with a 9 out of 10) the right tools to spread the word. Don’t push virality tools or reward programs to just everybody, that could go against you.

Revenue

You made it! Someone’s willing to pay you money, or do actions that will lead to revenue indirectly (such as: active readers in a publication that makes money via Google AdSense or other usual suspects).

There’s nothing for me to tell you about your revenue strategies or how to measure it, because I don’t know your business, but, remember, measure everything, segment your revenue reports by user acquisition channels, user behavior, etc. Then try to put more efforts in the best performing channels or try to fix what’s wrong with the others.

Enjoy!

The big-ass flag

You see the little guy holding a big flag? She’s the CEO. She has a great team of 1 to tens of people working real hard to deliver great product to a huge customer segment with a growing market. Who doesn’t.

Good news is that now she knows what business indicators (our old friends, the metrics) should be following and basing her decisions on. Bad news is that this alone is a full-time job. And as the company grows CEOs have to delegate work and responsibility to new executives. Delegating the ownership of these metrics is crucial. In this example I wrote possible departments that could own each metric. Read Marketing, Product, Growth Hacker™ (f*ck yeah buzzword), Biz Dev, …

So go build a dashboard with all these metrics and try to make all your decisions as data-driven as you can. And if you’d like to discuss your particular company or how does all this thing apply to it, don’t hesitate and contact me.

Credits: This whole pirates thing is nothing new, Dave McClure has a great presentation about it from back in 2007. If you’re interested in the subject, you should definitely go check him out. All the drawings from this post are carefully done by the author, Jordi Romero, using a Montblanc pen with a black fineliner refill, then scanned and vectorized to give it a more digital look.

Discussion in Hackernews

Create an e-commerce business

2012-11-15T10:00:00+00:00

This talk was presented in Congreso de internet and itnig friday’s events in November 2012.

Google Images in Google Analytics

2012-08-27T10:00:00+00:00

A friend of mine has a soccer blog and I happen to help him with the nuts and bolts behind it. I’m not tracking it 24/7 but some times I like to see how it’s going, and I open Google Analytics to check on its performance, see where the traffic’s coming from and if some post went viral.

One day, organic traffic went up noticeably, and after messing around with Google Analytics I saw that referral traffic went down significantly exactly at the same time! Bummer, I didn’t just nail some SEO trick. Something changed at Google’s end and now that’s messing with my data. That was on July 23rd 2011. After 5 more minutes of investigation, I realized all the traffic coming from Google Images was now being treated as organic search traffic, as before it was always considered referral traffic. I didn’t care much back then, so I left it like that. Mystery solved. I moved on to the websites I was actually working for.

But…

It turns out, one year later, I was again checking on my friend’s blog analytics. And looking at what keywords were bringing the most traffic, I realized there was no way I could segment real SEO effects from this combination of Web Search and Image Search. You can’t create a profile with just the real organic traffic, ignoring what comes from Google Images.

Or at least I didn’t know how to. So I search The Googlez® for half an hour, discussed the issue with a couple of colleagues, and then tweeted asking for help. It turned out the last option gave me an answer.

My friend Ferran Gavin recommended me to use this snippet to track Google Images traffic as its own source.

<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-XXXXXXX-X']);

var ref = document.referrer;
if (ref.search(/google\.([^\/]+)\/(ima?g|.*[?&]tbm=isch|.*[?&]site=images)/i) != -1) {
  var regex = /google\.([^\/]+)\/.*/i;
  var match = regex.exec(ref);

  if (ref.search(/[?&]prev=/i) != -1) {
    regex = /[?&]prev=([^&]*)/i;
    var match2 = regex.exec(ref);
    _gaq.push(['_addOrganic','images.googleSerps','q',true]);
    _gaq.push(['_setReferrerOverride', 'http://images.googleSerps.'+match[1]+unescape(match2[1])]);

  } else {
    _gaq.push(['_addOrganic','images.google','q',true]);
    _gaq.push(['_setReferrerOverride', 'http://images.'+match[0]]);
  }
}

_gaq.push(['_trackPageview']);

(function() {
  var ga = document.createElement('script'); ga.type = 'text/javascript';
  ga.async = true;
  ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www')
         + '.google-analytics.com/ga.js';
  var s = document.getElementsByTagName('script')[0];
  s.parentNode.insertBefore(ga, s);
})();
</script>

Source: Google Products / Analytics Forums

After reading the code, it’s obvious that it doesn’t only track Google Image’s traffic as its own organic source, but it also adds a different source for Google Image SERPS (the little boxes of images embedded in a normal Google Search Results Page). Useful trick.

I trust that guy’s SEO knowledge, so I just added the code to my friend’s blog after making sure the Javascript made sense, and then waited a few days to see how it worked.

After those changes, nothing actually changed, except that I started seeing the Source field in the Search / Organic report as google, images.google or images.googleSerps depending on where the traffic was coming from.

Finally, I can now create separate profiles for normal organic search traffic and for Google Images traffic. This is how I created a filter to show only traffic from Google Images (both normal and SERPs):

You can just use one filter and because the Filter Pattern field is a regular expression, it will match both.

I hope this article is useful for people with the same problem I had. Surprisingly, this solution is not easy to find on Google. It took just a minute thanks to Twitter and Ferran.

WAT Driven Development

2012-03-14T11:00:00+00:00

Yesterday @masylum showed me watbutton.com and after playing with it for 2 minutes we couldn’t help it: We needed WATs in our development tools ASAP. Read: Replace the Terminal bell with a WAT.

Imagine hearing Gary Bernhardt’s voice each time you hit an extra key by mistake. I no longer hit <Esc> more than once to exit insert mode in vim, because the second time I’d hear: WAT? What the fuck are you doing hitting escape again if you’re already in normal mode? This is the path to perfect typing.

Now, if you also want WATs in your Mac:

Grab your favorite WAT. Three of them are available at watbutton.com (look at the source). The one I like best is this one.
Convert it to a compatible AIF file. Follow these steps or just save yourself some time and use mine.
Copy the file to ~/Library/Sounds
Select it in System Preferences » Sound
Make sure you have your bell enabled in your terminal app. Most people disable it because they don’t master the art of precise typing, but this was before they knew about WAT Driven Development.

PS: My only contribution to WAT Driven Development was putting things together. Gary Bernhardt is an awesome dude who makes a living with his advanced programming screencasts and his WATs traveled around the interwebs thanks to his lightning talk. Noah Kantrowitz did watbutton.com. Pau Ramon showed it to me and got me excited to do the actual thing. He blogs here.

You can comment on the Hacker News entry.

API design and more

2011-12-01T12:00:00+00:00

This is the description (and slides) from the talk I gave at the toster.ru conference in Moscow.

The main point of the talk is to go through every major design decision around API design, so both API producers and consumers know what to offer or expect from a well designed REST API.

REST APIs are essential in any modern web application. It’s currently a trend not to build Web Apps but Platforms. A good REST API is the core of the platform, where web apps, mobile apps, 3rd party integrations, etc. can just use as its brain.

Some of the concepts the talk goes around are: HTTP, REST, URI, metadata, representations, security, versioning, pagination. These are all relevant aspects of a good REST API design. After that, some tips about implementation and deployment are thrown to the mix. Finally, scaling is mentioned as a key challenge a successful API will find. Horizontal scaling, HTTP cache, application cache, database replication and asynchrony are mentioned as possible methods to help the scaling of an API, although the design will still carry most of the responsability to decide if an API can scale easily or not.

Watch the talk dubbed in Russian:

Download the PDF or see it embedded here:

Teambox: Starting and learning

2011-11-17T14:00:00+00:00

Slides from my talk at the Barcelona Developer Conference 2011.

Stop being Paranoid, be Immortal

2011-01-16T13:00:00+00:00

A while ago, Saimon and I started upgrading Teambox to Rails 3. Once we got a bootable application (more on that in another post) the first big problem we faced was acts_as_paranoid. Its internals are a mess, so there was no chance we could just fix that for Rails 3. We decided we would just write a brand new gem that shared the API as much as possible.

The main goals were: implement almost the whole API from acts_as_paranoid (this way the impact of replacing it in Teambox would be minimal) and make it as small and lightweight as possible. We are true BDD believers, so we started writing a spec for what we needed. After that, writing the code was quite easy.

In our way, we changed some assumptions from acts_as_paranoid, such as the need of storing when a row was deleted. Because of that, we no longer needed a deleted_at field but a boolean deleted field. This change demands a migration:

class MigrateParanoidFields < ActiveRecord::Migration
  def self.up
    add_column :users, :deleted, :boolean
    add_index :users, [:deleted]
    User.update_all ["deleted = ?", true], "deleted_at IS NOT NULL"
    remove_column :users, :deleted_at
  end

  def self.down
    add_column :users, :deleted_at, :datetime
    add_index :users, [:deleted_at]
    User.update_all ["deleted_at = ?", Time.now], ["deleted = ?", true]
    remove_column :users, :deleted
  end
end

While doing all this, at some point I regretted changing the deleted field to a boolean, because it looks like every relational database out there decides to implement (or not) their own boolean data type. This is where Arel comes handy, because you can just do something like this:

default_scope where(arel_table[:deleted].eq(nil).or(arel_table[:deleted].eq(false)))

Although there has been discussions about the convenience of using default_scope for anything other than order, it just feels right to do it in this use case.

To sum up: the code is available at github or just as a Ruby Gem. Please feel free to contribute, Charles already did it!

I did it again!

2011-01-10T01:00:00+00:00

I said it once already, but I’m going to talk about the same thing today. I enjoy rewriting or reimplementing blog engines. Most definitely more than writing blog posts.

The last time I did that, I kept the design and went from a sinatra app with database backend to a git-backed engine (a fork of Nesta).

This time, i kept absolutely everything (design, html, feed, sitemap, about pages, etc.) but went to the static site generator Jekyll. The goal was to make this change transparent to the (possible) readers, search engines and feed subscribers would never notice the change, except for this post. In the last migration I moved all the blog posts to Markdown files, this was very nice, because I love formatting text using that markup language, and I still use it with Jekyll. The worst part were the haml and sass files. There’s no support for haml or sass on Github Pages (the generator I’m using to host this blog now), so I had to go back to plain CSS and HTML. This made me sad, but I definitely wanted everything in the same place and without using weird deployment strategies. Just git push for both posts and layout modifications. Github pages were the answer, so the move back made sense to me.

Other than that, I just had to replace some haml/erb/builder files with plain html/xml using Liquid and make sure everything was smooth again.

Thanks to the awesome Github pages service, all I had to do is push to github.com/jrom/jrom.github.com and wait a couple of minutes.

Enjoy!

Super simple authentication in Rails

2010-05-07T18:00:00+00:00

Here comes another short but (hopefully) useful Rails trick. In my client applications I often need to do some protected section to do backoffice stuff or similar. Sometimes I need a fully featured authentication system, then usually use Authlogic (although I’m willing to try Devise). Some other times you just need to hide a page to the public, and one password just works. And like everything in Rails, there’s a quick way of doing that.

All you need is some controller code to protect the private pages and some code to check the credentials. The easier way is not even creating any HTML code for that and take advantage of the HTTP Authentication. Here’s what I do in app/controllers/application_controller.rb:

helper_method :logged_in?

def logged_in?
  session[:login]
end

private
def authenticate
  login = authenticate_or_request_with_http_basic do |username, password|
    username == "username" && password == "password"
  end
  session[:login] = login
end

def do_logout
  session[:login] = nil
end

And now all it takes to force the user to authenticate for viewing some action, you just need to add a before_filter in that controller. It may look like this:

class NewsController < ApplicationController
  before_filter :authenticate, :except => [:index, :show]
  # ...
end

Here we are allowing public access to list and show a New but we are restricting all other actions (for example, creating, editing or destroying News) unless authenticated, but that’s getting offtopic.

As a small extra, there’s a helper method useful to show or hide special menus or something in the views, just put any private html inside an if logged_in? ... end.

That solution was really quick, but not very elegant. We don’t want our credentials hardcoded into a controller, and sure we don’t want our password in clear text! One better solution would be to use a config file and hash the password, replacing the comparison line with this one:

username == APP_CONFIG['username'] && Digest::SHA1.hexdigest(password) == APP_CONFIG['password']

And of course storing this two variables in our config YAML file. To create the hashed version of the password for the config file the easiest way is by using the Rails console or just irb, and use the hexdigest method shown here. This will provide a quick but nice solution to our private sections.

Gmail in Mutt

2010-04-30T18:00:00+00:00

Mutt is an open-source (GPL) text-based mail client for Unix. It may not be the best client if you receive a lot of messages formatted with HTML (most newsletters or good spam are), but it’s a nice program to know, because some day you may feel more hacker and want to use it.

To use Mutt, you must first install it. But that’s too easy: it’s on every package management system after that weird name: mutt.

Before touching Mutt, you must enable Gmail’s IMAP for your account, going to Settings → Forwarding and POP/IMAP → Enable IMAP. Like this.

After that comes the only tricky part: configuring Mutt to check your Gmail’s IMAP Inbox and send emails through Google’s SMTP server. And I already did the research on what’s needed to this. I’m using Google Apps for my personal domain, and it works exactly like a regular @gmail.com account, with the only difference of the username format. (Google Apps is absolutely a must-have for your domain unless you have some bigger solution).

You need to populate your ~/.muttrc like this:

# Me
set from = "you@gmail_or_your_domain.com"
set realname = "Jordi Romero"

# My credentials
set smtp_url = "smtp://you@gmail_or_your_domain.com@smtp.gmail.com:587/"
set smtp_pass = "password"
set imap_user = "you@gmail_or_your_domain.com"
set imap_pass = "password"

# My mailboxes
set folder = "imaps://imap.gmail.com:993"
set spoolfile = "+INBOX"
set postponed = "+[Gmail]/Drafts"

# Where to put the stuff
set header_cache = "~/.mutt/cache/headers"
set message_cachedir = "~/.mutt/cache/bodies"
set certificate_file = "~/.mutt/certificates"

# Etc
set mail_check = 30
set move = no
set imap_keepalive = 900
set sort = threads
set editor = "vim"

# GnuPG bootstrap
# source ~/.mutt/gpg.rc

Of course you’ll want to chmod 700 ~/.muttrc if you put that kind of sensitive data, or just don’t specify your passwords and will be prompted every time (for example in a non private environment). And you will also need to mkdir -p ~/.mutt/cache before firing mutt.

Using Mutt

Now you can start it by typing mutt in a terminal. Read the Documentation on how to move and use Mutt. The main concepts are similar to vim’s navigation shortcuts.

Encryption with GnuPG

One of the nice things about Mutt is that it has encryption/signing support out of the box. You just need to setup your keys in your environment and it will do the rest. If you already have your key in the ~/.gnupg/ directory, skip to the next point.

As before, you first need to install gnupg with your package management system. After that, you will need to:

# Generate your key
# You can use the default answers
# Choose a strong passphrase
gpg --gen-key

# Generate your Public key
gpg --armor --output pubkey.txt --export 'name'

# Register your public key in a public server
gpg --send-keys --keyserver hkp://subkeys.pgp.net

And you are done. You can share your pubkey.txt with everybody and everybody will be able to send you encrypted mails or check your signed messages.

Besides that, to setup correctly the environment for Mutt, you will have to uncomment the last line of the ~/.muttrc and copy the gpg.rc file to ~/.mutt/gpg.rc.

Now you can fire Mutt again and encrypt or sign a message by pressing the p key just before sending (y). Decryption or signature verification is done behind the scenes.

Feedback highly appreciated

I hope some of you will actually use Mutt and give back to me some tips! Until the comments are on, please use the contact page.

Config file in Rails apps

2010-04-28T23:00:00+00:00

How many times do you find yourself hardcoding something that you now you’ll have to refactor and extract into a config file? But you don’t, because you don’t have that config file, and you don’t want to loose 10 minutes thinking (or the XXI’s century equivalent, googling) a solution. If you are nodding and feeling guilty, continue reading.

In an existent Rails application, just type

rake rails:template LOCATION=http://github.com/jrom/rails-app.yml/raw/master/rails-app.yml.rb

or if you are about to create the app, extend the rails command like this:

rails <app> -m http://github.com/jrom/rails-app.yml/raw/master/rails-app.yml.rb

That wasn’t hard, was it? The code that just ran is so simple that you can go check it. After asking you the name of that config (or assuming the default: app) it will create the YAML file under the config directory and create an initializer to load its content when the application starts. The config comes with a demo variable, defined in the three typical Rails environments: production, development and test. You can use APP_CONFIG['variable'] (if the config name was app) anywhere and it will return the value for the current environment and that variable.

Enjoy it and use the issues section in Github for any comment about the code.

Bonus plus: it’s Rails 3 compatible!

Page caching with Sinatra and nginx

2010-04-28T01:00:00+00:00

I’ve built some small websites with Sinatra lately (this blog itself). And in exactly all the cases I needed page caching, because the content would change once a month, a week, or a day. Page caching is easy, but sometimes you just need some tip. Let’s fix that by giving some simple and direct instructions in order to enable page caching and serving it from nginx:

First of all, we need Sinatra::Cache, the Sinatra extension that will make our life much nicer. You can either gem install sinatra-cache or add gem "sinatra-cache", "0.3.2" to your Gemfile.

After that, you will have to require and activate the extension in a configure block:

require 'sinatra/cache'

module Jrom
  class Application < Sinatra::Base
    configure do
      register(Sinatra::Cache)
      set :root, File.dirname(__FILE__)
      set :cache_enabled, true
      set :cache_output_dir, Proc.new { File.join(root, 'public', 'cache') }
    end

    get '/' do
      "Hi there"
    end
  end
end

As you can see, first we register it, and then set a couple of config options. Actually, I wasn’t able to get it to work in a classic style app (when you just start coding get’s and post’s to the Ruby file, opposed to creating a subclass of Sinatra::Base), and that’s why I’m using the subclass style.

If this is the first time you see a Sinatra application using the Sinatra::Base thing, just remember to have a config.ru like this:

require 'app'
run Jrom::Application

Let’s continue, now we have our Sinatra app performing caching (by default it only does in production environment, check the cache_environment setting to change that if needed). A lot of people would stop here and go have some beers happy with an app that will be creating a cached page in every request, doing actually more work instead of less… That’s lame, but a lot of people does it.

The next but very important step is telling the web server (aka nginx) to serve the cached page if there is some. The following code must be added in the server { ... } block of the nginx config:

if (-f $request_filename)
{
  break;
}

if (-f $document_root/cache$request_filename)
{
  rewrite (.*) /cache$1 break;
  break;
}

if (-f $document_root/cache$request_uri.html)
{
  rewrite (.*) /cache$1.html break;
  break;
}

if (-f $document_root/cache$request_uri/index.html)
{
  rewrite (.*) /cache$1/index.html break;
  break;
}

This code is derived from the one published by Josh Susser on this blog post. His code as is didn’t work for me, if you know why, please tell me.

Now our app is caching and enjoying the cached files nicely. But two small tweaks can still be done:

Add <%= cache_timestamp %> in your layout to print a comment with the timestamp when the page was cached, and add this Capistrano tasks to create the cache directory, link it to shared and flush the cached files when deploying:

after "deploy:setup", "create_page_cache"
desc "Creates the cache dir"
task :create_page_cache, :roles => :app do
  run "umask 02 && mkdir -p #{shared_path}/cache"
end

after "deploy:update_code","symlink_shared_dirs"
desc "Links the public/cache with the shared/cache"
task :symlink_shared_dirs, :roles => :app do
  run "cd #{release_path} && ln -nfs {shared_path}/cache #{release_path}/public/cache"
end

set :flush_cache, true

task :keep_page_cache do
  set :flush_cache, false
end

after "deploy:cleanup", "flush_page_cache"
desc "Empties the page cache"
task :flush_page_cache, :roles => :app do
  if flush_cache
    run "rm -rf #{shared_path}/cache/*"
  end
end

I think that’s enough to get a healthy Sinatra application performing page caching and flushing when deploying. You can also use the cache_expire('/path') to expire pages on some actions (e.g.. when an article is saved), but that’s out of this post’s subject, just read the doc of the extension.

I hope that was useful to somebody, and I encourage you to cache every possible page in your web applications. The performance boost will be incredible.

I like coding blogs

2010-04-27T23:00:00+00:00

As I just mentioned, I’ve been in a passive-aggressive relationship with my blogger alter ego. There are many reasons to that, but one is more interesting to me:

I enjoy more writing blog engines than writing blog posts.

I’ve been using Wordpress most of the time, for which I developed some themes (most of them lost, but I just keep the last two). Then, I’ve coded blog engines in PHP by myself (the source code is lost), using Rails (never finished) and Sinatra (first version using a database and coded from scratch here). I’m sure I forgot some weekend projects done some years ago.

And now, this one. What’s special about this blog? Well, it’s the latest. And the prettiest. And is build as a Sinatra application using Git to store the posts. I discovered Nesta a couple of months ago thanks to the Peepcode blog. I cloned it and built this blog on top of it. I took the look and feel I already designed in my latest Sinatra blog (the one with the database that never got to see the sunlight) and voilà.

Besides from loading all the content from static files (pushed via Git), this blog features an awesome non-existent admin section, some very nice page caching (using the neat sinatra-cache extension by Kematzy) to prevent loading the Ruby stack, a feed and a sitemap. Oh, and the content is formatted using Markdown (almost everywhere) and Haml (where the layout may be trickier). For the stylesheet generation, Haml’s sister is used: Sass. There’s some code highlighting capabilities thanks to highlight.js.

There is one feature I haven’t implemented yet, but will do soon: comments. This blog now is using no database to work, and everything is page-cached when the first request arrives, so a traditional comments functionality would fuck everything up a little… unless I use some service like Disqus or Itense debate. I don’t like these services (if there’s a better alternative, please tell me), so I will have to code some mini-disqus-like web-service to feed my own blog’s comments. I’ll keep you posted.

Hi... again

2010-04-27T22:00:00+00:00

Hi, I’m Jordi Romero. This is a blog, or it’s supposed to be, where I can publish anything I may find useful. The subjects will vary, from programming to computer architecture, or maybe some sysadmin trick that took me all night to find out and want to share to make the world a better place. Time will tell.

I’m trying to have and maintain a blog since 2004! In 6 years I never published more than 20 posts, most of which never stayed online after some months. I started blogging in Catalan, my first language. Later on 2006 I deleted the blog and replaced it with a static CV in the front page (the first screenshot). One year later I started a new version of the blog (the right image) in Spanish, my second language. I published some useful Ruby on Rails tutorials, and an article about my keyboard that got some attention. Sincerely, nothing worth saving or translating to this newer version. Some good and interesting content is out there, and I will write it down.

If you just want to say something to me, make sure you check the contact page.