Un Pseudo-langage pour les algorithmes

Bonour à tous,

En vue d'initier des etudiants non encore informaticiens, je souhaite trouver un langage (un peu plus facile que le C) qui permette à ceux-ci de se debrouiller. Ils ont leur algorothme et souhaite transformer celui-ci en langage pour le faire tourner.

Avez-vous des idées pour ce pseudo langage? En existe-t-il et si oui, lesquels? Sinon, comment me conseillez-vous de faire?

Je pourrai leur apprendre le C, mais ca risque d'etre compliqué pour eux.

Un grand merci

essai le visual basic c'est quasiment une traduction en anglais de notre algorithme
ou essai windev

Merci pour les reponses.

Windev etant payant (cher), je ne peux y acceder.
VB me semble accessible, mais je souhaite quelque chose qui se rapproche encore plus des algo que de la programmation.

Si il y a d'autres idées, je suis preneur. Mais c'est vrai que vb a l'air pas mal.

Bonjour,

Quid du Pascal, ou bien du Delphi ? L'avantage de ces langages, comparés au C, est leur rigueur, qui permet de se concentrer sur l'algorithmique.

Je vais peut être dire une bétise mais il existe KPL qui permet de faire des choses proches de l'algo :
http://xo.developpez.com/tutoriel/kpl/1_intro/

Depuis quelques années maintenant, les classes préparatoires aux grandes écoles se sont tournés vers OCaml pour l'initiation à l'informatique. Leurs buts étant principalement l'enseignement de l'algorithmique, leur situation est à peu près similaire à la tienne. OCaml est particulièrement adapté pour la retranscription d'algorithmes et la manipulation de structures de données de façon naturelle. Par exemple en OCaml, écrire une structure d'arbre binaire de recherche et ses routines de manipulations se fait bien plus aisément et élégamment que dans n'importe quel autre langage (excepté Haskell probablement) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

type 'a bTree = Leaf | Node of 'a bTree * 'a * 'abTree;   let rec inser tree x = match tree with | Leaf -> Node( Leaf, x, Leaf ) | Node( fg, y, fd ) when x = y -> tree | Node( fg, y, fd ) when x < y -> Node( inser fg x, y, fd ) | Node( fg, y, fd ) -> Node( fg, y, inser fd x )   let rec find tree x = match tree with | Leaf -> false | Node( fg, y, fd ) when x = y -> true | Node( fg, y, fd ) when x < y -> find fg x | Node( fg, y, fd ) -> find fd x

---

OCaml est très puissant : fonctionnel, mais possédant des éléments impératifs. Il peut être compilé pour obtenir des performances correctes.


