Alberto Santini

How is religion correlated with poverty

Here is a wonderful infographic showing how religion correlates with poverty in various countries allover the world. The general trend, as clearly visible, is that the poorer the country the more important religion is in people’s life. Notable exceptions? The United States and Italy, despite having a good G.D.P. per capita are yet under the yoke of religious beliefs; on the other hand, former soviet republics’ citizens don’t care too much about religion even if their countries suffer of great economical problems.

Two amazing video footages from more than 100 years ago

The first has been shot by Thomas Edison (!!) at Paris 1900 Universal Exposition (Exposition Universelle) and features, a part from amazed and somewhat funny people posing in front of the camera, a brand new Tour Eiffel.

This second, breathtaking, one shows San Francisco just a few days after the 1906 earthquake.

Fail quickly, recover even more quickly

This wonderful piece by Aza Raskin of FastCo explain how a problem as big as human-powered flight has been challenged and solved just by finding ways to fail quicker.

The problem was the process itself. And a negative side effect was the blind pursuit of a goal without a deeper understanding of how to tackle deeply difficult challenges.

Isn’t it, after all, the same core principle behind being agile and lean in software development?

When one says “Well served by public transport”

Is your local market so well served by public transport?

Two indie short movies worth watching

Even if entirely different, both The Thobas Beale cipher and The external world are two indie produced short movies definitely worth watching.

Yep, he's on the moon all right. I've got to go after him.

This episode of Gumby, titled “Gumby on the moon”, seems to have more profound philosophical relevance than one can imagine, as pointed out by Medium Large:

No other film has ever been so frighteningly unequivocal in it’s simple yet brutal philosophy: the point of life is to keep living.
[…]
the very battle of wits between our hero and his attackers makes us question if our enemies are the results of our actions or does our very existence begat combatants.

A paradox by Raymond Smullyan

Raymond Smullyan is, among the other things, quite fond of paradoxes and logical oddities. I remember I eagerly read his book “The riddle of Sheherazade” when I was fourteen or so and it caused me hours and hours of amusement. Here is one of his moral paradoxes.

At a desert oasis, A and B decide independently to murder C. A poisons C’s canteen, and later B punches a hole in it. C dies of thirst. Who killed him?
A argues that C never drank the poison. B claims that he only deprived C of poisoned water. They’re both right, but still C is dead. Who’s guilty?

The photographic proof of time travel

This photo is titled “Reopening of the South Fork Bridge after flood in Nov. 1940 / 1941” and can be found at the Bralorne-Pioneer Museum. Don’t you notice something odd?

Via How to be a retronaut

Self-replicating wooden machines

I first became interested in albiogenesis some years ago, while reading the beautiful divulgative book by Dawkins “The selfish gene” (a reading that must, of course, be followed by the one of “The extended phenotype” and “The blind watchmaker”).
There is a lot to say about the subject and — because of the peculiar topic treated — also some degree of uncertainty, which results in the coexistence of various models that try to explain how life can have arose from inorganic matter.

A very simplified version of one of those models, put in terms that would scare a serious albiogenist, is the following: for some reason (mainly the availability of a huge amount of time) some of the component molecules of the primordial soup — say, the molecules in the form A-B — managed to be arranged in particular shapes with the property that, whenever they found in their proximity the proper components — say molecule A and molecule B — they were able to attract them and arrange them in the very same shape, so that at the end of the process we would have two identical molecules A-B.

Of course, this process is not that straightforward and at some point a slightly different molecules could have been produced (like molecule C-B or molecule A-B-A-B) and after a while, there were a lot of those replicant molecules around. During this casual mutations some of them may have developed the ability to actually attack other molecules: if the aggressive molecule A-B would have encountered molecule A-B-C, it could have managed to split its bonds and then used A and B to create another copy of itself, leaving C to swim alone in the primordial soup.

In a similar fashion, some molecule could have developed a way to protect itself from such aggressions — say, by enclosing A-B in a thick shell of @C@s — and the idea is that those kind of attack and protection mechanism would have slowly become so evolved to be called living being.

This is seems quite plausible, but not entirely intuitive, right? It would be nice if we could have some way to really visualize how such kind of replicant molecules could have formed and worked. Well, even if not exactly designed to show this, I found those two vintage videos by the Galton Laboratory quite inspiring in this sense and I hope that you will too.

Setting up and deploying a Jekyll blog in half an hour

The task

When I created this blog, I decided I didn’t want to spend a lot of time setting up a webserver — in my case this would have meant configuring fastcgi for nginx, including the startup scripts since they aren’t provided with archlinux — or, even worse, a dbms.
I wanted a quick way to start my blog, I wanted to deploy it easily and safely and to focus solely on writing, not on technical details of the blogging engine.

So the requirements we’re going to fulfill are:

