C’est vrai que j’avais entendu pas mal de chose sur le lisp (mis à part que c’est trop parenthésé) notamment qu’il plaît beaucoup aux mathématicien.
La programmation fonctionnelle n’autorise ni l’affectation ni les boucle ou c’est une légende urbaine ?
Pour ma part, voici l’ordre d’apprentissage que je te conseillerais :
le C pur : surtout pas de C++ ! Le C n’a pas cette approche objet qu’a le C++ et est donc un bon langage pour commencer. Il est énormément utilisé, surtout pour Linux, et c’est la langage qui a inspiré le C++, le Java, le PHP ou encore le C#. Tu pourras donc facilement passer à ceux là ensuite. De plus, le C est un langage de bas niveau ce qui te permet de bien comprendre comment s’articulent le système proprement dit et la programmation du système en question. On peut donc par la suite passer beaucoup plus facilement à l’assembleur si on le souhaite que si on apprend des langages de haut niveau.
le Java : ce langage est totalement orienté objet contrairement au C++ qui ne respecte pas tous les principes de la programmation objet. Il est de plus portable sur tous types d’architectures sans la moindre modification. C’est donc un excellent langage pour aborder la programmation objet, d’autant plus que sa syntaxe s’inspire fortement du C. L’inconvénient de Java est qu’on ne peut pas accéder directement aux ressources de bas niveau étant donné qu’il s’exécute dans une machine virtuelle. C’est un très bon langage pour coder des logiciels professionnels qui ne demandent pas forcément de la rapidité d’exécution.
le C++ : avec ça tu pourras contrôler ta machine à 100% tout en utilisant une approche objet. Cependant, il ne respecte pas totalement l’approche objet, d’où la nécessité de bien connaître la notion d’objet avant de s’y attaquer si on veut vraiment l’exploiter à fond. Il faut donc être calé en programmation et en conception objet si on veut être efficace.
Voila pour “débuter”, le reste dépendra de tes envies/besoins !
EDIT : personnellement, j’ai un faible pour l’assembleur qui permet de comprendre comment fonctionne un ordi dans ses moindres détails…
“La programmation fonctionnelle n’autorise ni l’affectation ni les boucle ou c’est une légende urbaine ?”
Plus ou moins. Je ne pense pas dire quelque-chose d’atroce en disant que ce n’est peut être pas “fonctionnel pur”, cependant il y a moyen de faire la même chose et dans des langages comme caml tu peux faire des boucles ou utiliser des références, c’est juste que c’est moche en général comparé au reste du code ^^. Il faut bien concevoir ton programme avec les structures de données adaptées. Après si ça devient vraiment trop coton à mettre en oeuvre et que tu passes ton temps à utiliser des choses qui sont apparues “en renfort” et peu de ce que sait faire le langage “à la base”, en comparaison, c’est sans doute qu’il faudrait peut être se tourner vers autre chose.
Enfin … corrige moi si je me trompe fran ^^.
[quote=“MisterFreez”]C’est vrai que j’avais entendu pas mal de chose sur le lisp (mis à part que c’est trop parenthésé) notamment qu’il plaît beaucoup aux mathématicien.
La programmation fonctionnelle n’autorise ni l’affectation ni les boucle ou c’est une légende urbaine ?[/quote]
Non ce n’est pas légendaire. En Haskell qui est un langage fonctionnel pure tu ne verras pas d’affectation comme a = 2 dans ton code. Pas de while non plus, on utilise des fonctions récursives. Exemple pour calculer le factorielle d’un nombre :
fac 0 = 1
fac n+1 = (n+1) * fac n
En Hakell on peut aussi utiliser les compréhensions de listes, les fonctions fold… Il autorise même les listes infinis grâce à l’évaluation paresseuse.
Ce nouveau livre t’en dira plus que moi : http://book.realworldhaskell.org/
Pour en revenir au sujet, je sais j’suis lourd, j’ai commencé avec le basic (peut de temps) et j’ai vraiment appris à programmer avec le Pascal, qui a l’avantage d’être très rigoureux (un chouilla moins que le C) et surtout très littéral, enfin si tu parles l’anglais, tu as l’impression de faire des algorithmes !
Le passage au C est assez simple ensuite.
J’y pensais, mais je me disais que c’était tellement plus à la mode que ça pouvait être un problême de trouver des gens avec qui causer pascal.
Lazarus n’est pas ce qu’on peut appeler un soft au point, mais c’est déjà énorme ! et tout ça en Free Pascal !
Son nom est significatif de l’état d’esprit des développeurs: Pascal ! lève toi et marche.
Il était mort, donc. 
A choisir Pascal pourquoi ne pas se tourner vers ADA, plus à la mode et plus documenté que Pascal.
Ah pi ça, tu es sûr que ton codage est propre, c’est sûr, vu que ça ne marche pas s’il ne l’est pas.
ADA plus à la mode que Pascal !!!
Quand on voit le nombre d’appli qui sont réalisées sous Delphi, je doute qu’ADA n’ait jamais la même popularité !
Delphi est à peine du Pascal. Tu passes ton temps à manipuler les mêmes objets que tu manipulerais en C++, et l’utilisation systématique de pointeurs de, handles, et autres objets atypiques font que tu oublies trés vite les déclarations. Son créateur a embrayé avec l’invention du C#, pour dire ce qui est sensé lui ressembler le plus.
Son transfert de Borland à Microsoft a sonner le glas de Delphi !
Java si on veut faire du multi-plateforme.
Sinon du C/C++ pour tout faire sur une plate-forme donné.
Je vais faire mon chieur mais on peux faire du multi plateforme avec du C/C++ mais bon c’est plus complexe et il faut adapter son code 
Légende urbaine.
De façon générale, une fonction ou procédure se définie par
Un langage fonctionnel met l’accent sur les arguments et le résultat. Par ailleurs, il n’y a pas de différence entre une fonction et un objet.
Exemple: tu peux définir la composition en Caml par
[code]let composition f g = function x -> f (g x);;
let prefix *$ = composition;;
[/code]
Tu obtiens
et par exemple
let f x = 2*x+1;;
let g = f *$ f;;
f (f 3);;
g 3;;
qui te donne
[quote]
f : int -> int =
g : int -> int =
#f (f 3);;
[code]let addition n =
let s = ref 0 in
begin
for i = 1 to n do
s:=!s+i;
done;
!s
end;;
addition : int -> int =
#addition 15;;
[code]#let addition =
let rec boucle r = function
| 0 -> r
| i -> (boucle (r+i) (i-1))
in boucle;;
addition : int -> int -> int =
#addition 15;;
L’apothéose est que tu peux montrer par exemple que la récursion ne rajoute te rien dès que tu peux manipuler des fonctions. Dans ce qui suit, on formalise se qu’est une fonction récursive i.e définie par
f(x) = si (t(x)) alors g(x) sinon ex(x,f(h(x)))
pour factorielle, tu as
t(x) = (x==0)
g(x) = 1 (uniquement appelé pour x=0 en fait)
h(x) = x-1
ex(x,y) = xy (on a n! = n((n-1)!)
La fonction (calcule t g h ex) renvoit la fonction factorielle si on lui fournit les bonnes fonctions.
[code]#(calcule t_fact g_fact h_fact ex_fact) 7;;
Ceci n’est faisable qu’en fonctionnel. Il y a deux écriture de la fonction calcule: la première est récursive et se fait très simplement (utilisation de rec). La deuxième est impérative avec des références et des boucles et non récursive. Son écriture est une méthode de dérécursification de n’importe quelle fonction récursive et est également la preuve qu’un langage récursif (avec des fonctions réentrantes) n’est pas plus puissant qu’un langage impératif non récursif.
[code] Caml Light version 0.76
#let calcule t g h ex x =
let rec fonction xp =
if (t xp) then (g xp)
else (ex xp (fonction (h xp)))
in (fonction x);;
calcule :
('a -> bool) -> ('a -> 'b) -> ('a -> 'a) -> ('a -> 'b -> 'b) -> 'a -> 'b =
#let t_fact = eq_int 0;;
t_fact : int -> bool =
#let g_fact _ = 1;;
g_fact : 'a -> int =
#let h_fact x = x-1;;
h_fact : int -> int =
#let ex_fact x y = x*y;;
ex_fact : int -> int -> int =
#let fact = (calcule t_fact g_fact h_fact ex_fact);;
fact : int -> int =
#(fact 7);;
Le tout est très court. Fais ça en C et on en reparlera
Je crois que c’est le C/C++, le mieux a apprendre, mais y a t’il des tutoriels pour apprendre à programmer.
fran.b tiens ca me fait penser que le caml ressemble un peu au scala n’y aurait-il pas un lien de parenté quelque part?
scala-lang.org/
Je ne connaissais pas Scala. À vue de nez ça a l’air d’être proche du Java et dédié au type abstrait ce qui en fait quelque chose de vraiment intéressant, les exemples donnés dans «Overview of Scala» montre une surcouche fonctionnelle sur Java. Intéressant comme truc…