Est-ce que les preuves exactitude de code jamais aller mainstream? [fermé]

Question

Tous les programmes les plus mais insignifiants sont remplis de bogues et donc tout ce qui promet de les supprimer est extrêmement séduisante. À l'heure actuelle, les preuves sont exactitude du code sont extrêmement ésotérique, principalement en raison de la difficulté d'apprendre cela et l'effort supplémentaire qu'il faut pour prouver un bon programme. Pensez-vous que proving code ne sera jamais décoller?

Answer 1

Pas vraiment dans ce sens, mais la programmation fonctionnelle pur est bon dans ce domaine. Si vous utilisez Haskell, il est probable que votre programme est correct si les compiles de code. À l'exception de IO, un bon système de type est une bonne aide.

Programmation également à contrat peut être utile. Voir Microsoft Code des marchés

Answer 2

  

Tous les programmes les plus mais triviaux

ne peut pas être complètement révélé être correct avec un effort raisonnable. Pour toute preuve formelle de correction, vous devez au moins une spécification formelle, et que les spécifications doit être complète et correcte. Cela est généralement rien que vous pouvez facilement créer pour la plupart des programmes mondiaux de réel. Par exemple, essayez d'écrire une spécification pour quelque chose comme l'interface utilisateur de ce site de discussion, et vous savez ce que je veux dire.

Ici, je trouve un bel article sur le sujet:

http://www.encyclopedia.com/doc/1O11-programcorrectnessproof.html

Answer 3

Le problème avec des preuves formelles est qu'il ne se déplace que le problème un pas en arrière.

Dire qu'un programme est correct équivaut à dire qu'un programme fait ce qu'il doit faire. Comment définissez-vous ce que le programme devrait faire? Il est spécifié. Et comment définissez-vous ce que le programme devrait faire en cas de pointe que la spécification ne couvre pas? Eh bien, alors vous devez faire les spécifications plus détaillées.

Alors disons que votre spec devient finalement assez détaillée pour décrire le comportement correct de tous les aspects du programme. Maintenant, vous avez besoin d'un moyen de rendre vos outils de preuve comprendre. Donc, vous devez traduire les spécifications dans une sorte de langage formel que l'outil peut comprendre la preuve ... Hé, attendez une minute!

Answer 4

La vérification formelle a parcouru un long chemin, mais le plus souvent l'industrie / outils largement utilisés en retard sur les dernières recherches. Voici quelques efforts récents dans ce sens:

Spec # http://research.microsoft.com/en-us/projects/specsharp/ Ceci est une extension de C # qui prend en charge les contrats de code (conditions pré / post et invariants) et peuvent utiliser ces contrats pour faire différents types d'analyse statique.

Des projets similaires à ce coexisteraient pour d'autres langues, comme JML pour Java, et Eiffel

a ce joli bien intégré.

Pour aller plus loin, des projets comme slam et blast peut être utilisé pour vérifier certaines propriétés de comportement avec annotation programmeur minimum / intervention, mais ne peut toujours pas faire face à la généralité des langues vivantes ( des choses comme dépassement d'entier / arithmétique de pointeur ne sont pas modélisés).

Je crois que nous verrons beaucoup plus de ces techniques utilisées dans la pratique à l'avenir. Le principal obstacle est que invariants du programme sont difficiles à déduire, sans annotations manuelles et les programmeurs sont généralement peu disposés à fournir ces annotations car cela est temps / trop fastidieux temps.

Answer 5

Non, sauf si une méthode de prouver automatiquement le code sans travail de développeur étendu se fait sentir.

Answer 6

Certains outils de méthodes formelles (comme par exemple DO-178C pour les logiciels critiques dans les avions civils. Ainsi, dans certains cas, ces approches sont possibles et utiles.

Bien sûr, le développement de logiciels moins buggy est très coûteux. Mais l'approche de la méthode formelle est logique pour un certain type de logiciel. Si vous êtes pessimiste, vous pourriez penser que le bug sont déplacés à partir du code à sa spécification formelle (qui peut avoir quelques « bugs », parce que la formalisation du comportement prévu d'un logiciel est difficile et sujette aux erreurs).

Answer 7

Je suis tombé sur cette question, et je pense que ce lien pourrait être intéressant:

Applications industrielles de Astrée

Prouver l'absence de RTE dans un système utilisé par Airbus avec plus de 130K lignes de code en 2003 ne semble pas être mauvais, et je me demande ce qu'il y aura quelqu'un dire que ce n'est pas du monde réel.

Answer 8

Non

. Le proverbe pour cela est: « En théorie, la théorie et la pratique sont les mêmes. Dans la pratique, non. »

Un exemple très simple:. Typos

En fait le code en cours d'exécution par les tests unitaires trouve des choses presque immédiatement, et un ensemble cohérent de tests niera le besoin de preuves formelles. Tous les cas d'utilisation - bon, mauvais, erreur, et cas limites -. Doivent être dénombrées dans les tests unitaires, qui finissent comme meilleure preuve le code est correct que cette preuve qui est distinct du code

Surtout si le changement des exigences, ou l'algorithme est mis à jour pour corriger un bug - la preuve formelle est plus susceptible de se retrouver à jour, même que les commentaires de code obtiennent souvent

.

Answer 9

Je pense que les limites imposées aux preuves exactitude en raison du problème de l'arrêt pourrait être le plus grand obstacle à des preuves correctness devenir mainstream.

Answer 10

Il est déjà utilisé par tout le monde. Chaque fois que vous utilisez la vérification du type de votre langage de programmation, que vous faites essentiellement une preuve mathématique de l'exactitude de votre programme. Cela fonctionne déjà très bien - juste vous devez choisir des types corrects pour chaque structure de la fonction et les données que vous utilisez. Le type, mieux vous allez vérifier pour obtenir plus précis. Les types existants disponibles dans les langages de programmation ont déjà des outils assez puissants pour décrire presque tous les comportements possibles. Cela fonctionne dans toutes les langues disponibles. C ++ et les langages statiques ne font que les contrôles dans la compilation, tandis que les langues plus dynamiques comme Python font quand le programme est exécuté. Le contrôle existe toujours dans toutes ces langues. (Par exemple, c ++ prend déjà en charge la vérification des effets secondaires de la même façon haskell fait, mais il vous suffit de choisir de l'utiliser.)