Cette version apporte une petit (r)évolution très importante car elle simplifie la syntaxe du langage.
Ainsi, pour déclarer les acteurs, nous avons cette façon :

prénom est un texte valant “Théo”

Cette instruction va créer l’acteur “prénom”, de rôle texte et ensuite de lui affecter la valeur “Théo”
Maintenant, on peut écrire directement :

prénom prend “Théo”

Ainsi l’interprète va créer automatiquement l’acteur, avec le rôle texte et lui affecter sa valeur !

Cette évolution permet au langage Linotte de se rapprocher de langages “modernes” comme le langage Python.
Actuellement, je fais découvrir l’informatique dans un collège à des enfants à travers la programmation d’un jeu vidéo.
Voici les différents ateliers pour arriver au jeu final :
https://github.com/cpc6128/LangageLinotte/issues?q=+label%3AAtelier+sort%3Acreated-asc+

Bonne programmation !

Voici les principales nouveautés sont :

• Le code source se trouve maintenant sur github : https://github.com/cpc6128/LangageLinotte
• L’Atelier est plus simple, j’ai supprimé des fonctionnalités qui n’étaient pas utilisées.
• Le thème sombre a été ajouté pour réduire la fatigue des yeux.
• Le langage a été simplifié avec notamment la disparition du mot clé “début”
• Les exemples ont été modifiés. J’ai effectué un nettoyage et reclassé les exemples dans des répertoires différents.

Prochaine version 3.0 cette année ?

Je travaille sur la prochaine version qui sera Linotte 3. Avec cette version, j’ai décidé de faire table rase avec le passé du langage.

Il y a des concepts que j’ai proposés il y a 10 ans qui ne sont plus utilisés aujourd’hui.

Donc, c’est la fin des souffleurs, de la compatibilité avec les anciennes versions de Linotte, des langages Linnet, Lyre, des greffons en Python, etc.

J’en profite aussi pour proposer une syntaxe moins contraignantes pour être dans l’air du temps. Je ne force plus la création des variables en début de fonction par exemple.

Si vous souhaitez la tester, c’est par ici :

https://github.com/cpc6128/LangageLinotte

Il y a des concepts que j’ai proposés il y a 10 ans qui ne sont plus utilisés aujourd’hui.

Donc, c’est la fin des souffleurs, des tests, de la compatibilité avec les anciennes versions de Linotte, des langages Linnet, Lyre, du webonotte, du serveurWeb, des greffons en Python, du télétype, etc.

J’en profite aussi pour proposer une syntaxe moins contraignantes pour être dans l’air du temps. Je ne force plus la création des variables en début de fonction par exemple.

De plus, je vais livrer l’Atelier avec une dizaine d’exemples, pas plus. Les exemples présenteront que 10% des possibilités du langage, mais cela permettra de facilité l’apprentissage et la découverte du langage.

Voici un exemple présentant cette syntaxe simplifiée :

Côté Atelier de programmation, je l’ai allégé et simplifié pour ne garder que l’essentiel. Le but est de le rendre plus facile d’accès et aussi pour moi… de réduire la quantité de code à maintenir.

Pour les curieux, vous pouvez tester une première version (attention, c’est une version alpha) :

https://github.com/cpc6128/LangageLinotte2

Bonne programmation !

Vous allez pouvoir programmer dans votre train, dans une classe d’école, dans votre lit, en marchant, sur la plage pendant vos vacances …

Cette application est encore très limitée… On ne peut pas encore programmer avec la toile : le graphisme n’est pas implémenté.

N’hésitez pas à l’installer, à me faire des retours sur le forum et surtout d’en parler autour de vous !

Bonne programmation !

[Linotte sur le PlayStore]

L’Atelier 2.7 est disponible pour : Ubuntu, Fedora, MacOS et Windows avec Java 7 ou 8 d’installé.

Maintenant, en plus de proposer mon logiciel libre depuis 11 ans, je veux maintenant proposer des formations pour apprendre à programmer avec le langage Linotte dans les écoles, collectivités ou entreprises. Si cela intéresse des personnes, n’hésitez pas à me contacter sur mon courriel contact@codevallee.fr ! Et oui, pourquoi ne pas vivre de son logiciel libre ? C’est mon prochain pari….

Bonne programmation !

Where is Alice ? est un jeu de réflexion très simple et qui s’inspire un peu des langages de programmation…

Le but étant de programmer un petit robot afin qu’il puisse rejoindre sa douce dulcinée …

C’est ici pour le télécharger : https://play.google.com/store/apps/details?id=fr.codevallee.whereisalice

Vidéo de présentation

Et hop, une petite copie d’écran :

Toujours dans l’esprit de rendre la programmation toujours plus accessible à toujours plus de monde, il est maintenant possible d’utiliser des fonctions lors de la création d’un programme en mode “bloc”.

Pour rappel, le mode “bloc” facilite la création des programmes en permettant d’utiliser “juste” avec une souris et non taper les commandes, dans le même esprit que Scratch.

J’ai également complément réécrit la gestion de coller-glisser dans cette nouvelle version.

N’hésitez pas à parler du langage Linotte autour de vous et notamment dans les écoles . N’oubliez pas qu’un forum est disponible pour échanger et partager vos créations.

Bonne programmation !

Dans le but de faciliter l’apprentissage de la programmation et notamment de l’algorithmique, l’atelier version 2.5 propose un nouveau module qui offre la possibilité de créer ses programmes visuellement et sans à avoir écrire une ligne de code. Il suffit juste d’une souris pour créer ses programmes ! Enfin presque…

Par exemple, voici la suite de Syracuse programmée avec ce nouveau module :

Il est tout à fait possible d’utiliser le mode pas à pas pour exécuter ce programme. Les blocs s’allument, les uns après les autres lors de leur exécution permettant de suivre facilement le chemin parcouru par l’algorithme.

L’exemple suivant est bien plus simple. Celui-ci demande à l’utilisateur la capitale de la France et attend la bonne réponse pour s’arrêter (sans avoir oublié de complimenter l’utilisateur bien entendu) :

Ce nouveau module peut être destiné aux écoles ou aux débutants voulant apprendre en douceur la programmation.

C’est une première version, n’hésitez pas à me remonter vos problèmes sur le forum et surtout à diffuser ce programme autour de vous pour le faire connaitre !

Pour les 10 ans du langage, il fallait bien une belle nouveauté pour fermer cette première décennie !

Côté langage Linotte, les nouveautés sont rares : j’ai seulement introduit la notion de gestionnaires de placement mais je ne suis pas encore satisfait du résultat. Les gestionnaires de placement permettront d’apporter une nouvelle façon de placer les composants sur une interface utilisateur (IHM).

La plus grosse évolution est l’intégration de deux nouveaux langages de programmation au sein de l’atelier Linotte. Ces deux langages héritent des principes de Linotte, mais avec des syntaxes plus concises.

Ces deux langages sont plutôt destinés ( pour l’instant ) à l’apprentissage de l’algorithmique : ils sont simples et ils sont faciles à apprendre. Voici Lyre et Linnet !

Lyre est en français. Par rapport au langage Linotte, déclarer une variable est plus simple et il est possible d’écrire du code sans fonction. Le mot clé “début” n’existe plus ainsi que les verbes “Lire” et “Fermer”. A l’instar des autres langages, on utilise les accolades.

Linnet est le pendant anglais du langage Lyre ! Et oui, il est maintenant possible de programmer en anglais dans l’atelier !

Ainsi, le même programme devient en langage Linnet :

Ces deux langages peuvent être étudiés au collège et au lycée. On peut commencer à programmer en Lyre par exemple dans le but de découvrir la programmation et les algorithmes en douceur. Puis, par la suite, en utilisant le même environnement de programmation, vous pouvez coder directement avec une syntaxe en anglais (les messages d’erreur restent en français !).

La documentation n’est pas encore rédigée… Elle devrait arriver d’ici quelques mois ! Mais vous pouvez commencer à découvrir ces langages en inspectant les exemples fournis avec l’atelier.

Très bonne programmation !

P.-S : Pour tester Linnet ou Lyre, il faut changer de langage de programmation avec le nouveau bouton “Langage”.

P.-P.-S : Les exemples du tutoriel à gauche de l’atelier s’adaptent au langage !

1. Simplification des appels de fonction :

   Il n’est plus obligatoire de définir les types des paramètres d’une fonction, les nommer est suffisant. L’interprète Linotte va déterminer automatique les types ( si ça ressemble à un canard alors c’est un canard ! )
   

   principale :
  parcours multiplication avec 5,3
multiplication : a, b
  affiche a * b
  reviens

2. Diverses simplifications syntaxiques :

   Après avoir simplifié les appels de fonction, j’ai terminé un autre chantier que j’ai entamé il y a quelques années : c’est la simplification de la déclaration des acteurs dans la section “les rôles”. Toujours basé sur la technique du Duck typing, Linotte détermine lui même le type de l’acteur :
   

