Planet OFSET

To content | To menu | To search

Tag - smalltalk

Entries feed - Comments feed

Monday, June 7 2010

DrGeoII new user interface

Here is a DrGeoII screenshot under the Pharo environment and language. The exposed construction is about a circle tangent to the blue line and crossing two points A and B. The Pharo user interface theme is Watery 2.

Next change will be with the macro-construction user interface to implement a Polymorph wizard dialog.

DrGeoII can be installed in Pharo from its source code repository.


Tuesday, June 1 2010

Horizontal grid artifact

I created a new artifact for Etoys, it is to divde a grid in two parts. It can be use to explain distribution in calculus 5*7=5*5+5*2. It is scriptable graphically with Etoys tiles.

Moreover, now the artifacts appear in a specific Artifacts category of the Object Catalog.


You can load in Etoys/Squeak/Pharo from its repository

Fraction Box Artifact

I created a new artifact for Etoys, it is to represent m parts among n parts. It is scriptable graphically with Etoys tiles.


You can load in Etoys/Squeak/Pharo from its repository

Wednesday, April 21 2010

Some more about Polymorph for DrGeo

Someone asked for a more elaborated UI for DrGeo, here are some progresses in this polymorphization of DrGeo. Known to work with Pharo 1.0.

In its latest Monticello package one can grab DrGeo at

DrGeo Polymorphization

To start a DrGeo instance, do a DrGeo new in a workspace and enjoy the UI.

Beware, style tools does not work in the toolbar.

It is also possible to use DrGeo as a service for Etoys when executing a DrGeo sample openInWorld

It is also possible to load XML description of DrGeo 1.1 geometric sketch, if one is interested you can grab it at and load a sketch with a command: DrGeo newXml: path

Beware sketch with embedded Scheme code will not work (just try)

Working sketch: mercedes, euler-line,

DrGeoII comes with a better interface for scripting with Smalltalk script, empowered by the IDE, nicer than the former Scheme one. See this elaborated demonstration (automatic translation link with Google in a comment, at the end of the article)

Thursday, April 15 2010

Pharo Smalltalk 1.0 is out

Pharo is a new Smalltalk programming environment, derived from Squeak. It is largely used by the Seaside web framework.

The 15 of April, the version 1.0 was released

Saturday, April 10 2010

UI with Pharo

How to write GUI application with Pharo Smalltalk?

In this series of articles I will use DrGeo Smalltalk porting effort to Pharo UI as an example. The articles use Pharo 1.0, but it should work with newer version without modification.

Do not hesitate to comment.

I start with with a kind of StandardWindow class I nammed DrGeoWindow, it is the main UI element of DrGeo:

StandardWindow subclass: #DrGeoWindow
     instanceVariableNames: 'view presenter domain'
     classVariableNames: ''
     poolDictionaries: ''
     category: 'DrGeoII-App'

If you look at the StandardWindow class definition, you see it uses a trait coming from the Polymorph UI framework:

