# Programmation Lisaac

Cette page est en travaux. Tant que cet avis n'aura pas disparu, veuillez en considérer le plan et le contenu encore incomplets, temporaires et sujets à caution. Si vous souhaitez participer, il vous est recommandé de consulter sa page de discussion au préalable, où des informations peuvent être données sur l'avancement des travaux.

# Tutorial : Lisaac pour le programmeur objet standard (Java/C++ par exemple)
## Introduction

Ce document a pour but de faire découvrir la programmation par prototype en Lisaac à quelqu'un ayant l'habitude des langages à classes. Ce n'est pas un document de référence mais un tutorial didactique. Ce n'est pas non plus un document expliquant les principes fondamentaux et les caractéristiques de la programmation orientée prototype.
Le plan est divisé en deux chapitres, le premier présente les notions les plus standards de la programmation objet, le deuxième présente des techniques moins connues voir novatrices. Après cela dépend évidement de l'expérience de chacun des lecteurs en la matière.
Le style narratif du document sera sous forme de question/réponse comme pour une FAQ (Foire aux questions). Mais contrairement aux FAQ vous devez lire toutes les parties dans l'ordre. Notez aussi que le plan utilise le vocable de la programmation objet à classe et le contenu introduit celui de la programmation objet à prototype utilisé dans Lisaac.
Si jamais quelque chose ne vous parait pas clair, ou si jamais vous avez une interrogation sur le pourquoi ou les avantages de Lisaac par rapport à ce que vous êtes habitués n'hesitez pas à modifier directement le document et à rajouter votre question à l'endroit le plus approprié. Néanmoins le document ne doit pas devenir un forum de discussion, vous pouvez utiliser la page dédiée pour cela.

## Chapitre 1 : Les notions basiques

* Déclarer une classe
* Hériter d'une autre classe
* Déclarer des attributs ou des méthodes
* Faire un main "hello world"
* Instancier des objets
* Déclarer des variables locales
* Le traitement des types de base
* Les conditionnelles et les boucles
* Lisaac/Block
* Lisaac/Keyword slot
* Les expression boolléennes
* Les templates
* Les conteneurs Tableau et Liste
* La gestion des erreurs
* Retour sur les points difficiles
* Lisaac/Référence rapide
AFAIRE : rajouter kkpart qu'il faut dire (-2) pour les int négatif

## Chapitre 2 : Utilisation avancée

* Transformer une méthode en attribut (ou l'inverse)
* Définir des mots clés dans la liste de paramètre
* Paramètres et valeurs de retour composés
* Utiliser la programmation par contrat
* Déclaration fine des droits d'un prototype
* Créer ses propres structures de contrôle
* Héritage dynamique

## Chapitre 3 : Les design-patterns classiques

A FAIRE : coder et enlever ceux qui ne sont pas réutilisable directement par du code. De plus certain sont triviaux comme Singleton et Prototype, d'autre sont d'un intéret limité par les mécanismes comme l'héritage partagé pour le Poids-mouche.
* Fabrique Abstraite (Abstract Factory)
* Monteur (Builder)
* Fabrication (Factory Method)
* Prototype (Prototype)
* Singleton (Singleton)
* Adaptateur (Adapter)
* Pont (Bridge)
* Objet composite (Composite)
* Décorateur (Decorator)
* Façade (Facade)
* Poids-mouche ou poids-plume (Flyweight)
* Proxy (Proxy)
* Chaîne de responsabilité (Chain of responsability)
* Commande (Command)
* Interpréteur (Interpreter)
* Itérateur (Iterator)
* Médiateur (Mediator)
* Memento (Memento)
* Observateur (Observer)
* État (State)
* Stratégie (Strategy)
* Patron de méthode (Template Method)
* Visiteur (Visitor)