Parmi les erreurs à éviter il y a :

• Ajout de lignes à chaque exécution d'un script avec des INSERT
• Erreur lorsque qu'une table ou une procédure stockée doit être créée et qu'elle existe déjà
• Et j'en passe...

Aujourd'hui je souhaitais donc partager une petite astuce lorsque vous avez besoin de modifier la structure d'une table en y ajoutant un champ supplémentaire. Si vous tenter d'éxécuter plusieurs fois le script suivant, vous aurez à partir de la seconde fois une belle erreur SQL.

ALTER TABLE `matable` ADD `monchamp` INT(0) NOT NULL ;

L'astuce est de créer une procédure stockée à la volée qui va se charger de vérifier si le champ n'existe pas et, le cas échéant, de le créer. Voici la formule magique.

-- On supprime la procédure stockée si elle existe déjà, afin d'éviter les erreurs et l'obsolescence de celle-ci
DROP PROCEDURE IF EXISTS AddColumnIfNotExists;
DELIMITER $$

CREATE PROCEDURE AddColumnIfNotExists(IN dbName tinytext, IN tableName tinytext, IN fieldName tinytext, IN fieldDef text)
BEGIN
	-- On vérifie si le champ existe déjà pour la base de données et la table données
	IF NOT EXISTS (
		SELECT * 
		FROM INFORMATION_SCHEMA.COLUMNS
		WHERE column_name = fieldName
		AND table_name = tableName
		AND table_schema = dbName
	)
	THEN
		-- On ajoute le champ s'il n'existe pas déjà
		SET @ddl = CONCAT('ALTER TABLE `', dbName, '`.`', tableName, '` ADD `', fieldName, '` ', fieldDef, ';');
		PREPARE stmt FROM @ddl;
		EXECUTE stmt;
	END IF;
END $$

DELIMITER ;

-- On appelle la procédure stockée pour ajouter le champ à la table si nécessaire (Database() renvoie le nom de la base de données en cours)
CALL AddColumnIfNotExists(Database(), 'matable', 'monchamp', 'INT(0) NOT NULL');

-- On supprime la procédure stockée pour éviter qu'elle n'encombre la base de données pour rien
DROP PROCEDURE AddColumnIfNotExists;

Voilà, c'est aussi simple que ça.

Dans un premier temps, lancer l'outil de test de Wampserver (dans l'icone de la barre de tâche : Apache > Service > Tester le Port 80) si vous utilisez cet environnement, ou éxecuter le script PHP suivant grâce à la commande :

php -n -f testPort.php

Fichier testPort.php :

<?php
$fp = @fsockopen("127.0.0.1", 80, $errno, $errstr, 1);
   $out = "GET / HTTP/1.1rn";
   $out .= "Host: 127.0.0.1rn";
   $out .= "Connection: Closernrn";
if ($fp)
{
    echo  'Your port 80 is actually used by :

';
   fwrite($fp, $out);
   while (!feof($fp))
   {
        $line = fgets($fp, 128);
        if (ereg('Server: ',$line))
        {

            echo $line;
            $gotInfo = 1;
        }

    }
    fclose($fp);
    if ($gotInfo != 1)
        echo 'Information not available (might be Skype).';
}
else
{
    echo 'Your port 80 is not actually used.';
}

echo '

Press Enter to exit...';
trim(fgets(STDIN));
?> 

Si comme moi vous avez marqué :

Your port 80 is actually used by :

Server: Microsoft-IIS/10.0

Press Enter to exit...

Vous devrez aller désactiver le service qui se lance sûrement au démarrage de votre ordinateur.

Pour ce faire, lancer le gestionnaire des services (Exécuter > services.msc), puis chercher "Service de publication World Wide Web" ("World Wide Web Publishing Service" pour les anglophones). Il devrait être défini en état "En cours d'éxecution" et type de démarrage "Automatique".

Pour libérer le port 80, vous devrez passer le serveur en type de démarrage "Manuel" et en forçant l'arrêt du service (clic droit > "Arréter"). Après cette opération, vous devriez pouvoir démarrer votre serveur Apache correctement.

Si vous avez des questions, n'hésitez pas à me les poser dans les commentaires.

