Voici la vidéo, enregistrée par Julien Tanguy (merci 😘) :

Les slides sont disponibles ici : https://dsferruzza.github.io/conf-programmation-fonctionnelle-en-scala

Le livre est récemment sorti sous le titre :

La programmation fonctionnelle

Introduction et applications en Haskell à l'usage de l'étudiant et du développeur

Pour moi, ce livre a un positionnement intéressant parmi les autres livres qui parlent de Haskell :

• il est en français
• il n'est pas horriblement long (~250 pages ici)
• il a un bon équilibre entre les aspects théoriques (historique, concepts) et pratiques (pas besoin d'attendre la moitié du livre pour écrire et exécuter du code, un "gros" exemple est développé dans 5 langages en plus de Haskell pour pouvoir comparer)
• il a un prix raisonnable pour ce genre d'ouvrages (32 €)

On cite souvent Haskell Programming From First Principles comme une bonne ressource pour débuter. Mais il est en anglais. Et il fait 1000+ pages. Et il coûte 59$. Et il n'y a pas de version papier. C'est clairement un bon bouquin, mais il demande beaucoup plus d'investissement. Le livre de Julien permet d'y aller plus en douceur et je pense que c'est une vraie qualité pour les débutants !

Pour l'acheter ou jeter un œil au sommaire ou au 1^er chapitre, rendez-vous sur le site de l'éditeur !

Gérer les erreurs avec l'aide du système de types de Scala !

Certaines fonctions de nos programmes peuvent échouer à calculer une valeur de retour. Plutôt que d'utiliser des exceptions, il est possible de tirer partie du système de types de Scala pour gérer les erreurs de manière plus fiable et lisible.

Nous verrons comment utiliser des ADT (Algebraic Data Type) comme Option, Try et Either, ainsi que disjunction et validation de Scalaz. On regardera aussi la bibliothèque Rapture et ses "modes" qui offrent la possibilité à l'appelant de choisir de quelle manière il veut encapsuler les éventuelles erreurs.

La gestion des erreurs est bien moins compliquée lorsque le compilateur peut nous aider !

Voilà la vidéo et les slides :

• Slides : https://dsferruzza.github.io/conf-gestion-erreurs-en-scala/ (dépôt GitHub)
• Vidéo : https://www.youtube.com/watch?v=TwJQKrZ23Vs

DevoxxFR 2016 c'était super, et j'espère revenir l'année prochaine !

Merci à Clément Delafargue de m'avoir fait découvrir les modes de Rapture.

Cet article est une très légère variante de celui que j'ai publié dans 24 jours de web 2014. Je l'ai aussi adapté en présentation.

Il y a un peu moins de deux ans, j'ai découvert la programmation fonctionnelle. Je me suis notamment renseigné sur un langage nommé Haskell, et je suis tombé sur un article qui énumérait des raisons pour lesquelles l'apprendre valait le coup. Parmi elles, il y avait la promesse que, même si on n'avait pas l'occasion ou l'intention d'utiliser ce langage tous les jours, l'apprendre permettrait d'être meilleur dans les langages "classiques" (dits impératifs). Un peu hésitant, j'ai commencé à apprendre et à jouer avec ce nouveau langage...

Au début, c'est déroutant. On a l'impression de ne plus rien savoir faire : la programmation purement fonctionnelle est un paradigme assez différent de la programmation impérative que l'on pratique dans la plupart des langages populaires. Mais avec un peu d'efforts, on commence à percevoir les avantages que ça apporte, et croyez-moi, ils sont vraiment intéressants ! Et savez-vous ce qui est encore plus appréciable ? La promesse est vraie : il est possible, dans une certaine mesure, d'appliquer des concepts de programmation fonctionnelle dans des langages comme JavaScript, et ça permet de faire des programmes plus fiables et plus faciles à maintenir !

Mais vous n'êtes pas obligé de me croire sur parole. Mon objectif avec cet article est de vous faire entrevoir le gain que l'on peut obtenir en appliquant des concepts de programmation fonctionnelle à des langages impératifs ; en l'occurrence, à JavaScript.

On va commencer en douceur avec quelques concepts théoriques, et puis on fera un peu de pratique en manipulant des tableaux en JavaScript. Pas besoin d'être Tony Stark, si vous avez déjà fait un peu de JavaScript, et éventuellement vu les fonctions en mathématiques, tout ça devrait vous parler !

La transparence référentielle

Avant toute chose, on va parler des fonctions, puisqu'elles sont au cœur de la programmation fonctionnelle. Voici un exemple de fonction en JavaScript :

// On définit une fonction "ajouterCinq" qui prend un nombre en paramètre,
// lui ajoute 5, et renvoie le résultat comme valeur de retour
function ajouterCinq(nombre) {
	return nombre + 5;
}

// On peut maintenant appeler cette fonction pour obtenir un résultat
// sans avoir à réécrire toute la logique de calcul à chaque fois

ajouterCinq(0);
// 5

ajouterCinq(8);
// 13

Les fonctions sont très importantes car elles permettent de regrouper les calculs similaires à un seul endroit dans le code, ce qui évite de se répéter et rend le code beaucoup plus lisible. Elles permettent de découper un problème compliqué en plusieurs problèmes moins compliqués, ce qui est très souvent une bonne idée.

Étudions une autre fonction :

function diviserParDeux(nombre) {
	var missile = lancerUnMissileThermonucleaire();
	fairePorterLeChapeauAuDrManhattan(missile);
	return nombre / 2;
}

Si on appelle diviserParDeux(4), on obtiendra 2 en valeur de retour. Mais on voit dans le code de la fonction que celle-ci va appeler d'autres fonctions qui vont visiblement modifier des choses qui sont à l'extérieur de la fonction diviserParDeux. Ce qui est gênant, c'est qu'on n'a pas idée des effets que va avoir l'appel de cette fonction étant donné que cela n'apparait ni dans ces paramètres d'entrée, ni dans sa valeur de retour. On dit que cette fonction comporte des effets de bord.

Notre fonction ajouterCinq n'a pas d'effets de bord : elle ne va pas accéder à des zones mémoire qui sont hors de son bloc de code. On dit que c'est une fonction pure. Et ce qui est pratique avec les fonctions pures, c'est qu'elles retournent toujours le même résultat lorsqu'on les appelle avec les mêmes arguments :

ajouterCinq(-4) == ajouterCinq(-4)
// --> 1 == 1
// --> true

// Alors que cela ne fonctionne pas forcément avec une fonction
// qui a des effets de bord
var n = 0;
function ajouterAuCompteur(nombre) {
	n = n + nombre;
	// On accède à la variable "n" sans qu'elle ne soit passée en paramètre
	// et on la modifie en lui assignant une nouvelle valeur
	return n;
}

ajouterAuCompteur(1) == ajouterAuCompteur(1)
// --> 1 == 2
// --> false

Les fonctions pures permettent la transparence référentielle : le résultat du programme ne change pas si on remplace une expression par une expression de valeur équivalente. Dans notre cas, comme on sait que ajouterCinq(-4) est strictement équivalent à 1 (car il n'y a pas d'effets de bords), on pourrait remplacer toutes les occurrences de ajouterCinq(-4) par 1 dans notre programme sans que ça ne change son résultat.

Si on remplaçait toutes les occurrences de diviserParDeux(6) par 3, on obtiendrait un programme différent car un appel à la fonction diviserParDeux(6) a des effets de bord que n'a pas la valeur 3.

La transparence référentielle est très intéressante car elle rend votre programme facilement prévisible par le lecteur : il devient possible de raisonner dessus comme si c'était une équation, et non plus une séquence d'instructions arbitraires ! Il y a même un terme pour désigner ce concept : equational reasoning.

En s'efforçant de construire son programme avec un maximum de fonctions pures, on va alors se retrouver à isoler les fonctions qui ont des effets de bord, ce qui offre plusieurs avantages :

• on sait quelles fonctions ont des effets de bord, ce qui permet d'être prudent lorsqu'on les manipule
• le cœur du programme, la logique métier, est exprimée avec des fonctions pures qui sont fiables, sans surprises, et aisément testables

Ne vous inquiétez pas si c'est encore un peu flou ; la prochaine partie sera moins théorique et plus concrète !

Les fonctions d'ordre supérieur

Dans la partie précédente, je suis rapidement revenu sur ce qu'est une fonction. Ce que je n'ai pas dit, c'est qu'en JavaScript, les fonctions sont des objets de première classe, au même titre que les chaines de caractères, les nombres, et bien d'autres...

Cela veut dire qu'une fonction peut :

• être expressible comme une valeur anonyme littérale
• être affectée à des variables ou des structures de données
• avoir une identité intrinsèque
• être comparable pour l'égalité ou l'identité avec d'autres entités
• être passée comme paramètre à une procédure ou une fonction
• être retournée par une procédure ou une fonction
• être constructible lors de l'exécution

Suivant les langages, les fonctions ne sont pas toujours des objets de première classe : en C, par exemple, ce n'est pas le cas. Mais quand c'est le cas, cela permet des constructions intéressantes : les fonctions d'ordre supérieur.

Une fonction d’ordre supérieur est une fonction qui accepte au moins une autre fonction en paramètre, et/ou qui retourne une fonction en résultat. C'est tout ! Voyons un exemple :

// On a une fonction qui accepte un nombre et renvoie ce nombre multiplié par 2
function multiplierParDeux(nombre) {
	return nombre * 2;
}

// On a une autre fonction qui accepte un paramètre quelconque, va l'afficher
// et le renvoyer en valeur de retour
function afficher(x) {
	console.log(x); // <-- Ceci est un effet de bord
	return x;
}

// Maintenant imaginons qu'on souhaite appliquer multiplierParDeux() sur un nombre,
// et ensuite afficher() sur le résultat
afficher(multiplierParDeux(5));
// 10
// --> 10

// Cela fonctionne, mais ce n'est pas pratique si on doit s'en servir beaucoup.
// Il faudrait avoir une fonction qui fasse les 2 actions directement,
// qu'on pourrait appeler afficherDouble()

// On pourrait faire comme ça
function afficherDouble(nombre) {
	return afficher(multiplierParDeux(nombre));
}

// Ou on pourrait créer une fonction plus générale
// qui pourrait être réutilisée partout !
function compose(f, g) {
	return function(x) {
		return f(g(x));
	};
}
// compose() accepte deux fonctions (f et g) en paramètre, et renvoie en retour
// une fonction (qui est équivalente à la composition de f et g)
// C'est donc une fonction d'ordre supérieur !

// Ainsi
var afficherDoubleBis = compose(afficher, multiplierParDeux);
// On indique "afficher" et pas "afficher()" car on veut désigner
// la fonction en elle-même, pas l'appeler

afficherDouble(5) == afficherDoubleBis(5)
// --> true

Cet exemple, bien qu'un peu abstrait, laisse entrevoir l'intérêt des fonctions d'ordre supérieur : on peut facilement créer des fonctions très générales et les rendre plus spécifiques en leur passant d'autres fonctions en paramètre. Cela permet de bien séparer les différentes tâches effectuées par nos fonctions. C'est justement en ayant en tête cette idée de séparer nos traitements en petites fonctions modulaires qu'on va regarder un exemple plus concret : la manipulation des tableaux.

Les tableaux

En JavaScript, un tableau peut être vu comme une liste ordonnée de valeurs. Une valeur peut être un nombre, un objet, une fonction, ... n'importe quel objet de première classe ! Rien ne l'empêche en JavaScript mais, quand on est bien élevé, on évite de faire des tableaux contenant plusieurs types de valeurs :

var tableau = [1, 2, 3, 4]; // Bien
var tableau = [1, "deux", 3, { valeur: 4 }]; // Mal

C'est une mauvaise pratique car il devient difficile de raisonner sur les fonctions qui vont manipuler une telle liste. Une solution serait que chaque élément de la liste soit un élément d'une structure qui permette d'exprimer tous les cas qu'on a besoin d'exprimer ; un objet pourrait faire l'affaire ici.

Les tableaux sont une structure de données extrêmement utile et répandue, et il y a un certain nombre d'opérations qu'on est amené à faire très souvent. Par exemple, on souhaite souvent transformer chaque élément d'un tableau en quelque chose d'autre.

// On a une liste d'objets qui représentent des villes
// (on peut dire qu'on l'a obtenue grâce à un appel HTTP vers une API externe)
var villes = [
	{ nom: "Nantes", departement: 44, presDeLaMer: false },
	{ nom: "Dunkerque", departement: 59, presDeLaMer: true },
	{ nom: "Paris", departement: 75, presDeLaMer: false },
];

// On veut obtenir une liste de chaines de type "ville (departement)"
function rendreVillesAffichables(villes) {
	for (var i = 0; i < villes.length; i++) {
		villes[i] = villes[i].nom + " (" + villes[i].departement + ")";
	}
	return villes;
}

rendreVillesAffichables(villes);
// --> ["Nantes (44)", "Dunkerque (59)", "Paris (75)"]

Le résultat est correct, mais il y a plusieurs problèmes avec cette fonction rendreVillesAffichables :

1. Elle modifie le tableau original, ce qui fait qu'elle n'est pas pure : en JavaScript, quand on copie une variable qui contient un tableau ou un objet, seule la référence vers les données est copiée, ce qui fait qu'une modification sur les cases du tableau ou les propriétés de l'objet sera visible depuis la variable originale et depuis la copie.

2. On a mélangé deux comportements dans notre fonction :

   • parcourir le tableau : c'est quelque chose de très courant, peu importe ce que contient le tableau
   • effectuer la transformation qu'on souhaite, pour une case donnée : c'est un comportement spécifique, et donc métier, qui se retrouve noyé dans la logique d'itération sur le tableau

Certes, l'exemple ici est plutôt simple et concis, mais on peut quand même améliorer ça !

map

On pourrait imaginer une fonction d'ordre supérieur qui permette d'abstraire le parcours du tableau. Cette fonction accepterait deux paramètres : le tableau à transformer, et une fonction effectuant la transformation sur un seul élément du tableau. Essayons de coder ça !

function transformerTableau(tableau, transformation) {
	// On crée un nouveau tableau qu'on va remplir
	// plutôt que de modifier celui fourni en paramètre
	var nouveauTableau = [];
	for (var i = 0; i < tableau.length; i++) {
		nouveauTableau[i] = transformation(tableau[i]);
	}
	return nouveauTableau;
}

// Ainsi, notre fonction rendreVillesAffichables devient :
function rendreVillesAffichables(villes) {
	function rendreUneSeuleVilleAffichable(ville) {
		return ville.nom + " (" + ville.departement + ")";
	}
	return transformerTableau(villes, rendreUneSeuleVilleAffichable);
}

rendreVillesAffichables(villes);
// --> ["Nantes (44)", "Dunkerque (59)", "Paris (75)"]

C'est quand même bien plus clair ! La fonction transformerTableau n'embarque aucune logique métier et fonctionne avec n'importe quel tableau, et la fonction rendreUneSeuleVilleAffichable, qui contient la logique métier de la transformation, est pure, et peut donc être testée très facilement.

Et le plus beau dans tout ça, c'est que notre fonction transformerTableau est tellement utile et générique qu'elle est déjà présente dans l'API des tableaux de JavaScript ! Dites bonjour à Array.map !

// La même chose que précédemment, mais en utilisant Array.map
function rendreVillesAffichables(villes) {
	function rendreUneSeuleVilleAffichable(ville) {
		return ville.nom + " (" + ville.departement + ")";
	}
	return villes.map(rendreUneSeuleVilleAffichable);
}

rendreVillesAffichables(villes);
// --> ["Nantes (44)", "Dunkerque (59)", "Paris (75)"]

La fonction map est présente sur tous les tableaux JavaScript. Quand on l'appelle, en lui passant en argument une fonction qui accepte un élément du tableau et renvoie le nouvel élément, elle va appliquer cette fonction à chaque case du tableau et renvoyer le résultat sous forme d'un nouveau tableau.

Le tableau de retour a exactement le même nombre d'éléments (dans le même ordre) que le tableau d'origine : map ne modifie pas la structure (le tableau en lui-même) mais son contenu (les éléments). Il est tout de même possible en JavaScript de modifier la structure du tableau (en ajoutant ou supprimant des éléments), mais c'est une très mauvaise idée (nous verrons bientôt une solution plus sympathique pour faire ça).

filter

Un autre besoin très courant lorsqu'on manipule des tableaux est de vouloir supprimer certains éléments suivant un critère spécifique. Encore une fois, nous sommes chanceux, il existe une fonction dans l'API des tableaux JavaScript qui fait exactement ça : Array.filter.

La fonction filter est, comme map, présente sur tous les tableaux JavaScript. Elle a besoin qu'on lui passe une fonction de prédicat, c'est à dire une fonction qui prend un élément comme paramètre et qui renvoie true ou false.

Par exemple, en partant de notre tableau de villes, on souhaite ne conserver que les villes qui sont près de la mer :

// Cette fois-ci, plutôt que de créer une fonction nommée,
// je passe une fonction anonyme
villes.filter(function(item) {
	// Si la ville est près de la mer, on renvoie true, sinon false
	return item.presDeLaMer;
});
// --> [ { nom: "Dunkerque", departement: 59, presDeLaMer: true } ]

Plutôt chouette, non ? On peut même chainer filter et map pour ne garder que les villes qui ne sont pas près de la mer et les afficher de manière élégante :

villes.filter(function(item) {
	return !item.presDeLaMer;
}).map(function(item) {	// Comme villes.filter renvoie un tableau,
			// on peut appeler map dessus !
	return item.nom + " (" + item.departement + ")";
});
// --> ["Nantes (44)", "Paris (75)"]

reduce

Enfin, on a parfois besoin de transformer un tableau en quelque chose d'autre. Autrement dit, on ne veut pas toujours conserver intacte la structure qui contient nos données (comme c'est le cas avec map et filter). Par exemple, on a un tableau qui contient des objets ayant tous une propriété age et on souhaite calculer la somme de tous les âges.

