Je m'intéresse à la conception de langage et en général, je peux facilement raisonner sur des fonctionnalités largement connues (par exemple, héritage, polymorphisme, délégués, lambdas, captures, garbage collection, exceptions, génériques, variance, réflexion, etc.), leurs interactions dans un langage particulier, les moyens de les implémenter, leurs limites, etc.
Au cours des derniers mois, j'ai commencé à lire sur Rust, qui possède un système de propriété qui garantit la sécurité de la mémoire et la gestion des ressources déterministes en forçant les durées de vie des objets à être statiquement vérifiables. Du point de vue d'un simple utilisateur de la langue, j'ai pu prendre le système presque immédiatement.
Du point de vue d'un concepteur de langage, cependant, il m'a fallu un certain temps pour comprendre pourquoi les choses à Rust sont exactement comme elles sont. Je ne pouvais pas immédiatement comprendre le raisonnement derrière certaines restrictions du système de propriété, jusqu'à ce que je me force à proposer des cas qui violeraient l'intégrité d'un système s'il n'avait pas ces aspects.
Ma question principale n'a rien à voir avec Rust et sa propriété en particulier - mais n'hésitez pas à l'utiliser comme exemple dans vos commentaires / réponses, si vous en avez besoin.
Lorsque les concepteurs de langage conçoivent une nouvelle fonctionnalité, quelle méthodologie ou processus utilisent-ils pour décider que la fonctionnalité fonctionne correctement?
Par "nouveau", je veux dire que ce n'est pas quelque chose qui a déjà été testé dans les langues existantes (et donc l'essentiel du travail a été fait par d'autres designers). Par «fonctionne correctement», je veux dire que la fonctionnalité résout correctement le problème prévu et qu'elle est raisonnablement à l'épreuve des balles. Par "à l'épreuve des balles", je veux dire qu'aucun code ne peut être écrit dans la langue ou un sous-ensemble particulier de la langue (par exemple un sous-ensemble sans code "dangereux") qui violerait l'intégrité de la fonctionnalité.
S'agit-il d'un processus d'essais et d'erreurs, dans le sens où vous proposez une forme simple de la fonctionnalité, puis essayez de trouver des moyens de la violer, puis de la corriger si vous la violez avec succès, puis répétez? Et puis, quand vous ne pouvez penser à aucune autre violation possible, vous espérez qu'il ne reste plus rien et l'appeler un jour?
Ou existe-t-il un moyen formel de prouver (au sens mathématique du terme) que votre fonctionnalité fonctionne, puis d'utiliser cette preuve pour obtenir en toute confiance la fonctionnalité (ou la plupart du temps) dès le départ?
(Je dois mentionner que j'ai une formation en ingénierie, pas en informatique. Donc, si je manque quelque chose qui serait évident pour les CS, n'hésitez pas à le signaler.)