retour

BinS
BinS is not Scheme. BinS is not Shell.

Le développement de BinS va être fortement ralentit cet été. En effet, je passe mes "vacances" chez mes parents et mon espace vital est suffisamment petit pour ne pas avoir de place pour poser mon Falcon...
Vivement octobre

Présentation

BinS est un shell fonctionnel orienté graphisme pour les ordinateur Atari.

Je crée BinS car je suis désolé de voir ramer les gros logiciels de retouche d'image à cause entre autres de leurs environnements graphique. Je me suis dit quand supprimant l'interface graphique et utilisant exclusivement l'assembleur, je pouvais arriver à une vitesse de calcul acceptable, tout en ayant le maximum de mémoire...

BinS se décompose en deux parties:

• le shell
  Il sert à charger les images, à lancer les traitements dessus. On peut le programmer. Les programmes BinS ressemble de loin à du Scheme. Sauf lors de l'évaluation des paramètres des fonctions. Contrairement au Scheme, je fais une évaluation paresseuse. Il est possible de charger qu'une fois les images en mémoire pour les traiter. Cela permet de minimiser les accès aux disques et donc de gagner un peu en vitesse par rapport à une shell classique.
• les modules.
  Ce sont des petits programmes que le shell charge en mémoire et utilise comme il peut. Les modules peuvent aussi être exécuter sous TOS. Dans ce cas, une traitement tel que (laplacien + négatif + gradation) chargera trois fois l'image et la sauvera trois fois, alors que sous le shell elle aurai été chargée et sauvée qu'une fois.

Fonctionnel

Quel type d'opérations doit réaliser mon langage? Il doit réaliser des choses comme: "assombrir l'image" ou "rendre l'image floue". On associe très facilement à ces opérations des fonctions "mathématiques" telles que:

   assombrir(image)
   flou(image)

   image:=flou(image)
   image:=assombrir(image)

   assombrir o flou (image)

La syntaxe de BinS est dans le style "lispien". C'est à dire que la seule structure de donnée est la liste. Une fonction est une liste, donc rien nous empêche d'évaluer une liste que l'on a généré.

La grosse différence avec les interpréteurs Lisp "classiques" est que j'ai choisi l'évaluation paresseuse au lieu de l'évaluation gourmande classique. Normalement, cela devrais me permettre d'implémenter facilement des "flots" et de bannir les affectations et de programmer en pur fonctionnel. Mais je mets quand même à disposition un mécanisme pour forcer l'évaluation gourmande (le force de Scheme). Mais je ne suis pas un théoricien des langages informatiques, je ne suis qu'un modeste étudiant. Il se peut que je fasse mauvaise route. Je serai ravi si quelqu'un pouvait me confirmer ma position.

Ici, vous pouvez télécharger une vieille version de l'interpréteur (datée de janvier 99).

Assembleur

Bins ne tournera que sur les Falcon030 d'Atari. Comme je le programme en assembleur, il me sera extrêmement difficile de le reassembler pour d'autre machine à moins de le réécrire entièrement. Je pourrais faire, si on me le demande, une version ST ou pour un clone Atari. Si quelqu'un voudra le porter pour l'Amiga, je lui donnerais volontiers les sources. Il n'aura que les appels systèmes à modifier.

Le Falcon n'est plus une bête de course en face des gros PCs actuels. Donc l'assembleur et un peu d'astuce me permettent de compenser le manque de puissance. En programmant directement la machine, je peux obtenir un exécutable minuscule (la version que je propose en téléchargement ne fait que 2014 octets) et ne possédant des performances bien supérieures à des équivalents compilés. De plus, le Falcon possède un DSP programmable (génial pour les filtres de convolution (multiplication de deux nombres de 24bits et addition d'un troisième avec deux déplacements en parallèle, le tout en 2 cycles d'horloges)) . En utilisant celui ci en parallèle avec le processeur, les performances sont plus qu'acceptables.

Modulaire

L'aspect modulaire de BinS lui offre une grande souplesse. Cela me permet de concentrer dans le noyau que les aspects fondamentaux du langage.
Grâce à l'évaluation paresseuse et au garbage collector, les modules sont gérés dynamiquement. C'est à dire qu'ils peuvent être chargé et déchargé à volonté. Si on travaille sur des grosses images, cela permet d'économiser de la mémoire.

Au risque de tourner le dos à l'idée de BinS, rien ne m'empèche de créer des modules de gestions d'environnement graphique...

En attendant, vous pouvez toujours télécharger les premiers modules.

Sémantique

E e1 v1     (funct e1)E f(e1) v2
	(Appel de fonction)
E (f e1) v2

Valvassori Moïse Dernière modification: Saturday 18 May 2002 , 14:00:21