La fonction Array.reduce (également appelée fold suivant les langages) est faite pour ça ! Elle a besoin des paramètres suivants : (attention ils ne sont pas dans le bon ordre, mais c'est plus simple à comprendre comme ça)

• un tableau (reduce s'appelle directement sur le tableau, comme map et filter)
• une valeur initiale (elle sera renvoyée si le tableau est vide, notamment)

• une fonction qui accepte deux paramètres :

  • la valeur actuelle de l'accumulateur (pour la 1ère itération, c'est la valeur initiale, et pour les suivantes, ce sera la valeur renvoyée par la fonction lors de l'itération précédente)
  • la valeur de la case du tableau courante

var personnes = [
	{ nom: "Bruce", age: 30 },
	{ nom: "Tony", age: 35 },
	{ nom: "Peter", age: 26 },
];

personnes.reduce(function(acc, cur) {
	// On ajoute l'âge courant à la valeur actuelle de la somme
	return acc + cur.age;
}, 0);
// --> 91

reduce est très pratique car elle permet de plier (fold) un tableau, ce qui est nécessaire relativement souvent. Elle est plus générale que map et filter ; on peut d'ailleurs les exprimer tous les deux en terme de reduce :

function map(tableau, transformation) {
	return tableau.reduce(function(acc, cur) {
		acc.push(transformation(cur));
		return acc;
	}, []);
}

function filter(tableau, predicat) {
	return tableau.reduce(function(acc, cur) {
		if (predicat(cur)) acc.push(cur);
		return acc;
	}, []);
}

Pour résumer, si vous avez un tableau et que vous voulez :

• appliquer une transformation sur chacune de ses cases en conservant leur ordre/nombre : map
• supprimer certaines cases en conservant l'ordre des autres : filter
• le parcourir pour construire une nouvelle structure de données : reduce

Ces fonctions permettent de manipuler des tableaux de manière pure, avec tous les avantages que ça implique. Je vous encourage à les utiliser, ou à définir vous-même les fonctions d'ordre supérieur dont vous avez besoin !

Conclusion

Tout le code ne peut pas être pur, surtout en JavaScript. Mais plus il l'est, plus il sera clair, réutilisable, fiable et vous fera vous poser les bonnes questions. Écrire du code qui fonctionne ne suffit pas. La transparence référentielle et les fonctions d'ordre supérieur sont des outils qui vous facilitent grandement la vie lorsque vous réfléchissez sur votre programme. Elles augmentent la qualité du code que vous écrivez. Le prix à payer est modique par rapport au gain !

Il existe d'autres concepts très intéressants en programmation fonctionnelle. On pourrait citer l'évaluation paresseuse, l'immuabilité, ou les systèmes de types avancés. Ces derniers permettent notamment quelque chose de similaire à l'analyse dimensionnelle en physique : le langage va nous empêcher d'exprimer des incohérences (on ne va pas additionner par erreur une valeur en km avec une valeur en miles, par exemple).

J'espère que vous avez apprécié cet article ! Voici quelques ressources si vous voulez approfondir un peu ces sujets :

• Learn You A Haskell For Great Good : LE livre pour débuter Haskell ; il est très accessible ; disponible en papier ou en ligne (traduction FR non officielle)
• JavaScript Alongé : un livre avancé sur JavaScript ; il explique et met en place certains concepts que nous avons survolés ici ; disponible en version dématérialisée ou en ligne
• Lo-Dash : une bibliothèque JavaScript qui propose notamment des fonctions d'ordre supérieur très intéressantes pour manipuler les collections
• Bacon.js : une bibliothèque JavaScript qui permet de faire de la programmation fonctionnelle réactive
• Is your programming language unreasonable? or, why predictability is important

Merci à Clément Delafargue, Francois-Guillaume Ribreau, Mathieu Le Gac, Elisabeth Hamel et Thibault Mahé pour leurs relectures !

A RSS reader (or aggregator) is a software that allows you to read syndicated web content (like news, blog posts, ...) in one unique place. This is very useful because:

• you don't have to visit every website/blog you follow to read new articles
• you can mark an article as read or unread (like you would do with an email in your inbox)
• you can read the content directly inside the reader (which is faster), or click on a link and open it in your browser (which gives you the full experience)
• you can let the reader opened all day (my CommaFeed tab in Firefox is pinned, and a little white dot appears on it when there are new articles)

CommaFeed is a "Google Reader inspired self-hosted RSS reader". You can get the source code on GitHub, and there is a free official instance here.

As CommaFeed is a web application, it doesn't have to run on the same computer you use to read news. You can host it on a server, so that you can get your unread news and mark them as read no matter where you are.

I will explain how to install you own instance.

Requirements

First, you need a server. A real server, a VPS, or a local virtual machine will do. In this document, I will assume you have Debian installed on it, but it's not a requirement.

You will need to have the following packages installed:

• git
• openjdk-7-jdk
• maven (3.x)
• supervisor

Finally, you will need a database server. Here I will assume you have a MariaDB (or MySQL) server running on localhost, with a commafeed:commafeed user that has write access on a commafeed database (you can also use PostgreSQL or SQLServer).

Installation

First, we create a user and its home:

useradd -d /opt/commafeed -s /bin/bash commafeed
mkdir /opt/commafeed
chown commafeed. /opt/commafeed
su - commafeed

Let's clone the repo:

git clone https://github.com/Athou/commafeed.git .
cd commafeed

Build the project (it can take around 5 minutes):

mvn clean package

Create the config file:

cp config.yml.example config.yml

Now, you need to edit config.yml. Get to the database section, and put:

database:
  driverClass: com.mysql.jdbc.Driver
  url: jdbc:mysql://localhost/commafeed?autoReconnect=true&failOverReadOnly=false&maxReconnects=20&rewriteBatchedStatements=true
  user: commafeed
  password: commafeed

I also recommend to enable two other options:

• pubsubhubbub: to automatically use the PubSubHubbub protocol on compatible feeds
• imageProxyEnabled: images in the news will be served through CommaFeed and not directly by the website that published the content

Let's try to launch it!

java -jar target/commafeed.jar server config.yml

You should see some log messages in the console while CommaFeed is launching and setting up the database. Then you can go to http://myserver:8082 with your web browser (where myserver is your server's IP/domain). You should see the welcome page. Type Ctrl + C in the console to kill CommaFeed.

Now, let's configure Supervisor to "daemonize" CommaFeed, so that we can launch it automatically on system startup.

Create a /etc/supervisor/conf.d/commafeed.conf file (as root) with this content:

[program:commafeed]
directory=/opt/commafeed
command=java -jar target/commafeed.jar server config.yml
process_name=commafeed
user=commafeed
autostart=true
autorestart=true

Reload Supervisor's config and check if CommaFeed is running:

supervisorctl reload
supervisorctl status

You should see that CommaFeed is running, and it will keep running even if you close your console. You can go to http://myserver:8082, use admin:admin to log in, change admin password (or disable admin user), create a new user and start using it!

Using a custom HTTP frontend

CommaFeed works, but you might want more, like accessing it on port 80 or 443 (with SSL) using a virtual host (so you can host other apps reachable via port 80/443).

In this document, I will use Apache2, but you can setup a similar configuration with any decent HTTP server.

First, install the apache2 package.

If you want SSL, you need to add the following line in /etc/apache2/ports.conf:

NameVirtualHost *:443

It allows Apache to use virtual hosts on port 443¹. Then, let's enable some mods:

a2enmod proxy proxy_http ssl

For SSL, I will assume that you have already created a certificate and its key² in a /etc/commafeed directory (it can be anywhere as long as the web server's user can read it).

Now we can create a virtual host in /etc/apache2/sites-available/commafeed:

<VirtualHost *:443>
    ServerName rss.mydomain.com

    <IfModule mod_ssl.c>
        SSLEngine on
        SSLCertificateFile /etc/commafeed/commafeed.pem
        SSLCertificateKeyFile /etc/commafeed/commafeed.key
    </IfModule>

    <IfModule mod_proxy.c>
        ProxyRequests off
        ProxyVia on
        ProxyPass / http://localhost:8082/
        ProxyPassReverse / http://localhost:8082/
        <Proxy *>
            Order deny,allow
            Allow from all
        </Proxy>
    </IfModule>
</VirtualHost>

Or, if you don't want SSL:

<VirtualHost *:80>
    ServerName rss.mydomain.com

    <IfModule mod_proxy.c>
        ProxyRequests off
        ProxyVia on
        ProxyPass / http://localhost:8082/
        ProxyPassReverse / http://localhost:8082/
        <Proxy *>
            Order deny,allow
            Allow from all
        </Proxy>
    </IfModule>
</VirtualHost>

Now, we can enable it, and restart Apache:

a2ensite commafeed
service apache restart

Last thing, we need to update the app.publicUrl key in CommaFeed's config:

app:
  # url used to access commafeed
  publicUrl: https://rss.mydomain.com

Restart CommaFeed:

supervisorctl restart commafeed

And head over to https://rss.mydomain.com!

Update

If you want to update CommaFeed, here is a simple script:

#!/bin/sh

cd /opt/commafeed
su commafeed -c "git pull"
su commafeed -c "mvn clean package"
supervisorctl restart commafeed
supervisorctl tail -f commafeed

Pay attention to the list of modified files displayed when the git pull command is executed: if config.yml.example has changed, you might need to take a look and edit config.yml.

Share the love

If (like me) you think CommaFeed is a great software, share the love by:

• using it
• telling your friends about it
• giving some feedback
• translating it
• improving it
• giving it a Flattr

I'm not affiliated with this project, but I'm using it everyday for a while (and sometimes reporting bugs).

Why?

I had this « make yourself a decent website » task on my todo list for more than a year. As I am more and more interested in what I do, I decided it was time to begin to give back and share some stuff I like.

Also, the « I should totally write a blog post about that! » situation happened too many times repeatedly these last weeks.

I think I will mostly write about Computer Science/Programming, and projects I like and/or make. But who knows...

How?

The first thing I want to write about is how I made this website/blog.

I used a Haskell library called Hakyll. Hakyll makes it easy to build a static website generator.

There are lots of static website generators[^1], but Hakyll is the best I tried. It is fast, while being highly customizable. And it can handle many cool stuff almost out-of-the-box, including:

• templating
• markdown (and many other formats, because it uses Pandoc)
• incremental build (you don't have to rebuild everything on every modification)
• CSS compression
• tags and metadata
• RSS/Atom feeds
• ...

Making a static website by hand can be painful. To avoid repeating code, people often use dynamic languages (such as PHP). But this sounds like a waste to me: on each request, the server has to compute the same operations over and over to serve the same page, just because the developer wants DRY[^2] code. This makes sense when you need to handle user inputs, but that is not always the case. For that kind of projects, Hakyll is a really nice tool.

You can find the source code here: https://github.com/dsferruzza/david.sferruzza.fr

Some little details

Two static website generators are never exactly the same (that's the point). So building one involves picking up some stuff from the example site, or from nice people, and developing the rest.

I will quickly show some of these features I picked up or developed.

I'm still a beginner, so if you have better solutions, please let me know!

Links in feed

As I said, Hakyll is able to generate RSS and Atom feeds[^3]. While generating a post's page, we will tell Hakyll to take a snapshot of the result, just after converting the post's markdown to HTML, and just before applying it to a template. This snapshot will then be put in the feed.

But what if a post contains a relative link?

Well, it will stay relative, and that's what we want for the post's page. But we don't want that for the feed, because feed readers won't be able to resolve it.

A solution would be to use the xml:base[^4] attribute in a root element of the feed. The feed rendering function let me think it would be possible to override the default feed templates. But I don't know if it is possible yet, nor how to do it...

So I picked up another solution from Clément Delafargue's blog. When generating posts' pages, Hakyll will resolve relative links before taking a snapshot for the feed, and then transform them back so that they will be relative in the rendered page (but not in the feed).

I believe that the first solution would be cleaner, but the second works nicely.

Update date

When I update a blog post, I want the date of the update to appear in the blog's page, but also in the feed (using <updated> tags).

Hakyll handles that with a modificationTimeField[^5] you can add to your post's context. But I don't really like the idea of the modification date only be kept on my file system. I want to be able to clone my blog's Git repository, build it and get exactly the same result every time. This would not be the case if I use a modificationTimeField, because Git don't store files' modification date.

So I created a updatedField, which is implemented exactly like dateField except that it only tries to get the date from a updated field in my content's metadata.

updatedField :: String -> String -> Context a
updatedField key format = field key $ \i -> do
    time <- getUpdatedTime locale $ itemIdentifier i
    return $ formatTime locale format time
  where
    locale = defaultTimeLocale

getUpdatedTime :: MonadMetadata m => TimeLocale -> Identifier -> m UTCTime
getUpdatedTime locale id' = do
    metadata <- getMetadata id'
    let tryField k fmt = M.lookup k metadata >>= parseTime' fmt
    maybe empty' return $ msum $ [tryField "updated" fmt | fmt <- formats]
  where
    empty'     = fail $ "getUpdatedTime: " ++
        "could not parse time for " ++ show id'
    parseTime' = parseTime locale
    formats    =
        [ "%a, %d %b %Y %H:%M:%S %Z"
        , "%Y-%m-%dT%H:%M:%S%Z"
        , "%Y-%m-%d %H:%M:%S%Z"
        , "%Y-%m-%d"
        , "%B %e, %Y %l:%M %p"
        , "%B %e, %Y"
        , "%b %d, %Y"
        ]

Now, if I want to indicate that I updated a post, I just need to add something like updated: 2014-12-01 12:30:00+02:00 in the post's metadata. It will be synced by Git :)

ISO 8601 dates

I wanted to use <time>[^6] tags in my posts' pages. <time> tags binds a machine-readable date to a human-readable date. This means we need a machine-readable date.

I picked up a quite simple solution from Julien Tanguy's blog. You just need to add a new dateField to the post's context. This dateField would have a format argument like that: (iso8601DateFormat Nothing).

Cabal sandbox

When you install Hakyll following the official tutorial, you type cabal install hakyll, which installs globally the latest version of Hakyll. In a previous project, I had some troubles when I started to update this globally-installed Hakyll.

So I decided I will use a sandbox this time.

Sandboxes ( in cabal > 1.18 ) are self contained environments of Haskell packages.[^7]

My haskell's dependencies (including Hakyll) are written in a .cabal file. Then it's easy:

• cabal sandbox init to initialize the sandbox
• cabal install --dependencies-only to install dependencies

It seems like, in a near future, Hakyll will generate the .cabal file when doing a hakyll-init my-site[^8].

Comments

Of course, it is not possible to make a comment system using Hakyll. But it is possible to integrate one.

I was lazy so I choose to use Disqus. As it includes a lot of stuff (Google Analytics, ~ 700 ko of data which is around 200% of this page's size without comments), I don't let it load itself automatically.

I made something quick and dirty to do so:

<div id="disqus_thread"><a href="#disqus_thread" onclick="disqus()">Load comments</a></div>

<script type="text/javascript">
	function disqus() {
		// Disqus code
	}
</script>

You should give Hakyll a try!

[^1]: Someone even made a website to list them [^2]: Don't Repeat Yourself [^3]: See the official tutorial [^4]: See https://developer.mozilla.org/en-US/docs/XML/xml:base [^5]: See http://jaspervdj.be/hakyll/reference/Hakyll-Web-Template-Context.html#v:modificationTimeField [^6]: Specification: http://www.w3.org/TR/html5/text-level-semantics.html#the-time-element [^7]: I took this quote from http://dev.stephendiehl.com/hask/ [^8]: According to https://github.com/jaspervdj/hakyll/issues/267