3. Doublures en entrée :

   Si la première fonction du programme contient des paramètres (doublures en Linotte), l’interprète interroge automatiquement l’utilisateur afin qu’il fournisse les valeurs pour chacune d’elles. Le code est ainsi plus court : le programmeur n’a pas besoin d’écrire de code pour créer les variables, ni d’interroger l’utilisateur !

   fibo : n
  si n < 2 retourne n
  sinon retourne fibo(n-1) + fibo(n-2)

4. Générer des images avec le webonotte :

   Grosse nouveauté apportée par cette version, la possibilité de générer des images avec le serveur Web. Cela permet de créer des sites dynamiques textuellement et graphiquement !
   
   

5. Multiplication des chaînes :

   Petite évolution juste pour s’amuser si on débute dans la programmation informatique !
   

   principale :
  a valant “je suis fou !” * 3
  début
  affiche a

6. Simplification des conditions et boucles :

   Toujours dans un esprit de simplification de l’écriture de son code, la virgule n’est plus obligatoire lors de l’écriture des boucles et des conditions :
   

   syracuse : e
  durée est un nombre
  début
  tant que e != 1 lis
  durée vaut durée + 1
  si (e mod 2) = 0, e vaut e / 2
  sinon e vaut e * 3 + 1
  ferme
  affiche durée
7. Jokers en folie :

   Le joker est un acteur particulier car il récupère la valeur de la boucle courante.
   Il est maintenant possible d’utiliser des dérivés du joker : joker’, joker” et joker”’
   qui vont récupérer les boucles parentes successives !

   jokers en folie :
  pour “Linotte” lis
  pour 5 affiche (joker+1) * joker’
  ferme

Cette version bêta est disponible depuis ce lien : http://langagelinotte.free.fr/forum/showthread.php?tid=1128

Bonne programmation !

Cette version 2.2.4 apporte les corrections suivantes :

• Webonotte ne chargeait plus correctement les livres et amélioration de la notice,
• affichage tronqué du crayon lors d’un redimensionnement de la toile,
• et enfin, bogue lié au mot clé “sinon” seul sur une ligne.

Des améliorations ont été apportées :

• Le Webonotte peut lire les exemples de l’Atelier : http://localhost:7777/b_tutoriels/a_debutant/poeme.liv?wbt_html=true ,
• ajout de la fonction mathématique atan2,
• modification du panneau projet en lui apportant un aspect moderne (UI),
• et la possibilité de changer la taille de la police de l’atelier en utilisant la combinaison contrôle+molette de la souris.

Voici la nouvelle notice du serveur HTTP :

Bonne programmation

L’amélioration de l’inspecteur :
L’inspecteur a (enfin!) été revu. Maintenant, il affiche la hiérarchie des appels de fonctions et l’ensemble des acteurs instanciés en mémoire.

La lecture au ralenti :
Il est possible de lire son livre au ralenti (et oui, du slowmotion en Linotte !) Chaque action est exécutée séquentiellement suivant un tempo paramétrable. Ainsi, on peut suivre le cheminement de son programme très facilement et on peut vérifier à tout moment les valeurs des variables : l’inspecteur est mis à jour à chaque changement d’action. Le délai entre deux actions est modifiable depuis le menu Outils.

Cette version intègre également les corrections suivantes :

-Correction (156) : Impossible d'utiliser le joker avec les casiers lors d'une boucle et
l'utilisation du verbe parcourir,
-Correction : Ajout d'un indicateur dans le sommaire s'il y a un acteur
inconnu : mise à jour automatique,
-Correction : La lecture des livres en mode syntaxe 1X ne fonctionnait plus.


N’hésitez pas à venir animer les pages google+ ou facebook avec vos questions ou en y présentant vos créations !

Cette version est téléchargeable depuis la page d’accueil et depuis la page Téléchargement.

Bonne programmation sous le soleil au rythme du débogueur !

Ai-je besoin de vous présenter ce jeu ? Créer par un certain Gabriele Cirulli, 2048 est un jeu comme j’aime : simple et addictif. Et quand je joue un tel jeu, je me demande pourquoi n’ai-je pas pensé à cette idée bien avant ?

Pour combler cette frustration, je me suis dit que je devais le proposer en langage Linotte en moins de 200 lignes. Çà été assez facile en fait. Je me suis inspiré d’un code en C très bien conçu : comme quoi, un langage de programmation, en français, en anglais, en chinois, la logique reste la même !

Vous pouvez jouer avec la souris en la glissant, bouton gauche enfoncé, vers la gauche, la droite, le haut ou le bas, ainsi comme sur un téléphone portable !
Pour les plus pressés, vous pouvez glisser vos pièces avec les flèches du clavier.

Voici le programme :

Pour jouer, ou l’améliorer, vous pouvez le télécharger depuis mon drive :
drive.google.com/folderview?id=0B1rRyAT2mvEMMnlYMlFUb0FBQmc&usp=sharing
Puis l’exécuter dans l’Atelier de programmation (le jeu peut également se jouer en double-cliquant dans votre navigateur de fichier !).

Bon jeu !

Vous pouvez la télécharger depuis ce lien.

J’ai corrigé une régression sur l’ajout des favoris qui ne fonctionnait plus. Autre bogue, le verbe “chercher” retourne maintenant la valeur 0 si l’élément recherché est positionné à la première place et non plus 1.

J’ai également travaillé sur le sommaire pour y ajouter un indicateur sur les fonctions qui contiennent des erreurs syntaxiques.

Egalement sur le sommaire, la fonction courante est mise en valeur pour rapidement se repérer dans son programme.

Ces évolutions sont petites mais elles contribuent à faire de l’Atelier de programmation un environnement très simple pour apprendre à programmer (si ce n’est pas le plus simple…).

Bonne programmation !

J’aurais pu le faire en moins de lignes mais j’ai ajouté quelques effets et une difficulté (notion de fluctuation) pour rendre le jeu moins prédictif.

Le code du programme est plus complexe que le précédent jeu que j’avais présenté mais il propose une bonne base pour créer un jeu plus complet avec d’autres niveaux et d’autres pièges !

J’ai ajouté quelques annotations dans le programme pour faciliter sa compréhension.
Si ce n’est pas assez clair, n’hésitez pas à écrire vos questions ou remarques en bas du billet dans la section commentaire !

Si vous voulez l’essayer ou l’améliorer, vous pouvez le télécharger depuis ce lien :

[Télécharger le jeu]

Bonne programmation !

La conception du langage de programmation a été axée sur le principe suivant : faire en sorte que le programmeur puisse créer facilement des objets graphiques et interagir avec eux en un minimum de commandes.

Pour preuve, j’ai réalisé ce petit jeu très simple à comprendre en exactement 100 lignes :

Le but du jeu est de tuer le maximum de monstres en évitant d’être touché. Un barre d’énergie indique la santé de votre vaisseau.

Voici le code complet du programme (plus loin, je présente une version dénudée ):

Pour bien comprendre la structure du programme, je propose une version simplifiée du programme : sans la gestion des collisions, des effets et des scores (54 lignes !) :

Si vous voulez l’essayer ou l’améliorer, vous pouvez téléchargement le livre et les images depuis ce lien :

[Télécharger le jeu]

Qui a dit que le programmation était compliquée ?

Voici les nouveautés apportées :

• Une mise en valeur des blocs (structures de contrôle) pour faciliter la création et la lecture de ses programmes :

• Un nouveau type d’objet graphique a été ajouté : la mosaïque. Cet objet graphique permet de dessiner facilement des objets ou personnages sur la toile à partir de pixels. Voici un petit monstre dessiné en quelques lignes :

• Autre fonctionnalité ajoutée, le “multi-toile”. Ce concept réservé au programmeur avancé offre la possibilité d’afficher plusieurs toiles en même temps dans un même programme. Voici un exemple en vidéo : https://www.youtube.com/watch?v=VugBph4×3L0

• Sous Windows 64 bits, l’association des fichiers .liv avec la machine virtuelle du langage Linotte fonctionne : dans l’explorateur Windows, un clic sur un livre lance le programme directement !

