****************************************
|
|
| Découvrir Linotte en dix
minutes |
|
|
**************************************
Dix
minutes pour découvrir les bases
* Remarques
-
Ce
document présente
rapidement quelques fonctionnalités du langage Linotte.
- Ce
n'est pas un
tutoriel pour
apprendre à programmer.
En 3 lignes, nous avons écrit
un premier programme qui peut
être directement exécuté dans l'atelier Linotte.
* Exemple
avec une
variable
La
notion de variables en
Linotte s'exprime à travers la
notion d'acteurs. Un acteur est caractérisé par un nom, un rôle (un
type) et une valeur.
La
déclaration des variables est
effectuée avant le bloc "début".
Cet
exemple créé l'acteur prénom typé texte et contiendra la valeur
"Nicolas".
Si vous
l'essayez dans
l'Atelier, vous obtiendrez à l'affichage :
Bonjour,
Nicolas
* Des types simples
Le langage propose seulement 5
types qui sont :
texte, nombre,
drapeau, casier, espèce
Nous verrons à travers les exemples comment les utiliser.
* Interaction
avec
l'utilisateur
Le verbe Demander interroge l'utilisateur
:
Le verbe Questionner peut être
également utilisé :
* Fonctions
mathématiques
Les fonctions disponibles sont
:
- Carré
d'un nombre : carré x
- Cosinus
: cos x
- Sinus
: sin x
- Fonction
exponentielle : exp x
- Logarithme
décimal: log x
- Logarithme
naturel: logn x
- Valeur
absolue : abs x
- Racine
carrée : racine x
- Arrondi
: arrondi x
- Cube
d'un nombre : cube x
- Puissance
: x puiss n
- Modulo
: x mod n
- Et
logique : x et n
- Ou
logique : x ou n
- Xou
logique : x xou n
- Tangente
: tan x
- Arc
cosinus : acos x
- Arc
sin : asin x
- Arc
tangente : atan x
- Hasard
:
hasard x
Exemple simple :
Exemple plus complexe :
D'autres fonctions seront proposées par le greffon Abaque
:
* Les
conditions
Le langage propose les
conditions suivantes :
- si
? = ?, ?
- si
? != ?, ?
- si
? > ?, ?
- si
? < ?, ?
- si
? >= ?, ?
- si
? <= ?, ?
- si
? est en collision avec ?, ? (à utiliser avec des objets graphiques)
- si
? est vide, ?
- si
? est non vide, ?
- si
? est
(vrai/faux), ?
- si ?, ?
- si
?
contient ?, ?
Les conditions peuvent
s'utiliser simplement sur une ligne :
On peut utiliser les blocs (*) :
La clause Sinon peut également être
utilisée
:
* Les
fonctions et paramètres
Un programme en Linotte est
constitué d'au minimum une
fonction (par convention, on nomme la première fonction "principale") :
Il est parfois utile de
découper un algorithme en plusieurs fonctions :
Il
suffit de préfixer un acteur d'un astérisque (*) et celui-ci devient un paramètre.
-->
Une fonction peut être utilisé en tant que fonction mathématique si celle-ci retourne une valeur :
* Les
blocs
Les
blocs sont des
structures internes à une
fonction. On peut les utiliser dans des conditions ou les boucles.
Un
bloc débute
avec le verbe lire
et termine avec le verbe fermer.
*
La récursivité
Implémenter des algorithmes récursifs en Linotte est possible. Le meilleur exemple... la suite de Fibonacci :
* Les
boucles
Les boucles, briques essentielles lors
de l'élaboration
d'algorithme sont présentes sous différentes formes dans le langage
Linotte.
La forme la plus usuelle est "pour n de a à b ... " :
La forme "tant que condition ... " est également
disponible :
* Un peu de
sucre ?
Quelques
raccourcis très utiles sont proposés.
- Raccourci pour le verbe
Afficher :
- Raccourci pour le verbe
Demander
:
- Raccourci pour
le verbe Valoir :
- Interpolation de chaîne :
- Regrouper plusieurs actions
identiques en une ligne :
Au lieu d'écrire :
L'utilisation
de l'esperluette contracte le livre ainsi :
- Regrouper plusieurs actions
différentes en une ligne :
- A
l'inverse, il est possible de découper une ligne !
Le joker est un acteur particulier
car celui-ci est alimenté par Linotte dés que l'on utilise la forme
simple des boucles : "pour chaque X ,".
Dans
cet exemple, à chaque itération, il prend une valeur
successive du tableau "prénoms".
- Inférence de types simples :
* Attraper
les erreurs
Nous sommes tous un
peu des têtes de
linotte... Une erreur est vite arrivée dans l'élaboration d'un
algorithme. Pour s'en protéger, et surtout, pour mieux comprendre
l'origine du problème, on entoure son algorithme du bloc
Essayer. C
elui-ci permet au développeur de procéder à
son
l'analyse et à sa correction :
Et si l'erreur est vraiment insaisissable, utilisons les grands moyens :
le débogage.
On avance dans l'algorithme en cliquant sur le bouton "Pas à pas" de
l'Atelier.
* Parallélisation
des traitements
Linotte est une tête
bien faite ! Ce n'est pas une tâche mais plusieurs qu'elle est capable
de traiter en
même temps !
Pas besoin de longues explications car c'est très simple à mettre en
place.
Au lieu d'utiliser le verbe Parcourir,
on utilise le verbe Appeler :
Le verbe Observer attend que
toutes les tâches "sleep" soient terminées.