At some point, he was faced with this error being displayed. We both looked at the problem and first made sure that said file existed. It was the case, weird…

A bit of googling will reveal that this is frequently fixed by appending the path to the pear folder to your php include_path (defined in your php.ini). But in his case, that was already done and it still wasn’t working.

Next up was to check permissions problem. Not having read permissions on the file would of been an easy one to fix, but again, this was not the cause of the problem.

At this point you might be asking yourself, how come the file exists, you have permission to read it, but yet, you can’t…

Well, the actual problem was that his OS was set up such that the maxfiles was set to 256 and PHPUnit had already reached that amount of open files.

To check if you have the same problem, try running phpunit using sudo dtruss -f -t open phpunit (Linux users will want to use strace -e open phpunit). In your output, you should see the files being opened. At some point, you’ll find Err#24, which indicates “To many file descriptors opened”. If you have this problem, then the following should help you fix it.

The solution to this problem is quite easy. What you’ll want to do is increase the maximum number of descriptors that can be used by a process. You can do it temporarily with ulimit -S -n 1024 (to use 1024 instead of 256). Another way is to edit it and keep those settings (until you change them again) is to use launchctl limit maxfiles 1024 unlimited.

At some point during the development, code coverage generation decided to stop working on my desktop (my remote CI still had no problem).

I started diagnosing the problem, being on Windows, I thought it could be due to the “poor job” I had done on installing php, pear and phpunit. I didn’t want to go through the trouble or reinstalling everything though and just did the minimum: uninstall and reinstall phpunit. No success at that point.

I decided to go back a week or two in my SVN revisions, have it generate code coverage and get to the point were code coverage generation would fail. Took around 2 SVN “update to” to get to that point. After that, I tried updating the tests, but the new tests were using new features. So I updated the code first, then started updating the test files one by one. After a couple of files, I hit an interesting message:

ErrorException [ 1 ]: Allowed memory size of 134217728 bytes exhausted (tried to allocate 543278 bytes) ~ C:\php\pear\Text\Template.php [ 134 ]

I never had that message show up before, which is kind of strange. I would have expected PHP to tell me that same message everytime it tried to generate the documentation but couldn’t…

So, quick fix was for me to edit my php.ini so that the memory_limit = 256M instead of 128M.

One small problem when you use the Serializable attribute of C# is that you cannot serialize dictionary directly and we all know dictionaries are a VERY useful structure to have serialized. One easy way to have serializable dictionaries is to use the DataContract attribute instead. It implies a bit more code compared to the version where you use the Serializable attribute, but not that much more (mostly the WriteObject and ReadObject lines).

I haven’t coded any of this, so thanks to user Loudenvier from Stackoverflow.com! This solution allows you to turn ANY object into an XML string representation. It also allows you to turn that string back into an object representation. Very useful.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public static class SerializationExtensions
{
    public static string Serialize<T>(this T obj)
    {
        var serializer = new DataContractSerializer(obj.GetType());
        using (var writer = new StringWriter())
        using (var stm = new XmlTextWriter(writer))
        {
            serializer.WriteObject(stm, obj);
            return writer.ToString();
        }
    }
    public static T Deserialize<T>(this string serialized)
    {
        var serializer = new DataContractSerializer(typeof(T));
        using (var reader = new StringReader(serialized))
        using (var stm = new XmlTextReader(reader))
        {
            return (T)serializer.ReadObject(stm);
        }
    }
}

How to use example

1
2
3
4
5
6
7
8
9

// dictionary to serialize to string
Dictionary<string, object> myDict = new Dictionary<string, object>();
// add items to the dictionary...
myDict.Add(...);
// serialization is straight-forward
string serialized = myDict.Serialize();
...
// deserialization is just as simple
Dictionary<string, object> myDictCopy = serialized.Deserialize<Dictionary<string,object>>();

Source: http://www.stackoverflow.com

On GameDev.net: Part 1 Part 2 Part 3 Part 4 Part 5

1

X = Hash.new {|h, k| h[k] = Hash.new(0)}

Avec ce code, à chaque fois qu’on crée un hash non-existant dans X, on ajoute un nouveau hash avec 0 comme valeur par défaut. Si maintenant on veut marshaller X, on obtient l’erreur suivante:

Marshal.dump(X)
TypeError: can’t dump hash with default proc

On obtient cette erreur puisque, lorsqu’on crée X, on a passé un bloc à new ce qui fait que lorsqu’on veut le marshaller, Ruby n’est pas mesure de marshaller le proc associé.
Afin d’être en mesure de marshaller X, il suffit simplement d’éliminer le proc en effectuant une copie vers un nouveau hash sans proc.

1
2
3

Y = Hash.new
X.each {|h, k| Y[h] = X[h]}
Marshal.dump(Y)

