existe-t-il un logiciel d'analyse de code qui permettent de d=E9terminer
les sp=E9cifications des exceptions que chaque m=E9thode et fonction
devraient avoir ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Luc Hermitte
On 6 oct, 23:58, ALB wrote:
existe-t-il un logiciel d'analyse de code qui permettent de déterminer les spécifications des exceptions que chaque méthode et fonction devraient avoir ?
Même si cela existait (je ne le crois pas, mais on ne sait jamais), cela ne résoudrait pas le fait que les vérifications seront toujours réalisées de façon dynamique. Voulons-nous vraiment un programme qui plante en opération à cause d'un petit oubli couplé à une modification un peu trop hâtive ?
Dernièrement, Scott Meyer a montré sur artima une façon [1] de vérifier statiquement que les fonctions d'une famille donnée appellent bien des fonctions de sous-familles compatibles.
[1] Sauf que quand ça compile sur notre compilateur, il ne faut vraiment pas être pressé. C'est plus une démonstration de faisabilité qu'aut re chose.
-- Luc Hermitte
On 6 oct, 23:58, ALB <lebatt...@crans.org> wrote:
existe-t-il un logiciel d'analyse de code qui permettent de déterminer
les spécifications des exceptions que chaque méthode et fonction
devraient avoir ?
Même si cela existait (je ne le crois pas, mais on ne sait jamais),
cela
ne résoudrait pas le fait que les vérifications seront toujours
réalisées
de façon dynamique.
Voulons-nous vraiment un programme qui plante en opération à cause
d'un petit oubli couplé à une modification un peu trop hâtive ?
Dernièrement, Scott Meyer a montré sur artima une façon [1] de
vérifier statiquement que les fonctions d'une famille donnée
appellent
bien des fonctions de sous-familles compatibles.
[1] Sauf que quand ça compile sur notre compilateur, il ne faut
vraiment
pas être pressé. C'est plus une démonstration de faisabilité qu'aut re
chose.
existe-t-il un logiciel d'analyse de code qui permettent de déterminer les spécifications des exceptions que chaque méthode et fonction devraient avoir ?
Même si cela existait (je ne le crois pas, mais on ne sait jamais), cela ne résoudrait pas le fait que les vérifications seront toujours réalisées de façon dynamique. Voulons-nous vraiment un programme qui plante en opération à cause d'un petit oubli couplé à une modification un peu trop hâtive ?
Dernièrement, Scott Meyer a montré sur artima une façon [1] de vérifier statiquement que les fonctions d'une famille donnée appellent bien des fonctions de sous-familles compatibles.
[1] Sauf que quand ça compile sur notre compilateur, il ne faut vraiment pas être pressé. C'est plus une démonstration de faisabilité qu'aut re chose.
-- Luc Hermitte
ALB
On 7 oct, 16:35, Luc Hermitte wrote:
On 6 oct, 23:58, ALB wrote:
> existe-t-il un logiciel d'analyse de code qui permettent de détermine r > les spécifications des exceptions que chaque méthode et fonction > devraient avoir ?
Même si cela existait (je ne le crois pas, mais on ne sait jamais), cela ne résoudrait pas le fait que les vérifications seront toujours réalisées de façon dynamique. Voulons-nous vraiment un programme qui plante en opération à cause d'un petit oubli couplé à une modification un peu trop hâtive ?
Dernièrement, Scott Meyer a montré sur artima une façon [1] de vérifier statiquement que les fonctions d'une famille donnée appellent bien des fonctions de sous-familles compatibles.
[1] Sauf que quand ça compile sur notre compilateur, il ne faut vraiment pas être pressé. C'est plus une démonstration de faisabilité qu'a utre chose.
-- Luc Hermitte
Hors problème de complexité (liée à la sémantique du langage), je ne vois pas pourquoi il n'existe d'analyse (statique) du code. (Je suis tout à fait d'accord, notamment pour des raisons de compatibilité historique, avec le fait que la gestion des exceptions se fait de manières dynamiques.) A priori, ce qui me semble le plus difficile à analyser serait les pointeurs de fonctions car la spécification des erreurs ne fait pas partie de la signature mais il est néanmoins possible de faire la liste de toutes les fonctions ayant une signature donnée et de lister toutes les exceptions qu'elles peuvent lancer.
S'agit-il de l'article <http://www.artima.com/cppsource/ codefeatures.html> ?
Le finalité de ma question est d'être sur d'avoir un code exception- safe.
Adrien
On 7 oct, 16:35, Luc Hermitte <luc.hermi...@gmail.com> wrote:
On 6 oct, 23:58, ALB <lebatt...@crans.org> wrote:
> existe-t-il un logiciel d'analyse de code qui permettent de détermine r
> les spécifications des exceptions que chaque méthode et fonction
> devraient avoir ?
Même si cela existait (je ne le crois pas, mais on ne sait jamais),
cela
ne résoudrait pas le fait que les vérifications seront toujours
réalisées
de façon dynamique.
Voulons-nous vraiment un programme qui plante en opération à cause
d'un petit oubli couplé à une modification un peu trop hâtive ?
Dernièrement, Scott Meyer a montré sur artima une façon [1] de
vérifier statiquement que les fonctions d'une famille donnée
appellent
bien des fonctions de sous-familles compatibles.
[1] Sauf que quand ça compile sur notre compilateur, il ne faut
vraiment
pas être pressé. C'est plus une démonstration de faisabilité qu'a utre
chose.
--
Luc Hermitte
Hors problème de complexité (liée à la sémantique du langage), je ne
vois pas pourquoi il n'existe d'analyse (statique) du code.
(Je suis tout à fait d'accord, notamment pour des raisons de
compatibilité historique, avec le fait que la gestion des exceptions
se fait de manières dynamiques.)
A priori, ce qui me semble le plus difficile à analyser serait les
pointeurs de fonctions car la spécification des erreurs ne fait pas
partie de la signature mais il est néanmoins possible de faire la
liste de toutes les fonctions ayant une signature donnée et de lister
toutes les exceptions qu'elles peuvent lancer.
S'agit-il de l'article <http://www.artima.com/cppsource/
codefeatures.html> ?
Le finalité de ma question est d'être sur d'avoir un code exception-
safe.
> existe-t-il un logiciel d'analyse de code qui permettent de détermine r > les spécifications des exceptions que chaque méthode et fonction > devraient avoir ?
Même si cela existait (je ne le crois pas, mais on ne sait jamais), cela ne résoudrait pas le fait que les vérifications seront toujours réalisées de façon dynamique. Voulons-nous vraiment un programme qui plante en opération à cause d'un petit oubli couplé à une modification un peu trop hâtive ?
Dernièrement, Scott Meyer a montré sur artima une façon [1] de vérifier statiquement que les fonctions d'une famille donnée appellent bien des fonctions de sous-familles compatibles.
[1] Sauf que quand ça compile sur notre compilateur, il ne faut vraiment pas être pressé. C'est plus une démonstration de faisabilité qu'a utre chose.
-- Luc Hermitte
Hors problème de complexité (liée à la sémantique du langage), je ne vois pas pourquoi il n'existe d'analyse (statique) du code. (Je suis tout à fait d'accord, notamment pour des raisons de compatibilité historique, avec le fait que la gestion des exceptions se fait de manières dynamiques.) A priori, ce qui me semble le plus difficile à analyser serait les pointeurs de fonctions car la spécification des erreurs ne fait pas partie de la signature mais il est néanmoins possible de faire la liste de toutes les fonctions ayant une signature donnée et de lister toutes les exceptions qu'elles peuvent lancer.
S'agit-il de l'article <http://www.artima.com/cppsource/ codefeatures.html> ?
Le finalité de ma question est d'être sur d'avoir un code exception- safe.
Adrien
Alp Mestan
A ma connaissance, aucun outil ne fait ce que tu veux. Ca doit pouvoir se faire... Mais tu ne peux toutefois pas tout prévoir. Tu peux te chopper un bad_alloc à l'exécution que tu n'aurais pu prévoir lors de la lecture du code par ton outil ou d'une éventuelle simulation de code pour tester le comportement face aux exceptions.
A ma connaissance, aucun outil ne fait ce que tu veux. Ca doit pouvoir
se faire... Mais tu ne peux toutefois pas tout prévoir. Tu peux te
chopper un bad_alloc à l'exécution que tu n'aurais pu prévoir lors de
la lecture du code par ton outil ou d'une éventuelle simulation de
code pour tester le comportement face aux exceptions.
A ma connaissance, aucun outil ne fait ce que tu veux. Ca doit pouvoir se faire... Mais tu ne peux toutefois pas tout prévoir. Tu peux te chopper un bad_alloc à l'exécution que tu n'aurais pu prévoir lors de la lecture du code par ton outil ou d'une éventuelle simulation de code pour tester le comportement face aux exceptions.
James Kanze
On Oct 7, 5:45 pm, ALB wrote:
On 7 oct, 16:35, Luc Hermitte wrote: > On 6 oct, 23:58, ALB wrote:
> > existe-t-il un logiciel d'analyse de code qui permettent > > de déterminer les spécifications des exceptions que chaque > > méthode et fonction devraient avoir ?
> Même si cela existait (je ne le crois pas, mais on ne sait > jamais), cela ne résoudrait pas le fait que les > vérifications seront toujours réalisées de façon dynamique. > Voulons-nous vraiment un programme qui plante en opération à > cause d'un petit oubli couplé à une modification un peu trop > hâtive ?
> Dernièrement, Scott Meyer a montré sur artima une façon [1] > de vérifier statiquement que les fonctions d'une famille > donnée appellent bien des fonctions de sous-familles > compatibles.
> [1] Sauf que quand ça compile sur notre compilateur, il ne > faut vraiment pas être pressé. C'est plus une démonstration > de faisabilité qu'autre chose.
Hors problème de complexité (liée à la sémantique du langage),
Je ne crois pas que ça soit lié à la sémantique du language. Mais...
je ne vois pas pourquoi il n'existe d'analyse (statique) du code.
Parce que l'état actuel de la technologie ne permet pas une analyse réelement intéressante. Il y a en fait deux aspects, assez distinct :
-- Ce que la fonction ne peut pas faire. Dans la pratique, le seul point intéressant ici, c'est la garantie que la fonction ne peut pas lever une exception ; dès qu'elle peut en lever une, qu'importe le type, il faut que ton code le prend en compte. À mon avis, l'analyse statique pourrait être appliquée ici, à condition de renoncer à la compilation separée (ou à condition de modifier profondement le modèle de compilation -- ce qui n'est pas forcément une mauvaise idée). Tout ce que je peux dire, c'est que cette analyse ne s'est pas imposée dans d'autres langages non plus, et que le C++ (à l'encontre de beaucoup d'autres langages) permet au moins une vérification à l'exécution.
-- Ce que la fonction fait. C-à-d que dans le cas de telle ou telle erreur, et lève réelement une exception d'un type donné. Actuellement, malheureusement, ça dépasse la technologie disponible.
Dans l'ensemble, je trouve que le C++ pourrait faire mieux à cet égard, mais les autres langages que je connais (par exemple le Java) font encore moins.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
On Oct 7, 5:45 pm, ALB <lebatt...@crans.org> wrote:
On 7 oct, 16:35, Luc Hermitte <luc.hermi...@gmail.com> wrote:
> On 6 oct, 23:58, ALB <lebatt...@crans.org> wrote:
> > existe-t-il un logiciel d'analyse de code qui permettent
> > de déterminer les spécifications des exceptions que chaque
> > méthode et fonction devraient avoir ?
> Même si cela existait (je ne le crois pas, mais on ne sait
> jamais), cela ne résoudrait pas le fait que les
> vérifications seront toujours réalisées de façon dynamique.
> Voulons-nous vraiment un programme qui plante en opération à
> cause d'un petit oubli couplé à une modification un peu trop
> hâtive ?
> Dernièrement, Scott Meyer a montré sur artima une façon [1]
> de vérifier statiquement que les fonctions d'une famille
> donnée appellent bien des fonctions de sous-familles
> compatibles.
> [1] Sauf que quand ça compile sur notre compilateur, il ne
> faut vraiment pas être pressé. C'est plus une démonstration
> de faisabilité qu'autre chose.
Hors problème de complexité (liée à la sémantique du langage),
Je ne crois pas que ça soit lié à la sémantique du language.
Mais...
je ne vois pas pourquoi il n'existe d'analyse (statique) du
code.
Parce que l'état actuel de la technologie ne permet pas une
analyse réelement intéressante. Il y a en fait deux aspects,
assez distinct :
-- Ce que la fonction ne peut pas faire. Dans la pratique, le
seul point intéressant ici, c'est la garantie que la
fonction ne peut pas lever une exception ; dès qu'elle peut
en lever une, qu'importe le type, il faut que ton code le
prend en compte. À mon avis, l'analyse statique pourrait
être appliquée ici, à condition de renoncer à la compilation
separée (ou à condition de modifier profondement le modèle
de compilation -- ce qui n'est pas forcément une mauvaise
idée). Tout ce que je peux dire, c'est que cette analyse ne
s'est pas imposée dans d'autres langages non plus, et que le
C++ (à l'encontre de beaucoup d'autres langages) permet au
moins une vérification à l'exécution.
-- Ce que la fonction fait. C-à-d que dans le cas de telle ou
telle erreur, et lève réelement une exception d'un type
donné. Actuellement, malheureusement, ça dépasse la
technologie disponible.
Dans l'ensemble, je trouve que le C++ pourrait faire mieux à cet
égard, mais les autres langages que je connais (par exemple le
Java) font encore moins.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
On 7 oct, 16:35, Luc Hermitte wrote: > On 6 oct, 23:58, ALB wrote:
> > existe-t-il un logiciel d'analyse de code qui permettent > > de déterminer les spécifications des exceptions que chaque > > méthode et fonction devraient avoir ?
> Même si cela existait (je ne le crois pas, mais on ne sait > jamais), cela ne résoudrait pas le fait que les > vérifications seront toujours réalisées de façon dynamique. > Voulons-nous vraiment un programme qui plante en opération à > cause d'un petit oubli couplé à une modification un peu trop > hâtive ?
> Dernièrement, Scott Meyer a montré sur artima une façon [1] > de vérifier statiquement que les fonctions d'une famille > donnée appellent bien des fonctions de sous-familles > compatibles.
> [1] Sauf que quand ça compile sur notre compilateur, il ne > faut vraiment pas être pressé. C'est plus une démonstration > de faisabilité qu'autre chose.
Hors problème de complexité (liée à la sémantique du langage),
Je ne crois pas que ça soit lié à la sémantique du language. Mais...
je ne vois pas pourquoi il n'existe d'analyse (statique) du code.
Parce que l'état actuel de la technologie ne permet pas une analyse réelement intéressante. Il y a en fait deux aspects, assez distinct :
-- Ce que la fonction ne peut pas faire. Dans la pratique, le seul point intéressant ici, c'est la garantie que la fonction ne peut pas lever une exception ; dès qu'elle peut en lever une, qu'importe le type, il faut que ton code le prend en compte. À mon avis, l'analyse statique pourrait être appliquée ici, à condition de renoncer à la compilation separée (ou à condition de modifier profondement le modèle de compilation -- ce qui n'est pas forcément une mauvaise idée). Tout ce que je peux dire, c'est que cette analyse ne s'est pas imposée dans d'autres langages non plus, et que le C++ (à l'encontre de beaucoup d'autres langages) permet au moins une vérification à l'exécution.
-- Ce que la fonction fait. C-à-d que dans le cas de telle ou telle erreur, et lève réelement une exception d'un type donné. Actuellement, malheureusement, ça dépasse la technologie disponible.
Dans l'ensemble, je trouve que le C++ pourrait faire mieux à cet égard, mais les autres langages que je connais (par exemple le Java) font encore moins.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Luc Hermitte
On 7 oct, 17:45, ALB wrote:
> Dernièrement, Scott Meyer a montré sur artima une façon [1] de > vérifier statiquement que les fonctions d'une famille donnée > appellent bien des fonctions de sous-familles compatibles.
S'agit-il de l'article <http://www.artima.com/cppsource/ codefeatures.html>
Oui.
-- Luc Hermitte
On 7 oct, 17:45, ALB <lebatt...@crans.org> wrote:
> Dernièrement, Scott Meyer a montré sur artima une façon [1] de
> vérifier statiquement que les fonctions d'une famille donnée
> appellent bien des fonctions de sous-familles compatibles.
S'agit-il de l'article <http://www.artima.com/cppsource/
codefeatures.html>
> Dernièrement, Scott Meyer a montré sur artima une façon [1] de > vérifier statiquement que les fonctions d'une famille donnée > appellent bien des fonctions de sous-familles compatibles.
S'agit-il de l'article <http://www.artima.com/cppsource/ codefeatures.html>