Quant aux autres propositions, Pascal reste un bon choix, même s'il n'a pas été remplacé en prépa par OCaml sans raison (il suffit de regarder les sujets de concours et la taille et la clarté des codes qu'on y trouve pour les deux langages pour le comprendre), par contre je recommanderais de ne surtout pas utiliser VB, qui est bien connu pour donner de mauvaises habitudes de programmation, sans parler du fait que VB n'est disponible sous Windows et que tant qu'à apprendre un langage autant en apprendre un qui puisse être utile partout. Le seul avantage de VB à mon goût, c'est qu'il est très facile de faire des GUIs avec, mais ça n'a pas l'air d'être ton objectif ?

--
Jedaï

Bonjour,
le langage le plus rugoureux de par sa conception meme est sans nul doute le pascal. J'ai commencé là dessus et j'avoue que c'est extremement pédagogique.

En revanche, je suis contre ce que viens de dire nahzhir "essai le visual basic", car c'est un langage absolument non rigoureux de par le fait que tu peux ne pas déclarer les variables (et c'est essentiel pour comprendre ce qu'est une variable pour certains élèves). Meme si certaines options rendent la programmation plus rigoureuse. En plus, sur certaines versions, tu n'as pas acces au mode console sous window, donc le débugage est pas térrible.

Citation:

---

Envoyé par ToTo13

Bonjour,
le langage le plus rugoureux de par sa conception meme est sans nul doute le pascal. J'ai commencé là dessus et j'avoue que c'est extremement pédagogique.

En revanche, je suis contre ce que viens de dire nahzhir "essai le visual basic", car c'est un langage absolument non rigoureux de par le fait que tu peux ne pas déclarer les variables (et c'est essentiel pour comprendre ce qu'est une variable pour certains élèves). Meme si certaines options rendent la programmation plus rigoureuse. En plus, sur certaines versions, tu n'as pas acces au mode console sous window, donc le débugage est pas térrible.

---

A propos de la rigueur et de OCaml : OCaml utilise un système d'inférence de type qui lui permet de détecter beaucoup d'erreur à la compilation. En combinant ça avec le système des "match" qui avertit si l'on oublie une alternative, une syntaxe rigoureuse et simple, un typage fort, etc, la plupart des erreurs sont détectées à la compilation contrairement à beaucoup d'autre langage. Quand un programme se lance sans protestation, on a de bonne chance de le voir marcher ! De plus, OCaml vérifie les bornes de ses tableaux à l'exécution, ne possède pas de pointeurs, mais uniquement des références sécurisées... En bref OCaml est un langage très sûr, qui s'appuie sur des preuves mathématiques pour assurer que son fonctionnement est sain.

--
Jedaï

allons allons que de rigorisme
un langage qui utilise des variables sans les déclarer n'est pas si horrible
d'autant qu'il suffit de mettre option explicit pour contourner l'obstacle

que dire de Pascal qui permet de déclarer des variables sans les utiliser ?
un manque de rigueur ??

pour moi un langage est un outil qui doit permettre
d'arriver à un résultat rapidement avec un bon équilibre temps de développement temps de production

Pascal est certes rigoureux mais ressemble par trop à un lego où il faut tout faire soi même alors que visual basic offre un grand nombre de fonctions et structures intégrées et documentées

je ne vois pas trop comment on peut de nos jours séparer l'apprentissage
de l'algo de celle de la programmation

la mise en oeuvre d'un algo est largement tributaire des structures offertes par le langage et la simplicité de visual basic permettent de se focaliser sur l'algo sans s'enferrer dans les subtilités du langage

random, je trouve que tu dis n'importe quoi '_'

Visual Basic n'est pas du tout orienté vers l'algorithmique comme l'a souligné Jedai.
Il sert uniquement à faire des GUI facilement.

Je pense aussi que le meilleur choix est sans doute Ocaml, ou si l'on préfere manipuler des langages itératifs pascal.

Mais Ocaml est vraiment génial pour l'algo :)

Citation:

---

je ne vois pas trop comment on peut de nos jours séparer l'apprentissage
de l'algo de celle de la programmation

---

Pourtant c'est ce qui se fait dans toutes les vraies écoles d'informatique.

Citation:

---

la mise en oeuvre d'un algo est largement tributaire des structures offertes par le langage et la simplicité de visual basic permettent de se focaliser sur l'algo sans s'enferrer dans les subtilités du langage

---

Très souvent il est beaucoup plus simple d'adapter un algo avec ocaml.

C'est aussi pour ça que c'est le langage enseigné dans les CPGE, de plus en plus de facs et pas mal d'écoles...

Ca risque de partir en troll tout ça!

D'ailleurs rajoutons une couche! Vous avez oublié l'ADA! Avec une syntaxe proche du Pascal, il permet beaucoup plus (trop?) de rigueur. Peut-être un peu chiant pour faire du calcul car tous changement de type (au sens informatique) doit être explicitement écrit.

On peut aussi parler du FORTRAN :oops:

Personne n'en a encore parlé ici, mais il est aussi possible de se fabriquer un langage proche d'un existant, et ensuite d'utiliser un convertisseur (comme un analyseur lexical passé par LEX). Je crois que ceci a déjà été fait pour franciser des langages comme C ou Pascal (i.e. remplacer int par entier, float par reel,...).
Avec ça tu écrit ton algo dans un pseudo-langage proche d'un vrai langage, et ensuite tu converti puis compile ton prog.

Un point à creuser donc...

Citation:

---

Envoyé par Teuchteu

Ca risque de partir en troll tout ça!

D'ailleurs rajoutons une couche! Vous avez oublié l'ADA! Avec une syntaxe proche du Pascal, il permet beaucoup plus (trop?) de rigueur. Peut-être un peu chiant pour faire du calcul car tous changement de type (au sens informatique) doit être explicitement écrit.

---

L'ADA est très bien, mais un petit peu TROP rigoureux pour le débutant : ce langage est si pesant que le débutant risque de s'y noyer plutôt que d'en retirer quoique ce soit... Ce qui n'enlève rien à ADA qui est un langage remarquable pour qui vise la sûreté. :)
(NB : En Caml également, toute transtypage doit être explicite (passer par une fonction en fait), mais on en a moins souvent besoin que dans la plupart des autres langages car l'inférence de type de Caml permet le polymorphisme sans effort (on ne parle pas du même polymorphisme qu'en Java ici, mais plutôt d'un système qui se rapproche des templates à la C sans les inconvénients : cf mon exemple d'arbre binaire))

