Quel est l'intérêt des langages dynamique, en général ?

Version imprimable

Voir 40 message(s) de cette discussion en une page

04/12/2009, 13h31
benwit

Si je vous comprend bien, ce vous vous souhaitez faire, c'est que cela soit permis directement au niveau du langage parce que sinon, il y a moyen de le faire "en dehors".

Je ne nie pas qu'il y a des cas où ce soit intéressant mais après, il y a le risque que ce soit mal utilisé (et qu'une solution trouvée à la conception aurait été préférable).

Si je peux me permettre, pour faire une analogie avec SQL, il y a les ordres qui opèrent sur la structure et d'autres sur les données.
J'ai entendu dire par des "DBA" qu'une application ne devrait pas comporter des ordres DDL.
Si on pense à une "méta application" qui créerait des schémas de base de données, on peut désapprouver ce conseil.
Toutefois, je l'ai compris le jour où j'ai vue une application faite par des novices (et malheureusement utilisé parce que le front-end est joli) : à chaque création de cours, 50 tables sont créées !
04/12/2009, 13h47
kaymak
<dérive>
Citation:
Code:

1 2 3 4 Object o = new Object(); o.addMethod("int sum(int x,int y) { return x+y;}"); int s = o.sum(1,2);
Cela n'est pas possible en java ? :perplexe:

Pourtant c'est un compilé, j'ai toujours pensé que c'était plus simple de gérer ces fonctions dynamique sur des langages compilé, plutôt qu'avec des langages interprétés.

Mais bon vous m'avez un peu perdu avec vos langages dynamique et static alors c'est peut être une grosse ânerie.
</dérive>

Citation:
Envoyé par pseudocode
.
Code:

1 2 3 4 if (o instanceof MyResource) { o.addInterface(java.io.Closable); o.addMethod("void close() { this.disconnect(); }"); }
J'aurais plutôt vu un équivalent des classes Proxy. Même si on limite la possibilité de génération de code.
Code:

1 2 3 4 5 6 7 if (o instanceof MyResource) { o.addMethod(new Method("close", new Class[] {}), new InvocationMethod() { public Object invoke(Object o, Object[] params) { ((MyResource) o).disconnect(); return null; } });
Après, c'est clair que les cas d'utilisation sont rares et il faut pas utiliser ça n'importe comment.

Citation:

Envoyé par gorgonite

meta programmation sur Java ?
tu as utilisé cet outil http://www.jetbrains.com/mps/index.html ?

Heu... non. Mais ca m'a l'air surtout orienté sur la création de langage spécifique aux domaines (DSL). Ca n'a pas trop de rapport avec les langages dynamiques (je dirais même le contraire).

Citation:

Envoyé par benwit

Je ne nie pas qu'il y a des cas où ce soit intéressant mais après, il y a le risque que ce soit mal utilisé (et qu'une solution trouvée à la conception aurait été préférable).

Je n'ai pas dit que ca devait être utilisé tout le temps. Bien au contraire, j'apprécie la rigueur imposée par le typage statique et le "blindage" qu'il procure dans des applications complexes.

Il y a cependant des cas où l'on maitrise parfaitement ce que l'on fait (un petit "bloc" de code, une classe autonome, ...). Dans ces cas là, on peut utiliser la programmation dynamique sans trop de risque et ainsi avoir une plus grande souplesse pour écrire une solution.
Code:

1 2 3 4 5 6 int getTotalPrice(int clientId) { Query query = new Query("SELECT SUM(price) AS grandtotal FROM Orders WHERE client=%cid%"); query.cid = clientId; Object o = Database.execute(query); return o.grandtotal; }
Citation:

Envoyé par kaymak

Cela n'est pas possible en java ? :perplexe:

Pourtant c'est un compilé, j'ai toujours pensé que c'était plus simple de gérer ces fonctions dynamique sur des langages compilé, plutôt qu'avec des langages interprétés.

On pourrait tout a fait ajouter dynamiquement une méthode a un objet, mais le compilateur ne serait pas au courant (au moment de la compilation). Et donc il ne pourrait pas vérifier les noms/types des méthodes/variable, ce qui est tout de meme le gros avantage du typage statique :D.

Le typage statique impose qu'une variable ne change pas de type pendant son utilisation. Elle conserve donc le type qui lui a été donné au départ (dans le code du programme), ce qui permet au compilateur de faire tous les tests (et optimisations) nécessaires.