SystemWindow subclass: #StandardWindow
	uses: TEasilyThemed - {#theme}
	instanceVariableNames: ''
	classVariableNames: ''
	poolDictionaries: ''
	category: 'Polymorph-Widgets-Windows'

In a few words, a trait is a mechanism to import in a given class, an interface of methods, without the need of subclassing or poly- inheritance.

This keyword uses: TEasilyThemed - {#theme} says import the methods from trait TEasilyThemed without the method named @theme@.

So what is coming along this trait TEasilyThemed?

The screen shot bellow shows the hierarchy of the DrGeoWindow class, its direct ancestor is selected so we can see its interface. The methods imported from the trait are emphasized:

DrGeoWindow hierarchy

For the UI developer, the trait brings two advantages:

  1. Services of UI elements like dialogs: question dialog, file dialog, ...
  2. Controls to build up your own complex UI elements in your window: controls like button, menu, toolbar, entry,...

In a next article, we will learn how to use these controls to enhance our window features.

Saturday, April 3 2010

DrGeo for Pharo Smalltalk

Pharo uses the Metacello system to install a source package with its dependencies.

I have updated DrGeo to make it compliant with Pharo 1.0. I also took the opportunity to write a ConfigurationOfDrGeo using Metacello package management facility.

The Configuration is for now in the DrGeo repository:

To install it, execute in a Workspace:

Gofer new
   url: ''  ;
   package: 'ConfigurationOfDrGeo';
(Smalltalk at: #ConfigurationOfDrGeo) perform:#load.

To start DrGeo, execute in Worspace:

DrGeo sample openInWorld

Sunday, April 19 2009

Fun avec les messages

En programmation orientée objet Smalltalk, nous n'appelons pas des méthodes mais nous envoyons des messages à des objets pour leur demander poliment d'exécuter un traitement. L'objet recevant le message décide alors de la méthode à utiliser pour répondre à cet appel.

Un message est simplement un nom et une éventuelle liste d'arguments. A partir des messages, le programmeur construit des petits phrases (les badinages Smalltalk). Pour ce faire il existe trois types de message : les messages unaire, binaire et à mot clé.

Message unaire

Le message unaire est le plus simple, il est envoyé à un objet sans argument, l'écriture du message suit directement celle de l'objet (le receveur). Par exemple, pour demander à un nombre son cosinus, nous lui envoyons simplement le message cos :

0.5 cos
-->  0.877582561890373

( 1 + 2i ) cos 
--> 2.032723007019665 - 3.0518977991518 i

#( 0 0.5 ) cos
--> #(1.0 0.877582561890373)

Le même message est envoyé à des objets (les receveurs) de différentes natures (respectivement instances des classes Float, Complex et Array). A la réception du message, le receveur décide du traitement à appliquer.

Dans une chronique précédente, nous avions introduit les objets durée que nous pouvons créer en envoyant le message unaire seconds à un nombre :

90 seconds
--> 0:00:01:30

Message binaire

Un message binaire est envoyé à un objet avec un seul argument. L'écriture du message suit celle du receveur suivi d'un objet, l'argument. Par exemple, pour ajouter deux nombres, nous utilisons le message binaire + :

5 + 2
--> 7

L'addition n'est donc pas un opérateur défini dans le langage, c'est une méthode définie dans les classes souhaitant répondre à ce message. Ainsi des objets comme des durées répondent à ce message :

90 seconds + 30 seconds
--> 0:00:02:00

Dans l'expression ci-dessus, il y a trois messages. Il faut savoir que les messages unaires sont prioritaires sur les messages binaires, l'exécution se fait donc dans l'ordre suivant :

  1. 90 seconds --> Duration 0:00:01:30
  2. 30 seconds --> Duration 0:00:00:30
  3. le message + est envoyé à l'instance Duration 0:00:01:30 avec comme argument l'instance Duration 0:00:00:30

Les objets couleurs répondent aussi à ce message pour mélanger des couleurs :

Color red + Color blue
--> Color magenta

Quelle est la priorité lorsque une expression comporte plusieurs messages binaires ? En cas d'égalité de priorité, l'exécution se fait de gauche à droite. Ainsi

4 + 5 * 4
--> 36

est arithmétiquement équivalent à ( 4 + 5 ) * 4. Puisque les opérateurs n'existent pas en tant que tel dans le langage Smalltalk, il n'y a pas non plus de notion de priorité des opérateurs. Pour obtenir la priorité souhaitée, utiliser des parenthèses :

4 + ( 5 * 4 )
--> 24

Message à mot clé

Un message à mot clé est envoyé à un receveur avec plusieurs arguments, les arguments sont intercalés entre les différentes composantes du message à mot clé. Par exemple, pour définir une couleur à partir de ses composantes rouge, verte et bleue nous envoyons le message r:g:b: à l'objet Color :

Color r: 1 g: 0 b: 0
--> Color red

Point x: 5 y: 0.5
--> 5@0.5

La deuxième expression définit un point de coordonnées (5 ; 0.5) en utilisant le message x:y: envoyé à la classe Point. Noter qu'un point se définit aussi avec le message unaire @ envoyé à un nombre avec un autre nombre comme argument.

Le message à mot clé est de priorité inférieure à celle des messages unaire et binaire. L'ordre de priorité des messages est donc :

message unaire > message binaire > message à mot clé

Pour définir notre point, nous pouvons donc écrire :

Point x: 5 y: 1 / 2 

mais les parenthèses sont nécessaires lorsque nous utilisons le message @ pour définir notre point ;

5 @ ( 1 / 2 )

Sans les parenthèses l'expression aura un autre sens, explicitée ici avec les parenthèses :

( 5 @ 1 ) / 2

C'est une expression valide car un point comprend le message /, le résultat est le point ( 5 / 2) @ (1 / 2)

Exemple de composition

Pour en revenir au badinage, voici une recette d'un quatre quarts écrite en Smalltalk :

preparation := Recette new.
preparation ajoute: 200 g de: Sucre.
preparation ajoute: 200 g de: Farine.
preparation ajoute: 20 g de: Levure.
preparation ajoute: 3 de: Oeuf.
preparation melange.
preparation cuisson: 45 minutes

Les arguments Sucre, Farine, Levure et Oeuf sont des classes comme tout autre objet. En Smalltalk les classes sont des objets de première classe.


Notre rapide panorama des messages s'achève ici. Pour compléter cette mise en bouche, je vous invite à la lecture du livre Squeak par l'exemple.

Tuesday, March 24 2009

1978, ThingLab, géométrie interactive en Smalltalk

Vous pensez que la géométrie interactive fut inventée dans les années 80 ? Et bien non. Un système précurseur de gestion de contraintes fut développé dans les années 70. Il permettait, entre autre chose, et, comme cas particulier de son application, de construire des figures géométriques interactives. Le Xerox Parc Labs des années 70 n'en fini donc pas de nous étonner par la richesses de ses innovations.

En faisant une recherche bibliographie j'ai trouvé une vidéo de démonstration de ThingLab[1] datant de 1978. ThingLab est un système général à gestion de contraintes. Dans sa vidéo, l'auteur montre l'utilisation de son système dans la mise en forme de documents, sur des expressions arithmétiques avec contraintes, en mécanique et un exemple géométrique avec le quadrilatère de Varignon,... C'est en quelque sorte un ancêtre des logiciels de géométrie interactive.

Il fut développé en Smalltalk, au Xerox Parc dans le cadre de la thèse d'Alan Borning.

Une vidéo de démonstration par son auteur, de cette époque (format ogv - 45Mo, format mov - 130Mo)

Quelques captures écrans sur son utilisation...

En géométrie, avec le quadrilatère de Varignon

Oui, c'est de la géométrie interactive, l'utilisateur déplace les sommets et la figure est recalculée. ThingLab, varignon

En arithmétique

Les cases sans ancre contiennent des valeurs libres que le système ajuste en fonction des valeurs imposées dans les autres cases. ThingLab, arithmetic

En mécanique

Le système calcule les contraintes sur les différentes parties de la structure. ThingLab, mecanic

Bon c'est vrai, Sketchpad dans les années 60 était pas mal, c'était il y a 45 ans. Et maintenant ?

Saturday, March 14 2009

Fun avec les types

Comme nous l'avons écrit précédemment, Smalltalk ne définit pas de type. Le typage est défini au niveau de la hiérarchie des classes. Cet aspect et la dimension purement objet du langage induisent une mutation des types complètement triviale, définie au niveau des classes elles-mêmes. Deux trois exemples simples illustrent le propos.

La classe Fraction définit le concept de fraction. Comment créer une fraction ? A partir de deux entiers. Donc nous créons une instance de Fraction non pas à partir de la classe Fraction mais à partir d'une instance de SmallInteger. Vous êtes perdu ? Un petit exemple :

(2 / 5) class
  -> Fraction

Et oui, à aucun moment la classe @@Fraction@@ est explicitement utilisée. Que se passe-t-il ? C'est ici que la dimension purement objet du langage rentre en action :

# @@2 / 5@@ doit être compris comme l'envoi du message {{@@/@@}} à l'instance {{@@2@@}} avec comme argument {{@@5@@}}.
#  {{@@/@@}} n'est pas un opérateur (dans une prochaine chronique je vous expliquerai que les opérateurs n'existent pas en Smalltalk), c'est le nom d'une méthode - noté {{@@#/@@}} dans la terminologie Smalltalk - définie dans la classe @@SmallInteger@@
# C'est donc la méthode @@SmallInteger>>/@@ qui décide ce qu'elle doit faire et, en particulier, quel type d'instance elle va retourner. Lorsqu'elle détecte que l'argument passé à {{@@/@@}} est un entier (ici 5), elle décide de créer une instance de @@Fraction@@, de l'initialiser correctement et de la retourner comme résultat.

Ainsi, du fait que les opérateurs sont également définis comme des envois de message à des instances de classe (la fameuse dimension purement objet), c'est possible. Ce n'est même pas une surcharge d'opérateur, mais de méthode...


Bien sûr nous pouvons additionner des fractions avec le message {{@@+@@}} défini dans la classe {{@@Fraction@@}} :

(2 / 5) + (2 / 3)

-> 16/15

( (2 / 5) + (2 / 3) ) class

-> Fraction

Poursuivons avec un autre exemple :

(1 / 3) + (2 / 3)

-> 1

(1 / 3) + (2 / 3) class

-> SmallInteger

Là c'est intéressant, nous avons la somme de deux fractions qui retourne un entier (@@SmallInteger@@). En fait, le message {{@@+@@}} défini dans la classe @@Fraction@@ vérifie si la somme des deux fractions (@@self@@ et celle passée en argument à {{@@+@@}}) donne mathématiquement un entier, si c'est la cas, une instance de @@SmallInteger@@ est retournée au lieu d'une fraction.

Un autre exemple illustre cette {{mutation}} des types. Le calcul d'une factoriel se fait naturellement en envoyant le message @@#factorial@@ à un entier :

6 factorial

-> 720

6 factorial class

-> SmallInteger

50 factorial

->  30414093201713378043612608166064768844377641568960512000000000000

50 factorial class

->  LargePositiveInteger

Selon, la factorielle demandée un petit ou grand entier est retourné. La mise en musique avec les fractions devient intéressantes :

(50 factorial / 49 factorial)

-> 50

(1000 factorial / 999 factorial)

-> 999

(1000 factorial / 999 factorial) class

-> SmallInteger


Après un passage par les grands entiers et les fractions, un petit entier est retourné dans les deux cas.

Ce que nous avons montré pour les fractions est vrai pour tout autre domaine. Ce qui semble être une opération arithmétique est en fait l'envoi d'un message qui peut retourner une instance de tout autre objet. Bien sûr, depuis l'environnement Smalltalk, le programmeur peut aisément examiner le code des classes et méthodes concernées.

That's all folks!

Sunday, March 8 2009

Fun avec les durées

Le langage Smalltalk ne définit pas de type au sens des langages comme C++, Java, Php, Python. En fait du point de vue de ces langages, Smalltalk semble ne définir aucun type, uniquement la référence vers des instances de classes (car Smalltalk est purement objet). En fait le typage de Smalltalk est d'un autre ordre : c'est un typage du second ordre qui s'appuie sur la hiérarchie des classes.

Du point de vue de l'écriture du code cela donne une élégance telle que le code ressemble à des petites phrases (voire des badinages, d'où le nom Smalltalk). Cela apparaît de façon éclatante avec les objets représentant des durées.

Pour représenter une durée de 2 heures, on peut envoyer le message hours à l'instance de SmallInteger 2, cela retourne une instance de Duration:

2 hours
-->  0:02:00:00

La classe de l'instance retournée est bien une durée:

2 hours class
 --> Duration

De la même façon, des durées se définissent à partir de minutes, secondes, journées, semaines,....:

30 minutes
--> 0:00:30:00

90 minutes
--> 0:01:30:00

3 days
--> 3:00:00:00

3 weeks 
--> 21:00:00:00

La classe Duration est dans la hiérarchie de Magnitude, ces deux classes définissent des opérations d'addition et de comparaison sur les durées, cela permet d'écrire un code éloquent comme celui-ci :

2 hours = 120 minutes
 --> true

voire comme celui-ci :

90 minutes > 2 hours
 --> false

et même des opérations et des comparaisons comme celles-ci :

( 5 days + 48 hours ) = 1 week
 --> true

La cerise sur le gâteau, et pas des moindres, c'est que ceci n'est pas défini au niveau du langage mais de la bibliothèque de classes. L'utilisateur peut donc non seulement lire depuis l'environnement Smalltalk le code d'implémentation de cela mais également l'étendre pour ses propres besoins.

That's all folks!

Saturday, January 10 2009

Les scripts avec Dr. Geo II

Dans cet article je montrerai comment utiliser les scripts Dr. Geo II pour construire dans une figure la courbe représentative d'une fonction, puis la tangente en tout point de cette courbe. La figure sera construite afin de pouvoir changer la fonction indépendamment de tout le reste.

La courbe représentative

On commence par construire un segment sur lequel on place un point mobile, nommé 'move me'.


Ensuite nous définissons notre fonction à l'aide d'un premier script en allant dans le menu Dr. Geo 'numerics>edit script'. Pour définir notre fonction nous pourrions définir un script avec comme argument une abscisse mais cela ne serait pas pratique. Nous allons plutôt définir notre fonction comme un bloc de code, c'est une spécialité de Smalltalk. Notre script s'appelle maFonction, c'est simplement la fonction cosinus : maFonction.png

Nous définissons ensuite un deuxième script qui aura un argument, un point, et qui retournera un autre point le projeté du premier sur la courbe[1]. Pour calculer l'ordonnée de ce point nous utilisons notre fonction définie précédemment :


Les scripts retourne un résultat par le mot clé '^'

Nous allons maintenant utiliser ce script pour afficher ces coordonnées dans la figure. Pour cela nous utilisons la fonction 'numerics>use script' du menu Dr. Geo. Une boîte de dialogue s'affiche alors, elle explique comment utiliser les scripts. Pour tout script, après avoir sélectionner les arguments dans la figure, il faut cliquer à l'emplacement où nous souhaitons afficher la valeur retournée par le script. Pour chaque script disponible, les commentaires des premières lignes de son source code sont affichés et constituent une indication utile pour l'utilisateur :


Dans notre exemple, nous choisissons le script pointM:, nous sélectionnons le point 'move me' de la figure comme argument, puis nous cliquons à l'emplacement souhaité dans la figure pour afficher le résultat.

Nous construisons ensuite le point géométrique M avec comme coordonnées le résultat du script. Il existe une fonction pour faire exactement cela avec Dr. Geo: menu 'points>points defined by its coordinates'. Le point ainsi construit est un point de la courbe représentative de notre fonction, pour avoir la courbe il nous suffit de demander le lieu de ce point M lorsque le point 'move me' parcourt le segment. Cela nous donne la courbe :


La tangente

Pour construire la tangente nous calculons en premier lieu la pente en tout point de la courbe (nous supposons que notre fonction est continue). Pour ce faire nous définissons un script qui pour un point de la courbe retourne la pente, un réel :


Le script pourra paraître étrange, en effet il n'y a pas de parenthèses autour de la soustraction, Smalltalk n'utilise pas la priorité des opérateurs arithmétiques mais celle des messages.

Nous utilisons ensuite ce script par le menu 'numerics>use script' avec comme argument notre point M de la courbe. Éventuellement nous nommons dans la figure ce script 'pente'. Son affichage n'est pas nécessaire pour la suite, mais permet simplement de rendre compte à l'utilisateur de la valeur de la pente en M.

Pour construire notre tangente nous avons besoin de deux points. Nous avons déjà le point M. Il nous faut un point N sur la tangente. Pour ce faire nous définissons un script pointN: qui à partir du point M retourne les coordonnées de ce point N :


Pour finir, à partir de ce dernier script, nous construisons les coordonnées de ce point N dans la figure, puis le point N et enfant la tangente passant par les points M et N. A propos de scripts utilisés dans une figure, Dr. Geo donne pour chacun d'eux des informations sur leur nom et les arguments utilisés :


On change de fonction

La conception proposée ci-dessus est indépendante de la fonction utilisée, nous pouvons donc varier les plaisirs et définir diverses fonctions.

En définissant la fonction en x->cos(4x) +sin(x)

	^ [:x | (x * 4) cos + x sin]

Cela nous donne la courbe suivante et bien sûr la tangente est toujours correcte : courbeTangente1.png

Ou bien x->x * cos(x)

	^ [:x | x * x cos]


Je ne sais pas vous, mais moi, j'aurais adoré faire mumuse avec ça au lycée...


[1] Lorsque nous définissons un point, il faut l'entendre en tant qu'objet Point Smalltalk, c'est à dire un couple de coordonnées. En Smalltalk un Point peut se définir par 54@45.2.

Sunday, December 14 2008

Smalltalk, the Free Software spirit in action

In this article, I explain how Smalltalk is since 30 years a practical social implementation of the freedom #3 and #4 of the Free Software philosophy: freedom to study, to modify and to redistribute a software.

Free Software takes a philosophical position toward software and how it should be shared. Open Source (OS) software, with the same practical position, does not share this philosophical position. Its position is more Free Software can improve the process to develop software.

Free Software (FS) is based one four simple freedoms:

  1. freedom to use the software
  2. freedom to redistribute the software
  3. freedom to study the software
  4. freedom to modify and to redistribute the software

FS does not care about the business aspect attached to software, it is not against it however it is deliberately socially targeted. This social dimension of FS software is very important, and it is for me an important difference with OSS. It makes the human been at the center. It is particularly clear with the freedom \#3.

So how are all these considerations related to the Smalltalk paradigm?[1]

Before being a Smalltalk experienced coder, I was a C++ developer. With this language I wrote the Dr. Geo interactive geometry software, targeted for educators in mathematics. When we look at the Dr. Geo sources the barrier of entrance for an educator to study and to modify the source code is very high and for most users out of reach. I think it is a serious problem regarding the social dimension of the FS. Not only C++ is a complicate language, worst the environments to develop and to modify the source code are not intuitive and limited in their scope[2]. These problems appear in all the languages I have used but Smalltalk.

So what is special about Smalltalk?

In 1981, Dan Ingalls a founding father of Smalltalk, wrote in the Byte magazine:

The purpose of the Smalltalk project is to provide computer support for the creative spirit in everyone. Our work flows from a vision that includes a creative individual and the best computing hardware available. We have chosen to concentrate on two principle areas of research: a language of description (programming language) that serves as an interface between the models in the human mind and those in computing hardware, and a language of interaction (user interface) that matches the human communication system to that of the computer.

The focus is not only on a suited language for creativity for everyone but also a user interface to interact with it. This later point was very innovative 30 years ago, it is still innovative today. So what is exposed there is how to make as smooth as possible the access to creativity with software: it is true not only when creating new software but also when studying and modifying an existing software.

Indeed, with Smalltalk it is just so obvious to modify a software you are using. Not only with the key stroke [Alt]-b you access to the source code of the application your are using, but you can also modify its source code and all the processes of compilation and execution is done transparently. With Smalltalk the barrier of entrance to modify source code is very low and it makes it a wonderful tool perfectly matching the philosophical approach of Free Software.

Next Dan explained:

Personal Mastery: If a system is to serve the creative spirit, it must be entirely comprehensible to a single individual.

This principle is very strong and it clearly states the application source code and all its necessary components must be in the reach of the user. How is it explicitly done with Smalltalk and what are the consequences for the end user?

To achieve Personal Mastery as defined by Dan, Smalltalk is written in itself. If you take a script language like Python, this one is written in C and most of its libraries are also written in C. C is a different language, thus another environment, thus a barrier when one wants to understand the use or design of the Python class libraries. I remember how complicated it was for me when I wanted to understand how to use the GTK+ binding for Python.

In Smalltalk, the language itself is written in Smalltalk, it is circular: all the class libraries are written in Smalltalk, even the basic arithmetic or boolean operators or loop and test constructors are written in Smalltalk. The consequence is that for the user, it is just one mouse clic away (Implementor button in the class browser) to access to the definition of these classes. So again there is a direct access to the source to study a software as wished in the FS philosophy, with Smalltalk it is pushed very far to make it accessible to a lot of users.

Good Design: A system should be built with a minimum set of unchangeable parts; those parts should be as general as possible; and all parts of the system should be held in a uniform framework.

This is the idea of Smalltalk being largely written in itself, thus only a minimal part of Smalltalk cannot be changed (6 keywords and 3 message sending protocols), then most of Smalltalk can be studied as any piece of Smalltalk code and of course modified if necessary by the end user.

I found it very interesting how Smalltalk, long time before FS, pushed very far this idea of the access to source code. This is a thought I want to share with you.


[1] Smalltalk is not only a programming language but also a way to interact with a computer.

[2] With these environments the user is limited to the source code of the software. From these environments, the user can't easily browse in the source code of the third party components (like widget and standard class libraries) used to developed the software itself, and of course the user can't modify easily these components.

Wednesday, October 15 2008

Une association Landaise remporte un prix international

DrGeoII #1 at ESUG 2008 Innovation Technology Awards Mont de Marsan, le 15 octobre 2008 - OFSET, l'organisation pour le logiciel libre dans l'éducation et l'enseignement, annonce qu'elle a gagné le premier prix du concours ESUG2008 d'innovation technologique pour son projet Dr. Geo II.

Ce concours eu lieu en marge des conférences internationales ESUG2008 à Amsterdam sur le langage et l'environnement de programmation Smalltalk. Les conférences ESUG s'adressent principalement aux développeurs Smalltalk de l'industrie du logiciel.

Vingt et un participants de part le monde ont concouru à cet événement, dont des laboratoires, des sociétés, des consultants. Les projets furent présentés au public des conférences et le vote de celui-ci sanctionna les meilleurs projets. Dr. Geo II a remporté la première place.

À propos de Dr. Geo II

Dr. Geo poster Dr. Geo II est un framework de géométrie interactive. Il permet de créer des figures géométriques et de les manipuler interactivement en respectant leurs contraintes géométriques. Il est utilisable dans des situations d'enseignement/apprentissage avec des élèves du primaire ou du secondaire.

Dr. Geo II propose des fonctionnalités innovantes comme l'intégration du langage de programmation Smalltalk pour définir des scripts — bouts de programme — dans une figure ou bien encore une construction fonctionnelle d'une figure interactive.

Il est programmé avec Smalltalk et basé sur l'environnement graphique Morph de Etoys. En tant que tel, une figure interactive de Dr. Geo II s'intègre et se mélange avec l'ensemble des éléments graphiques et interactifs de l'environnement Etoys OLPC : livre interactif, document multimédia, programmation graphique Etoys, etc. Dr. Geo II suit en cela l'approche pédagogique constructiviste de l'OLPC et Etoys.

À propos d'OFSET

OFSET est une organisation Landaise à vocation internationale dont l'objectif est la promotion des logiciels libres pour l'éducation et l'enseignement. À ce titre, elle développe des logiciels libres éducatifs ainsi que des documentations pour aider à l'émergence et l'utilisation des logiciels libres. Pour en savoir plus sur ses projets. visiter

- page 2 of 3 -