Citation:

---

Envoyé par Teuchteu

On peut aussi parler du FORTRAN :oops:

---

Et du COBOL non ? :roll:

Citation:

---

Envoyé par Teuchteu

Personne n'en a encore parlé ici, mais il est aussi possible de se fabriquer un langage proche d'un existant, et ensuite d'utiliser un convertisseur (comme un analyseur lexical passé par LEX). Je crois que ceci a déjà été fait pour franciser des langages comme C ou Pascal (i.e. remplacer int par entier, float par reel,...).
Avec ça tu écrit ton algo dans un pseudo-langage proche d'un vrai langage, et ensuite tu converti puis compile ton prog.

Un point à creuser donc...

---

Franchement, si on apprend à programmer c'est tout de même pour opérer dans le monde réel après, donc l'intérêt d'apprendre un langage en Français spécifique à son labo et probablement peu portable... Sans parler du gros effort nécessaire pour l'enseignant dans ce cas, alors qu'il a déjà des outils tout à fait appropriés.

--
Jedaï

Citation:

---

Envoyé par Jedai

Franchement, si on apprend à programmer c'est tout de même pour opérer dans le monde réel après, donc l'intérêt d'apprendre un langage en Français spécifique à son labo et probablement peu portable... Sans parler du gros effort nécessaire pour l'enseignant dans ce cas, alors qu'il a déjà des outils tout à fait appropriés.

---

Tout dépend si Terminator désire initier ses étudiants à l'algo où à la prog. En fait, en relisant son premier post, je ne suis toujours pas très sûr de ce qu'il souhaite.

Reste tout de même que la plupart des langages ont beaucoup de "concepts" en commun : les boucles, les condition.

Partir d'un pseudo langage traduit tout seul en C peut-être intéressant pour se détacher des langages, le temps de quelques heures de TP. Ensuite passer à des langages concret.

Je pense qu'on part souvent trop rapidement vers un langage pour pouvoir faire des applications pratiques de ce que l'on apprend (i.e. traduire nous même le pseudo code), ce qui fait qu'on perd la vision générale de la prog. C'est mon point de vue :cry:

De plus cela peut-être un projet intéressant à donner à d'autres étudiants lors de cours sur les langages et les compilateurs, si cela est abordé bien sur.

P.S.: J'ai commencé à programmer en BASIC, puis Pascal, puis Delphi. Certes ces langages sont utilisés dans "le monde réel", mais je ne les utilise plus aujourd'hui (en tout cas je ne m'en servirai jamais au travail), et je ne m'en porte pas plus mal. :wink:

Bon, je vais tout de même apporter ma petite contribution :
Ada est effectivement un bon choix si l'on souhaite acquérir une programmation rigoureuse. C'est d'ailleurs aussi le cas (voire même davantage) en C. Par contre, cela suppose des connaissances en informatique, tant en programmation qu'en algorithmique...

OCaml est (pour les souvenirs que j'en ai :) ) un excellent langage si l'on souhaite se concentrer davantage vers l'algorithmique. Mais personnellement, j'avoue avoir un réel penchant pour Lisp (ou un dérivé, tel Scheme). Lisp essentiel pour la manipulation de listes, pour la récursivité, etc, etc . . .

Donc d'après ce que j'ai compris de la question de Terminator, je conseillerai davantage Lisp ou OCaml :)

ps : en plus, parmi les dérivés de Lisp, on compte E-Lisp (Emacs Lisp) : on peut très rapidement faire de petites fonctions que l'on intègrera à l'éditeur, permettant d'avoir de petits résultats ``visuels'' assez rapidement :) ; tout en gardant le côté interprétation directe depuis l'éditeur ;)

Quelques exemples d'E-Lisp :

Des codes ``calculatoires'' :

Code:

---

1 2 3 4

(defun double (a) "double the value of the argument" (interactive "p") (message "double (%d) : %d" a (* 2 a)))

---

Ou de manipulation de texte sous Emacs :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