04/12/2009, 14h44
kaymak

<dérive suite>

Citation:

On pourrait tout a fait ajouter dynamiquement une méthode a un objet, mais le compilateur ne serait pas au courant (au moment de la compilation). Et donc il ne pourrait pas vérifier les noms/types des méthodes/variable, ce qui est tout de meme le gros avantage du typage statique .

Le typage statique impose qu'une variable ne change pas de type pendant son utilisation. Elle conserve donc le type qui lui a été donné au départ (dans le code du programme), ce qui permet au compilateur de faire tous les tests (et optimisations) nécessaires

OK, merci de ta réponse !

Mais du coup, j'ai envi de dire, que c'est le compilateur qui ne prévoit pas le cas d'utilisation.
Que comme je l'imaginais, se serait tout à fait possible, plus rapide et mieux géré qu'en langage interprété, si tant est que le compilo l'ai prévu.
<dérive suite & fin si personne n'à rien à y redire ^^>
04/12/2009, 14h48
gorgonite

Citation:

Envoyé par pseudocode

Heu... non. Mais ca m'a l'air surtout orienté sur la création de langage spécifique aux domaines (DSL). Ca n'a pas trop de rapport avec les langages dynamiques (je dirais même le contraire).

via un DSL, on peut introduire du "sucre syntaxique" pour construire des stubs de manière transparente, et ainsi donner une impression de objets à la SmallTalk ?
donc ça a un rapport... il n'y a qu'à voir comment de simples extensions camlp4 arrivent à intégrer l'évaluation paresseuse ou des "constructeurs d'ordre supérieur" dans un langage qui ne les gère pas nativement (et qui est quand même beaucoup plus statiquement typé :aie:)

Citation:

Envoyé par Jack Sparrow

J'aurais plutôt vu un équivalent des classes Proxy. Même si on limite la possibilité de génération de code.

Oui, mais la partie "interessante" dans mon exemple c'etait la ligne "addInterface" qui permet par la suite de réutiliser le typage statique.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 Object o = ... // add Closable behavior if needed if (!(o instanceof Closable)) { o.addInterface(java.io.Closable); o.addMethod("void close() { /* nothing to do */ }"); } doSftuff( o ) ; /* doSftuff( (Closable) o ); // Necessaire avec le typage statique */ } void doStuff (Serializable o) { .. } void doStuff (Closable c) { .. }

On peut aussi avoir ça du coup :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    Object o = ...
 
    // add Closable behavior if needed
    if (!(o instanceof Closable)) {
        o.addInterface(java.io.Closable);
        o.addMethod("void close() { /* nothing to do */ }");
        o.addInterface(java.io.Serializable);
    }
 
    doSftuff( o ) ;
   /* doSftuff( (Closable) o ); // Necessaire avec le typage statique */
}
 
void doStuff (Serializable o) { .. }
void doStuff (Closable c) { .. }

Et même ça :

Code:

1
2
3
4
5
6
7
8
    Object o = ...
    // add Closable behavior if needed
    if (!(o instanceof Closable)) {
        o.addInterface(java.io.Closable);
      }
 
(    (Closable) o).close();
}

Et là, ça me semble mal

04/12/2009, 17h49
maa

Je suis du même avis que benwit

Au final, il ressort qu'un langage statique peut très bien gérer:
- L'instrospection
- La métaprogrammation
- Les fonction d'ordre supérieur
- Les fonction lambda
- L'évaluation et la modification du code au runtime. On peut d'ailleurs tout à fait modifier la définition d'un classe au runtime en c#. Il faut utiliser le TypeBuilder (http://oreilly.com/catalog/progcshar...h18.html#17553). On peut même compiler au runtime du code pour l'exécuter.

Citation:

Si les langages statique d'aujourd'hui implemente des propriete des langages dynamiques, sont-il toujours statiques ?

J'ai l'impression que beaucoup d'avantages qu'on attribue exclusivement aux langages dynamiques existe en fait également en statique et même de façon plus poussée (cf. les expressions lambda). Pourquoi a t-on ces à priori ? Je me demande si ça n'est pas parce qu'on se lance facilement dans l'apprentissage d'un langage dynamique en croyant qu'il est plus facile à maitriser et sans vérifier les possibilités en statique. On prend à mon avis le problème à l'envers, car les débutants devraient justement s'obliger à une certaine rigueur au début pour bien comprendre les mécanismes de la programmation.

