The app uses various algorithms to calculate your friend’s most interesting tweets, providing a daily Atom feed with the top 50. The idea is that you potentially miss out on a lot of interesting Tweets during the day – there’s just too many tweets to read. MissTweets solves this by showing you your friend’s top tweets once a day.

Check out the site.

CSS has advanced so far recently, that I believe it can go some way to replacing Photoshop in the design process. With that in mind, I present YMockup – UI mockups using HTML and CSS.

With YMockup, you can code up a general theme for your site – and then drag/edit/resize elements to your hearts content! It’s really flexible, and you can create any kind of element that your site needs.

The best part of it, is that you can reuse all the CSS and HTML in your actual site – no need to cut up the designs in Photoshop.

Try out the demo here (only supports WebKit based browsers, such as Chrome or Safari).

YMockup Features:

• Customisable for any HTML/CSS
• Edit elements in place
• Drag and drop
• Snap to grid dragging
• z-index control
• Move elements with the arrow keys (hold ctrl)

If you want to use your own themes/elements, clone the repository and follow the README – it’s designed to be used locally, so you can edit the HTML and CSS in your preferred editor.

As you can see, I’ve include the aristo theme – since I’m primarily using this to build Bowline applications.

Of course this won’t be everybody’s cup of tea, and does require a good knowledge of HTML/CSS. However, I believe it’s perfect for design minded hackers, like myself.

• New desktop app framework using wxWidgets, WebKit and Ruby 1.9.
• Improved and faster binding API
• New API for asynchronous Ruby/JS callbacks
• Bundler support
• Background updating
• Loads of fixes and optimizations

There’s also a new JavaScript framework for Bowline which will be released soon. It’s designed to be fairly de-coupled from Bowline – so you can use it for web applications. The idea is that you can share a lot of code between your desktop apps and your web applications.

Additionally I’ve been working on a project for in-memory models called SuperModel.
SuperModel works particularly well inside Bowline apps. Here are the main features:

• Serialisation
• Validations
• Callbacks
• Observers
• Dirty (Changes)
• Ruby Marshaling to disk
• Redis support

I’ve also re-written SuperModel in JavaScript – it’ll be integral to the next Bowline release.

Syncro is another recent project – it’s like Juggernaut on steroids! Syncro let’s you easily synchronise Ruby classes and state between remote clients. It’s also has some fancy features like offline support. You can now make Bowline apps, that function fully offline, and then can synchronize up to your servers (and any other clients) when they come back online.

All that work has made Taskforce possible. Taskforce is a collaborative work manager. Think of it as a cross between Things.app and Google Wave. Here’s a recent screenshot of Taskforce working on top of Bowline on OSX.

If you’re interested, sign up.

There is another way though. Remail is a project I’ve just released that brings REST to email.

Remail proxies emails through Google App Engine:

• To send an email – just send a POST request to your Remail Google App Engine.
• To receive an email – Remail will send a POST request to a callback URL.

It’s that simple. App Engine gives you 2000 free emails a day, and if you need more – the prices are very reasonable.
It’s worth mentioning, that at the moment, Remail only works with Rails 3.

Step 1 – App Engine

So, firstly create a App Engine project:

Next, install the Python developer SDK.

Clone the remail-engine git repository:

git clone git://github.com/maccman/remail-engine.git

Configure the remail-engine application.yaml file, by adding the name of your App Engine project (the yaml key is called application).
Then, you’ll need to configure the settings.yaml file. Specify the public url of your site as outbound_url, and a random string as api_key (you can generate one using uuidgen).

Add the remail-engine to the App Engine SDK and deploy.

Step 2 – ActionMailer

Install the remail gem:

sudo gem install remail

Add add it to your Gemfile:

gem "remail"

Now configure Remail, either in application.rb, or in the environment files:

  config.action_mailer.delivery_method = :remail
  config.action_mailer.remail_settings = {
    :app_id  => "remit-yourappname",
    :api_key => "changeme"
  }

Right, so now we can send email. How about receiving them? We need to specify a callback controller like this:

class EmailsController < ApplicationController
  skip_before_filter :verify_authenticity_token

  def create
    if request.headers["Authorization"] != "yourapikey"
      return head(:unauthorized)
    end
    UserMailer.receive(params[:email][:raw])
    head :ok
  end
end

Remail will send a POST request to that controller when it receives any emails.
If your Rails app isn’t available – Remail will try again and again – backing off as time goes by.

Right, so those are the two steps to using Remail in your application. You can now generate mailers as usual – everything should just work.

There’s a good Railscast on using ActionMailer with Rails 3, and a good Rails Guide on the subject.

Audi have launched a new site for the Goodwood Festival of Speed.

