This first post will include a large-ish number of Erlang links that’s I’m aggregating mostly consisting of existing web frameworks.

HTTP Servers

These are servers commonly used for deployment, similar to Ngnix, Lighttpd, Apache and so on.

• Mochiweb is a very lightweight HTTP server written in Erlang.
• Yaws is a HTTP high perfomance 1.1 webserver particularly well suited for dynamic-content web applications.
• Inets is a container for Internet clients and servers. Currently, an HTTP client and server, a TFPT client and server, and a FTP client has been incorporated into Inets. The HTTP server and client is HTTP 1.1 compliant as defined in RFC 2616.

Web Frameworks

These are actual web frameworks which make developer’s lives easier, similar to Ruby, Merb, Sinatra and so on.

• Nitrogen uses an event-driven model built on top of Erlang pattern matching. Nitrogen allows you to tag elements with any Erlang term, and then act on the tag in server-side code when the user clicks on, hovers over, or otherwise interacts with the element. Catching the event is as simple as writing an Erlang function.
• Webmachine is not much like the Web frameworks you’re used to. It is an application layer that adds HTTP semantic awareness on top of the excellent bit-pushing and HTTP syntax-management provided by mochiweb, and provides a simple and clean way to connect that to your application’s behavior.
• ErlyWeb is a component-oriented web development framework written in Erlang and designed to work with Yaws, a high-performance Erlang web server. ErlyWeb simplifies building database-driven webapps that follow the tried and true MVC pattern using a great language with many outstanding strengths.
• The Erlang Web is an open source framework for applications based on HTTP protocols, giving the developer better control of content management. With Erlang Web’s simple but extensible concept of including dynamic content in pages, libraries of reusable components can be built. Currently it supports INETS and Yaws webservers, but others are planned in the future.
• Chicago Boss is fully asynchronous, using one single process to handle hundreds or thousands of simultaneous requests, and thus it solves the classic c10k problem. All other web frameworks will break down and cry if you ask them to process more than a few dozen simultaneous requests on a single machine. Chicago Boss is built with Erlang, the same platform used by banks and telecoms to achieve unprecendented scalability and (no exaggeration) 99.9999999% reliability.

Other Erlang Projects

This is a list of interesting Erlang projects that i’ve found on the web so far.

• Fuzed is an Erlang-based clustering system designed to let several single-threaded processes (which may or may not be reliable) form
  into a pool which can serve requests to remote hosts. These resources need not be homogeneous, Fuzed breaks them up into homogeneous pools
  internally and serves out requests without “crossing the streams” of different software/versions of software.
• ErlyDTL is an Erlang implementation of the Django Template Language. The erlydtl module compiles Django Template source code into Erlang bytecode. The compiled template has a “render” function that takes a list of variables and returns a fully rendered document.
• EUnit is a unit testing framework for Erlang. It is very powerful and flexible, is easy to use, and has small syntactical overhead.
• Apache CouchDB is a document-oriented database that can be queried and indexed in a MapReduce fashion using JavaScript. CouchDB also offers incremental replication with bi-directional conflict detection and resolution.
• Erlang-AMF is an AMF0 and AMF3 library (ActionScript data exchange).

Interesting Reads

• New Facebook chat feature scales to 70m users using Erlang
• Apache vs. Yaws
• Replacing Apache with Yaws

Trying to get a windows rails environment going this morning I stumbled upon something interesting – all ‘a’ characters were missing from cucumber and rspec output.

This has something to do with UTF-8 encoding and there’s a ticket and wiki post on cucumber about it, but no solution that I found acceptable.

Everything comes down to having change encoding in the current cmd window. This is achieved via a simple call to chcp 1252, but nobody want’s to do this every time, right?

To get this executed automaticaly and without resorting to serious registry editing, simply add this line to your cucmber.bat and any other batch files that are exhibiting this problem. You can find cucumber.bat in your /ruby/bin folder.

Here’s what it looks like:

chcp 1252
@ECHO OFF
IF NOT "%~f0" == "~f0" GOTO :WinNT
@"ruby.exe" "c:/ruby/bin/cucumber" %1 %2 %3 %4 %5 %6 %7 %8 %9
GOTO :EOF
:WinNT
@"ruby.exe" "%~dpn0" %*

This was my first more or less serious attempt at creating a new theme for WordPress and it turned out to be a pretty trivial task, or at least as far as WordPress itself is concerned.  I love the fact that it doesn’t get in the way and there’s very little PHP required to create a brand new theme. I took out most of the typical blog stuff like linkrolls, calendar, pages, etc and just left what it is – just a blog.

For this design I tried to use some golden ratio here and there and it seems to do the trick. I found an awesome freeware tool by Markus Slewz which helped tremendously.

Overall this took about a day and a half, from design to launch, so a weekend well spent. And yes, I do love damask.

This is my set up when building CSS layouts. I save a layout copy in Photoshop or Fireworks as a 50% transparent PNG which is then displayed on the page with a high z-index. This overlays my actual HTML layout and allows me to test for pixel precision. On the screenshot I’m testing a layout simultaneously in all browsers required by the project – IE6, IE7 and Firefox.

Took me a couple of days to figure it out. The Facebook API is pretty amazing. I’m especially impressed by the total sandboxing of hosted applications. The styles, the JavaScript, everything gets sandboxed. It’s pretty amazing as a platform.

The hardest part was simply learning the FBML and figuring out what works and what doesn’t.

Here’s what you need:

