.
Je trouve try/except moins lourd que le traitement au cas par cas - les
gouts et les couleurs...
Et comme ça, quand les exceptions remontent, c'est qu'il n'y a pas de
traitement d'erreur à faire (ou que le développeur a écrit du cod e
jetable sans traitement d'erreur).
Mais en tout cas elles ne sont pas passées sous silence (ce qui a des
effets indésirables à postériori nettement plus difficiles à ce rner).
C'est pour cette raison qu'on conseill de ne jamais mettre en place de
filtre except "catchall" de façon inconsidérée.
Ok
La méthode à la perl amène
finalement à une meilleur fiabilité puisque le programmeur doit pe nser à
traiter ou commenter précisément chaque cas d'anomalie.
Là, je ne suis pas d'accord. J'ai fait pas mal de C (en plus du C++), où
il faut gérer les erreurs de cette façon [*]. Sauf à avoir des
développeurs très expérimentés et qui blindent leur code - rare - on
retrouve généralement des codes de retour non traités...
Tout à fait
Ben, tu ajoutes un décorateur à ta fonction, avec un bloc try/excep t
autour de l'appel à la fonction et zoooo.
Là il faudra que je me repenche sur les décorateurs mais python avanc e
.
Je trouve try/except moins lourd que le traitement au cas par cas - les
gouts et les couleurs...
Et comme ça, quand les exceptions remontent, c'est qu'il n'y a pas de
traitement d'erreur à faire (ou que le développeur a écrit du cod e
jetable sans traitement d'erreur).
Mais en tout cas elles ne sont pas passées sous silence (ce qui a des
effets indésirables à postériori nettement plus difficiles à ce rner).
C'est pour cette raison qu'on conseill de ne jamais mettre en place de
filtre except "catchall" de façon inconsidérée.
Ok
La méthode à la perl amène
finalement à une meilleur fiabilité puisque le programmeur doit pe nser à
traiter ou commenter précisément chaque cas d'anomalie.
Là, je ne suis pas d'accord. J'ai fait pas mal de C (en plus du C++), où
il faut gérer les erreurs de cette façon [*]. Sauf à avoir des
développeurs très expérimentés et qui blindent leur code - rare - on
retrouve généralement des codes de retour non traités...
Tout à fait
Ben, tu ajoutes un décorateur à ta fonction, avec un bloc try/excep t
autour de l'appel à la fonction et zoooo.
Là il faudra que je me repenche sur les décorateurs mais python avanc e
.
Je trouve try/except moins lourd que le traitement au cas par cas - les
gouts et les couleurs...
Et comme ça, quand les exceptions remontent, c'est qu'il n'y a pas de
traitement d'erreur à faire (ou que le développeur a écrit du cod e
jetable sans traitement d'erreur).
Mais en tout cas elles ne sont pas passées sous silence (ce qui a des
effets indésirables à postériori nettement plus difficiles à ce rner).
C'est pour cette raison qu'on conseill de ne jamais mettre en place de
filtre except "catchall" de façon inconsidérée.
Ok
La méthode à la perl amène
finalement à une meilleur fiabilité puisque le programmeur doit pe nser à
traiter ou commenter précisément chaque cas d'anomalie.
Là, je ne suis pas d'accord. J'ai fait pas mal de C (en plus du C++), où
il faut gérer les erreurs de cette façon [*]. Sauf à avoir des
développeurs très expérimentés et qui blindent leur code - rare - on
retrouve généralement des codes de retour non traités...
Tout à fait
Ben, tu ajoutes un décorateur à ta fonction, avec un bloc try/excep t
autour de l'appel à la fonction et zoooo.
Là il faudra que je me repenche sur les décorateurs mais python avanc e
Pour quoi faire ? Ce n'est pas parce qu'une fonction lève une
exception qu'il faut rattraper cette exception à ce niveau là (si tu
sais gérer l'exception au niveau de la fonction, tu ne la laisse pas
se propager, donc si tu la laisse se propager c'est que ce n'est
précisément pas le bon endroit pour la gérer, cqfd).
A condition de ne pas la laisser remonter par simple fainéantise.
Ok par contre la personne qui créé un module est la plus à même à
comprendre ce qui peut générer les exceptions ? Et d'y remédier ?
Imaginons que tu crées un module qui fasse des entrées/sorties sur des fichiers à un niveau bas. Il y a le traitement des données mais il y a surtout les entrées/sorties sur le disque. Un module de plus haut niveau compte sur ce module de bas niveau pour faire la lecture/écriture sur le disque. Si une erreur arrive quand le fichier est écrit (un exemple parmis d'autres), que doit faire le module de bas niveau ? Eventuellement, réessayer ou essayer de contourner le problème. Mais si ça ne le fait vraiment pas ? Crois-tu vraiment que l'exception ne doit pas remonter ?
Pour quoi faire ? Ce n'est pas parce qu'une fonction lève une
exception qu'il faut rattraper cette exception à ce niveau là (si tu
sais gérer l'exception au niveau de la fonction, tu ne la laisse pas
se propager, donc si tu la laisse se propager c'est que ce n'est
précisément pas le bon endroit pour la gérer, cqfd).
A condition de ne pas la laisser remonter par simple fainéantise.
Ok par contre la personne qui créé un module est la plus à même à
comprendre ce qui peut générer les exceptions ? Et d'y remédier ?
Imaginons que tu crées un module qui fasse des entrées/sorties sur des fichiers à un niveau bas. Il y a le traitement des données mais il y a surtout les entrées/sorties sur le disque. Un module de plus haut niveau compte sur ce module de bas niveau pour faire la lecture/écriture sur le disque. Si une erreur arrive quand le fichier est écrit (un exemple parmis d'autres), que doit faire le module de bas niveau ? Eventuellement, réessayer ou essayer de contourner le problème. Mais si ça ne le fait vraiment pas ? Crois-tu vraiment que l'exception ne doit pas remonter ?
Pour quoi faire ? Ce n'est pas parce qu'une fonction lève une
exception qu'il faut rattraper cette exception à ce niveau là (si tu
sais gérer l'exception au niveau de la fonction, tu ne la laisse pas
se propager, donc si tu la laisse se propager c'est que ce n'est
précisément pas le bon endroit pour la gérer, cqfd).
A condition de ne pas la laisser remonter par simple fainéantise.
Ok par contre la personne qui créé un module est la plus à même à
comprendre ce qui peut générer les exceptions ? Et d'y remédier ?
Imaginons que tu crées un module qui fasse des entrées/sorties sur des fichiers à un niveau bas. Il y a le traitement des données mais il y a surtout les entrées/sorties sur le disque. Un module de plus haut niveau compte sur ce module de bas niveau pour faire la lecture/écriture sur le disque. Si une erreur arrive quand le fichier est écrit (un exemple parmis d'autres), que doit faire le module de bas niveau ? Eventuellement, réessayer ou essayer de contourner le problème. Mais si ça ne le fait vraiment pas ? Crois-tu vraiment que l'exception ne doit pas remonter ?
Pardon ? Tu a déjà essayé d'avoir une gestion d'erreur fiable et non
intrusive avec un langage n'ayant pas de support pour les exceptions ?
Je n'ai pas dit ça enfin ;)
Qui a dit qu'il fallait les gérer "au plus près" ? Le bon endroit pour
gérer une exception, c'est là où on a le contexte nécessaire pour la
gérer - ce qui est très différent de "au plus près".
On m'aurait donc menti ?
plus sérieusement il y a un peu trop de modules qui laissent remonter
des exceptions sans les traiter.
Je n'ai pas la prétention d'être un king de la programmation n'y d'avoir
les bonnes habitudes.
Par contre celle de poser toutes les questions y compris les plus c....La méthode à la perl amène finalement à une meilleur fiabilité
puisque le programmeur doit penser à traiter ou commenter précisément
chaque cas d'anomalie.
Mdr.
C'est déjà çagestion d'erreur à la Perl:
fait_quelquechose ou crashe("ça n'a pas marché")
pas faux
Pour quoi faire ? Ce n'est pas parce qu'une fonction lève une
exception qu'il faut rattraper cette exception à ce niveau là (si tu
sais gérer l'exception au niveau de la fonction, tu ne la laisse pas
se propager, donc si tu la laisse se propager c'est que ce n'est
précisément pas le bon endroit pour la gérer, cqfd).
A condition de ne pas la laisser remonter par simple fainéantise.
Ok par contre la personne qui créé un module est la plus à même à
comprendre ce qui peut générer les exceptions ? Et d'y remédier ?
Ou un bloc exception en fin des blocs de définitions de fonctions.
OOh, oui, génial. Comme les 'on error go to...' de VB ?
Ouii pourquoi pas
PS: c'est quoi VB ?
Pardon ? Tu a déjà essayé d'avoir une gestion d'erreur fiable et non
intrusive avec un langage n'ayant pas de support pour les exceptions ?
Je n'ai pas dit ça enfin ;)
Qui a dit qu'il fallait les gérer "au plus près" ? Le bon endroit pour
gérer une exception, c'est là où on a le contexte nécessaire pour la
gérer - ce qui est très différent de "au plus près".
On m'aurait donc menti ?
plus sérieusement il y a un peu trop de modules qui laissent remonter
des exceptions sans les traiter.
Je n'ai pas la prétention d'être un king de la programmation n'y d'avoir
les bonnes habitudes.
Par contre celle de poser toutes les questions y compris les plus c....
La méthode à la perl amène finalement à une meilleur fiabilité
puisque le programmeur doit penser à traiter ou commenter précisément
chaque cas d'anomalie.
Mdr.
C'est déjà ça
gestion d'erreur à la Perl:
fait_quelquechose ou crashe("ça n'a pas marché")
pas faux
Pour quoi faire ? Ce n'est pas parce qu'une fonction lève une
exception qu'il faut rattraper cette exception à ce niveau là (si tu
sais gérer l'exception au niveau de la fonction, tu ne la laisse pas
se propager, donc si tu la laisse se propager c'est que ce n'est
précisément pas le bon endroit pour la gérer, cqfd).
A condition de ne pas la laisser remonter par simple fainéantise.
Ok par contre la personne qui créé un module est la plus à même à
comprendre ce qui peut générer les exceptions ? Et d'y remédier ?
Ou un bloc exception en fin des blocs de définitions de fonctions.
OOh, oui, génial. Comme les 'on error go to...' de VB ?
Ouii pourquoi pas
PS: c'est quoi VB ?
Pardon ? Tu a déjà essayé d'avoir une gestion d'erreur fiable et non
intrusive avec un langage n'ayant pas de support pour les exceptions ?
Je n'ai pas dit ça enfin ;)
Qui a dit qu'il fallait les gérer "au plus près" ? Le bon endroit pour
gérer une exception, c'est là où on a le contexte nécessaire pour la
gérer - ce qui est très différent de "au plus près".
On m'aurait donc menti ?
plus sérieusement il y a un peu trop de modules qui laissent remonter
des exceptions sans les traiter.
Je n'ai pas la prétention d'être un king de la programmation n'y d'avoir
les bonnes habitudes.
Par contre celle de poser toutes les questions y compris les plus c....La méthode à la perl amène finalement à une meilleur fiabilité
puisque le programmeur doit penser à traiter ou commenter précisément
chaque cas d'anomalie.
Mdr.
C'est déjà çagestion d'erreur à la Perl:
fait_quelquechose ou crashe("ça n'a pas marché")
pas faux
Pour quoi faire ? Ce n'est pas parce qu'une fonction lève une
exception qu'il faut rattraper cette exception à ce niveau là (si tu
sais gérer l'exception au niveau de la fonction, tu ne la laisse pas
se propager, donc si tu la laisse se propager c'est que ce n'est
précisément pas le bon endroit pour la gérer, cqfd).
A condition de ne pas la laisser remonter par simple fainéantise.
Ok par contre la personne qui créé un module est la plus à même à
comprendre ce qui peut générer les exceptions ? Et d'y remédier ?
Ou un bloc exception en fin des blocs de définitions de fonctions.
OOh, oui, génial. Comme les 'on error go to...' de VB ?
Ouii pourquoi pas
PS: c'est quoi VB ?
Là, je ne suis pas d'accord. J'ai fait pas mal de C (en plus du C++), où
il faut gérer les erreurs de cette façon [*]. Sauf à avoir des
développeurs très expérimentés et qui blindent leur code - rare - on
retrouve généralement des codes de retour non traités...
Là, je ne suis pas d'accord. J'ai fait pas mal de C (en plus du C++), où
il faut gérer les erreurs de cette façon [*]. Sauf à avoir des
développeurs très expérimentés et qui blindent leur code - rare - on
retrouve généralement des codes de retour non traités...
Là, je ne suis pas d'accord. J'ai fait pas mal de C (en plus du C++), où
il faut gérer les erreurs de cette façon [*]. Sauf à avoir des
développeurs très expérimentés et qui blindent leur code - rare - on
retrouve généralement des codes de retour non traités...
La méthode à la perl amène finalement à une meilleur fiabilité
puisque le programmeur doit penser à traiter ou commenter
précisément chaque cas d'anomalie.
Mdr.
gestion d'erreur à la Perl:
fait_quelquechose ou crashe("ça n'a pas marché")
C'est du Garcimore, ta gestion d'erreur. Le résultat final est
exactement le même que celui d'une exception non gérée (traceback en
moins). C'est toi qui parles de "fiabilité" ?
La méthode à la perl amène finalement à une meilleur fiabilité
puisque le programmeur doit penser à traiter ou commenter
précisément chaque cas d'anomalie.
Mdr.
gestion d'erreur à la Perl:
fait_quelquechose ou crashe("ça n'a pas marché")
C'est du Garcimore, ta gestion d'erreur. Le résultat final est
exactement le même que celui d'une exception non gérée (traceback en
moins). C'est toi qui parles de "fiabilité" ?
La méthode à la perl amène finalement à une meilleur fiabilité
puisque le programmeur doit penser à traiter ou commenter
précisément chaque cas d'anomalie.
Mdr.
gestion d'erreur à la Perl:
fait_quelquechose ou crashe("ça n'a pas marché")
C'est du Garcimore, ta gestion d'erreur. Le résultat final est
exactement le même que celui d'une exception non gérée (traceback en
moins). C'est toi qui parles de "fiabilité" ?
Là, je ne suis pas d'accord.
Je programme quasiment que sur de l'embarqué. Et en embarqué,
il faut
considérer que rien n'est acquis. Par exemple, c'est pas parce qu'un
fichier
s'est ouvert que l'on pourra le lire ou l'écrire à
volonté. Les ressources
sont limitées, l'environnement hostile et l'utilisateur
imprévisible.J'ai du mal à faire passer le message aux informaticiens
habitués à la
programmation sur PC où ils considèrent que presque tout est
possible sans
gestion d'erreur. Et ça pose de vrais problèmes. C'est vrai que
c'est
beaucoup plus lourd de gérer les erreurs correctement mais on c'est
nécessaire ET indispensable.
Je suis d'accord, mais pas d'accord sur le fait qu'on regle tout a coup de
gros try catch partout histoire de dire que c'est ok ... Comme tu dis, les
ressouces sont limitees, mais le pire pour moi c'est que mes ptites
bestioles recoivent de partout des donnees, par ethernet, par gsm (sms ou
datas), par modem, par wifi ... bref, TRES communicante, et si un des
appareils autour m'envoi des conneries, tout le reste peut partir en live
Evidemment si j'ai pas le choix jvais try catcher tout ca, mais bon
Les problèmes ne se règlent pas forcément à coup
de try/except et sûrement pas avec des gros try et des except sans
condition comme dans un de mes posts précédents (ce qu'il faut
absolument éviter).
Des simples tests pour valider une valeur de variable peuvent beaucoup
améliorer la stabilité du système.
Du genre, tu reçois une trame d'un autre appareil que tu as
conçu. Comme tu as conçu l'émetteur et le récepteur
tu sais que la trame as une taille x. Dans le récepteur, tu programmes
tout avec cette taille sans vérifier que la trame reçue as bien
la bonne taille. Erreur. La loi de Murphy dit qu'à un moment ou un
autre...
Evidemment, il est impossible de penser à toutes les sources d'erreurs
possibles.
Nicolas
Là, je ne suis pas d'accord.
Je programme quasiment que sur de l'embarqué. Et en embarqué,
il faut
considérer que rien n'est acquis. Par exemple, c'est pas parce qu'un
fichier
s'est ouvert que l'on pourra le lire ou l'écrire à
volonté. Les ressources
sont limitées, l'environnement hostile et l'utilisateur
imprévisible.
J'ai du mal à faire passer le message aux informaticiens
habitués à la
programmation sur PC où ils considèrent que presque tout est
possible sans
gestion d'erreur. Et ça pose de vrais problèmes. C'est vrai que
c'est
beaucoup plus lourd de gérer les erreurs correctement mais on c'est
nécessaire ET indispensable.
Je suis d'accord, mais pas d'accord sur le fait qu'on regle tout a coup de
gros try catch partout histoire de dire que c'est ok ... Comme tu dis, les
ressouces sont limitees, mais le pire pour moi c'est que mes ptites
bestioles recoivent de partout des donnees, par ethernet, par gsm (sms ou
datas), par modem, par wifi ... bref, TRES communicante, et si un des
appareils autour m'envoi des conneries, tout le reste peut partir en live
Evidemment si j'ai pas le choix jvais try catcher tout ca, mais bon
Les problèmes ne se règlent pas forcément à coup
de try/except et sûrement pas avec des gros try et des except sans
condition comme dans un de mes posts précédents (ce qu'il faut
absolument éviter).
Des simples tests pour valider une valeur de variable peuvent beaucoup
améliorer la stabilité du système.
Du genre, tu reçois une trame d'un autre appareil que tu as
conçu. Comme tu as conçu l'émetteur et le récepteur
tu sais que la trame as une taille x. Dans le récepteur, tu programmes
tout avec cette taille sans vérifier que la trame reçue as bien
la bonne taille. Erreur. La loi de Murphy dit qu'à un moment ou un
autre...
Evidemment, il est impossible de penser à toutes les sources d'erreurs
possibles.
Nicolas
Là, je ne suis pas d'accord.
Je programme quasiment que sur de l'embarqué. Et en embarqué,
il faut
considérer que rien n'est acquis. Par exemple, c'est pas parce qu'un
fichier
s'est ouvert que l'on pourra le lire ou l'écrire à
volonté. Les ressources
sont limitées, l'environnement hostile et l'utilisateur
imprévisible.J'ai du mal à faire passer le message aux informaticiens
habitués à la
programmation sur PC où ils considèrent que presque tout est
possible sans
gestion d'erreur. Et ça pose de vrais problèmes. C'est vrai que
c'est
beaucoup plus lourd de gérer les erreurs correctement mais on c'est
nécessaire ET indispensable.
Je suis d'accord, mais pas d'accord sur le fait qu'on regle tout a coup de
gros try catch partout histoire de dire que c'est ok ... Comme tu dis, les
ressouces sont limitees, mais le pire pour moi c'est que mes ptites
bestioles recoivent de partout des donnees, par ethernet, par gsm (sms ou
datas), par modem, par wifi ... bref, TRES communicante, et si un des
appareils autour m'envoi des conneries, tout le reste peut partir en live
Evidemment si j'ai pas le choix jvais try catcher tout ca, mais bon
Les problèmes ne se règlent pas forcément à coup
de try/except et sûrement pas avec des gros try et des except sans
condition comme dans un de mes posts précédents (ce qu'il faut
absolument éviter).
Des simples tests pour valider une valeur de variable peuvent beaucoup
améliorer la stabilité du système.
Du genre, tu reçois une trame d'un autre appareil que tu as
conçu. Comme tu as conçu l'émetteur et le récepteur
tu sais que la trame as une taille x. Dans le récepteur, tu programmes
tout avec cette taille sans vérifier que la trame reçue as bien
la bonne taille. Erreur. La loi de Murphy dit qu'à un moment ou un
autre...
Evidemment, il est impossible de penser à toutes les sources d'erreurs
possibles.
Nicolas