J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
J'ai cependant quelques problèmes avec la mise au point des programmes,
je fais partie des gens qui font beaucoup de petites fautes
d'inattention et j'ai l'habitude que le compilateur les détecte toutes
pour moi. Quelles sont les techniques de débogages plus avancées que le
saupoudrage de «print» du code? Saupoudrage qui du reste n'est pas très
recommandé s'il s'agit de traquer une erreur causée par une mauvaise
valeur envoyée vers le code d'une bibliothèque. Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de
variables?
J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
J'ai cependant quelques problèmes avec la mise au point des programmes,
je fais partie des gens qui font beaucoup de petites fautes
d'inattention et j'ai l'habitude que le compilateur les détecte toutes
pour moi. Quelles sont les techniques de débogages plus avancées que le
saupoudrage de «print» du code? Saupoudrage qui du reste n'est pas très
recommandé s'il s'agit de traquer une erreur causée par une mauvaise
valeur envoyée vers le code d'une bibliothèque. Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de
variables?
J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
J'ai cependant quelques problèmes avec la mise au point des programmes,
je fais partie des gens qui font beaucoup de petites fautes
d'inattention et j'ai l'habitude que le compilateur les détecte toutes
pour moi. Quelles sont les techniques de débogages plus avancées que le
saupoudrage de «print» du code? Saupoudrage qui du reste n'est pas très
recommandé s'il s'agit de traquer une erreur causée par une mauvaise
valeur envoyée vers le code d'une bibliothèque. Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de
variables?
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, â¦) et j'ai besoin de calcul er des
distances entre deux objets ou des intersections.
J'aimerais avoir quelques indications sur la façon de s'en tirer hab ilement.
La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est
ni très joli, ni très maintenable!
Je pensais créer une classe singleton «PlanStrategy» en ch arge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figu res
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «Pla nStrategy»
pour traiter les cas qu'il ne connaît pas.
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détec te
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code?
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, â¦) et j'ai besoin de calcul er des
distances entre deux objets ou des intersections.
J'aimerais avoir quelques indications sur la façon de s'en tirer hab ilement.
La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est
ni très joli, ni très maintenable!
Je pensais créer une classe singleton «PlanStrategy» en ch arge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figu res
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «Pla nStrategy»
pour traiter les cas qu'il ne connaît pas.
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détec te
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code?
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, â¦) et j'ai besoin de calcul er des
distances entre deux objets ou des intersections.
J'aimerais avoir quelques indications sur la façon de s'en tirer hab ilement.
La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est
ni très joli, ni très maintenable!
Je pensais créer une classe singleton «PlanStrategy» en ch arge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figu res
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «Pla nStrategy»
pour traiter les cas qu'il ne connaît pas.
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détec te
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code?
[…] Je trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
Des introductions à Python, il y en a plein. Des simples, des
compliquées, en français, en anglais...
J'ai cependant quelques problèmes avec la mise au point des programmes, […] Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de
variables?
Il y a des environnements de développements qui permettent de faire de
l'analyse de code. J'utilise Eclipse avec le plugin PyDev. Un peu lourd
mais très efficace. Il existe également d'autres solutions que je
n'utilise pas.
[…] Je trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
Des introductions à Python, il y en a plein. Des simples, des
compliquées, en français, en anglais...
J'ai cependant quelques problèmes avec la mise au point des programmes, […] Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de
variables?
Il y a des environnements de développements qui permettent de faire de
l'analyse de code. J'utilise Eclipse avec le plugin PyDev. Un peu lourd
mais très efficace. Il existe également d'autres solutions que je
n'utilise pas.
[…] Je trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
Des introductions à Python, il y en a plein. Des simples, des
compliquées, en français, en anglais...
J'ai cependant quelques problèmes avec la mise au point des programmes, […] Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de
variables?
Il y a des environnements de développements qui permettent de faire de
l'analyse de code. J'utilise Eclipse avec le plugin PyDev. Un peu lourd
mais très efficace. Il existe également d'autres solutions que je
n'utilise pas.
Pour calculer les distances, une simple fonction peut suffire.
Exemple :
[…]
Pour déboguer, regarde la doc de Python sur le module pdb
C'est simple, mais déjà suffisant.
Pour calculer les distances, une simple fonction peut suffire.
Exemple :
[…]
Pour déboguer, regarde la doc de Python sur le module pdb
C'est simple, mais déjà suffisant.
Pour calculer les distances, une simple fonction peut suffire.
Exemple :
[…]
Pour déboguer, regarde la doc de Python sur le module pdb
C'est simple, mais déjà suffisant.
Michael Grünewald writes:j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections. […]
En fait, le calcul de la distance va dans chaque cas dépendre du type
des deux figures impliquées. Les langages objets comme Python ne font de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de choisir
une version en fonction de tous les types de paramètres.
Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figures
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «PlanStrategy»
pour traiter les cas qu'il ne connaît pas.
C'est une très bonne idée. Vraiment.
Il reste encore à définir ce qu'est
la distance (sûrement le min des distances des composants).
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détecte
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code?
Il y a pdb (je n'ai jamais essayé, en général je m'en sors avec des
print...)
Si tu en arrives à des programmes assez compliqués, tu vas amèrement
regretter le typage statique.
Mais c'est un autre débat. La réponse
habituelle pour python est : écrire des tests unitaires, des tas de
tests unitaires, etc.
Michael Grünewald<michipili@yahoo.de> writes:
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections. […]
En fait, le calcul de la distance va dans chaque cas dépendre du type
des deux figures impliquées. Les langages objets comme Python ne font de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de choisir
une version en fonction de tous les types de paramètres.
Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figures
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «PlanStrategy»
pour traiter les cas qu'il ne connaît pas.
C'est une très bonne idée. Vraiment.
Il reste encore à définir ce qu'est
la distance (sûrement le min des distances des composants).
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détecte
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code?
Il y a pdb (je n'ai jamais essayé, en général je m'en sors avec des
print...)
Si tu en arrives à des programmes assez compliqués, tu vas amèrement
regretter le typage statique.
Mais c'est un autre débat. La réponse
habituelle pour python est : écrire des tests unitaires, des tas de
tests unitaires, etc.
Michael Grünewald writes:j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections. […]
En fait, le calcul de la distance va dans chaque cas dépendre du type
des deux figures impliquées. Les langages objets comme Python ne font de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de choisir
une version en fonction de tous les types de paramètres.
Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figures
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «PlanStrategy»
pour traiter les cas qu'il ne connaît pas.
C'est une très bonne idée. Vraiment.
Il reste encore à définir ce qu'est
la distance (sûrement le min des distances des composants).
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détecte
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code?
Il y a pdb (je n'ai jamais essayé, en général je m'en sors avec des
print...)
Si tu en arrives à des programmes assez compliqués, tu vas amèrement
regretter le typage statique.
Mais c'est un autre débat. La réponse
habituelle pour python est : écrire des tests unitaires, des tas de
tests unitaires, etc.
j'ai implémenté quelques classes représentant des figure s dans le plan
(des points, des lignes brisées, â¦) et j'ai besoin de calc uler des
distances entre deux objets ou des intersections. [â¦]
En fait, le calcul de la distance va dans chaque cas dépendre du ty pe
des deux figures impliquées. Les langages objets comme Python ne fo nt de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de chois ir
une version en fonction de tous les types de paramètres.
je ne comprends pas très bien ce que tu veux dire: «Python ne [fait]
de liaison dynamique que sur un paramètre.» La liaison dynamiq ue,
c'est bien ce qu'on appelle aussi la résolution des méthodes? C'est-Ã
dire l'opération qui étant donné un objet et une méth ode trouve la
bonne fonction a appeler?
La paramètre dont tu parles dans le cas de Python, c'est la classe de
l'objet, c'est ça (la valeur de retour de type)? Dans le cas de Lisp
, je ne vois pas du tout ce que cela peut vouloir direâ¦
Si tu en arrives à des programmes assez compliqués, tu vas am èrement
regretter le typage statique.
C'est déjà fait! :) J'ai implémenté un algorithme de triangulation de
Delaunay, cela m'a pris un temps complètement intolérable,
essentiellement à cause de fautes de frappe⦠j'ai regrettà © OCaml avec
lequel j'aurais réglé ça en une demi-journée au lieu de deux jours.
Mais c'est un autre débat. La réponse habituelle pour python e st :
écrire des tests unitaires, des tas de tests unitaires, etc.
Très bien, je me plierai à ce nouveau mantra. Est-ce qu'il a d es
outils ou des méthodologies spéciaux pour écrire les tests unitaires
en Python?
j'ai implémenté quelques classes représentant des figure s dans le plan
(des points, des lignes brisées, â¦) et j'ai besoin de calc uler des
distances entre deux objets ou des intersections. [â¦]
En fait, le calcul de la distance va dans chaque cas dépendre du ty pe
des deux figures impliquées. Les langages objets comme Python ne fo nt de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de chois ir
une version en fonction de tous les types de paramètres.
je ne comprends pas très bien ce que tu veux dire: «Python ne [fait]
de liaison dynamique que sur un paramètre.» La liaison dynamiq ue,
c'est bien ce qu'on appelle aussi la résolution des méthodes? C'est-Ã
dire l'opération qui étant donné un objet et une méth ode trouve la
bonne fonction a appeler?
La paramètre dont tu parles dans le cas de Python, c'est la classe de
l'objet, c'est ça (la valeur de retour de type)? Dans le cas de Lisp
, je ne vois pas du tout ce que cela peut vouloir direâ¦
Si tu en arrives à des programmes assez compliqués, tu vas am èrement
regretter le typage statique.
C'est déjà fait! :) J'ai implémenté un algorithme de triangulation de
Delaunay, cela m'a pris un temps complètement intolérable,
essentiellement à cause de fautes de frappe⦠j'ai regrettà © OCaml avec
lequel j'aurais réglé ça en une demi-journée au lieu de deux jours.
Mais c'est un autre débat. La réponse habituelle pour python e st :
écrire des tests unitaires, des tas de tests unitaires, etc.
Très bien, je me plierai à ce nouveau mantra. Est-ce qu'il a d es
outils ou des méthodologies spéciaux pour écrire les tests unitaires
en Python?
j'ai implémenté quelques classes représentant des figure s dans le plan
(des points, des lignes brisées, â¦) et j'ai besoin de calc uler des
distances entre deux objets ou des intersections. [â¦]
En fait, le calcul de la distance va dans chaque cas dépendre du ty pe
des deux figures impliquées. Les langages objets comme Python ne fo nt de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de chois ir
une version en fonction de tous les types de paramètres.
je ne comprends pas très bien ce que tu veux dire: «Python ne [fait]
de liaison dynamique que sur un paramètre.» La liaison dynamiq ue,
c'est bien ce qu'on appelle aussi la résolution des méthodes? C'est-Ã
dire l'opération qui étant donné un objet et une méth ode trouve la
bonne fonction a appeler?
La paramètre dont tu parles dans le cas de Python, c'est la classe de
l'objet, c'est ça (la valeur de retour de type)? Dans le cas de Lisp
, je ne vois pas du tout ce que cela peut vouloir direâ¦
Si tu en arrives à des programmes assez compliqués, tu vas am èrement
regretter le typage statique.
C'est déjà fait! :) J'ai implémenté un algorithme de triangulation de
Delaunay, cela m'a pris un temps complètement intolérable,
essentiellement à cause de fautes de frappe⦠j'ai regrettà © OCaml avec
lequel j'aurais réglé ça en une demi-journée au lieu de deux jours.
Mais c'est un autre débat. La réponse habituelle pour python e st :
écrire des tests unitaires, des tas de tests unitaires, etc.
Très bien, je me plierai à ce nouveau mantra. Est-ce qu'il a d es
outils ou des méthodologies spéciaux pour écrire les tests unitaires
en Python?
C'est ton cas : ce qui détermine la méthode à appeler, c'est le couple
des types des paramètres.
Tu ne peux pas écrire cela dans un langage object à la
Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et Dylan, et
peut-être quelques autres).
C'est ton cas : ce qui détermine la méthode à appeler, c'est le couple
des types des paramètres.
Tu ne peux pas écrire cela dans un langage object à la
Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et Dylan, et
peut-être quelques autres).
C'est ton cas : ce qui détermine la méthode à appeler, c'est le couple
des types des paramètres.
Tu ne peux pas écrire cela dans un langage object à la
Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et Dylan, et
peut-être quelques autres).
Salut,
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections.
J'aimerais avoir quelques indications sur la façon de s'en tirer
habilement.
La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est
ni très joli, ni très maintenable!
Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figures
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «PlanStrategy»
pour traiter les cas qu'il ne connaît pas.
Quelles sont les suggestions des développeurs chevronnés dans ce cas …
de figure?
J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détecte
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code? Saupoudrage qui du
reste n'est pas très recommandé s'il s'agit de traquer une erreur
causée par une mauvaise valeur envoyée vers le code d'une
bibliothèque. Y-a'il des outils pour «tracer» le code, qui notamment
afficheraient les affectations de variables?
Salut,
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections.
J'aimerais avoir quelques indications sur la façon de s'en tirer
habilement.
La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est
ni très joli, ni très maintenable!
Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figures
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «PlanStrategy»
pour traiter les cas qu'il ne connaît pas.
Quelles sont les suggestions des développeurs chevronnés dans ce cas …
de figure?
J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détecte
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code? Saupoudrage qui du
reste n'est pas très recommandé s'il s'agit de traquer une erreur
causée par une mauvaise valeur envoyée vers le code d'une
bibliothèque. Y-a'il des outils pour «tracer» le code, qui notamment
afficheraient les affectations de variables?
Salut,
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections.
J'aimerais avoir quelques indications sur la façon de s'en tirer
habilement.
La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est
ni très joli, ni très maintenable!
Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figures
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «PlanStrategy»
pour traiter les cas qu'il ne connaît pas.
Quelles sont les suggestions des développeurs chevronnés dans ce cas …
de figure?
J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détecte
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code? Saupoudrage qui du
reste n'est pas très recommandé s'il s'agit de traquer une erreur
causée par une mauvaise valeur envoyée vers le code d'une
bibliothèque. Y-a'il des outils pour «tracer» le code, qui notamment
afficheraient les affectations de variables?
à (at) Tue, 07 Feb 2012 19:17:33 +0100,
Alain Ketterlin écrivait (wrote):C'est ton cas : ce qui détermine la méthode à appeler, c' est le couple
des types des paramètres.
Effectivement.Tu ne peux pas écrire cela dans un langage object à la
Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et Dylan, et
peut-être quelques autres).
Heu... Le polymorphisme permet pourtant exactement cela. Il est
explicite en Java et en C++ (et beaucoup d'autres langages orientés
objet à typage fort). Il est "simulable" en Python/Perl/Ruby bien que
non explicite.
à (at) Tue, 07 Feb 2012 19:17:33 +0100,
Alain Ketterlin <alain@dpt-info.u-strasbg.fr> écrivait (wrote):
C'est ton cas : ce qui détermine la méthode à appeler, c' est le couple
des types des paramètres.
Effectivement.
Tu ne peux pas écrire cela dans un langage object à la
Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et Dylan, et
peut-être quelques autres).
Heu... Le polymorphisme permet pourtant exactement cela. Il est
explicite en Java et en C++ (et beaucoup d'autres langages orientés
objet à typage fort). Il est "simulable" en Python/Perl/Ruby bien que
non explicite.
à (at) Tue, 07 Feb 2012 19:17:33 +0100,
Alain Ketterlin écrivait (wrote):C'est ton cas : ce qui détermine la méthode à appeler, c' est le couple
des types des paramètres.
Effectivement.Tu ne peux pas écrire cela dans un langage object à la
Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et Dylan, et
peut-être quelques autres).
Heu... Le polymorphisme permet pourtant exactement cela. Il est
explicite en Java et en C++ (et beaucoup d'autres langages orientés
objet à typage fort). Il est "simulable" en Python/Perl/Ruby bien que
non explicite.