• Des travaux ont été effectués pour améliorer le visuel du langage. Découvez le nouveau logo du langage, inspiré fortement de l’icône des hackers (http://www.catb.org/hacker-emblem/) :

• L’Atelier de programmation a également son nouveau logo :

• Vous pouvez également essayer les premiers travaux que j’ai effectués sur la plateforme mobile Android. Pour l’instant, les developpements sont stoppés par manque de temps… mais le POC fonctionne très bien !
  C’est ici pour découvrir et tester cette version alpha : http://langagelinotte.free.fr/forum/showthread.php?tid=1109 ou télécharger directement l’application ici.

• La dernière actualité et non la moindre… c’est la fin du forum. Ce forum a été le poumon du langage pendant des années. Malheureusement, l’atelier devenant de plus en plus stable, moins en moins de monde participait à son animation. La continuité de ce forum se fera sous une autre forme, et sera surtout plus « sociale » : groupe facebook, groupe google+, ou pourquoi pas : sur developpez.com, openclassroom ? Je ne sais pas encore…

Je vous laisse vous amuser avec cette nouvelle version et prenez autant de plaisir à programmer que j’ai eu à la concevoir !

Voici les nouveautés et corrections apportées :

• Possibilité de ne pas mettre le verbe évoquer lors d’appels de fonctions, il est appelé implicitement si une phrase ne contient pas de verbe :
  
• Attribut “orientation” du composant Indicateur non reconnu si on le valorise à “verticale”
• Symbole “…” incorrectement interprété dans certains cas
• Le chargement dynamique des variables ne fonctionnait plus
• Il manque un message d’erreur lorsque l’interprète ne parvient pas à charger une image.
• Correction du message : “Vérification syntaxique : la déclaration des acteurs doit être effectuée en début de fonction ou de paragraphe”

Wam profite de cette version pour proposer une nouvelle version de son tutoriel en version 2.1.5 (il fait maintenant 265 pages !!).

Cette nouvelle version apporte notamment tout un chapitre sur la réalisation d’IHM en langage Linotte :

Voici les modifications apportées :

• Remplacement de tous les screens du tutoriel par la possibilité de copier/coller le code Linotte du tutoriel directement dans l’atelier.
• Amélioration du chapitre La programmation : qu’est-ce que c’est ? : réécriture du chapitre.
• Modification du chapitre Installation : simplification du chapitre.
• Amélioration du chapitre Les variables : ajout du mot clé acteur.
• Amélioration du chapitre Les verbes : ajout d’une remarque sur la possibilité de copier/coller le code Linotte directement dans l’atelier.
• Correction du chapitre Le verbe Afficher :  - tous les verbes du langage Linotte peuvent utiliser les variables anonymes.
  • ajout d’une astuce.
• Amélioration du chapitre La navigation dans le livre : point de vue utilisateur : ajout de screens.
• Correction du chapitre Les espèces : correction de la remarque sur l’utilisation des attributs dans une condition.
• Modification du chapitre Le graffiti :
  • modification des exemples (Remplacement du raccourci :: par est un).
  • ajout des attributs de la toile
  • ajout d’une astuce concernant la boîte à espèces.
• Modification du chapitre Le praxinoscope : modification des exemples (autoriser le retour chariot après la virgule et modification des chemins d’accès).
• Modification du chapitre Interaction avec l’utilisateur : suppression de l’astuce concernant l’attribut “pointeur” de la toile.
• Ajout du chapitre Les variables locales.
• Amélioration du chapitre Les paramètres : explication des mots clés doublure et rôle.
• Correction du chapitre Le verbe Retourner : correction de l’exemple avec une condition (adaptation à la nouvelle version du langage).
• Amélioration du chapitre Le verbe Attacher : ajout d’une remarque ( Possibilité de ne pas utiliser le verbe Évoquer lors d’appel de fonctions).
• Ajout du chapitre Le forum.
• Modification du chapitre Les raccourcis disponibles : modification d’un exemple (autoriser le retour chariot après la virgule, l’esperluette et quelques autres symboles).
• Ajout de la partie V - La programmation d’IHM.

Pour apprendre à programmer d’une façon amusante, nous partons du principe que l’enfant doit pouvoir interagir avec l’ordinateur avec des mots simples, courts et surtout que le résultat doit être visible graphiquement.

L’avantage de cet atelier est qu’il est réalisé en langage Python : le professeur peut ainsi le modifier et l’améliorer facilement s’il connait le langage Python (Jython en fait) et les mécanismes des greffons proposés par le langage Linotte.

Linotte est un langage de programmation simple, mais nous allons le simplifier en peu plus !

Ainsi, nous allons créer un greffon graphique qui affiche une horloge sur l’écran.

Afficher une horloge est assez complexe, car il faut dessiner un cercle, afficher les chiffres autour du cadran et bien positionner les aiguilles.
Nous allons cacher cette complexité en le réalisant directement en langage Python.

Nous laisserons à l’enfant seulement la possibilité d’afficher l’horloge, puis de modifier les aiguilles de l’horloge directement en langage Linotte.

Etape 1 : l’écriture du greffon minimal en Python

La structure d’un greffon graphique en langage Python est la suivante :

Ce petit bout de code permet d’afficher le texte Hello sur la toile et propose la fonction message().

Pour utiliser ce greffon, il va falloir l’enregistrer dans un fichier Simple.py (attention à bien respecter la casse) dans le répertoire greffons de votre Atelier Linotte.
Ensuite, il faut signaler ce greffon avec ces caractéristiques auprès de l’Atelier, pour cela, créez le fichier simple.greffon.xml contenant ce xml :

Vous enregistrez ce fichier dans le répertoire greffons de votre Atelier.

Suite à ces deux actions, relancez l’Atelier : votre greffon est prêt à être utilisé !

Testons-le avec cet exemple dans l’Atelier :

Voici le résultat sur la toile :

Et sur le tableau :
Coucou !

Nous avons toutes les bases pour créer notre Atelier de programmation !

Etape 2 : l’écriture du greffon Horloge en Python

Nous allons maintenant créer un greffon en Python qui affiche une horloge.

Voici le code Python que vous allez sauvegarder dans un fichier Horloge.py dans le répertoire greffons :

Le descripteur du greffon nommé horloge.greffon.xml contient :

Après avoir créé ces deux fichiers, vous relancez l’Atelier.
Maintenant, nous pouvons créer notre Atelier de programmation !

Etape 3 : Création d’un Atelier de programmation niveau 1

Ce premier niveau permet d’afficher l’horloge avec l’heure souhaitée.

L’enfant doit être accompagné pour réaliser le programme suivant :

Le résultat est directement visible après l’exécution du livre :

Compliquons un peu plus les choses …

Etape 4 : Création d’un Atelier de programmation niveau 2 avec une boucle

Pour ce deuxième exemple, nous allons ajouter une boucle permettant d’afficher l’heure en temps réel :

Il ne manque que le son du tictac !

Etape 5 : Création d’un Atelier de programmation niveau 3 avec des conditions, des boucles

Et pour les enfants motivés, nous allons réaliser un vrai programme.
Le programme suivant affiche une comtoise, une vraie.. si si ! Avec le balancier qui se balance !

Voici le programme qui doit être réalisé :

L’Atelier de programmation est terminé.

Conclusion :
Le professeur peut adapter son cours en modifiant le greffon et les enfants ont découverts les bases de la programmation simplement et en s’amusant.

Vous trouverez tous les fichiers de l’exemple Horloge sur forum.

Un autre atelier pédagogique pour apprendre à programmer est proposé : Le robot.

Découvrez les modifications apportées au document :

Bonne lecture et merci Wam pour ton travail !

Les travaux réalisés sur cette version ont été axés sur la correction de bogues et l’amélioration de la cohérence de l’Atelier et du langage de programmation.

Les grosses nouveautés apportées par cette version sont :

• l’Atelier fonctionne sur Raspberry PI, testé avec la version 8 de Java,
• ajout de quelques évolutions syntaxiques détaillées dans la liste ci-dessous,
• et enfin, beaucoup de corrections de bogues !

Autre nouveauté, en utilisant l’exemple Demonstration_IHM, vous pouvez venir discuter sur le serveur de messagerie écrit en Linotte et hébergé sur mon Raspberry PI !

Si vous ne connaissez pas encore l’Atelier et le langage, vous pouvez les découvrir à travers cette petite vidéo :

Voici la liste exhaustive des modifications apportées par la version 2.1.1 :


-Evolution : Il est possible d'écrire comme condition : "A = B" au lieu "A == B"
-Evolution (98): Ajout de la commande tilde : ~angle radian ou ~angle degré
-Evolution : Ajout de l'exemple pedagogiques/fonction_bessel.liv
-Evolution : Ajout de l'exemple pedagogiques/fleur.liv
-Evolution : Possibilité de désactiver un composant IHM en utilisant la fonction composant.désactiver(vrai)
-Evolution (83) : Possibilité de changer l'icône de certains composants IHM
-Evolution (84) : Ajout du composant IHM MenuCaseàCocher
-Evolution (81) : Possibilité d'ajouter un sous-menu à un menu
-Evolution (79) : Ajout du verbe interrompre boucle et de l'exemple : interrompre.liv
-Evolution (78) : Ajout de l'historique des derniers livres utilisés dans l'Atelier
-Evolution : On peut écrire "pour 10, affiche joker" au lieu de "pour chaque 10, affiche joker"
-Evolution (72) : Autoriser le retour chariot après la virgule, l'esperluette et quelques autres symboles
-Evolution (88) : Linotte fonctionne sur raspberry et java 8
-Evolution (91) : Possibilité d'additionner deux casiers ainsi : c3 vaut c1 + c2 ou même c3 vaut c1 + 2
-Correction (87): On peut ne peut pas mettre de répertoire dans le chemin d'accès au bibliothèque
-Correction (86): Le message "La syntaxe de la doublure est incorrecte" s'affiche de temps en temps
-Correction (82): Problème de rafraichissent de la toile
-Correction (77): Afficher un grand nombre
-Correction (76): Bogue dans l’instanciation des prototypes
-Correction (74): a vaut 3(5) ne produit pas d'erreur
-Correction (73): java.lang.NullPointerException = #(y@b)=y+(2+h(2))*l
-Correction (75): Le verbe annihiler ne fonctionne plus avec les espèces graphiques : fuite mémoire


Cette version est téléchargeable depuis cette adresse : http://langagelinotte.free.fr/wordpress/?page_id=119

• Premier outil proposé : l’analyse en “temps réel” de la syntaxe et de la sémantique de son programme :

  

  Ainsi, l’Atelier devient intelligent !
  Il souligne d’un liseré rouge les variables qui n’existent pas et d’un liseré gris les variables globales.

• Le deuxième outil est l’affichage des méthodes fonctionnelles des espèces et des greffons :

  

• Le troisième outil est l’inclusion d’une base de données SQL (HSQLDB) : deux exemples montrent comment créer et manipuler des tables SQL en Linotte à l’aide du greffon SQL.

• Voici la liste des autres nouveautés et travaux apportés par cette version :

  -Evolution : Affichage du numéro de la ligne qui a produit l’erreur dans l’Atelier
  -Evolution : La fonction clonage peut s’écrire clone(acteur) : affiche clone(a) au lieu de : affiche #a
  -Evolution : Ajout de l’exemple : j_expert/echiquier.liv
  -Evolution : Ajout du mot clé “greffons” au début d’un livre pour indiquer la dépendance aux greffons (SQL.liv)
  -Evolution : Ajout du verbe recharger
  -Evolution : Ajout d’une base de données intégrée (HSQLDB) et de l’exemple /exemples/tutoriels/d_greffons/SQL.liv et SQL_DAO.liv
  -Evolution : Ajout de la possibilité de mettre une texture sur les espèces graphiques suivantes : cercle, chemin, crayon, ligne, mégalithe, point, polygone, rectangle
  -Evolution : Controle + Page Bas, affiche le cahier précédent
  -Evolution : Controle + Page Haut, affiche le cahier suivant
  -Evolution : Controle + M, permet d’agrandir ou réduire le cahier
  -Evolution : Ajout du composant graphique sousformulaire
  -Evolution : Ajout de l’acteur particulier “|” pour effectuer un retour à la ligne : affiche “Sur une ligne.” + | + “Sur une autre ligne.”
  -Evolution : Ajout de la méthode “clignoter” au formulaire
  -Evolution : Ajout du greffon Horodatage (exemple horodatage.liv)
  -Evolution : Définition des prototypes syntaxiquement (exemple starwar.liv)
  -Evolution : Complétion des espèces et affichage de méthodes fonctionnelles dans l’Atelier
  -Evolution : Vérification et contrôle des acteurs par l’Atelier
  -Correction : diff (!=) et égal(==) fonctionnent avec deux espèces
  -Correction : Problème du double affichage du programme dans la barre des tâches.
  -Correction : Meilleur gestion de la mémoire

Découvrez les modifications apportées au document :

Bonne lecture et merci Wam pour ton travail !

La chose est corrigée grâce au formidable travail de Wam, un contributeur actif sur le forum.

Voici une première version de son tutoriel : Documentation_Linotte_version_2_0_4_0_0.pdf

J’en profite pour annoncer la sortie de la version 2.0.3 qui corrige des bogues mineurs et puis en même temps, de vous souhaiter une bonne année 2013 !

Qu’elle soit riche en programmes !

Voici la liste des corrections depuis la version 2.0 :

-Correction : Bogue lors de l'utilisation de l'inférence et les espèces: texte vaut "${heure}"
-Correction : Le verbe Temporiser ne marche pas avec une valeur inférieur à une seconde
-Correction : Il est possible d'arrêter des appels récursifs (correction temporaire)
-Correction : Problème de clignotement de la toile avec la Pipette
-Correction : Bogue lors de l'utilisation de l'inférence : affiche "${heure}" + "."
-Correction : Le verbe Temporiser semble ne pas marcher dans certains cas
-Correction : Exemple Fibonacci ne fonctionne pas correctement avec un nombre n très grand
-Correction : Possibilité d'avoir des infobulles sur la boitetexte
-Evolution : Ajout de l'évènement contrôle-entrée sur la boitetexte

La version 2.0 est sortie il y a quelques jours. Il est temps d’officialiser cette naissance sur le site du langage !

Cette version est téléchargeable à partir de cette page : ici !

Voici la liste des nouveautés apportées par cette version :

*25/11/12 - Linotte 2.0.1
-Correction : Les greffons peuvent retourner des espèces
*14/11/11 - Linotte 2.0
-Evolution : Ajout de la commande tilde ~trace 1 ou ~trace 0 pour activer ou désactiver les traces
-Evolution : Ajout du verbe provoquer : provoque une erreur
-Evolution : Syntaxe 2.0 : ajout du verbe nommer permettant de donner un nom au livre courant
-Evolution : Ajout du verbe montrer : "montre toile", affiche la toile et recherche le focus
-Evolution : Ajout du composant graphique scrolleur : exemple scrolleur.liv
-Evolution : Ajout de la boite à espèces
-Evolution : Ajout des propriétés rx et ry à la toile : ajout de l'exemple bureau.liv
-Evolution : Meilleurs affichage des greffons Java dans le menu Prototype
-Evolution : Ajout du composant graphique barre : exemple barre.liv
-Evolution : Nouveaux formats des commentaires
-Evolution : Casiers anonymes
-Evolution : Possibilité de mettre une image sur le fond d'un formulaire (exemple BasicTime.liv)
-Evolution : Ajout des fonctions chargecasiernombres et chargecasiertextes au Conduit
-Evolution : Possibilité d'être compatible avec la syntaxe 1.X avec l'option Outils/Options/Compatibilité Linotte 1X activée
-Evolution : Ajout du manageur de style (le couteau Suisse de l'Atelier ...)
-Evolution : Ajout de la fonctionnalité "Navigation dans le livre"
-Evolution : Possibilité d'exporter son livre en image au format PNG
-Evolution : Ajout de l'option -1 en ligne de commande pour forcer l'utilisation de la syntaxe 1.X
-Evolution : Nouvelle syntaxe 2.0
-Correction : La fermeture d'un formulaire appelle qu'une fois l'évènement "clic souris".
-Correction : Amélioration de l'import de livre


Vous trouverez plus de détail sur cette version dans un article que j’ai posté sur linuxfr : http://linuxfr.org/news/linotte-2-0

N’oubliez pas de venir sur le forum discuter et présenter vos créations et pourquoi pas, découvrir le nouveau greffon TCPLinotte permettant de créer des programmes communiquant sur le réseau !

Bonne programmation !

Commençons la découverte de la nouvelle syntaxe en regardant cet algorithme implémentant la suite de Syracuse. La clarté du programme permet de nous affranchir d’écrire des commentaires dans le programme ! N’est-ce pas ?

Le code suivant calcule le nombre de Fibonacci pour une valeur N.
Deux façons de l’exécuter : soit en passant par les tests qui vont s’assurer que l’algorithme calcule la bonne valeur pour n=60 ou alors interactivement, en demandant à l’utilisateur une valeur quelconque de N :

Et pour la fin de la démonstration, admirons l’affichage d’une vague qui suit votre souris sur l’écran :

La version 1.99 est une version intermédiaire avant la version finale 2.0 qui devrait arriver à la fin de l’année.

Cette version est téléchargeable ici :

• Linotte 1.99.10

Et voici les quelques documentations compatibles avec cette nouvelle syntaxe :

• Présentation rapide
• Découvrir Linotte en 10 minutes

Voici une liste non exhaustive des nouveautés :

• Toutes les variable sont locales au contexte (paragraphe ou bloc) sauf celles présentes dans la section “globale”. Le symbole § disparaît.
• La mémoire est vidée avant chaque lancement de livre
• Il doit disparaitre les mots clés suivants : livre, paragraphe, rôle, action.
• “alors” ne doit plus être utilisé mais seulement la virgule lors de l’utilisation des conditions.
• La version 2.0 est capable de “comprendre” la syntaxe Linotte 1.X.

Vos anciens programmes sont toujours compatibles avec l’Atelier 1.99 mais à condition d’être affublés de l’indicateur suivant : “version 1″ :

Vous pouvez partager votre avis et vos idées sur le forum :
http://langagelinotte.free.fr/forum/showthread.php?tid=967

Bonne programmation !

Les deux fichiers suivants doivent être localisés dans le répertoire .linotte/greffons présents dans votre répertoire personnel.

• La première étape consiste à créer le descripteur du greffon dans un fichier nommé mathlib.greffon.xml :
  
<?xml version="1.0" encoding="UTF-8"?>
<greffon nom="Mathlib" espece="mathlib" class="Mathlib" lang="python">
<description>Librairie de fonctions mathématiques</description>
<auteur>Exemple</auteur>
<version>0.1</version>
</greffon>


Ce fichier est la carte d’identité du greffon. Il contient les informations permettant à l’interprète Linotte d’initialiser correctement le greffon.

• Maintenant, nous allons créer notre fichier en langage Python avec notre éditeur Python préféré.
  Voici le fichier Mathlib.py qui doit être déposé dans le même répertoire que le descripteur :
  
from org.linotte.greffons.externe import Greffon
class Mathlib(Greffon) :
def slot_pgcd(self, a, b) :
while (b > 0):
r = a % b
a, b = b, r
return a
def slot_somme(self, liste) :
compteur = 0
somme = 0
while compteur < len(liste) :
somme += liste[compteur]
compteur += 1
return somme
def slot_moyenne(self, liste) :
return self.slot_somme(liste) / len(liste)


  Notre fichier Python propose 3 méthodes fonctionnelles : pgcd, somme et moyenne. Comme vous pouvez le remarquer, l’interprète Linotte ne prendra en compte que les méthodes commençant par slot_.

• Relancez l’Atelier Linotte et vérifiez la présence de votre greffon dans la boite A propos présent dans le menu Aide :
  

• Et enfin, dans l’Atelier Linotte, créons notre nouveau livre : DemoMathLib.liv:
  

• Pour tester notre greffon, nous allons écrire le livre suivant :
  
principale :
math est un mathlib
notes est un casier de nombre valant 12, 14, 15, 10, 9, 14
début
affiche math.pgcd(121,803)
affiche math.somme(notes)
affiche math.moyenne(notes)


• Et voilà le résultat sur le tableau après lecture du livre :
  
11
74
12.33333333333333392545227980008349


N’hésitez pas à venir sur le forum si vous voulez plus d’aide pour écrire des greffons en Python :
http://langagelinotte.free.fr/forum/

• Ajout du manageur de greffons permettant de télécharger et installer très facilement les greffons,

• Amélioration et ajout de composants graphiques pour créer des IHM évoluées,

• Ajout de la gestion des favoris dans l’Atelier,

• Possibilité d’ajouter dans le code source de son programme des tests automatiques.

• Et enfin et surtout… la possibilité d’écrire des greffons en Python. Ainsi, vous pouvez étendre les possibilités du langage en y ajoutant des fonctions supplémentaires.

Obtenez librement cette nouvelle version à partir de la page de “téléchargement”.

Je travaille également sur un nouveau projet nommé Parangon-Lang s’appuyant sur le moteur du langage Linotte et ces paradigmes. C’est un langage de programmation en anglais très proche du Basic.

Bonne programmation.

• La première évolution syntaxique est la possibilité de déclarer des fonctions en tant que variables :
  Fonction Lambda :
Principal :
Rôles :
x & y :: nombre
multiplication :: lambda x | y <- x * y
Actions :
multiplication (5,6) !


• La deuxième évolution syntaxique est l’ajout de l’opérateur ternaire :
  Opérateur ternaire :
Principal :
Rôles :
note <- 15
Actions :
ter (note<10,"refusé", "admis") !


  Et en utilisant les fonctions en tant que variables et l’opérateur ternaire,
  on peut obtenir du code très concis :

  Nombre de Fibonacci :
Principal :
Rôles :
n :: nombre
fibo :: lambda n <- ter (n<2, n, fibo (n-1) + fibo (n-2))
Actions :
fibo (20) !


• La dernière évolution syntaxique est la possibilité d’écrire des livres courts en préfixant son code par un pied-de-mouche. La structure du programme est simplifiée mais il ne peut plus être structuré en paragraphes :
  ¶
"Bonjour avec Linotte ${version}" !
"On a plus le droit de dire que la Linotte est bavarde" !


• Et enfin,la nouvelle interface Alizé qui introduit la notion d’Espace de Travail :
  

Obtenez librement cette nouvelle version à partir de la page de “téléchargement”.

Bonne programmation.

• Les univers en 3 dimensions
  Cette version apporte des nouveaux objets graphiques permettant de créer des mondes simples en 3D.
  Voici un exemple de réalisation (seulement 30 lignes !) :
  
• Ajout de l’inférence de types pour les nombres et textes
  L’inférence de types est un nouveau mécanisme proposé par le langage. Il permet au développeur d’obtenir un code plus aéré lorsqu’il utilise les types simples :
  Au lieu d’écrire nb :: nombre <- 3.14 , il peut écrire simplement nb <- 3.14. Linotte est capable de déterminer le type de l’acteur si celui est un nombre ou texte.
• Ajout de l’interpolation des acteurs
  L’interpolation d’un acteur consiste à évaluer la valeur d’un acteur à l’intérieur d’une chaîne de caractères :
  message <- "Vous utilisez la version ${version} du langage !"
• Ajout de l’exemple piano.liv
  L’exemple piano.liv est basé sur le nouveau greffon Métrome. Ce dernier propose des fonctions pour s’amuser avec les sons MIDI de votre ordinateur.
• Ajout de l’exemple impression_toile.liv
  Découvrez le greffon Imprimeur et amusez-vous à imprimer la toile.
• Ajout du gestionnaire de greffons
  Le gestionnaire de greffons permet d’installer ou mettre à jour un greffon automatiquement. Les exemples impression_toile.liv et piano.liv utilisent cette nouvelle fonctionnalité.

Cette version est téléchargeable ici : http://langagelinotte.free.fr/wordpress/?page_id=119

Ce thème n’est pas nouveau car il existait déjà sous Gnome 2. Par contre, j’ai choisi le thème Bright pour décorer mes fenêtres : le thème Elegan_Brit étant ridiculement petit.

Souvenez-vous du thème Atlanta pour Metacity toujours disponible avec Gnome 2 : le thème que l’on utilise jamais car il nous rappelle les premières version de KDE. Là, je dois avouer qu’il a un certain style avec Elegan_Brit :

Le fond d’écran Google Classic apporte un touche retro au bureau. Il est disponible ici.

J’ai utilisé le super jeu d’icônes Areao43 (les anciens doivent se souvenir de Area o.42 ?) disponible sur gnome-look par là.

C’est plus carré et moins “smooth” que Faenza mais ça fait du bien de changer de temps en temps !

Cette version, fruit de 4 mois de travail,apporte son lot de corrections de bogues et quelques nouveautés.
La principale est la possibilité d’afficher plusieurs commandes sur une ligne :

Demande nom;Affiche "valeur : " + nom

Ensuite, le jeu Astronotte est intégré au menu de votre système si vous utilisez le format DEB, RPM ou l’installateur Windows.

Dés que Linotte est installé, courrez télécharger le nouveau jeu Plumes Mêlées de Momo112 : vous serez convaincu de la qualité des logiciels que l’on peut produire avec ce langage !

La liste des nouveautés est proposée ci-dessous :

-Evolution : Simplification de l’écriture des greffons
-Evolution : La toile peut être transparente (avec le greffon Tweak)
-Evolution : Ajout du lanceur.exe et lanceur.conf
-Evolution : Le verbe Appeler peut appeler un paragraphe dynamiquement (cf ParagrapheDynamique.liv)
-Evolution : Ajout du greffon PressePapier presse-papier.liv
-Evolution : Possibilité d’utiliser le point-virgule pour mettre plusieurs commandes sur une ligne.
-Evolution : Ajout de l’exemple Astronotte.liv (+ un lien sous Windows dans le menu démarrer)
-Evolution : Amélioration du moteur pour mieux supporter la charge
-Evolution : Affiche de la toile passe de 25ms à 15ms
-Evolution : Ajout de l’exemple SleepSort.liv
-Correction : Compatibilité avec le jdk 1.7 et suppression de la fonctionnalité d’accès au base de données (à réécrire sous la forme d’un greffon )
-Correction : Le bouton Stop n’est plus bloqué par le verbe Attendre
-Correction : Execution des évènements de sortie dès que l’on quitte la toile
-Correction : Bogue de l’utilisation du joker avec le verbe appeler dans une boucle
-Correction : jinotte.jar ne peut modifier le fichier de paramètres
-Correction : jinotte.jar plus léger
-Correction : Verbe “appeler” en fin de livre : http://langagelinotte.free.fr/punbb/viewtopic.php?id=450
-Correction : Ajout du thème Linotty (merci momo112)
-Correction : Bogue remonté par momo112 : http://langagelinotte.free.fr/punbb/viewtopic.php?id=442

Dans un terminal, exécutez la ligne suivante :

su -c ‘alternatives –install /usr/lib64/mozilla/plugins/libjavaplugin.so libjavaplugin.so.x86_64 /usr/java/jdk1.7.0/jre/lib/amd64/libnpjp2.so 20000′

Relancez votre navigateur… et utilisez cette page http://www.javatester.org/ pour tester si l’activation du plugin est correcte.

Et voilà le résultat :

1. Téléchargez Java 7 en version RPM sur le site d’Oracle ici : http://www.oracle.com/technetwork/java/javase/downloads/java-se-jdk-7-download-432154.html
2. Cliquez sur l’archive ainsi téléchargée pour installer le RPM,
3. Après être passé en root en utilisant un terminal, exécutez la ligne suivante :
   /usr/sbin/alternatives –install /usr/bin/java java /usr/java/jdk1.7.0/bin/java 3
4. Puis lancez l’outil alternatives: /usr/sbin/alternatives –config java
5. Choisissez l’option 3 et enfoncez la touche [Entrée]
   Et voilà !
6. Vérifiez l’installation en tapant la ligne de commande suivante : java -version
7. Vous devez obtenir :
   
8. Vous noterez que ce post est aussi un prétexte pour vous montrez mon bureau sous Gnome 3 avec le thème Faience et le thème GTK3 Zukitwo…
9. Une dernière copie d’écran pour la route :
   

• Plumes Mêlées

Momo112 nous propose un nouveau jeu : Plumes Mêlées.

Ci-dessous, la présentation du jeu par l’auteur :
“Comme son nom l’indique, il s’agit d’un jeu de … mots mêlés.
Le principe du jeu est simple, il suffit de trouver des mots listés dans une grille de lettre. Les mots peuvent être dans n’importe quel sens, seulement, les lettres d’un mot sont toujours alignées et doivent se toucher.
La version 0.5 de Plumes Mêlées est disponible sur CodingTeam, et permet de jouer au pack de grilles de base (contenant 15 grilles) et peut être enrichi par des packs téléchargeables (bientôt disponibles).
Voici le site du jeu : http://plumesmelees.fr.nf
Et si vous trouvez un bug ou une erreur dans les grilles, n’hésitez pas à les rapporter ici, ou sur l’interface prévu sur CodingTeam.”

• Noteradio

Toujours Momo112 , il nous présente la version 3.2.0 de Noteradio : elle offre en plus d’un rafraichissement graphique, un système de mise à jour simplifié pour les versions mineures.
Pour rappel, Noteradio est un logiciel vous permettant de retrouver une sélection de radios françaises.

Site de noteradio : http://noteradio.fr.nf

• SleepSort

C’est l’algo du moment… le « Sleep sort », un astucieux algorithme pour trier une liste de nombres : http://drgoulu.com/2011/06/19/le-sleep-sort/

Le voici en langage Linotte :
Sleepsort :

Principal :
Rôles :
paramètre :: casier de nombre <- 7, 1, 3 ,2, 5, 6, 4, 0, 3
Actions :
pour chaque paramètre, lis
appelle sleep avec joker
ferme
observe sleep

Sleep :
Rôles :
* élément :: nombre
Actions :
attends élément secondes
élément !
reviens


• Du côté de Linotte 1.4

Le prochaine version de Linotte devrait apparaitre d’ici 3 mois. Les nouveautés s’accumulent :

1. Linotty : le nouveau thème graphique par Momo112 change les icônes de l’Atelier.
2. La toile peut être transparente (enfin!) en utilisant le greffon Tweak :
3. La syntaxe évolue : il est possibilité d’écrire deux commandes sur une ligne en utilisant le point-virgule : demande a;affiche a
4. Et maintenant, il existe un lanceur pour Windows permettant de lancer un livre depuis un exécutable (un .exe), la présentation est ici : http://langagelinotte.free.fr/punbb/viewtopic.php?id=457

Merci pour votre lecture et au prochaine numéro !

On peut s’inspirer des langages suivant :
AlgoBox : http://www.xm1math.net/algobox/changelog.html
Scilab : http://www.scilab.org/support/documentation/tutorials

Ce projet s’appelle Abaque et se présente comme un greffon au langage (pour rappel, les greffons du langage Linotte sont écris en Java ou Python).

Les contributions peuvent être de l’ordre des idées, de la description des algorithmes à implémenter ou même de la programmation des fonctions mathématiques directement en java ou python.

Une discussion a été ouverte sur le forum :
http://langagelinotte.free.fr/forum/showthread.php?tid=842

Une page dédiée au greffon est disponible sur le wiki :
http://langagelinotte.free.fr/wiki/index.php?title=Abaque

Docteur Gnu, c’est grave ?

J’ai parcouru la page regroupant quelques thèmes pour le shell sur le site Deviantart (découvert grâce à cette formidable page sur du site FedoraFr) mais aucun thème est aussi beau et agréable qu’Adwiata.

Garder ce thème, c’est aussi respecter le choix des développeurs Gnome.

J’ai opté pour une autre solution : ne modifier que le thème Mutter. Pour cela, j’ai téléchargé le thème Small And lite sur le site Gnome-Look. Je l’ai décompacté dans le répertoire .themes et ensuite, avec l’outil Tweak Tool, depuis dans l’onglet Current Theme, j’ai sélectionné mon thème “Small and Lite”.

Un redémarrage sur Shell est obligatoire pour prendre en compte le thème (ou Alt F2 + r).

Et voilà le résultat (il beau et mince mon gnome ?) :

Votre mission : ressortir de ce terrain fort hostile afin de repartir tranquillement chez vous…. (votre femme/homme vous attend à la maison !)

Je vous laisse essayer ce petit retro-jeu écrit en Linotte mélangeant Space Invaders et Arkanoid. Il vous faudra avoir les nerfs solides pour réussir la traversé !!

(cliquez sur l’image pour jouer !)

Les évolutions ont été axées sur : la simplification de la syntaxe et la possibilité d’écrire des bibliothèques externes (greffons) dans le but d’enrichir le langage.

La première nouveauté est une simplification syntaxique de la déclaration d’un nouvel acteur. Ainsi, il est possible de remplacer la forme suivante « nb est un nombre » par celle-ci « nb :: nombre ».
De plus, on peut également remplacer le participe présent «valant» par l’opération «<-»:
« nb :: nombre <- 10», signifie : « nb est un nombre valant 10»

La deuxième nouveauté est le fait que l’on puisse (enfin) utiliser les opérations suivantes :
!=, ==, <=, >=, <, >

On obtient ainsi une syntaxe plus concise lors de l’écriture de conditions :

• si a < b alors ....
• tant que a < b alors ....

J’en ai profité pour ajouter la fonction mathématique hasard, plus pratique à utiliser que le verbe Mélanger :
Affiche hasard (10)

La troisième est l’ajout de la notion de synonyme. Elle offre une capacité simple pour personnaliser le langage.

Ainsi, on peut écrire un tel livre (à condition d’avoir défini correctement les synonymes):

Programme : Syracuse
Traitement : Application de la suite de Syracuse
Types :
durée :: nombre vide
e :: nombre
Algorithme : Boucle
demander e
tant que e != 1, début
durée vaut durée + 1
si (e mod 2) == 0 alors e vaut e / 2
sinon, e vaut e * 3 + 1
fin
afficher durée
terminer

Les synonymes sont à définir dans un fichier sysnonymes.def que l’on dépose dans le répertoire .linotte situé dans votre répertoire personnel ou dans le répertoire du langage (au même niveau que Linotte.jar).

La quatrième nouveauté est la possibilité de créer des acteurs locaux à des sous-paragraphes :

Livre : acteurs locaux à un sous-paragraphe
Paragraphe : principal
Rôles :
mon casier :: casier de nombre vide
Actions :
pour chaque 10, lis
§ b :: nombre valant 15
mélange b
ajoute b dans mon casier
ferme
affiche mon casier


La cinquième et la plus importante nouveauté est l’ajout de la notion de prototype :

La notion de prototype offre au programmeur la possibilité de modifier un objet Linotte (un acteur) pendant l’exécution du programme : on peut ajouter soit des nouveaux attributs à un objet, soit des méthodes fonctionnelles. Les objets ainsi créés peuvent être clonés à l’identique.

Comme indiqué ci-dessus, la notion de méthode fonctionnelle apparait dans le langage. Elle offre la possibilité d’attacher à des objets des traitements liés à l’objet même.

Rien de mieux qu’un exemple complet pour découvrir les possibilités offertes !

L’exemple suivant L’attaque des clones va vous plonger dans le film du même nom… Dans un premier temps, on créé le prototype stormtrooper qui va être enrichi d’attributs, puis de méthodes fonctionnelles et, ensuite, que l’on va le cloner une centaine de fois pour créer l’armée.
Le source de l’exemple est disponible ici : L’attaque des clones

Les greffons :

Cette nouvelle approche prototype apporte une simplification de l’écriture des greffons.
En plus d’un descripteur de greffons décrivant le nom du prototype et ses attributs :

On peut maintenant écrire les méthodes fonctionnelles en Java :

Ainsi, nous pouvons écrire ce livre :

Hello World avec un greffon :
Démonstration :
Rôles :
messager :: majordome
Actions :
affiche messager.présentation("Jules")
termine


Et à l’exécution, on peut admirer le résultat sur le tableau :

Bonjour, mon cher Jules, je suis votre serviteur Nestor

De plus, un greffon peut exposer sa documentation directement dans l’Atelier Linotte :

On pourra facilement écrire des bibliothèques de fonctions pour le langage Linotte (bibliothèques mathématiques, physiques, capacité d’affichage d’objets en 3D, etc…)

En bonus, quelques modifications visuelles de l’Atelier, notamment la nouvelle option Bonifier l’Atelier facilitant la lecture des algorithmes :

Et enfin, voici le reste des modifications :

• Ajout de l’exemple asciinotte.liv
• Ajout de l’exemple presse-papier.liv
• Ajout du greffon PressePapier.
• Ajout de la fonction ASCII et CHR
• Ajout de la fonction mathématique hasard : affiche hasard (10)
• Possibilité de modifier la précision arithmétique
• ajout de l’exemple precision_arithmetique.liv
• Ajout de la recherche dans l’Atelier
• Il faut utiliser les doubles-chevons pour charger dynamiquement les acteurs
• Affichage des numéros de ligne dans l’Atelier
• Ajout du l’exemple liNotPad.liv (exemple pour utiliser les méthodes fonctionnelles avec le Conduit)
• Ajout du greffon Conduit (exemple pour utiliser les méthodes fonctionnelles avec les greffons)
• Ajout de l’exemple majordome.liv (exemple pour utiliser les méthodes fonctionnelles avec les greffons)
• Ajout du greffon Majordome (exemple pour utiliser les méthodes fonctionnelles avec les greffons)
• Ajout de l’événement “clic droit souris”
• Ajout du bouton “activer le bouton de trace” dans l’onglet Audit
• Ajout du thème d’icônes Extra-Elementary (merci momo12)
• Ajout du composant BoutonMenu (voir le livre menu.liv)
• Ajout de l’exemple : starwar.liv
• Ajout de l’exemple : chronometre.liv
• Ajout du verbe attacher
• Ajout du verbe évoquer
• Ajout du verbe décrémenter
• Ajout du verbe incrémenter
• Optimisation d’environ 50% du moteur d’exécution
• Correction du verbe Insérer

Pour faire simple et rapide, un prototype est un objet modifiable pendant l’exécution d’un livre : on peut modifier sa structure, c’est à dire, ajouter des caractéristiques ou des méthodes fonctionnelles.

En Linotte, toutes les espèces sont des prototypes.

Les méthodes fonctionnelles sont également une nouvelle notion apparue dans cette version.

Une méthode fonctionnelle est un paragraphe que l’on attache à une espèce. Ainsi, l’espèce porte en elle-même les traitements qui lui sont propres.

Voici un exemple :

Ces deux nouveautés (prototype et méthode fonctionnelle) ouvrent des possibilités importantes dans la création des greffons.

Il est possible de créé un prototype avec des méthodes fonctionnelles écrites en langage Java. Vous aurez plus d’information sur cette page qui sera étoffée dans les prochains jours :

http://langagelinotte.free.fr/wordpress/?page_id=176

La version 1.3 alpha 6 est téléchargeable à partir de cette page :

http://langagelinotte.free.fr/wordpress/?page_id=142

La documentation n’est pas encore à jour. Il est ainsi fortement recommandé de lire les nouveaux exemples inclus dans le répertoire /exemples/tutoriels/i_prototype/ pour découvrir et comprendre les nouvelles notions introduites dans le langage.

Voici la liste des nouveautés :

-Evolution : ajout de l’option “Bonifier le cahier”
-Evolution : ajout du l’exemple liNotPad.liv (exemple pour utiliser les méthodes fonctionnelles avec le Conduit)
-Evolution : ajout du greffon Conduit (exemple pour utiliser les méthodes fonctionnelles avec les greffons)
-Evolution : ajout de l’exemple majordome.liv (exemple pour utiliser les méthodes fonctionnelles avec les greffons)
-Evolution : ajout du greffon Majordome (exemple pour utiliser les méthodes fonctionnelles avec les greffons)
-Evolution : ajout de l’événement “clic droit souris”
-Evolution : Ajout du bouton “activer le bouton de trace” dans l’onglet Audit
-Evolution : Ajout du thème d’icônes Extra-Elementary (merci momo12)
-Evolution : Ajout du composant BoutonMenu (voir le livre menu.liv)
-Evolution : Ajout de l’exemple : starwar.liv
-Evolution : Ajout de l’exemple : chronometre.liv
-Evolution : Ajout du verbe attacher
-Evolution : Ajout du verbe évoquer
-Evolution : Ajout du verbe décrémenter
-Evolution : Ajout du verbe incrémenter
-Evolution : Optimisation d’environ 30% du moteur d’exécution
-Evolution : Ajout des acteurs locaux à sous-paragraphe
-Evolution : Ajout de l’exemple acteur_local_sous_paragraphe.liv
-Correction : Correction du verbe Insérer

Je ne peux en vouloir qu’à moi !

Pourquoi ?

1. Depuis deux ans, je ne grave plus mes photos par manque de courage mais surtout… par manque de temps… Comment trier, renommer, catégoriser, et faire en sorte que les photos soient groupées par paquet de 4 Go (un DVD…) sans que cela prenne une après-midi entière ?
   Du coup, les photos datant de moins de deux ans n’existaient que sur ce disque dur externe….
2. Parce que j’ai voulu réinstaller MS Windows XP sur un de mes portables alors que j’ai un live CD reçu un jour par la poste depuis l’Afrique du sud….
3. Parce que ce fameux Windows XP est “paquagé” dans un CD portant la mention : Windows XP Restore… LE CD pour les nuls… tu insères la galette dans ton lecteur et tu le laisses faire…. car ce CD fait tout … je dis bien tout !
   Il le fait tellement bien qu’il formate tout…. tout ce qu’il trouve…
4. Et c’est là que je m’en veux… j’ai bien débranché une prise USB….  je m’en souviens bien…. mais ce n’était pas la bonne… C’était juste ma souris…. Mon disque dur externe était resté branché pendant toute la réinstallation de Windows sans que je ne me doute de rien (Suivant… clic… Suivante… Clic…)!

Et voilà comment la Terre peut s’arrêter de tourner à cause d’une étourderie lourde de conséquence…

Mon esprit, pas si amorphe que ça, retrouve quelques bons réflexes…. ne surtout rien écrire sur ce disque dur et le débrancher le temps de trouver une solution.

Ni une, ni deux, je pars sur le net à la recherche d’un logiciel capable de retrouver mes photos : Google était devenu mon meilleur ami !

J’avais bien dans la tête le nom d’un logiciel libre : Photorec mais celui-ci présente une interface obscure en ligne de commande…

Quoi, faire confiance à un tel logiciel ? Lui remettre toute ma vie entre ses mains ?
Telle une âme perdue… je me retrouve sur le download.com… (sans commentaire !) et je télécharge PC Inspector File Recover (je ne propose pas de lien, il n’est pas libre !). Il semble avoir une bonne réputation sur les forums…

Je l’installe sur mon ordi, rebranche mon DD tout nu et laisse travailler ce logiciel, fermé mais gratuit…

5 jours après… (2 jours pour lire le DD et 3 jours pour sauvegarder les fichiers…) me voilà à découvrir ce qu’il a récupéré…. 2 millions de fichiers de taille identique… jpg, mp3, doc, etc… Pas un fichier plus grand, ni plus petit… pas de jaloux !! Si l’image a une taille inférieure à 1.7 mo alors, ouf, elle est entière sinon… elle se retrouve tronquée ! Et de plus, les méta-informations Exif de mes photos…. ont disparu !

Je m’enfonce dans un gouffre sans fond… la moitié de mes photos semblent perdues…  et puis une lumière réapparait… et si j’essayais PhotoRec ? Après avoir lu et relu la présentation et le tutoriel sur le site… je décide de l’installer.

Fonctionnant en mode batch, il me restaure correctement toutes mes photos en temps réel (j’ai oublié de dire que j’utilise un deuxième disque dur pour sauvegarder mes images récupérées) : les tailles semblent correctes, les méta-informations également !

Je suis sauvé par le libre !

70 heures après, il n’a toujours pas terminé… mais je suis déjà passé à l’étape suivante…  chaque photo récupérée porte le nom du cluster où est stockée l’image : p45645645.jpg.

Je dois maintenant trouver un logiciel libre capable de renommer mes photos en puisant la date du cliché dans la photo et l’intégrer dans le nom du fichier…

J’ai trouvé ce logiciel : Métamorphose mais il ne semble pas prendre en compte les informations EXIF des photos.

Des idées ?

Il est intégré dans la dernière version de l’Atelier Linotte. Vous le trouvez dans le répertoire : /exemples/tutoriels/f_jeux/pac-man/.

Le jeu ne respecte pas tout à fait le gameplay de l’original… pour cause, je n’ai jamais été un grand joueur de Pac-man (trop nul ?). Pourtant, ce jeu ne manque pas de qualités: très simple et très prenant.

Alors… transformez votre PC en borne d’arcade !

Cette version 1.2.4 apporte son petit lot de nouveautés mais les corrections ont été axées principalement sur la stabilisation du moteur d’exécution.

Dans la forme, l’interface a été modifiée ainsi :

• Le télétype fait son apparition dans l’Atelier.
  A travers ce nouvel outil, on peut maintenant tester rapidement des commandes Linotte sans à avoir à créer un livre. Je me suis inspiré des environnements du langage LOGO.
  Telle une ligne de commande, on peut modifier l’affichage (le tableau ou la toile), effectuer des calculs, vérifier des variables et même les modifier alors qu’un livre est en cours de lecture !
• Une première version d’un nouveau didacticiel est intégrée directement dans l’Atelier. Il propose les premières bases pour commencer à programmer en Linotte et propose des exemples de programmes.
• Pour les experts, un onglet Audit est ajouté.
  L’Audit permet de surveiller en temps réel l’état du livre en cours de lecture et la mémoire de l’Atelier. C’est l’outil idéal pour optimiser vos programmes !

Dans le fond, le langage s’enrichit encore :

• Une nouvelle espèce graphique est ajoutée, le praxinoscope. Cette espèce permet de créer des objets animés ( ou sprite : personnage qui marche, objet animé, etc…)
  Une démonstration est disponible dans l’exemple praxinoscope.liv.
• Le verbe “piquer” dessine sur l’écran un point à l’aide du crayon. Ce verbe est apparu à l’occasion d’un petit (et sans prétention…) hommage au mathématicien Mandelbrot.
  Ce verbe est utilisé pour dessiner la fractale de Mandelbrot : à découvrir dans l’exemple mandelbrot.liv
• On peut stocker la valeur d’un acteur dans un cookie lors de l’utilisation d’applet (applet_cookie.html et cookie.liv)

Et en plus profond du langage… quelques optimisation par-ci par-là et une meilleure gestion des clics avec la souris sur la toile.

A vous de jouer et bonne programmation !

Au menu :

• Une stabilisation du nouveau moteur d’exécution du langage et des corrections de bogues remontés depuis le forum.

• L’ajout de la complétion dans l’Atelier. Si vous tapez les premières lettres d’un mot et si vous appuyez simultanément sur les touches [contrôle] et [espace] l’Atelier vous propose de le compléter.
  

• Linotte s’ouvre sur le web à l’instar des langages Ruby on Rails et PHP : un serveur HTTP est intégré à l’Atelier et permet de créer des sites complètements dynamiques ! Un nouveau format de livre est disponible : le WebLivre, il mélange du langage HTML et du langage Linotte.
  <html><% affiche “site dynamique en Linotte !” %></html>
  Pour débuter, lancez l’Atelier Linotte 1.2.2, ouvrez dans votre navigateur Internet l’adresse suivante http://localhost:7777/notice et suivez les indications pour effectuer vos premiers tests !

• Et cerise, sur le gâteau… on peut maintenant se connecter à une base de données pour y lire et même modifier vos données très simplement ! Linotte peut se connecter nativement à MySQL mais il est possible d’utiliser une autre base de données si vous possédez les pilotes JDBC ad hoc !

Bon téléchargement et bonne rentrée !

La grosse évolution proposée est technique: le moteur d’ “exécution” des livres a été réécrit à 100%, il supporte plus efficacement la parallélisation des traitements et la récursivité.
Le débogage a été grandement amélioré, on peut suivre un livre au pas à pas en utilisant le verbe “déboguer”.

L’ergonomie de l’Atelier s’améliore encore, les actions Annuler, Rétablir, Copier, Coller sont disponibles dans le menu contextuel si on effectue un clique droit sur le cahier.
De plus, il est possible d’exporter ses livres au format PDF : pratique pour les imprimer sur du papier (et les lire sur la plage) !

Et enfin, des exemples créés par la communauté ont été ajoutés :

- Paint Pour Linotte vous aidera à exprimer sur la toile vos talents de dessinateur (ppl.liv).

- NoteRadio est le livre qui va vous suivre pendant toutes les vacances ! Ecoutez vos radios préférées, disponibles d’un clic de souris et classées par thèmes.

- BasicTimer pourrait bien vous suivre également… Il vous préviendra dés que votre thé ou votre infusion sera à votre goût !

- Une envie d’aventure ? Extirpez-vous d’un tortueux labyrinthe avec labyrinthe.liv

- Des vacances studieuses ? Décortiquez les algorithmes suivants : décomposition en facteur premiers d’un nombre et la suite de Syracuse.

- Plouf… avec vagues.liv.

- Et le soir, avant de vous coucher, n’oubliez pas d’afficher l’horloge digitale douce, ces lumières chatoyantes vous aiderons à vous endormir…

Bon téléchargement et bonne programmation (profitez quand même de l’été pour vous détendre) !

Voici la liste (presque) exhaustive des nouveautés :

-Evolution : Nouveau moteur Alizé V1
-Evolution : Amélioration du débogage (verbe déboguer)
-Evolution : Ajout du menu “exporter au format PDF”
-Evolution : Ajout de l’exemple vagues.liv
-Evolution : Ajout de l’exemple Noteradio.liv
-Evolution : Ajout de l’exemple decomposition_facteurs_premiers.liv
-Evolution : Ajout de l’exemple horloge_digitale_douce.liv
-Evolution : Ajout de l’exemple horloge_digitale.liv
-Evolution : Ajout de l’exemple syracuse_recursif.liv
-Evolution : Ajout de l’exemple syracuse.liv
-Evolution : Ajout de l’exemple labyrinthe.liv
-Evolution : Ajout de l’exemple cercle.liv
-Evolution : Ajout de l’exemple TeaTime.liv
-Evolution : Ajout de l’exemple BasicTimer.liv
-Evolution : Ajout de l’exemple moyenne.liv
-Evolution : Ajout de l’exemple (Paint pour Linotte) ppl.liv
-Evolution : Ajout des boutons Undo, Redo, Copier, Coller dans la popup du cahier
-Correction : On peut cacher un formulaire (visible à non)
-Correction : Focus activé pour valider dés que l’on demande un nombre
-Correction : Bogue utilisation d’un fichier avec un nombre (remonté par momo12)

Livre : les drapeaux
Rôles :
a est un drapeau valant vrai
Actions :
Si a est vrai alors affiche "c'est vrai !"
Termine

Un nouveau site est créé : http://bibliolinotte.wordpress.com/. Il sera alimenté par les utilisateurs de l’Atelier Linotte.
(Menu Bibliothèques / Partager)

Voici les autres nouveautés :
-Evolution : Ajout du bouton pour publier en ligne son livre
-Evolution : Ajout des fonctions : sup, inf, égal, diff (voir l’exemple conditions_drapeaux.liv)
-Evolution : Ajout des thèmes dans l’Atelier : Tango et Crystal
-Evolution : Ajout du rôle drapeau (ajout de l’exemple drapeaux.liv)
-Evolution : Ajout de l’exemple unicode.liv
-Evolution : Ajout de la fonction µ : convertis un code unicode en hexa en caractère affichable

-Evolution : Ajout de l’option permettant de formater un livre
-Evolution : Ajout du jeu Cave
-Evolution : Ajout de la syntaxe simplifiée des espèces: ‘x de toile’ devient ‘x@toile’
-Evolution : L’opération de clonage supporte les parenthèses
-Evolution : Il est possible de mémoriser les livres ouverts dans l’Atelier
-Correction : Pas de message d’erreur si le paragraphe n’existe pas avec le verbe ‘Parcourir avec’
-Correction : Meilleur affichage des formules mathématiques dans l’Atelier

Elle ferme un premier cycle  : la conception d’un langage simple de programmation en français. Le prochain cycle sera l’enrichissement et surtout la recherche de bras et doigts pour m’aider à maintenir, améliorer et évoluer le code ou  créer des plugins pour enrichir le langage.

Je vous laisse découvrir avec cette copie d’écran la principale nouveauté de cette nouvelle version :

Vous avez deviné… les onglets ! C’est presque une révolution pour les programmeurs en Linotte…. De plus, la gestion du Annuler/Rétablir a même été améliorée !

L’Atelier gagne en convivialité !

Les autres nouveautés sont détaillées ici :

-Evolution : Ajout de la fonction mathématique exponentielle (exp).
-Evolution : Nouvelle syntaxe pour définir un paragraphe.
-Evolution : Nouvelle syntaxe pour définir un livre.
-Evolution : Ajout de l’exemple ’suissbox.liv’.

La documentation a été mise à jour par dadodudou. Il a notamment ajouté un paragraphe sur les boucles FOR. Un grand merci pour cette mise à jour !