Pour récupérer votre timeline, il est nécessaire de suivre 3 étapes : la mise en place de l'espace de travail, l'authentification avec OAuth, la connexion et la récupération de la timeline. Nous réaliserons cela sous la forme d'une classe dédiée afin que vous puissiez la réutiliser dans d'autres projets et évenuellement la compléter avec d'autres méthodes. Notre classe possèdera en attribut les différentes informations de connexion (elles pourraient être récupérer dans la base de données ou dans un fichier de configuration), un constructeur qui gérera la connexion, et une ou plusieurs méthodes gérant les différents appels à Twitter.

Mise en place de l'espace de travail

Tout d'abord, il vous faut un compte Twitter (j'espère que vous en avez déjà un). Voici le mien @SarramegnaG.

Ensuite il vous faut configurer un nom de domaine local car Twitter n'accepte pas les requêtes provenant de localhost ou 127.0.0.1. Pour ce faire, vous irez dans /etc/hosts pour les linuxiens ou C:\Windows\System32\drivers\etc\hosts pour les windowsiens et vous ajouterez la ligne suivant (avec le nom de domaine de votre choix) :

127.0.0.1	monsiteweb.tld
127.0.0.1	www.monsiteweb.tld

Vous pourrez ensuite accéder avec votre site local (accessible à l'adresse http://localhost/ ou http://127.0.0.1/) en tapant http://monsiteweb.tld dans votre navigateur.
Si votre site se trouve dans un sous répertoire, vous voudrez peut-être jouer avec le VirtualHost pour aller taper directement dans le bon répertoire.

Troisième étape, il vous faut déclarer votre application web chez Twitter. Ce n'est pas obligatoire, mais c'est mieux.
Rendez-vous à l'adresse https://dev.twitter.com/apps et connectez-vous.
Créez une nouvelle application et nommez la comme vous le désirez. Une fois valider, vous pourrez modifier l'accès en lecture/écriture si vous souhaitez pouvoir tweeter depuis votre site web. Vous pouvez maintenant générer votre jeton en cliquant dans l'onglet "Détails" et sur le bouton "Créer mon jeton d'accès" ("Create my access token").

Authentification avec OAuth

Qu'est ce que OAuth ?

OAuth est un protocole libre [...] qui permet l'authentification à une API sécurisée d'une façon simple et standard depuis son bureau ou une application web. Pour les développeurs d'une application accédant à une API, OAuth est une façon de publier et d'interagir avec des données protégées. Pour les développeurs fournissant une API, OAuth permet de donner accès aux données tout en protégeant le pseudonyme et le mot de passe des utilisateurs.
Source

En d'autres termes, OAuth sert à authentifier un utilisateur depuis votre site web en ne fournissant ni pseudonyme, ni mot de passe. Du coup votre site se retrouve avec un jeton d'accès qui autorise l'accès aux données du service concerné (Twitter ici). Il peut donc être facilement révoqué si vous le désirez.

Pour obtenir ce jeton, une série d'étapes se met en place : pour avoir accès à vos données, le site web va demander à Twitter un jeton non autorisé. Vous êtes ensuite redirigé vers Twitter pour confirmer ou non la demande de jeton (le lien se fera grâce au jeton non autorisé qui sera fourni dans l'url). Si vous confirmez, vous serez redirigé vers le site qui a fait la demande en fournissant (grâce à l'URL) le code de confirmation associé à ce jeton. Le site fait enfin une demande à Twitter avec le jeton fraichement approuvé et le code de confirmation afin de récupérer le jeton qui permettra au site de récupérer vos données de Twitter.

En noir, les appels serveur à serveur. En rouge, les redirections de l'utilisateur.

Dans notre cas, nous ne gèrerons qu'un compte Twitter, celui associé à notre site web. On va donc pouvoir sauter les étapes de demande de jeton et de redirection de l'utilisateur. Ces informations nous sont données dans l'onglet "OAuth tool" de l'application que nous venons de créer sur Twitter aux rubriques "Jeton d'accès" ("Access Token") et "Jeton d'accès secret" ("Access token secret").

Le squelette de notre classe :

<?php

class MyApp_Service_Twitter {

	public function __construct() {
	}
}

Ajoutons-y les informations de notre compte :

<?php

class MyApp_Service_Twitter {

    private $accountEmail = 'monadresse@email.com'; // Email du compte
    private $accessToken = '123456789-abcdefghijklmnopqrstuvwxyz0123456789abcd'; // Access token
    private $accessTokenSecret = 'abcdefghijklmnopqrstuvwxyz0123456789abcdefg'; // Access token secret

	public function __construct() {
	}
}

La connexion à Twitter se fait en deux étapes. La création d'un jeton OAuth avec la classe Zend_Oauth_Token_Access puis la connexion au compte Twitter grâce à la classe Zend_Service_Twitter.

<?php

class MyApp_Service_Twitter {

    private $accountEmail = 'monadresse@email.com'; // Email du compte
    private $accessToken = '123456789-abcdefghijklmnopqrstuvwxyz0123456789abcd'; // Access token
    private $accessTokenSecret = 'abcdefghijklmnopqrstuvwxyz0123456789abcdefg'; // Access token secret
    private $token = null;
    private $twitter = null;

	public function __construct() {
		// Création du jeton
	    $this->token = new Zend_Oauth_Token_Access();
	    $this->token->setToken($this->accessToken);
	    $this->token->setTokenSecret($this->accessTokenSecret);

		//Connexion au compte Twitter
	    $this->twitter = new Zend_Service_Twitter(array(
	        'username' => $this->accountEmail,
	        'accessToken' => $this->token
	    ));
	}
}

A partir de là, l'appel aux méthodes de Zend_Service_Twitter est enfantin. Il suffit de créer autant de méthode à notre classe que nous souhaitons. Créons par exemple deux méthodes, une qui nous renverra notre timeline, et une autre qui nous permettra de tweeter sur notre compte par exemple.

<?php

class MyApp_Service_Twitter {

    private $accountEmail = 'monadresse@email.com'; // Email du compte
    private $accessToken = '123456789-abcdefghijklmnopqrstuvwxyz0123456789abcd'; // Access token
    private $accessTokenSecret = 'abcdefghijklmnopqrstuvwxyz0123456789abcdefg'; // Access token secret
    private $token = null;
    private $twitter = null;

	public function __construct() {
		// Création du jeton
	    $this->token = new Zend_Oauth_Token_Access();
	    $this->token->setToken($this->accessToken);
	    $this->token->setTokenSecret($this->accessTokenSecret);

		//Connexion au compte Twitter
	    $this->twitter = new Zend_Service_Twitter(array(
	        'username' => $this->accountEmail,
	        'accessToken' => $this->token
	    ));
	}

	public function getMyTimeLine() {
		return $this->twitter->status->userTimeline(
			array('id' => 'SarramegnaG')
		);
	}

	public function postTweet($message) {
		return $this->twitter->status->update($message);
	}
}

Il ne vous reste plus qu'à utiliser vos méthodes fraichement créées dans votre contrôleur par exemple.

<?php

class TwitterController extends Zend_Controller_Action {

    public function indexAction() {
		$twitter = new MyApp_Service_Twitter();
		$this->view->timeline = $twitter->getMyTimeLine();
	}
}

Voilà, j'espère que ce tutoriel vous aura aider et que vous avez pris autant de plaisir à le lire que moi à l'écrire.

Rien de plus simple ici, la mise en place de la traduction s'organise en 4 parties :

1. Choisir le format de stockage des traductions
2. Paramétrer Zend_Translate dans le bootstrap
3. Intégrer Zend_Translate à la vue
4. Créer le(s) fichier(s) de traduction

Partie 1 :

Le format de stockage, appelé aussi adaptateur, permet de stocker les traductions avec plusieurs avantages et inconvénients. Je ne ferai que citer les 3 principaux :

• Tableau (array) : Utilise les tableaux PHP
  Avantages et inconvénients : Petites pages ; l'utilisation la plus simple ; seulement pour les programmeurs
• Csv : Utilise les fichiers à séparation par virgule (*.csv/*.txt)
  Avantages et inconvénients : Format simple de fichier texte ; rapide ; problèmes possibles avec les caractères Unicode
• Gettext : Utilise les fichiers binaires gettext (*.mo)
  Avantages et inconvénients : Norme GNU pour Linux ; thread-safe (contrairement à gettext de PHP) ; besoin d'outils pour la traduction

Nous allons ici prendre le cas de la traduction via un simple tableau PHP mais vous comprendrez qu'il est aussi très simple de mettre en œuvre une traduction avec les autres adaptateurs.

Partie 2 :

Le constructeur de la classe Zend_Translate prend 4 paramètres :

1. Le type de l'adaptateur
2. Le chemin vers le fichier ou le répertoire contenant les fichiers
3. La langue
4. Les options

Voici le code concernant la configuration de l'object Zend_Translate :

$translate = new Zend_Translate(
	'array',
	APPLICATION_PATH . '/languages',
	'auto',
	array('scan' => Zend_Translate::LOCALE_DIRECTORY)
);

On dit ici que :

• le type de l'adaptateur est "array" (un tableau PHP)
• les fichiers de langues sont stockés dans le répertoire "languages" du répertoire Application
• la langue par défaut est la langue locale (ex : fr)
• les fichiers se nomment et se trouvent en fonction de la langue locale (ex : fr.php ou fr/monfichierdelangue.php)

On peut définir la langue locale grâce à :

$translate->setLocale('fr');

Et finalement, on l'ajout au registre pour une utilisation plus tard dans l'affichage de la page :

Zend_Registry::set('Zend_Translate', $translate);

Voici le code complet :

<?php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

	public function _initTranslate() {
		$translate = new Zend_Translate('array', APPLICATION_PATH.'/languages', 'auto', array('scan' => Zend_Translate::LOCALE_DIRECTORY));
		$translate->setLocale('fr');
		Zend_Registry::set('Zend_Translate', $translate);
		return $translate;
	}
}

Partie 3 :

Le plus dur est fait ! Voici donc le code pour la vue :

<?php echo $this->translate('I_LOVE_THIS_BLOG')?>

On fait donc appel à l'aide de vue Zend_View_Helper_Translate pour traduire un texte. Ici "I_LOVE_THIS_BLOG" est ce qu'on appelle une clé de traduction puisqu'elle sera la même pour toutes les langues. Il n'y a pas d'obligation de l'écrire en majuscule mais c'est une bonne habitude d'écrire les constantes des scripts PHP ainsi.

Partie 4 :

Eh oui, on enchaine ! Rien de plus simple que de constituer maintenant les fichiers de traductions. On prend pour premier exemple le fichier de traductions fr.php :

<?php
	return array(
		'I_LOVE_THIS_BLOG' => 'J\'adore ce blog !'
	);

Pour ajouter une clé de traduction, il suffit d'ajouter une valeur au tableau avec :

• en clé : la clé de traduction
• en valeur : le texte traduit dans la langue qui convient.

Pour le fichier de traductions en.php, il conviendra de traduire le texte comme ceci :

<?php
	return array(
		'I_LOVE_THIS_BLOG' => 'I love this blog !'
	);

Conclusion :

Voilà, c'est tout pour aujourd'hui, et comme vous avez été patient(e) et avez lu ce tutoriel jusqu'au bout, je vous donne un cadeau bonus pour gérer le changement de langue, le log des traductions inexistantes, et même un lien vers des fichiers pour traduire vos erreurs de formulaires automatiquement.

Bootstrap.php

<?php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

	public function _initTranslate() {
		// On récupère la session de la langue
		$languageNamespace = new Zend_Session_Namespace('Language');
		$translate = new Zend_Translate('array', APPLICATION_PATH.'/languages', 'auto', array('scan' => Zend_Translate::LOCALE_DIRECTORY));
		// On définit la langue des traductions
		if ($translate->isAvailable($languageNamespace->country)) {
			$translate->setLocale($languageNamespace->country);
		} else {
			$translate->setLocale('fr');
		}

		// On stocke les traductions manquantes dans un fichier de log
		$writer = new Zend_Log_Writer_Stream(APPLICATION_PATH.'/log/translate-not-found.log');
		$log = new Zend_Log($writer);
		$translate->setOptions(array(
			'log' 				=> $log,
			'logMessage'      	=> "La clé de traduction '%message%' n'est pas connue en langue '%locale%'",
			'logUntranslated' 	=> true,
			'route'				=> array($translate->getLocale() => 'fr'),
		));

		Zend_Registry::set('Zend_Translate', $translate);

		Zend_Validate_Abstract::setDefaultTranslator($translate); // Pour gérer la traduction des erreurs de formulaires

		return $translate;
	}
}

IndexController.php

<?php

class IndexController extends Zend_Controller_Action {

	public function languageAction() {
		$this->_helper->layout()->disableLayout();
		$this->_helper->viewRenderer->setNoRender(true);

		$languageValue = $this->_request->getParam('country', 'fr');
		$languageNamespace = new Zend_Session_Namespace('Language');
		$languageNamespace->country = $languageValue;

		// On redirige vers la page précédente
		$this->_redirect($this->_request->getServer('HTTP_REFERER'));
	}
}

La faute à qui ? Il suffit de regarder du côté des magic_quotes.

Avec les versions de PHP précédant la version 5.3.0, vous obtiendrez très probablement ce genre de problème. En effet, le paramètre magic_quotes_gpc par défaut est à true. De ce fait, les paramètres passés par la méthode GET (mais aussi POST et les cookies) sont manipulés pour ajouter un slash devant le délimiteur de chaîne qu'est l'apostrophe, ce qui peut être embêtant lors de l'affichage.

Plusieurs solutions s'offrent donc à vous.

En php :

<?php
// En remplaçant
echo "Nom: ".$_GET["nom"];
// par
echo "Nom: ".stripSlashes($_GET["nom"]);

Mais ceci n'est pas très pratique car il faudrait faire beaucoup de cas par cas. Du coup on peut réaliser une petite manipulation au début de notre page comme ceci (proposée par la doc PHP) :

<?php
if (get_magic_quotes_gpc()) {
	$process = array(&$_GET, &$_POST, &$_COOKIE, &$_REQUEST);
	while (list($key, $val) = each($process)) {
		foreach ($val as $k => $v) {
			unset($process[$key][$k]);
			if (is_array($v)) {
				$process[$key][stripslashes($k)] = $v;
				$process[] = &$process[$key][stripslashes($k)];
			} else {
				$process[$key][stripslashes($k)] = stripslashes($v);
			}
		}
	}
	unset($process);
}

Mais là encore, c'est pas top !

La fonction stripSlashes() (opération inverse de addSlashes()) permet de supprimer les slashes pratiques car ils évitaient de faire appel à la fonction mysql_escape_string() (ou addSlashes()) avant insertion dans une base de données. En revanche, il est maintenant nécessaire de faire appel à stripSlashes() avant affichage. Ainsi, depuis la version 5.3.0, cette option n'est plus activée par défaut ce qui évite d'avoir les slashes d'échappement.
Du coup, lorsque l'on écrit un script destiné à n'importe quelle version de PHP, il doit déterminer comment celui-ci est configuré ou forcer la configuration pour savoir s'il faut ou non ajouter des slashes.

La meilleure des solutions serait de désactiver les magic_quotes dans le php.ini.

; Magic quotes

; Magic quotes for incoming GET/POST/Cookie data.
magic_quotes_gpc = Off

; Magic quotes for runtime-generated data, e.g. data from SQL, from exec(), etc.
magic_quotes_runtime = Off

; Use Sybase-style magic quotes (escape ' with '' instead of ').
magic_quotes_sybase = Off

Mais tout le monde n'y a pas accès. Une autre solution (encore) est de configurer cela dans le fichier .htaccess :

php_flag magic_quotes_gpc Off

Le problème c'est que cette commande n'est pas exécutée sur OVH, mais heureusement, ils nous en fournissent une autre pour désactiver les magic_quotes (à mettre dans le fichier .htaccess) :

SetEnv MAGIC_QUOTES 0

Et le tour est joué.

Pour la petite histoire, qu'est ce que l'URL rewriting ?

L’URL rewriting permet de réécrire des URL complexes de façon simplifiée et est notamment utilisé pour le référencement.

En effet, des liens plus simples facilitent le travail des robots d'indexation et évitent les erreurs de saisie des visiteurs (suppression des accents et autres caractère spéciaux). Elle permet aussi de sécuriser l'accès à ses pages en masquant les noms de variables passées dans l’URL.

On va donc voir comment mettre en place l'URL rewriting avec Zend Framework (ce qu'on pourrait aussi bien faire avec un .htaccess mais bon, Zend c'est cool) et ceci, en 3 parties : le bootstrap, la réécriture d'URL dans la vue et le fichier INI.

Le bootstrap :

<?php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

	protected function _initRouter() {
		$front = $this->bootstrap('FrontController')->getResource('FrontController'); // On récupère le frontController
		$config = new Zend_Config_Ini(APPLICATION_PATH . '/configs/application.ini', 'production'); // On récupère la config (avec les paramètres de routage)
		$routing = new Zend_Controller_Router_Rewrite(); // On instancie notre objet de routage
		$routing->addConfig($config, 'routes'); // On le configure
		$front->setRouter($routing); // Et on mélange le tout
	}
}

Plein la vue :

<?php echo $this->url(array('id' => $idArticle, 'name' => $titreArticle), 'article', true); ?>

Pour afficher le lien, on passe en premier paramètre un tableau correspondant à nos variables (cf la dernière ligne du fichier INI), en second, le nom de la route, et en dernier on spécifie que les paramètres de la page en cours sont à ignorer.

Le fichier INI :

[production]
routes.article.type = "Zend_Controller_Router_Route_Regex" ;Le type de routage
routes.article.route = "article/(\d+)-(\w+).html" ;La regex qui correspond à l'URL à router
routes.article.defaults.controller = "article" ;Le contrôleur vers lequel on route l'URL
routes.article.defaults.action = "voir" ;L'action vers lequel on route l'URL
routes.article.map.1 = "id" ;Le nom du paramètre correspondant à la première paire de parenthèses
routes.article.map.2 = "name" ;Le nom du paramètre correspondant à la deuxième paire de parenthèses
routes.article.reverse ="article/%d-%s" ;Ce qui va nous permettre de faire l'opération inverse en donnant l'id de l'article ainsi que son nom

Le tour est joué.

Je précise deux points que je n'ai pas traité plus haut :

1. Pour éviter des conflits avec les autres appels de l'aide de vue "url", il convient de passer la valeur 'default' en second paramètre de celle-ci pour ne pas utiliser la route de la page en cours.
2. Il convient aussi de supprimer les caractères du nom de l'article qui ne seraient pas compatibles avec la classe [A-Za-z_] (correspondant à \w)

A bientôt !

Lorsque vous avez cherché à faire des jointures entre vos tables, vous avez peut-être rencontré ce message d'erreur :

Select query cannot join with another table

Ceci est dû au fait que ZF ne permet pas de sélectionner des champs provenants d'autres tables que la table présente dans le FROM.

L'objet Zend_Db_Table_Select est destiné à sélectionner des données sur une table précise. Des jointures peuvent être faites, mais il n'est pas possible de sélectionner des colonnes ne faisant pas partie de la table sous jacente. Cependant, ceci aurait pu être utile dans certains cas, et l'objet Zend_Db_Table_Select possède une clause spéciale déverrouillant cette limitation. Passez la valeur false à sa méthode setIntegrityCheck. Il est alors possible de sélectionner des colonnes hors table. Attention toutefois, l'objet row/rowset résultant sera verrouillé. Impossible d'y appeler save(), delete() ou même d'affecter une valeur à certains de ses champs. Une exception sera systématiquement levée.

De ce fait, afin de contourner cette restriction, il convient d'appeler la méthode setIntegrityCheck() de la classe Zend_Db_Select comme ceci.

<?php

class Application_Model_DbTable_Articles extends Zend_Db_Table_Abstract {
    protected $_name = 'articles';
    protected $_primary = 'idArticle';

    public function obtenirArticleEtCommentaires($idArticle) {
    	$select = $this->select()->setIntegrityCheck(false)
    				->from(array('a' => $this->_name), array('*'))
    				->joinLeft(array('c' => 'commentaires'), 'c.idArticle = a.idArticle', array('*'))
    				->joinLeft(array('u' => 'utilisateurs'), 'u.idUtilisateur = c.idUtilisateur', array('nomUtilisateur'))
    				->where('a.idArticle = ?', $idArticle);
    	return $this->fetchAll($select);
    }
}

Rien de plus, rien de moins. Votre requête devrait maintenant correctement se lancer.

A bientôt !

Il me sert avant tout de bloc-note mais aussi à faire partager mes découvertes afin que vous trouviez rapidement une solution à vos problèmes si je les ai déjà rencontrés.

Je ferai en sorte de le tenir actualisé aussi souvent qu'une nouvelle découverte me le permettra.

Vous pourrez donc y consulter divers articles traitant d'autant de sujets que possible dans le domaine du développement web (HTML5, CSS3, jQuery, PHP, Zend, ...) mais aussi des nouvelles technologies.

Je suis ouvert à toutes questions ou suggestions par message en passant par cette page.

Guillaume SARRAMEGNA