Quel langage de programmation génère des bugs plus petit nombre de difficiles à trouver? [fermé]

softwareengineering.stackexchange https://softwareengineering.stackexchange.com/questions/22769

Question

Quelle langue, à votre avis, permet au programmeur moyen de sortie comporte avec le moins de bugs difficiles à trouver? Ceci est bien sûr, une question très large, et je suis intéressé à très large et des réponses générales et sagesses.

Personnellement, je trouve que je passe très peu de temps à chercher des bogues étranges dans les programmes Java et C #, alors que le code C a son ensemble distinct de bugs récurrents et Python / similaire a son propre ensemble de commun et des bugs stupides qui seraient détectés par le compilateur dans d'autres langues.

Je trouve aussi qu'il est difficile de considérer les langages fonctionnels à cet égard, parce que je ne l'ai jamais vu un programme vaste et complexe écrit dans le code entièrement fonctionnel. Votre entrée s'il vous plaît.

Edit: une clarification complètement arbitraire de bug difficile à trouver. Prend plus de 15 minutes pour se reproduire, ou plus de 1 heure pour trouver cause et solution

Pardonnez-moi si cela est un double, mais je ne trouve rien sur ce sujet spécifique.

Était-ce utile?

La solution

Le système de type plus puissant de la langue, plus les bogues seront pris au moment de la compilation lui-même.

La figure ci-dessous compare certaines des langages de programmation bien connus en termes de puissance, la simplicité et la sécurité de leurs systèmes de type. [ Source ]

text alt

* La prise en compte de la possibilité d'utiliser des constructions dangereuses.

C # se fait fourrer dans la ligne dangereuse en raison du mot-clé « dangereux » et les machines de pointeur associé. Mais si vous voulez penser à ceux-ci comme une sorte de sensation mécanisme de fonction étrangère en ligne libre de cogner C # vers le ciel.

J'ai marqué Haskell '98 pure, mais GHC Haskell ne pas pur à cause de la famille à risque * de fonctions. Si vous désactivez * à risque puis sautez GHC Haskell en conséquence.

Autres conseils

À mon avis Haskell vous aide à éviter certaines sources communes d'erreurs:

  • il est purement fonctionnelle: fonctions ne peuvent pas avoir (involontaires) des effets secondaires, ce qui rend la programmation multicœur plus facile et moins sujette aux erreurs
  • il est fortement typé: vous ne pouvez pas par exemple mélanger accidentellement bool, char, les valeurs int et float
  • il est statiquement typé: beaucoup d'erreurs de programmation sont prises au moment de la compilation
  • null ne fait pas partie des définitions de type valeur: par cela, vous évitez le milliards erreur dollar
  • il y a beaucoup de fonctions prêtes à l'emploi, d'ordre supérieur que vous pouvez réutiliser au lieu d'écrire votre propre, peut-être défectueux, les implémentations
  • il a un garbage collector: les erreurs de mémoire sont presque éliminés (sauf pour les « fuites d'espace » en raison de sa stratégie d'évaluation paresseuse)

Traditionnellement les plus difficiles à trouver des bugs sont interraciales conditions dans les applications multi-thread car ils sont

  • presque impossible de reproduire
  • peut être très subtile

Par conséquent, vous avez besoin des langues qui gèrent l'parallism pour vous autant et intrusive possible. Ce ne sont pas encore grand public. Java fait un peu, mais vous laisse avec la partie dure.

Pour ma compréhension, vous avez besoin d'un langage fonctionnel depuis le « non » est sideeffects la chose qui en premier lieu fait les deux points de balle disparaissent. Je l'ai vu que le travail est en cours pour faire de manière transparente Haskell efficace une langue multi-thread, et je crois que la forteresse a été conçu à partir du sol pour être un langage parallèle efficace.

Edit: poignée Java Executors encore plus des parties dures. Vous devez effectuer les tâches individuelles sont conformes à l'interface Callable.

Ada est conçu pour que le plus possible est pris au moment de la compilation plutôt que de l'exécution. Cela signifie qu'il faut souvent 10 fois plus pour obtenir un programme Ada compiler que l'équivalent serait en Java par exemple, mais quand il ne vous compilez peut être beaucoup plus confiant que des classes entières d'insectes ne se manifestent lorsque les est le programme run.

