OOC ou le C Objet
Découvert sur DLFP, je ne peux que m'empresser de vous montrer ce tout nouveau compilateur ou plutôt "meta compilateur" qu'est "ooc". A la manière de ObjectiveC, ooc permet de travailler sur un langage objet simple et efficace, tout en proposant une compilation binaire. Le principe de ooc est de parser votre code, le transformer en C puis le compiler avec GCC.
La technologie ne faisant pas tout, le langage proposé est très important. Et ici, le ooc est un plaisirs des yeux. Typage, pointeur par défaut sur objets, réflexions, transparence... tout y est! Et comme vous allez travailler vers du C, la plupart des librairies sont utilisables: gcc, sdl, opengl... que dire de plus ? Et bien nous pouvons voir quelques exemples ensemble.
En premier lieu, installons nous une version de ooc (v 0.0.2 ici) de cette manière:
su -
#ou pour ubuntu, sudo -s
cd /opt
wget http://ooc-language.googlecode.com/files/ooc-linux-bin-0.2.tar.bz2
tar jxvf ooc-linux-bin-0.2.tar.bz2
cd ooc
ln -s /opt/ooc/bin/ooc /usr/local/bin
#testons:
ooc -V
# ooc v0.2 codename ninja, built on 2009-06-26 00:40:03
exit
Ok c'est bon nous avons notre compilateur. Passons maintenant à un bon vieux "hello world" comme nous savons les apprécier :)
On va se faire un répertoire dans notre dossier utilisateur afin de travailler, puis on y entre, et enfin, on va coder:
(Passer en utilisateur, si vous êtes encore root)
mkdir ~/ooc-tutorial
cd ~/ooc-tutorial
gedit tutorial1.ooc &
Dans gedit, sélectionnez une coloration syntaxique java, ou si vous préférez utiliser vim, taper "Echap :set ft=java". C'est la coloration la plus proche.
func main {
printf ("Hello World !!!\n");
}
Voilà... notre premier test est créé. Sauvez et allez dans votre console, on va le compiler:
ooc tutorial1.ooc
Dans votre répertoire apparait un binaire, c'est bel et bien votre programme. Essayez de le lancer:
./tutorial1
# Hello World !!!
Et voilà pour le premier test.
OOC permet aussi de travailler avec des objets. Attention, il n'existe pas d'encapsulation de variables dans OOC, au point de vue sécurité des API c'est un peu la fête du slip rouge, mais l'objectif est de coder rapidement. A vous, développeur, de faire en sorte de bien coder et de bien documenter votre code.
Créez un second fichier, nommons le tutorial2.ooc, puis éditez le:
//On crée une classe Person
class Person {
String first_name, name;
Int age;
}
//on va utiliser notre classe:
func main {
Person p = new Person;
p.name = "Foo";
p.first_name = "Bar";
p.age = "28";
//affichons voir quelques informations:
printf ("Person name is: %s\n", p.name);
printf ("Person first name is: %s\n", p.first_name);
printf ("Person age is: %d\n", p.age);
}
On le compile de la même manière, et on teste:
ooc tutorial2.ooc
./tutorial2
#Person name is: Foo
#Person first name is: Bar
#Person age is: 28
Sympa non ? moi je trouve ça chouette :)
Bon, parlons maintenant de quelques spécificités de ooc. D'abords, tout les objets sont des pointeurs... ce qui implique qu'une fonction qui reçoit un Object et le modifie manipule l'objet par référence. Regardons un exemple:
//On crée une classe Person
class Person {
String first_name, name;
Int age;
}
//cette fonction va manipuler un pointeur d'objet
func modifyPersonName (Person pers){
printf ("Modification...\n");
pers.name = "Baz";
}
//on va utiliser notre classe:
func main {
Person p = new Person;
p.name = "Foo";
p.first_name = "Bar";
p.age = "28";
//affichons voir quelques informations:
printf ("Person name is: %s\n", p.name);
printf ("Person first name is: %s\n", p.first_name);
printf ("Person age is: %d\n", p.age);
//ici on change l'objet
modifyPersonName (p);
//Et on vérifie:
printf ("Person name is: %s\n", p.name);
printf ("Person first name is: %s\n", p.first_name);
printf ("Person age is: %d\n", p.age);
}
On compile, on teste:
ooc tutorial2.ooc
./tutorial2
#Person name is: Foo
#Person first name is: Bar
#Person age is: 28
#Modification...
#Person name is: Baz
#Person first name is: Bar
#Person age is: 28
C'est effectivement très simple.
On continue encore... ? non, je vous laisse aller voir la page du langage de référence qui est très fournie et pourtant rapide à lire. Vous y verrez comment utiliser des packages, des espaces de nom, comment utiliser des librairies, comment travailler avec des références de fonctions, etc...
Un petit clin d'oeil à Java ici: Table 1-1. Correspondance tables of types in C, Java, and ooc un "hahahaha" placé sur la cellule "pointer to function" inexistant en Java :)
L'auteur explique aussi pourquoi il développe ce langage en "opposition" à Java et C#. Je retiens un aspect important qui fait que je me penche sur ooc depuis quelques temps:
- Java est tendu. Vous avez besoin d'une infrastructure imposante pour utiliser des programmes développés en Java.
- C# mono est un bon système mais tout comme Java il impose une infrastructure de développement imposante
Niveau langage:
- Java et C# sont de bons langages, puissant et solides. Mais les restrictions et les "wrappeurs" pour les librairies telles que GTK ou OpenGL sont compliqués à passer.
- La notion Pointeur de Java est tout relative, et en C# elle est purement et simplement catastrophique à utiliser. Ici, la gestion de pointeur et de référence est assez simple à appréhender
- Rien à dire en terme de possibilités sur OOC, et le fait d'être un meta langage vers le C permet d'utiliser toutes les librairies existantes
Par contre:
- OOC ne gère pas l'encapsulation et cela peut devenir très gênant !
- OOC ne permet pas (pas encore) de créer des librairies paratagées et je vous avoue que j'adorerai...
- les options de la ligne de commandes sont purement et simplement pas documentés !!! heureusement j'ai regarder le code source ici: CommandLineInterface.java pour trouver des options sympatiques comme "-noclean" qui me permet de voir le code C généré :)
Bref, il est clair que OOC est encore jeune, très jeune même. Il n'y a qu'un seul développeur actif pour le moment, mais l'avenir de OOC me parait de bon augure !
Ressources:
Editions 29 juin
Comme le stipule l'auteur, une manière plus jolie permet de coder mon exemple:
//On crée une classe Person
class Person {
String first_name, name;
Int age;
func new(=first_name, =name, =age);
//cette fonction va manipuler un pointeur d'objet
func setName(=name);
func print {
printf("Person name is: %s\n", p.name);
printf("Person first name is: %s\n", p.first_name);
printf("Person age is: %d\n", p.age);
}
}
//on va utiliser notre classe:
func main {
Person p = new Person("Foo", "Bar", 28);
//affichons voir quelques informations:
p.print();
//ici on change l'objet
p.setName("Baz");
//Et on vérifie:
p.print();
}
Ici, l'auteur nous présente en fait la manière d'initialiser directement des valeurs lors de la construction ou de l'appel à setName.
Par contre, mon exemple qui permet de voir la modification par référence disparait :)
Je vous invite à lire le code ci dessus et d'apprécier à quel point la sémantique est instinctive.
Trackbacks
Pour ajouter un trackback (retrolien) sur ce ticket, utilisez cette adresse: http://www.metal3d.org/index.php/trackback/default/tb?id=blog%2F207
Hello! Je suis flatté de voir déjà un article sur ooc ;)
Je tenais à préciser quelques points.
Déjà, tutorial2.ooc peut être simplifié considérablement comme vu ici: http://ooc.pastebin.com/m7bb2f3cf
Pour l'encapsulation ce n'est qu'un défaut de jeunesse évidemment ;) dans les prochaines versions, il y aura le même niveau de contrôle qu'en java, ou presque (private, protected, public).
Pour les options de lignes de commande, je me suis rendu compte après la sortie que j'avais oublié d'écrire le manuel du compilateur ;) il est en cours d'écriture et sera bientôt disponible sur le site officiel http://ooc-lang.org/
Entièrement d'accord avec toi sur le principe de simplification. L'idée étant de montrer le principe et non de coder propre (sifflement... air gêné)
Je vais modifier mon code pour que ce soit plus joli en effet.
En fait, en ce qui concerne les arguments de ligne de commande, j'ai juste été étonné de ne pas voir d'option "-h" ou "--help" ;)
En tout cas, heureux de voir l'auteur commenter sur ma petite intro.
Je ne manquerai pas à continuer d'en parler !
Bon eh bien puisque qu'on me reproche des choses, j'ai sorti la version 0.2.1. Avec tous les -help dont on peut rêver (-h, -help, --help, -help-backends, -help-gcc, -help-make, et un petit bonus pour les curieux).
A prendre sur http://ooc-lang.org/download comme d'habitude.
Et en plus je suis devenu contributeur ! :) En avant les thread, les expressions régulières et tout !!!
Viva le C :)
Juste encore une petite remarque: tu parles de la version 0.0.2, qui n'existe pas. Je suppose que tu veux dire la version 0.2.0 (note: la 0.2.1 est sortie depuis)