Avec l’ensemble des librairies qui ont été codés avec le temps (GTK, FTLK, Qt, wxWidgets, OpenGL, SDL, etc.), la majorité des plateformes informatiques ont commencés à devenir de plus en plus uniformes, permettant ainsi de déployer un même code sur plusieurs machines utilisant des systèmes d’opérations différents. On observe de plus la présence d’environnements de développement intégrés (EDI) multi-plateformes tel que Netbeans, Eclipse et Code::Blocks. Toutefois, il reste à déterminer quelle plateforme est la plus apte à permettre un développement qui sera rapide, efficace et de qualité. Afin de débattre de cette question, il est nécessaire d’évaluer certains aspects essentiels à la création d’un logiciel. Un logiciel peut être très facile à programmer mais être de piètre qualité en termes de performance (facilité de développement). Il peut être très long à programmer mais ne rien coûter (coûts reliées au développement). Les outils que les plateformes nous offrent peuvent être flexibles mais nécessiter une grande connaissance de ceux qui les emploient. Pour le développeur qui souhaite vendre son logiciel, il faut aussi connaître les diverses restrictions qui s’appliquent lorsqu’on emploi une librairie. Bref, il s’agit ici d’un ensemble d’aspects que nous aborderons afin de déterminer quelle plateforme entre Windows et Linux convient le mieux à un programmeur.

Commençons donc par les bases. L’objet en PHP est semblable à celui dans les autres langages: il contient des attributs (variables) ainsi qu’un ensemble de méthodes nous permettant de le manipuler.

Afin de rendre ce texte aussi utile qu’agréable, voici donc un petit objet, qui est en fait une page html:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Page {
	private $title = '';
	private $content = '';
 
	public function __construct($title = 'Titre par défaut', $content = 'Je suis du contenu')
	{
		$this->title = $title;
		$this->content = $content;
	}
 
	public function setTitle($title)
	{
		$this->title = $title;
	}
 
	public function setContent($content)
	{
		$this->content = $content;
	}
 
	public function render()
	{
		echo '<html>';
		echo '<head>';
		echo '<title' . $this->title . '</title>';
		echo '</head>';
		echo '<body>';
		echo $this->content;
		echo '</body>';
		echo '</html>';
	}
}

(oui, cette méthode render() est plutôt malpropre, mais pour les bien de la cause, on va souffrir un peu!)
Ainsi, avec cet objet, il m’est possible d’afficher une page HTML dont je peux modifier dynamiquement le contenu ainsi que le titre. Par exemple

1
2
3
4

$page = new Page();
$page->setTitle('Accueil');
$page->setContent('Ceci est un contenu vraiment intéressant!');
$page->render();

Me permet en 4 lignes d’afficher une page HTML complète (bien sûr il manque quelques tags pour la rendre valide w3c!)

Bon, maintenant voyons ce qui se passe vraiment. Premièrement, on a écrit la définition de notre objet, notre page doit avoir un titre et un contenu. Ce sont nos deux variables privées ($title et $content) car par défaut, un objet veut garder ses attributs (variables) à lui seul. Il en est le seul propriétaire et veut donc être le seul qui peut avoir le plaisir de les modifier. Bien sûr, il est possible de permettre aux autres de modifier ces variables en les rendant publiques, mais pourquoi gâcher le plaisir de notre objet???

Par la suite, on déclare deux méthodes qui permettent de modifier les variables par leur intermédiaire: setTitle($title) et setContent($content). La méthode __construct (débutant en PHP5) est l’équivalent du constructeur en C++. Lorsqu’on fait new Page(), il appelle le constructeur en lui donnant aucun attribut, il se contentera donc d’utiliser ceux par défaut. Finalement, la méthode render() permet l’affichage dans le navigateur du contenu précédemment affecté par les deux méthodes setTitle et setContent.

Pour ceux qui ne comprennent absolument rien de ce qui vient d’être dit, passons en mode ralenti

1

$page = new Page();

Ceci déclare un nouvel objet Page. Pour que PHP puisse utiliser un objet, il faut que celui-ci existe. Donc, en faisant new Page(), on dit à PHP “SVP mon Dieu, crée une Page sans attributs”. PHP, notre Dieu, fait. $page = permet d’attribuer ce nouvel objet à une variable pour le manipuler par la suite.

1

$page->setTitle('Accueil');

Ici, on dit à notre objet, par l’intermédiaire de la flèche qui signifie que l’on descend dans la branche d’héritage, que l’on veut qu’il exécute sa méthode setTitle avec comme paramètre le texte Accueil. Cela aura pour effet de modifier la variable interne $title de notre objet pour ‘Accueil’.

1