(defun my-insert-buffer (buffer) "Insert after point the contents of BUFFER. Puts mark after the inserted text. BUFFER may be a buffer or a buffer name." (interactive "*bInsert buffer: ") (or (bufferp buffer) ; note : les 'or' sont intelligents <=> && (setq buffer (get-buffer buffer))) (let (start end newmark) (save-excursion (save-excursion (set-buffer buffer) (setq start (point-min) end (point-max))) (insert-buffer-substring buffer start end) (setq newmark (point))) (push-mark newmark)))

---

Lisp est tres agréable à manipuler quand on a l'habitude, mais pour débuter je conseille vraiment ocaml :)

2+x c'est plus intuitif que (+ 2 x)

et la récursivité/manipulation de listes se fait tres bien aussi en caml :)

J'apporte ma contribution:

J'ai "commencé" la programmation avec ADA (je met le mot entre guillemets, car c'est le premier cours de prog que j'ai suivi mais j'avais un peu touché au basic et pascal avant pour le plaisir) et contrairement à ce qui a été dit plus tot, j'ai trouvé tres bien pour commencer. Je ne me suis pas "perdu dedans" et quand il a fallu par la suite passer au C, ça c'est fait très aisément. Je pense qu'une transition dans l'autre sens aurait été plus difficile.

Quand à la question "peut-on dissocier l'apprentissage de l'algorithmique et celui de la programmation?" je pense que non. Les "vraies" écoles comme a dit qqun ici séparent les deux cours, mais je pense qu'il commencent par un cours de prog, puis ensuite seulement un cours d'algo (en parallèle au cours de prog)
En effet, dans n'importe quel language de prog, on voit tres rapidement les itérations, les conditions, etc... qui sont des mécanismes important pour n'importe quel algorithme de base, et apprendre l'algo sans avoir commencé par un peu de programmation me semble difficile

Citation:

---

Envoyé par Biosox

je pense qu'il commencent par un cours de prog, puis ensuite seulement un cours d'algo

---

Un cours de prog oui, mais pas forcément dans un langage. Et rappelons nous que les algos existaient bien avant l'ordinateur. Nous avons tous appris les divisions entières (division euclidienne) au primaire sans savoir programmer (enfin pour ceux qui ne sont pas né un PC dans les mains). Nous avons (tous?) suivi une recette de cuisine pour faire un gateau sans pour autant savoir programmer.

Mais on ne sait toujours pas vraiment si Terminator cherche à initier les étudiants à la prog ou à l'algo...

Hum, juste pour information, en classe préparatoire on en est toujours à Caml Light et non pas OCaml.

Mais pourquoi beaucoup tiennent tant à Pascal ? C'est trop impératif comme langage, on manipule pas des fonctions simplement, c'est pas pratique pour l'algorithmique, à l'inverse de Caml.

En Caml, l'écriture des algorithmes est naturelle, tu manipules des fonctions super simplement. Tu les passes en argument avec une syntaxe claire, tu les fous dans une structure, des affectations de fonctions par ci par là...

Comme disait Jedai, c'est super sûr avec l'inférence des types.
En plus, le pattern matching c'est très puissant, les types unions c'est super pratique pour modéliser toutes les structures inductives d'algorithmique, rapide comme les grands langages comme C++...

En plus le code est très concis...

Notez qu'aux concours des Grandes Ecoles, tous ceux qui font du Pascal sont désavantagés par rapport à ceux qui font du Caml, statistiquement... Bon c'est peut-être pas un truc pertinent j'avoue, parce que les meilleures classes prépa n'utilisent pas Pascal en général.

Il n'y a plus que 3 prépas en france qui utilisent pascal je crois, toutes les autres travaillent avec caml :)

Ma pierre à l'édifice:

Il est indispensable d'apprendre à ces gens qu'un algorithme se traduit dans un langage. L'implémentation d'un algorithme dans un langage n'est pas une simple transposition de mots clés.

Apprendre à implémenter un même algorithme sur plusieurs langages est indispensable.

Pascal et Ada sont un bon début.
Ensuite C, C++: Il y a des chances que ça crash assez vite (pointeurs...) et ce sera formateur. Ils apprendront l'utilité de renseigner un algorithme avec des post-conditions, invariants...

Pour changer ensuite du tout au tout, Lisp, Prolog et Anubis!

Voilà, après avoir vu tout ces langages, ils auront appris:
- la difficulté de traduction d'un algorithme
- L'intérêt de ne pas connaître le langage cible au moment de la rédaction d'un algorithme