En 4 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.
Exemple avec une variable :
Principal :
Rôles
:
prénom :: texte <-
"Nicolas"
Actions :
Affiche "Bonjour, " +
prénom
La
déclaration des acteurs est
effectuée dans le bloc Rôles.
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
:
Exemple du verbe demander :
("Ceci
est un commentaire !")
Principal :
Rôles :
prénom :: texte
Actions :
Affiche "Quel est ton prénom ?"
Demande
prénom
Affiche "Bonjour, " + prénom
Le verbe Questionner peut être
également utilisé :
Exemple du verbe questionner :
Principal :
Rôles :
prénom
:: texte
Actions :
Questionne prénom sur "Quel est ton prénom ?"
Affiche "Bonjour, " + prénom
* 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 mathématique
:
Principal :
Actions :
Affiche carré 4
Affiche 2 puiss 3
Affiche vrai ou faux
Affiche (2
puiss 3 + 5 * 6 - 1 ) / 3
Exemple plus complexe :
Syracuse :
Principal :
Rôles :
durée :: nombre <- 0
e :: nombre
Actions :
demande e
tant que e != 1, lis
durée vaut
durée + 1
si (e mod 2) ==
0 alors e vaut e / 2
sinon, e vaut e
* 3 + 1
ferme
affiche durée
D'autres fonctions seront proposées par le greffon Abaque
:
si
? est en collision avec ?
alors ? (à utiliser avec des objets graphiques)
si
? est vide alors ?
si
? est non vide alors ?
si
? est
(vrai/faux) alors ?
si ? alors ?
si
?
contient ? alors ?
Les conditions peuvent
s'utiliser simplement sur une ligne :
Exemple conditions 1 :
Principal :
Actions :
Si (2 * 2)
== (2
+ 2)
alors affiche "j'ai raison."
Si (3 * 3)
>
(3 + 3) alors affiche "j'ai toujours raison !"
On peut utiliser les sous-paragraphes (*) :
Exemple
conditions 2 :
Principal :
Actions :
Si (2 * 2) == (2 + 2) alors lis
affiche "j'ai
raison"
ferme
Si (3 * 3) > (3
+ 3) alors lis
affiche "j'ai toujours raison !"
ferme
La clause Sinon peut également être
utilisée
:
Exemple conditions 3 :
Principal :
Actions :
Si (2 * 2)
== (2
+ 2) alors lis
affiche
"j'ai raison"
ferme
Sinon, affiche
"j'ai tort !"
* Les
paragraphes et doublures
Un programme en Linotte est
constitué d'au minimum un
paragraphe (par convention, on nomme le premier paragraphe "principal") :
Exemple Paragraphe simple :
Principal :
Rôles :
prénom 1 :: texte
Actions :
Demande prénom 1
Affiche "bonjour, " + prénom 1 + "
!"
Il est parfois utile de
découper un algorithme en plusieurs paragraphes :
Exemple
Paragraphe 2 :
Principal :
Rôles :
Note1 :: nombre
Note2 :: nombre
Note3 :: nombre
Actions :
Parcours question avec "Pierre", note1
Parcours question
avec "Jacques", note2
Parcours question
avec
"Hugo", note3
Affiche "La note
de
Pierre est " + note1
Affiche "La note
de
Jacques est " + note2
Affiche "La note
de
Hugo est " + note3
Question :
Rôles :
*
prénom :: texte
* valeur
:: nombre
Actions :
Affiche "Quelle est la note de " + prénom + "
?"
Demande valeur
Reviens
Il
suffit de préfixer un acteur d'un astérisque (*) et celui-ci devient un paramètre (ou une
doublure).
-->
Un paragraphe peut être utilisé en tant que fonction si celui-ci retourne une valeur :
Exemple
Paragraphe 3 :
Principal :
Actions :
Affiche "La note de Pierre est " +
question("Pierre")
Affiche "La note de Jacques est " +
question("Jacques")
Affiche "La note de Hugo est " + question("Hugo")
Question :
Rôles : * prénom :: texte
valeur :: nombre
Actions :
Questionne valeur sur "Quelle est
la note de " + prénom + " ?" retourne valeur
* Les
sous-paragraphes
Les
sous-paragraphes sont des
structures internes à un
paragraphe. On peut les utiliser dans des conditions ou les boucles.
Un
sous-paragraphe débute
avec le verbe lire
et termine avec le verbe fermer.
Exemple sur les
sous-paragraphes :
Principal :
Rôles :
âge ::
nombre
Actions :
Affiche
"Quel est ton âge ?"
Demande âge
Si âge <
10
alors lis
affiche
"Tu es bien jeune pour programmer !"
affiche
"Mais tu es plein de promesses !"
Ferme
Sinon, si
âge < 15 alors lis
affiche
"Tu iras loin à programmer en langage
Linotte !"
affiche
"Ton
avenir sera riche !"
Ferme
Sinon,
affiche "Tu fais bien plus jeune que tes "
+ âge + " années !"
* Les
acteurs locaux
Linotte stocke les
acteurs créés dans une bibliothèque interne.
On
peut facilement manipuler le même acteur d'un paragraphe à un autre :
Exemple :
Principal :
Rôles :
v :: texte <-
"Voici une valeur"
Actions :
Affiche "Voici le
texte : " + v
Parcours message
Message :
Rôles :
v :: texte
Actions :
Affiche "On a bien la
même valeur : " + v
Reviens
Ce comportement, pratique pour
débuter lorsque l'on programme peut être finalement pénalisant à long
terme car il est producteur d'erreurs.
Linotte
propose une parade qui réduit la visibilité de l'acteur au
paragraphe courant et même, à un sous-paragraphe, elle consiste à
ajouter devant l'acteur le symbole § :
Exemple avec des acteurs
locaux :
Principal :
Rôles :
§ v ::
texte <-
"Voici une valeur"
Actions :
Affiche "Voici le
texte : " + v
Parcours message
Message :
Rôles :
§ v ::
texte
Actions :
Si v est vide alors
lis
§ libellé :: texte
<- "La valeur est vide !"
Affiche
libellé
Ferme
Sinon, lis
§ libellé ::
texte <- "La valeur n'est pas vide : "
Affiche libellé + v
Ferme
Reviens
*
La récursivité
Implémenter des algorithmes récursifs en Linotte est possible. Le meilleur exemple... la suite de Fibonacci :
Fibonacci :
Principal :
Rôles :
n :: nombre
Actions :
"Entrez un nombre :" !
n ?
fibo(n) !
Fibo :
Rôles :
* n :: nombre
Actions :
si n < 2 alors retourne n
retourne fibo(n-1) + fibo(n-2)
* 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 ... " :
Exemple de boucle :
Principal :
Rôles :
Notes :: casier de nombres vide
Prénoms :: casier de textes <-
"Pierre", "Jacques", "Hugo"
b :: nombre
Actions : Pour b de 0 à 2, lis
§ note ::
nombre
parcours
question avec prénoms {b}, note
ajoute note
dans notes
ferme Pour b de 0 à 2, lis
affiche "La
note de " + prénoms {b} + " est " + notes {b}
ferme
Question :
Rôles :
* prénom :: texte
* valeur :: nombre
Actions :
Affiche "Quelle est la note de " +
prénom + " ?"
Demande valeur
Reviens
La forme "tant que condition ... " est également
disponible :
Exemple de boucle :
Principal :
Rôles :
Notes :: casier de nombres vide
Prénoms :: casier de textes <-
"Pierre", "Jacques", "Hugo"
b :: nombre <- 0
Actions : Tant que b < 3 ,
lis
§ note ::
nombre
parcours
question avec prénoms {b}, note
ajoute note
dans notes
b vaut b + 1
ferme Tant que b > 0,
lis
b vaut b - 1
Affiche "La
note de " + prénoms {b} + " est " + notes {b}
ferme
Question :
Rôles :
* prénom :: texte
* valeur :: nombre
Actions :
Affiche "Quelle est la note de " +
prénom + " ?"
Demande valeur
Reviens
* Un peu de
sucre ?
Quelques
raccourcis très utiles sont proposés.
- Raccourci pour le verbe Afficher :
Sucrerie 1 :
Principal :
Actions :
"Bonjour
" !
- Raccourci pour le verbe Demander
:
Sucrerie 2 :
Principal :
Rôles :
prénom
:: texte
Actions :
"Quel
est ton prénom ?" !
Prénom ?
"Bonjour, " +
prénom !
- Raccourci pour le verbe Valoir :
Sucrerie 3 :
Principal :
Rôles :
prénom
:: texte
Actions :
prénom vaut "Pierre" prénom ="Pierre"
- Interpolation de chaîne :
Sucrerie 4 :
("A partir de Linotte 1.5")
Principal :
Rôles :
prénom
:: texte <- "Amandine"
Actions :
Affiche "Le prénom est ${prénom}"
- Regrouper plusieurs actions identiques en une ligne :
Au lieu d'écrire :
Sucrerie 5
:
Principal :
Rôles :
nom :: texte
prénom :: texte
Actions :
nom ?
prénom ?
nom !
prénom !
L'utilisation
de l'esperluette contracte le livre ainsi :
Sucrerie 6 :
Principal :
Rôles :
nom &
prénom :: texte
Actions :
nom &
prénom ?
prénom &
nom !
- Regrouper plusieurs actions différentes en une ligne :
Sucrerie 7 :
Principal :
Rôles :
nom & prénom :: texte
Actions :
demande nom ;
affiche nom
demande prénom ;
affiche prénom
- A
l'inverse, il est possible de découper une ligne !
Sucrerie
8
:
Principal :
Rôles : Prénoms ::
casier de textes <- "Pierre",
"Jacques",
"Hugo", ...
"Paul", "Nicolas"
Actions :
Pour chaque prénoms, affiche joker
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 :
Sucrerie 9 :
("A partir de Linotte 1.5")
("Pour les types nombre ou texte, Linotte peut déterminer automatiquement le type :")
Principal :
Rôles :
prénom <- "Amandine"
âge <- 1
Actions :
Affiche "${prénom} à ${âge} an !!"
* 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. Celui-ci permet au développeur de procéder à
son
l'analyse et à sa correction :
Algorithme
farfelu :
Principal :
Rôles :
valeur :: nombre <- 10
Actions : essaie, lis
tant que valeur
> 0 , lis
§ valeur temporaire :: nombre <- valeur - 1
si (valeur / valeur temporaire) > 0 alors lis
affiche "Je peux continuer"
valeur vaut valeur - 1
ferme
sinon, valeur vaut valeur - 2
ferme
ferme sinon, affiche
"Pfff, une erreur dans ton algorithme lorsque valeur = " ...
+ valeur
Et si l'erreur est vraiment insaisissable, utilisons les grands moyens :
le débogage.
Algorithme farfelu :
Principal :
Rôles :
valeur :: nombre <- 10
Actions : débogue
tant que valeur > 0 , lis
§ valeur
temporaire :: nombre <- valeur - 1
si (valeur /
valeur temporaire) > 0 alors lis
affiche "Je peux continuer"
valeur vaut valeur - 1
ferme
sinon, valeur
vaut valeur - 2
ferme
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 :
Sleep sort :
Principal :
Rôles :
paramètres :: casier de nombre
<- 7, 1, 3, 2, 5, 6, 4, 0, 3
Actions :
pour chaque paramètres, appelle
sleep avec joker observe sleep
Le verbe Observer attend que
toutes les tâches "sleep" soient terminées.
Vous avez découvert les
premiers rudiments de la programmation avec le langage Linotte en seulement dix minutes.
Ces premiers éléments sont suffisants pour écrire vos
premiers programmes. Si vous rencontrez quelques problèmes, n'hésitez pas à solliciter la communauté sur le forum.
Mais profitons de cette vaillante lancée pour découvrir,
en dix minutes de plus,
ce que Linotte propose en tant que langage de programmation
informatique moderne dans la
deuxième partie de cette exploration !