diff --git a/source/_static/ressources/uml/UMLNotationSummary.pdf b/source/_static/ressources/uml/UMLNotationSummary.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..04715b61845da46dfbffbdfa645f3ea5c10b1e7a
Binary files /dev/null and b/source/_static/ressources/uml/UMLNotationSummary.pdf differ
diff --git a/source/index.rst b/source/index.rst
index c56ca4b6f35c1def161dadd7ce476cd159bb6a14..8bc6b83d2108072a7cf96d8b7106a09e3a037aa6 100644
--- a/source/index.rst
+++ b/source/index.rst
@@ -20,4 +20,6 @@ Cette documentation sert de référence en ce qui concerne les outils et usages
vai/index.rst
+ poo/index.rst
+
diff --git a/source/poo/general.md b/source/poo/general.md
new file mode 100644
index 0000000000000000000000000000000000000000..ef9dfe224af97cac4612324b9c7dc63dd7c0529f
--- /dev/null
+++ b/source/poo/general.md
@@ -0,0 +1,127 @@
+# Introduction
+
+La programmation orientée objet (POO) est un paradigme de programmation qui permet de modéliser des concepts du monde réel sous forme d'objets.
+Veremes utilise principalement le PHP et le TypeScript pour développer qui sont deux langages prenant en charge ce paradigme.
+
+Les objets sont des instances de classes, qui sont des modèles pour la création d'objets. Les classes contiennent des propriétés, qui sont des variables qui stockent l'état de l'objet, et des méthodes, qui sont des fonctions qui définissent le comportement de l'objet.
+
+L'encapsulation est un concept clé de la POO qui consiste à masquer l'état interne d'un objet et à fournir une interface publique pour interagir avec cet objet.
+
+L'héritage est un autre concept important de la POO qui permet à une classe d'hériter des propriétés et des méthodes d'une autre classe parente. Cela permet de créer des classes dérivées qui héritent des fonctionnalités de la classe parente et peuvent également ajouter leurs propres fonctionnalités.
+
+Le polymorphisme est un autre concept clé de la POO qui permet à un objet d'être traité comme un objet d'un type différent. Cela permet de créer des classes qui partagent une interface commune mais ont des comportements différents.
+
+En utilisant ces concepts de base, la POO permet de créer des programmes plus modulaires, maintenables et évolutifs, car les objets peuvent être réutilisés et étendus de manière flexible.
+
+## Concepts clés de la POO
+
+### Classes, Interface, objets
+
+Une classe est un modèle pour la création d'objets qui définit les propriétés et les méthodes que posséderont les objets créés à partir de cette classe. Les propriétés sont des variables qui stockent l'état de l'objet, tandis que les méthodes sont des fonctions qui définissent le comportement de l'objet. C'est une sorte de plan pour créer des objets.
+
+
+
+Un objet est une instance d'une classe, c'est-à-dire qu'il est créé à partir d'un modèle de classe. Les objets ont des propriétés et des méthodes qui sont définies dans leur classe correspondante.
+
+L'encapsulation est un concept clé de la POO qui consiste à masquer l'état interne d'un objet et à fournir une interface publique pour interagir avec cet objet. Les niveaux de visibilité des propriétés (**public**, **private** et **protected**) sont utilisés pour définir l'accès à ces propriétés.
+
+Les objets ont une portée limitée à leur cycle de vie, c'est-à-dire qu'ils existent uniquement tant qu'ils sont référencés par une variable. Lorsqu'une variable qui fait référence à un objet est détruite ou affectée à une autre valeur, l'objet est libéré de la mémoire.
+
+
+
+ci-dessous un exemple concret de classe et de son utilisation:
+```php
+// Définition de la classe
+class XWing {
+ // propriétés
+ public owner;
+ private hasWeapons = true;
+
+ // méthodes
+ public function fly() : void {
+ error_log($this->owner ' décolle de Yavin IV');
+ }
+
+ public function shoot() : int {
+ if ($this->weapon) {
+ error_log($this->owner ' tire sur l\'ennemi');
+ } else {
+ error_log($this->owner ' ne peux pas tirer');
+ }
+ }
+}
+
+
+// Utilisation de la classe
+
+$YL = new XWing();
+$YL->owner = 'Yellow leader'
+
+$YL->fly(); // print : Yellow leader décolle de Yavin IV
+
+```
+
+L'interface va définir le comportement d'une classe.
+
+Il faut voir l'interface comme un contrat qui va imposer à la classe l'utilisant des attributs et des méthodes sans les définir.
+
+Exemple : Je signe un contrat de travail, je m'engage à réaliser les tâches qui m'incombent en tant que salarié.
+
+### Interactions et abstraction
+
+Les objets peuvent intéragir les un avec les autres de différentes manières.
+
+Un objet peut utiliser un autre objet, l'objet composant fait alors parti intégrante d' l'objet conteneur, les deux objets sont alors lié et la destruction de l'objet conteneur entraine la destruction de l'autre objet. On parle alors de **composition**, exemple : Une voiture est composé d'un moteur, d'une carroserie, ... La destruction de la voiture entraine la destruction des autres sous-objets.
+
+Un objet peut être composé d'un ensemble d'objets, on parle alors d'**aggrégation**. Dans ce cas l'objet conteneur contient plusieurs sous-objet d'un même type. Le lien est moins fort que la composition, dans le sens ou la desturction du conteneur n'entrainera pas forcément la destruction des autres objets car il ne les référence pas directement. On parle d'aggrégation, exemple : une bibliothèque contient des livres.
+
+Une classe peut **hériter** d'une autre classe, on parle alors de **spécialisation ou d'héritage**. La classe enfant va alors hériter des propriétés et des méthodes de la classe parente, la classe enfant peut comporter d'autre propriétés et d'autre méthode et peut surcharger également les éléments du parents. Ce mécanisme permet d'éviter la duplication de code.
+
+Une classe peut **implémenter** une interface, la classe en question devra alors avoir défini les méthode et contenir les attributs spécifié par l'interface.
+
+Ces deux dernier concepts permettent à l'objet de prendre différentes formes ou à modifier son comportement en fonction du contexte d'utilisation. On parle alors de **polymorphisme**.
+
+Une classe peut ne pas être prévue pour créer des objet mais pour servir de parent à plusieurs classes enfants dans le but de mutualiser du code, on parle alors de **classe abstraite**. On peut aussi parler de **méthodes abstraites** qui imposent les mêmes contraintes qu'une interface aux classe enfant (elle devront être surchargées obligatoirement).
+
+Dans la majorité des langages (c'est le cas dans ceux utilisés par Veremes), **une classe ne hérité que d'une seule autre classe en revanche elle peut implémenter autant d'interface qu'elle veut**.
+
+Dans le cas de PHP, ll existe un autre élément permettant la mutualisation de code redondant, il s'agit du **trait**. Le trait à la différence de l'interface autorise l'implémentation d'un code par défaut, il s'agit d'une collection de méthodes, c'est trés pratique en revanche c'est à utiliser avec précaution, le code implémenté dans le trait impliquant un contexte d'utilisation qui n'est pas forcément implémenter par votre classe ou vos objets.
+
+Les visibilités auront un impact sur l'usage du code mutualisé.
+
+Le code **privé** ne sera accessible que par la **classe elle-même**.
+Le code **protégé** sera accessible par **la classe et ses enfants**.
+Le code **public** sera accessible par **tout le monde** y compris de l'extérieur de l'objet final.
+
+Sur des exemples concrets : Vous pouvez interagir avec votre voitures via le volant, les pédales, des boutons ce serait des méthodes publics de l'objet voiture. Un Camion à le même comportement qu'une voiture lorsqu'on interagit avec le volant on pourrait parler de comportement protégé d'un véhicule. L'électronique de la voiture fait transiter les informations depuis les boutons aux composants électronique finaux par un flux spcifique et qui m'est totalement opaque, on est sur un comportement privé.
+
+### Modélisation
+
+Ces éléments et leurs intéractions peuvent être modéliser sur un diagramme de classe grâce à l'[UML](http://documentation-dev.veremes.net/dev/fr/_static/ressources/uml/UMLNotationSummary.pdf)
+
+## Exemple d'utilisation dans Vitis
+
+### Héritage
+
+### Implémentation
+
+### Traits
+
+### Utilisation de l'interface de manipulation des fichiers
+
+
+
+A partir du moment ou votre controlleur hérite de `VitisAbstractController`, il pourra accéder au `FileManager` car il y a une relation de composition protégé entre les deux classes.
+
+Le FileManager a une relation de composition avec l'une des deux classes ou les deux classes implémentant L'interface `FileAccessorInterface`, à savoir `LocalAccessor` et `S3Accessor`. La nuance d'une ou deux étant compliqué je rentre pas dans le détail.
+
+Le Filemanager se comporte alors comme une **Factory Method** (on en parlera plus tard), qui va fournir l'objet que l'on veut en fonction de la configuration de Vitis. Cette classe va agir comme une couche d'abstraction pour le développeur, c'est à dire qu'il passera le chemin d'écriture et le code lui retournera l'objet adapté pour interagir avec le systéme de fichier utilisé par Vitis.
+
+## Autres mot clés
+
+final
+
+self
+
+static
+
diff --git a/source/poo/images/blueprint.jpg b/source/poo/images/blueprint.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..c9ac1cc4cdd472459c136fc3f8197dd92eedc57b
Binary files /dev/null and b/source/poo/images/blueprint.jpg differ
diff --git a/source/poo/images/fileAccessor.png b/source/poo/images/fileAccessor.png
new file mode 100644
index 0000000000000000000000000000000000000000..6dbb9bbd832448880e0fcc60fbd740af001403b6
Binary files /dev/null and b/source/poo/images/fileAccessor.png differ
diff --git a/source/poo/images/x-wing.jpg b/source/poo/images/x-wing.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ea99c7d5aba46bcc2d3b10bdb93b36a8422a27a5
Binary files /dev/null and b/source/poo/images/x-wing.jpg differ
diff --git a/source/poo/index.rst b/source/poo/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..920f2f09d39e8a9a510421a2bf5ef9c467e5f752
--- /dev/null
+++ b/source/poo/index.rst
@@ -0,0 +1,14 @@
+Programmation orienté objets
+============================================
+
+
+Nous allons parler ici de conceptes de programmation.
+
+A quoi ça sert, pourquoi l'utiliser, comment ça fonctionne ?
+
+============================================
+
+.. toctree::
+ :maxdepth: 2
+
+ general.md
\ No newline at end of file