En fait un langage devrait être statique par défaut et dynamique pour des besoins spécifique (comme faire de la récursivité sur des types non connus à l'avance). C'est la direction que prend c# et je la trouve tout à fait logique: il faut d'abord avoir de la rigueur et ensuite s'autoriser de la souplesse, ça évite bien des ennuis car on sait ce que l'on fait. En dynamique, c'est l'inverse: souplesse à volonté au moment de taper de le code... la rigueur et les ennuis tombent au runtime !

Le seul vrai avantage que je retiens pour l'instant est qu'il est facile de faire une petite modification, sans avoir à recompiler, etc. Mis à part ça, un langage statique suffisamment évolué semble pouvoir faire tout ce que fait un langage dynamique.

Sinon on ne m'a pas répondu si Java était aussi souple que le langage C# (inférence de type, variables implicitement typés, expressions lambda, variables dynamiques, etc.). Parce que pour en revenir à mon problème initial, il me faut choisir un ERP et je n'en vois aucun de gratuit écrit en .NET.

Citation:

Le typage statique impose qu'une variable ne change pas de type pendant son utilisation. Elle conserve donc le type qui lui a été donné au départ (dans le code du programme), ce qui permet au compilateur de faire tous les tests (et optimisations) nécessaires.

Oui et c'est logique d'ailleurs. Le language ne devrait pas permettre à une variable de muter vers n'importe quoi. Pourquoi est-ce qu'un objet "Personne" pourrait-il se transformer en un objet "Ordinateur" ? En revanche, il serait peut être logique qu'un objet "Personne" puisse évoluer vers le type "Professeur" et gagner ainsi en fonctionnalités. :roll:

Citation:

C'est pour ca que je parle d'écosystème si tu utilises PHP sans un Framework tu ne vas pas en voir les avantages. Pour reprendre ton exemple tu compares un langage (PHP) à "une plateforme de développement" ASP.net. Cela dit tu ne retrouveras pas le confort de Visual Studio.

J'utilisais le framework Zend. En fait je travaillais sur un projet magento. Mais l'utilisation du framework ne change rien au fait qu'il n'y a pas de code behind, pas de réelle séparation entre les couches métiers et affichage, etc. sans compter que la programmation objets est très limitée...
Côté IDE, il en ressort que même en utilisant de bons éditeurs comme netbeans on a une assistance très limitée et associé à une lourdeur pour parser le code et le confronter à la doc. Croyez moi, quand on passe de ASP.net à PHP, on vraiment l'impression de retourner à l'âge de pierre au niveau confort de programmation!
04/12/2009, 18h46
pseudocode

Citation:

Envoyé par Jack Sparrow

On peut aussi avoir ça du coup :
(...)
Et même ça :
(...)
Et là, ça me semble mal

Ce n'est pas que c'est mal, c'est juste que les vérifications ne sont pas faites au moment de la compilation mais de l'exécution.

Le typage statique nous permet (en Java) d'appliquer le mantra "si ca compile alors c'est que j'ai implémenté toutes les méthodes nécessaires". Donc on n'aura pas d'exception du type "Unknown method".

Citation:

Envoyé par maa

Je me demande si ça n'est pas parce qu'on se lance facilement dans l'apprentissage d'un langage dynamique en croyant qu'il est plus facile à maitriser et sans vérifier les possibilités en statique.

Comme l'a dit Jedai, c'est surtout que l'on confond le "typage dynamique" et le "langage de programmation dynamique".
05/12/2009, 00h35
batataw

Citation:

Envoyé par maa

J'utilisais le framework Zend. En fait je travaillais sur un projet magento. Mais l'utilisation du framework ne change rien au fait qu'il n'y a pas de code behind, pas de réelle séparation entre les couches métiers et affichage, etc. sans compter que la programmation objets est très limitée...
Côté IDE, il en ressort que même en utilisant de bons éditeurs comme netbeans on a une assistance très limitée et associé à une lourdeur pour parser le code et le confronter à la doc. Croyez moi, quand on passe de ASP.net à PHP, on vraiment l'impression de retourner à l'âge de pierre au niveau confort de programmation!

"En ce qui concerne l'interet des languages dynamiques il faut pas essayer de le comparer a un langage static car tu n'en verras que les défauts.
Ton choix doit se faire en fonction du projet."

"Tu ne trouveras pas l'équivalent de Visual Studio."

- Est-ce que ton projet se prete au langage dynamic?
- C'est étrange Zend fournit le patron de conception MVC.
- En ce qui concerne l'objet qu'est-ce qu'il te manque?

Il faut que tu passes un peu de temps a étudier les possibilités que PHP t'offre ca sert a rien de les comparer. Si tes besoins passent par un langage de type C# ou Java et bien fonce.
05/12/2009, 00h44
batataw

Citation:

Envoyé par Bibi218

J'avoue que j'aimerais bien en savoir un peu plus là-dessus.
Python est pour l'instant mon langage préféré, mais si je l'ai choisi, c'est pour sa bibliothèque standard, sa syntaxe qui ne me pique pas les yeux, ainsi que quelques autres petites choses citées plus haut. Par contre, j'ai beaucoup d'assert qui trainent dans mon code, et ma documentation comprend presque systematiquement des informations sur le type de mes variables, validés par des décorateurs.

Je suis conscient que je dois manquer quelque chose, auquel cas merci de m'éclairer ! Mais ce qui m'a séduit dans Python, c'est vraiment le côté haut niveau, pas le typage dynamique.

"changer ta façon de développer", je veux bien, mais vers quoi du coup ?
Et quel est l'intérêt pour de la programmation Web en particulier ?

Si tes projets demandent un typage fort n'hésite pas a switcher de langage.
Un informaticien se doit d'etre polyglotte. De plus ce qui compte vraiment c'est la maitrise des concepts.

Pour répondre a ta question je te recommande les méthodes d'intégrations continues comme ca ton code est constamment validé.

Citation:

Envoyé par Jedai

D'un autre côté pas mal d'aficionados des langages dynamiques tendent à attribuer au dynamisme des avantages qui sont plutôt dûs au niveau d'abstraction et à imputer au typage statiques des désavantages qui n'existent que dans les systèmes de typage explicite faiblement expressifs et fragiles des langages mainstream...

Jedai, je t'aime :)

Sinon, pour ce qui est de l'ajout dynamique de méthodes à l'exécution : en OCaml, l'utilisation des fonctions est très souple, il est possible de créer une hashtable dont les éléments sont des fonctions, et les fonctions que l'on y ajoute peuvent être créées dynamiquement, par exemple l'on pourrait avoir une fonction qui, à partir d'un code dans un langage donné, produirait un arbre syntaxique et une autre fonction qui exécuterait cet arbre (avec d'éventuels arguments qui pourraient être passés par une liste, par exemple).

Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 let arbre=ast_of_code "def main(msg): print(msg)" in let fonction=execute_ast arbre in (* note : la fonction execute_ast pourrait attendre 2 arguments : l'arbre et les arguments de la fonction main du code, le code ne serait alors pas immédiatement exécuté *) Hashtbl.add tbl "ma_fonction" fonction (* ... *) try (Hashtbl.find tbl "ma_fonction") [String "Bonjour"] (* les arguments de la fonction main seraient une liste d'un type somme et là, le code serait effectivement exécuté *) with | Not_found -> ()

13/12/2009, 14h50
ypicot

Citation:

Envoyé par maa

...j'ai perdu un temps fou à debugger des erreurs de syntaxe, de typage, de propriétés ou méthodes inexistantes, etc. Il faut dire que je dois faire pas mal d'erreurs d'inattentions, étant habitué à ce qu'une compilation me signale toute ces erreurs...

On sait que passer du procédural à l'objet (ou le contraire), de l'objet au fonctionnel (et réciproquement), de la moto à la voiture (et inversement) demande une certaine phase d'adaptation. Au début, on est toujours perdu, on recherche ce dont on a l'habitude. Ce n'est qu'après un certain temps qu'on remarque ce qui est ajouté, et surtout a quoi ca sert et comment on l'utilise.

Pour reprendre ton exemple (erreur de typage, ...) ce genre de choses n'est effectivement pas détecté par le compilo, puisqu'il n'y a pas de compilo.
En fait, c'est remplacé par autre chose : un développement piloté par les tests. C'est ton harnais de tests qui va détecter ce genre de boulette, ainsi que de nombreuses autres.
Les tests existent bien sûr dans quasiment tous les langages (y compris statiques), mais ils sont encore plus vitaux dans les langages dynamiques. A noter que pyunit est intégré à Python.

Développer dans un langage dynamique avec les réflexes d'un langage statique va te conduire au même endroit que piloter une moto avec les réflexes d'une conduite auto : dans le mur.

Par contre, quand tu maitrises les deux, tu peux choisir l'un ou l'autre en fonction du contexte (c'est vrai pour les langages et les véhicules).

Yvan
14/12/2009, 00h36
maa

Merci beaucoup pour ce conseils sur les tests unitaires. Je n'en ai pas fait lors du développement de mon application en php et c'est clair que ça m'aurait sûrement éviter pas mal d'erreurs.
26/07/2010, 06h48
Katleen Erna

Mise à jour du 26.07.2010 par Katleen
Les langages statiques sont-ils trop sophistiqués et complexes ?

=> http://www.developpez.net/forums/d95...s/#post5367400

Edit de Gordon : débat déplacé pour ne pas détourner celui-ci de son sujet initial (l'intérêt des langages dynamiques)
26/07/2010, 08h43
Invité

Citation:

Envoyé par maa

Mise à jour du 26.07.2010 par Katleen
Les langages statiques sont-ils trop sophistiqués et complexes ? Un cadre de Google montre Java et C++ du doigt

...

Source : Déclarations de Rob Pike

:fleche: Pensez-vous que Java et C++ soient devenus trop complexes ?

:fleche: Pourquoi les langages gagnent-ils toujours en complexité ?

:fleche: Que pensez-vous de l'initiative Go ?

:fleche: Go deviendra-t-il à terme aussi compliqué que les autres langages lorsqu'il sera beaucoup utilisé ?

-

Les langages ne sont pas responsables de cette complexité, c'est plutôt ce qu'on fait avec

Ok je m'interresse à Go (comme à tout ce que produit google) mais je ne vais pas entrer dans cette stratégie de communication : poser une question absurde pour faire jazzer..

C'est vrai les languages deviennent complexes, mais les nouvelles stratégies de programmation tardent à être implémentées dans les langages sous forme de primitive (cf Ajax) on copi colle de gros patés de code parce qu'on ne peut rien faire d'autre. De nouveaux langages apparaissent qui font en une seule directive ce qui exige des centaines de lignes de C+ ou des milliers d'assembleur

Mais dés qu'on sort des sentiers battus, on est bien obligés de détricoter les process, refaire tout à la main et changer juste ce qui nous intéresse

Bon, la question est volontairement biaisée
Il n'existe pas de réponse satisfaisante, si ce n'est qu'il faut bien surveiller toutes les nouvelles stratégies de productivité des développeurs. Pas seulement les langages mais aussi les IDE's, les générateurs, les outils de refactoring... Et croire les ainés quand ils disent que trois lignes de regex remplacent 50 lignes de splits/merge !
26/07/2010, 08h59
Gordon Fowler

Débat sur la complexité des langages statiques déplacé pour ne pas détourner celui-ci de son sujet initial (l'intérêt des langages dynamiques)

=> http://www.developpez.net/forums/d95...s/#post5367400

Cordialement,

Gordon
26/07/2010, 10h16
eyquem

Citation:

Je suis programmeur c#, qui est statique et fortement typé. (...) Comprendre un programme existant est aussi bien plus évident quand on connait le type des objets et que l'on peut remonter à leurs définitions ou la définition de leurs membres, et ceci n'est pas possible avec un langage dynamique.

message #1

Est-ce que quelqu’un pourrait expliquer en quoi consiste « remonter à leurs définitions ou la définition de leurs membres » auquel il est fait référence dans cette phrase.

Ceci évoque-t-il une possibilité de C# ou de tout langage dynamique en général ?

Merci.
27/07/2010, 09h56
el_slapper

Citation:

Envoyé par eyquem

Est-ce que quelqu’un pourrait expliquer en quoi consiste « remonter à leurs définitions ou la définition de leurs membres » auquel il est fait référence dans cette phrase.

Ceci évoque-t-il une possibilité de C# ou de tout langage dynamique en général ?

Merci.

Langage statique en général.

ça veut dire que quelque part dans le code, il existe une définition unique de la donnée sur laquelle je suis en train de bosser. Et ça permet de comprendre un peu mieux ce qui se passe.

Voir 40 message(s) de cette discussion en une page