Along with photos and videos, Audi are interacting with their community by embedding a moderated Twitter feed into their site.

Any tweet with the hash tag #audifos is put on a Socialmod queue and, once moderated, is displayed on Audi’s site.

Last weekend was the BET Awards which over 5.8 million people tuned into.

BET ran a coordinated website to the awards, which they updated throughout the ceremony. They also had a ‘Wall of Tweets‘, showing all the Twitter commentary mentioning their awards, and tweets from selected artists and celebrities.

Socialmod did the moderation for all the ‘tweets’, preventing any libelous or objectionable content appearing on their website.

At one stage the top 9 trending topics on Twitter all referred to the BET Awards, so we had many thousands of tweets to process. Their moderators were working throughout the awards to try and get people’s tweets displayed as soon as possible.

We received about 1.3 million hits during the awards, so we had to provision a few more servers. However, our server setup is elastic, which means we easily scaled with the extra demand.

I thought I”d post this as a good example of using Socialmod to moderate Twitter Feeds.

On Thursday, vinspired had a conference called Generation Digital. Participants could tweet about the event, including the hash tag #gendig. These tweets were then moderated, and re-published on vinspired’s site.

Twitter is a great tool for conferences, allowing you to get feedback, even live during a session.

Socialmod lets you specify Twitter search terms, and will then automatically receive new Tweets:

These items can then be moderated like any other:

We then republish a ‘clean’ feed of moderated content, which you can put on your website:

We’ve also had a lot of feedback, which is always very useful because ultimately you don’t know what your customers want, unless they tell you.

Generally we were getting the message that the limits on the plans were too low, people needed to do more moderation.

With that in mind we’ve increased the moderation limit on all the plans, apart from the Basic one, and made all the ‘Automated’ plans (including Mechanical Turk) $10 less.

Here are the updated plans:

Non-automated plans:

Automated plans:

In addition we’ve increased the cap on the free plan from 50 to 100 moderations per month.

This pricing changes will apply immediately, and also apply to existing signed up customers.

The general process goes likes this:

• Comment (i.e. UGC text content) is created
• A POST request is sent to Socialmod, with the text to be moderated and the Comment’s id
• Moderator moderates text
• A POST request is sent from Socialmod to your designated callback url with the moderators verdict
• You then choose to hide/show that item depending on whether you’re doing pre/post moderation, and obviously the verdict.

Firstly, install the gem:

sudo gem install socialmod

Generate your Rails app, and add the gem to config/enviroment.rb;

config.gem "socialmod"

We need to configure the Socialmod library to use your api key.

config/initializers/socialmod.rb

Socialmod::Base.api_key = '00000000-0000-0000-0000-000000000000'

Now we’re going to generate the scaffolding for the Comment model, and install the state machine plugin:

script/generate scaffold comment body:text state:string
script/plugin install git://github.com/pluginaweek/state_machine.git
rake db:migrate

Now to implement the pending, passed and failed states on the Comment model:

app/model/comment.rb

class Comment < ActiveRecord::Base
  state_machine :initial => :pending do
    event :passed do
      transition [:pending, :failed] => :passed
    end

    event :failed do
      transition [:pending, :passed] => :failed
    end

    state :pending, :passed, :failed
  end
  named_scope :passed, :conditions => {:state => "passed"}
end

And now we’re going to add the Socialmod specifics to the Comment model.
After the comment is created, the comment text is sent to Socialmod.

app/model/comment.rb

after_create :create_on_socialmod
def create_on_socialmod
  Socialmod::Item::Text.create(
    :data => body,
    :custom_id => id
  )
end

Now generate the callback controller. Below you can see we’re finding the comment, and passing or failing it based on the callback’s verdict.

You’ll also notice we’re skipping the verify_authenticity_token method. We don’t need XSS protection here (since we’re checking the signature of the callback – verifying its identity).

app/controllers/callback_controller.rb

class CallbackController < ApplicationController
  skip_before_filter :verify_authenticity_token, :only => :index

  def index
    callback = Socialmod::Callback.new(params)
    unless callback.valid?
      return head(403)
    end

    comment = Comment.find(callback.custom_id)
    if callback.passed?
      comment.passed!
    else
      comment.failed!
    end
    head 200
  end
end

How does Socialmod know which callback url to use?
Well you need to specify it in the settings:

Unfortunately the callback aspect of it makes testing locally difficult – that’s something that should be tested in the staging environment.

And that’s really all there is to it. You can choose whether or not you want pre-moderation by showing/hiding comments in the pending state.
One nice touch you could add is to only show pending items to the users that created them, so they can get some instant feedback.

The next blog post will show you how to use images with Socialmod.