1. Facebook account
2. Local box with Apache
3. Domain name pointing to your home IP. I use No-Ip.

Here are the steps I took.

1. Setting up development application on Facebook. Follow the guide, it’s pretty straight forward.
2. Set up No-Ip to point *.dev.mydomain.com to my local box. This allows me to create as many Rails applications as I need to.
3. Configured Apache to forward all calls to fbtest.dev.mydomain.com to localhost:3000 using mod_proxy like so:

   <VirtualHost *:80>
     ServerName fbtest.dev.mydomain.com
     ProxyPass / http://127.0.0.1:3000/
   </VirtualHost>

4. gem install rfacebook
5. cd /anywhere/fbtest
6. rails .
7. ruby script/plugin install svn://rubyforge.org/var/svn/rfacebook/plugins/rfacebook_on_rails
8. rake facebook:setup
9. Go to http://www.facebook.com/developers/apps.php
10. Copy and paste API key and secret to config/facebook.yml. Set canvas_path to the local path on Facebook, ie /myfacebookapp/ and callback_path to local path on your server, ie /facebook/.
11. ruby script/generate controller facebook index
12. Edit index method in Facebook controller, like so:

    class FacebookController < ApplicationController
      def index
        @result = fbsession.friends_get.uid_list
      end
    end

13. Edit index.rhtml like so:

    <% @result.each do |uid| %>
      <fb:name uid="<%= uid %>" />
    <% end %>

14. Start Apache
15. ruby script/server
16. Now you should be able to hit your Facebook application page at http://apps.facebook.com/myfacebookapp

You should see a list of your friends. Took me about 30 minutes to figure all this out.

Apple has a history of creating infrastructure around its products and there’s no reason to think that iPhone will be any different. Developing web applications which specifically target the iPhone could, and probably will be the next big thing. As a web developer it’s a good idea to get on this early in the game.

My opinion is even further solidified by this video. Seems like Microsoft has already lost the battle. The best quote from the video is “[iPhone] doesn’t change our strategy, it doesn’t change our approach”. Great, that means Windows Mobile will stay the same and 3rd party partners will continue putting out crappy cellphones.

Windows Mobile is not just an unfriendly OS, it hates its users. I can’t stand using it.

In Firefox it utilizes window.globalStorage which is a part of HTML 5 draft. Internet Explorer, unsurprisingly had this ability since version 5 using #default#userData behavior and unsurprisingly it’s somewhat awkward. Unfortunately, Safari/Webkit don’t seem to support local storage at all as of now, so this is more of a demo.

<html>
<body>

<script>
LockBox = {
	ensureStorage: function()
	{
		if(LockBox.storage != null)
			return;

		var storage;

		if(document.all)
		{
			storage = document.createElement("span");
			storage.style.behavior = "url(#default#userData)";

			if(document.body)
				document.body.appendChild(storage);
			else
				throw new Error("DomStorage works only after dom loaded");

			storage.load("lockbox");
		}
		else
		{
			storage = globalStorage[location.hostname];
		}

		LockBox.storage = storage;
	},

	set: function(name, value)
	{
		LockBox.ensureStorage();

		if(document.all)
		{
			LockBox.storage.setAttribute(name, value);
			LockBox.storage.save("lockbox");
		}
		else
		{
			LockBox.storage[name] = value;
		}
	},

	get: function(name, defaultValue)
	{
		LockBox.ensureStorage();

		var result = document.all
			? LockBox.storage.getAttribute(name)
			: LockBox.storage[name]
		;

		return result || defaultValue;
	}
}

//
// Here's a little demo.
//
var value = parseInt(LockBox.get('count', 0));
alert(value);
LockBox.set('count', value + 1);
</script>

</body>
</html>

In a regular controller I load up all my @packages but instead of a plain sitem_map.rhtml, I have a site_map.rxml file which looks like this:

xml.instruct!
xml.urlset "xmlns" => "http://www.google.com/schemas/sitemap/0.84" do
  xml.url do
    xml.loc         "http://test"
    xml.lastmod     w3c_date(Time.now)
    xml.changefreq  "monthly"
  end
  @packages.each do |package|
    xml.url do
      xml.loc         "http://www.noobkit.com/page/ref/#{package.full_name}"
      xml.lastmod     w3c_date(package.created_at)
      xml.changefreq  "monthly"
    end
  end
end

w3c_date goes into your_controller_helper.rb.

def w3c_date(date)
  date.utc.strftime("%Y-%m-%dT%H:%M:%S+00:00")
end

That’s all to it. Packages provide entry points to their entire API trees and should be enough information for Google to start crawling there.

There doesn’t seem to be that much available out there. Here are a few interesting links that I found online:

• Scalable story promotion
• Writing a Digg-Style Popularity Algorithm
• Archive – the first day of Digg that’s in Archive.org has SQL in HTML comments. It’s obviously very simple and trivial, but does give a couple of hints about early inner-workings.I formatted it myself, the original source is all on one line.

select
  items.id as id,
  title,
  ctitle,
  url,
  bodytext,
  username,
  category_id,
  top_flag,
  category_autopost_threshold,
  dig_count,
  obscene_count,
  users.id as userid,
  approved,
  deleted,
  obscene_flag,
  sdelete_flag,
  catdaysback
from
  (items inner join users on userid = users.id)
where
  (approved = 1 and deleted = 0  and obscene_flag != 1) and
  (top_flag = 1 or (items.dig_count >= category_autopost_threshold)) and
  (sdelete_flag != 1)
order by date_promoted desc