D'abord une définition:. Un bug difficile à trouver, si je comprends bien, est un bug qui peut être reproduit, mais la cause est difficile à trouver

Probablement l'aspect le plus important est ce que je qualifierais exiguïté , à savoir jusqu'où peut échapper un bug, la taille est la portée d'un bug peut potentiellement influencer. Dans des langages comme C, un bug, par exemple un indice de tableau négatif ou pointeur non initialisée, peuvent affecter littéralement tout partout dans l'ensemble du programme, donc dans le pire des cas, vous devez vérifier tout partout pour trouver la source de votre problème.

Les bonnes langues que l'aide concernant les modificateurs d'accès et les appliquer d'une manière qui rend difficile ou impossible de les contourner. Les bonnes langues que vous encourager à limiter la portée de vos variables, au lieu de le rendre trop facile d'avoir des variables globales (par exemple « tout pas déclaré explicitement est une variable globale avec un type de défaut et la valeur »).

Le deuxième aspect important est concurrency . Les conditions de course sont généralement difficiles à reproduire et donc difficiles à trouver. Les bonnes langues offrent des mécanismes de synchronisation faciles à utiliser, et leurs libs standard sont thread-safe si nécessaire.

Ceci termine déjà ma liste; d'autres choses comme le typage fort aide à des bogues de prises au moment de la compilation, mais ces bugs ne serait probablement pas difficile de trouver plus tard.

Compte tenu de tout cela, je dirais que Java et C #, et bien d'autres langues dans le monde JVM et .net, conviennent pour éviter les bugs difficiles à trouver.

Depuis Excel est le plus largement utilisé DSL, je vais aller avec Excel. (Hors VBA bien sûr)

Il correspond à la facture:

  • Il est toujours facile de reproduire (ici est une feuille de calcul - il ne fonctionne pas)
  • Il est assez facile de trouver le bug, car il est tout à fait « fonctionnelle » - commencer par la cellule qui est mal et de remonter toutes ses dépendances
    • .

Ceci est une question difficile parce que la plupart des bugs ne sont pas la faute de la langue elle-même -. Ils sont plutôt la faute des développeurs de faire des erreurs dans la façon dont ils utilisent la langue

Je crois qu'il ya plusieurs aspects des caractéristiques linguistiques qui affectent la probabilité de bugs:

  • Interactivité - langages dynamiques avec REPLs encouragent l'interaction / l'expérimentation avec des programmes en cours d'exécution et beaucoup plus petits cycles code / test. Si vous pensez que l'itération est une bonne façon de découvrir des solutions simples propres et détecter / éliminer les bugs alors cela aurait tendance à favoriser les langues interactives.

  • Expressivité -. Si le code est plus court et a moins boilerplate / complexité accessoire, alors il est plus facile de voir bugs / erreurs logiques

  • Sécurité Type - la vérification de plus de temps de compilation, plus de bugs seront pris par le compilateur si en toute sécurité générale de type est une bonne chose. Cependant ceux-ci ne sont généralement pas difficile à trouver de bugs - même dans une langue entièrement dynamique du mauvais type dans une structure de données généralement provoquer une erreur d'exécution très évidente, et TDD reprend presque toujours ce genre de bugs .

  • immutabilité - beaucoup de bugs durs sont dus à des interactions complexes de l'état mutable. Langues qui mettent en valeur immuabilité (Haskell, Clojure, Erlang) ont un énorme avantage par mutabilité évitant

  • Programmation fonctionnelle - approches fonctionnelles à l'écriture de code ont tendance à être plus code orienté "correct prouvable" que d'objets avec des séquences complexes d'effets / interactions. Mon expérience est que FP permet d'éviter les bugs difficiles -. Je crois qu'il ya quelque part un peu de recherche universitaire que je ne trouve pas actuellement que le dos ce haut

  • soutien Concurrency - problèmes de concurrence sont particulièrement difficiles à détecter et corriger ce qui est la raison pour laquelle cela est si important. Tout ce qui nécessite verrouillage manuel est finalement vouée à l'échec (et cela inclut à peu près tous approche orientée objet à la concurrence). Meilleur langue que je connais à cet égard est Clojure - il a une approche unique de la gestion de ce logiciel concurrency moissonneuses-batteuses mémoire transactionnelle avec des structures de données immuables pour obtenir un roman, cadre fiable et composable concurrency. Voir http://www.infoq.com/presentations/Value-Identity- État-Rich Hickey pour plus d'idées