$page->setContent('Ceci est un contenu vraiment intéressant!');

Comme précédemment, on demande à notre objet d’exécuter sa méthode setContent pour modifier sa variable $content cette fois-ci. On lui attribut le texte ‘Ceci est un contenu vraiment intéressant!’.

1

$page->render();

Finalement, on demande à notre magnifique objet d’exécuter sa méthode render(), sans argument, qui retourne ses deux attributs formatés pour afficher une page HTML.

On voit donc que la POO en PHP est très similaire à celle en C++ ou autre langage OO. C’est compréhensible … on emploi les mêmes termes pour désigner les mêmes choses, non?

En conclusion, avec ce bref introduction à l’OO, je serais en mesure de vous montrer des scripts qui pourront vous permettre de gagner soit du temps, ou encore d’avoir bien du plaisir à voir la puissance que vous avez entre les mains. Enfin, il suffit seulement de savoir ce que l’on veut faire et comment on va s’y prendre pour y arriver.

La programmation orientée objet (ou POO) est un chef d’oeuvre en soi. Pourquoi? Parce que sa simplicité et sa rigueur en font l’une des meilleures façons de concevoir un logiciel, que se soit à l’aide de PHP, de C++ ou de tout autre langage orientée objet.

Mais qu’est-ce qu’ont les programmes orientés objets de si orgasmiques? Et bien, un ensemble de choses. Je ne ferais qu’en citer quelques-uns :
La possibilité d’écrire des classes réutilisables dans d’autres projets.
La possible de partager du code avec d’autres tout en ayant la capacité de retravailler sur son code sans affecter celui des autres.
La possibilité d’avoir des variables internes qui ne peuvent être travaillées par des processus externes.
La liste continue…

Bon, commençons donc avec les rudiments de la POO, en langage C++.

Qu’est-ce qu’un objet? Et bien, il s’agit d’une classe, ou d’un ensemble d’information à propos d’un concept. Par exemple, la classe voiture pourrait être définie comme suit :

1
2
3
4
5
6
7
8
9
10
11
12

class Voiture
{
	public:
		Voiture(int position_x = 0, position_y = 0);
		void avancer(int distance);
		void reculer(int distance);
		pair<int , int> obtenirPosition() const; 
 
	private:
		int position_x_;
		int position_y_;
}

Qu’est-ce que c’est que ce beau tas de code? Et bien, il s’agit de la déclaration de la classe voiture! Eh oui, vous avez découvert votre première classe! Bon, il s’agit ici d’une classe bien banale qui permettra à votre objet Voiture de se déplacer vers l’avant et vers l’arrière. Elle gardera les positions en x et en y (bien que puisque la voiture se déplace actuellement seulement selon l’axe des x, la position y nous est inutile).

Maintenant, attaquons-nous au code qui fera en sorte qu’il y ait de l’action. Premièrement, il faut un constructeur, c’est-à-dire que tout objet Voiture doit être construit avant de pouvoir fonctionner.

1
2
3
4

Voiture::Voiture(int position_x, int position_y)
: position_x_(position_x), position_y_(position_y)
{
}

Ici, on utilise le même nom que la classe pour déclarer ce constructeur. Vous noterez l’utilisation de : avant position_x_ et position_y_. Il s’agit d’une liste d’initialisation, c’est-à-dire que ces valeurs seront initialisées avec les valeurs dans les parenthèses. Pourquoi donc faire cela?

En C++, la création d’objet ce fait de cette façon : premièrement, on crée les attributs (les variables private), puis on appelle le constructeur qui se charge alors de construire l’objet. S’il arrivait qu’un objet A était inclus dans un autre objet B, cela aurait pour effet d’initialiser l’objet A avec des paramètres par défaut. Or, faire cela implique créer un objet avec des paramètres qu’on va changer quelques instants après, ce qui est une perte d’efficacité et une preuve de manque d’intelligence (vous ne voudriez pas paraître stupide non?).

Bon, avec ce constructeur, votre objet peut être créé. Mais rien de plus. Faisons à présent les deux fonctions de déplacement :

1
2
3
4
5
6
7
8

void avancer(int distance)
{
	position_x_ += distance;
}
void reculer(int distance)
{
	position_x_ -= distance;
}

Code très simple. Ajoute ou enlève à la valeur de position_x_, un de nos attributs internes.

Finalement, il nous faut une fonction qui sera en mesure de nous donner notre position en x et en y!

1
2
3
4

pair <int , int> obtenirPosition() const
{
	return make_pair(position_x_, position_y_);
}

Avec ça, vous pouvez déjà faire une Voiture, la faire avancer et reculer et même obtenir sa position! Wow, vous avez presque le début d’un jeu de course entre les mains! À vous de repousser les limites maintenant.