Generation of static pages: HTML. No PHP/CGI/RoR to be served.
Deployment as easy as typing git push.
The blog must support pagination, categories and syntax highlighting of code snippets.
It must be ready to be used in half an hour.

Jekyll

Jekyll is a generator for static websites and — in particular — blogs. It works in a pretty simple way: you create a directory tree with layout files and posts, then tell Jekyll to work on it and it will produce a static website ready to be served by nginx, lighttpd, apache or whatever. The files you create can be HTML, Markdown or Textile with liquid elements; for this blog, I decided to use HTML5 (with a touch of CSS3) for my layouts and Textile for the posts’ content.

The directory tree must include a _layouts and a _posts folder, a _config.yml and an index.html (or .markdown or .textile) file. I also have an _includes folder for shared pieces of code and _extensions for my Jekyll extensions (see below). Apart from those, you can have every other folder in your website root, such as stylesheets, javascripts or images.

When you’re ready, you just do a:

$ jekyll

In your root folder and everything gets compiled and put in _site.

Installing Jekyll (and extensions)

Jekyll provides by its own nature a very small set of features. It lacks, for example, support for categories or tags: something you can’t label as a minor nuisance. So, a lot of people started forking it on Github and added the features they needed most. We won’t do that (remember the half an hour goal?), but will instead use the jekyll_ext gem, which gives Jekyll the ability to be extended in a modular and non invasive way. So, the first thing to do is just installing the proper gems on the server (and on our dev machine, in order to work locally):

# gem install jekyll jekyll_ext

Also, we want to have fancy syntax highlighting when writing code; something like this:

def collect # :yield: e
  rows = @rows.collect{|row| row.collect{|e| yield e}}
  Matrix.rows(rows, false)
end

So we’ll install the syntax highlighter pygments, which is natively supported by Jekyll. Since the Python3 version is bugged (buggy Python software? what a surprise, wow…), I had to install the Python2 version on the server:

# pacman -S python2-pygments
# cd /usr/bin
# ln -s pygments2 pygments

On my development machine, on the contrary, everything worked good even with the newest pygments, so I just did a:

# port install py-pygments

Finally, remember that the executable for the extended version of Jekyll is now ejekyll, so you won’t spend hours wondering why extensions are not working, if you keep using the jekyll command.

Setting up the server

Here the main goal is to have a deployment process as easy and quick as possible. To achieve that, we’ll use the power of git! We want our compiled website to be put in ~/public_html/blog on the server and the effort in going from the raw source to a deployed website must be as much as typing

$ git push

To begin, let’s setup a new git repository on the server:

$ mkdir -p ~/git/blog
$ cd ~/git/blog
$ git --bare init

Then, on the dev machine:

$ cd ~/Sites
$ git clone user@server:git/blog
$ cd blog
$ echo "_site" > .gitignore

And we’re ready to start writing. But, wait… I have to keep the promise: deploying must be as easy as pushing on the repository. So, basically, we want the source compiled on the server each time we push it. Don’t you feel like this is a perfect task for a git hook? I do! So let’s create the hook on the server:

$ cd ~/git
$ mkdir -p tmp/blog
$ cd blog/hooks
$ touch post-receive
$ chmod u+x post-receive

Open it with your favorite text editor and let’s do the magic:

#!/bin/sh
GIT_REPO=$HOME/git/blog
TMP_REPO=$HOME/git/tmp/blog
DEPLOY=$HOME/public_html/blog

git clone $GIT_REPO $TMP_REPO
ejekyll --no-auto $TMP_REPO $DEPLOY
rm -Rf $TMP_REPO
exit

Here we are: each time we push with git, our website gets compiled and put in place. So far, so good, but right now we have nothing to compile. Let’s now install the extensions and configure Jekyll.

Using extensions

First of all we want to prepare the ground for the Jekyll extensions we want to use. We’ll use some of rfelix extensions, so on the dev machine we just clone them from his repository:

$ cd ~/Sites/blog
$ clone https://github.com/rfelix/my_jekyll_extensions.git _extensions
$ rm -Rf _extensions/.git _extensions/README.textile

Since I only want support for categories I removed every other extension a part from the following, but you can have a better idea on what you need and what you don’t, by looking at each extension’s description on the github page.

$ ls _extensions
category_gen  my_filters  tag_category_iterator

Configuring Jekyll

Configuring Jekyll is very simple: everything needs to go in the _config.yml file. Here we’ll add support for pagination, syntax highlighting and permalinks:

pygments: true
paginate: 10
permalink: /:title

Permalink specifies the format of the URL to access your posts. A more popular choice would maybe have been:

permalink: /:categories/:year/:month/:day/:title

Which is provided by default via the keyword

permalink: pretty

Conclusions

From now on, it’s just a matter of writing layouts and the actual posts, taking full advantage of the extensions; so… the only limit is your fantasy!

When a hard hat gets bored

When a hard hat gets bored and there’s a TV network in his proximity, this is what happens.