Le langage un moins puissant, moins d'options, il vous donne de tirer votre pied.

langages de haut niveau comme Java et C # produira moins de bugs que les langages de bas niveau comme C ++.

Cela dit, je crois que Java est plus sûr que C #. Java est artificiellement si limité qu'un programmeur moyen sans connaissances avancées peut maîtriser et produire des programmes stables.

Quelle langue, à votre avis, permet le programmeur moyen de sortie Caractéristiques avec le moins de bogues difficiles à trouver?

A mon avis, Delphi. En se basant sur Pascal, le langage est assez simple et intuitive pour le programmeur moyen (ou même inexpérimentés codeurs) pour ramasser facilement, et son outil riche et soutien bibliothèque font la plupart des bugs faciles à trouver.

  • typage fort et un compilateur strict que les prises de nombreuses erreurs communes.
  • syntaxe intuitive qui ne favorise pas les erreurs communes. ( "Last Bug, du monde" if (alert = RED) {LaunchNukes;}, ne compilera pas, par exemple.)
  • Un modèle d'objet bien conçu qui élimine la plupart des erreurs C ++ communes POO.
  • et le contrôle Bounds vérifie la plage construit dans la langue, radicalement réduire les risques de problèmes de sécurité.
  • Probablement le compilateur le plus rapide connu à l'homme, ce qui augmente votre productivité et rend plus difficile de perdre votre train de pensée en attendant une construction.
  • Le débogueur débogueur de Visual Studio veut être comme quand il grandit.
  • Suivi des fuites construit directement dans le gestionnaire de mémoire, ce qui rend la mémoire, ainsi qu'éliminer les fuites trivial.
  • Une grande maturité bibliothèque standard offrant des moyens préconstruits et de pré-testés pour accomplir des tâches courantes sans avoir à construire vos propres implémentations, peut-être buggy.
  • Les navires avec des outils utiles, comme un système d'enregistrement puissant et un profileur, pour faire le suivi des problèmes plus facile.
  • Fort soutien communautaire pour les questions communes qui ne sont pas dans la bibliothèque standard, y compris d'un tiers parti puissant bibliothèque concurrency.

Une chose à prendre en compte est le temps de rotation.

Pour les cinq dernières années, je me suis principalement développé des applications web en Java (JSF, Seam, etc.). Récemment, je suis un nouvel emploi, et nous utilisons Perl (avec Catalyst et Moose).

Je suis beaucoup plus productif en Perl, que moi en Java.

Pas besoin de compiler et (chaud) Déployez, est une des raisons. Je trouve aussi que l'écriture des cas d'utilisation est plus facile, car il peut se faire de façon plus itérative. Et les cadres en Java semblent être complexes inutiles, au moins pour les projets que j'ai participé.

Je suppose que le nombre de bugs dans mon code Perl est plus ou moins le même que le nombre de bugs dans mon code Java, il pourrait même être plus élevé. Mais, je trouve et plus facile et plus rapide pour trouver et corriger ces bugs.

Peut-être que l'arpentage le nombre d'outils disponibles pour l'analyse statique et dynamique du code pour chaque langage de programmation pourrait donner une idée. Les nouveaux outils pour une langue, il est plus probable que la langue est soit très populaire parmi les utilisateurs ou très populaires pour générer des bugs difficiles à trouver. Mais je ne peux pas obtenir de Google me pointer vers une étude faite à ce sujet. Il convient également de noter que certaines langues telles que C peuvent être utilisés pour le travail autour des bogues matériels sous-jacents ainsi que le travail autour de l'usure du matériel à mesure qu'il vieillit.

Au lieu de parler de langues que de parler de langue caractéristiques

  • forces java vous de penser à des exceptions (lancers francs ...) et vous devez soit publisch ou gérer ces exceptions. Est-ce que me empêche d'oublier errorsituations vraiment ou que j'utilise plus d'exceptions qui sont dérivés de SystemException qui ne nécessitent pas cette manipulation?
  • Qu'en est « la conception par contrat » (http://en.wikipedia.org/wiki/Design_by_contract) qui me force à réfléchir avant et postconditions. J'ai lu qui est maintenant possible avec c # -4,0.
Licencié sous: CC-BY-SA avec attribution
scroll top