Que voulait dire Bill Gosper en disant qu'une structure de données n'est qu'un stupide langage de programmation? [fermé]

Il y a une citation de Ralph William Gosper, Jr qui dit:

Une structure de données n'est qu'un stupide langage de programmation.

Que voulait-il dire par là? Hélas, tout ce que je peux trouver dans Google à ce sujet est des copies / pâtes implacables de la citation elle-même, sans aucun contexte.

Eh bien, il semble que le cœur de la déclaration soit:

Une structure de données n'est qu'un ... langage de programmation

Ce qui est tout à fait vrai si vous y réfléchissez. Après tout, les compilateurs comptent tout le temps sur cette transitivité; ils prennent un langage de programmation, le convertissent en une structure de données, effectuent des transformations sur ces données, puis transforment le résultat en un autre langage de programmation.

En fait, si vous le vouliez, vous pourriez même rendre quelque chose de fou comme une structure de données C, qui vous permet d'écrire du code C en appelant ses différentes méthodes - par exemple (en quelque sorte en C #, car c'est ce que j'utilise en ce moment):

var C = nouveau HorribleCObject ();
C.Fonction <int> ("main", typeof (char [] []), typeof (int))
  .Variable ("i", typeof (int), 0)
  .Pendant ("i", Func (i) => i <10))
     .Call ("printf", "% d", "i")
     .PostIncrement ("i")
  .EndWhile ();
  .Retour (0)
 .EndFunction ();

Maintenant, en ce qui concerne la citation complète: pourquoi quelque chose comme ça serait stupide par rapport à (disons) écrire en C lui-même? Il devrait être assez évident que c'est verbeux et pas aussi lisible que son équivalent en C (et, dans la pratique, pourrait ne pas prendre en charge toute l'étendue de ce que C peut faire - typedefs serait délicat); par conséquent, cette structure de données n'est qu'un langage de programmation "stupide", intégré dans un "vrai" langage de programmation. Cette même logique peut être généralisée à n'importe quelle structure de données à laquelle vous pouvez penser; les listes chaînées ne sont qu'une version "stupide" de Lisp, et les cartes de hachage ne sont qu'une version "stupide" d'un langage de programmation Hash théorique (Hasp?).

Le fait est que nous ne voulons pas toujours écrire Hasp pour interagir avec nos cartes de hachage. C'est le problème que rencontrent toutes les langues spécifiques à un domaine - d'une part, un DSL bien implémenté est suffisamment puissant pour exprimer tout ce que le modèle sous-jacent peut faire; d'autre part, vous devez implémenter la DSL en premier lieu, puis d'autres personnes doivent l'apprendre. Cela prend du temps et des efforts qu'ils ne veulent probablement pas dépenser; après tout, je veux juste mettre des choses dans ma carte de hachage et ensuite vérifier que d'autres choses s'y trouvent, je ne veux pas apprendre toutes les subtilités de la programmation orientée hachage.

Donc, à peu près sans y penser, nous prenons ces langages de programmation théoriques très spécifiques et très intelligents et les distillons jusqu'aux quelques opérations stupides incorporées dans une structure de données. Une liste chaînée contient une petite collection de méthodes simples; une carte de hachage en a d'autres. Nous ignorons les autres opérations plus puissantes que vous pourriez potentiellement effectuer sur la structure de données (la plupart des implémentations LinkedList n'ont pas de fonction .Map ou .ForEach, par exemple, et je ne peux même pas imaginer ce que vous feriez dans Hasp), en faveur de leur implémentation explicite dans le langage de programmation parent - ce que la plupart des programmeurs vont connaître.

Les structures de données sont, pour l'essentiel, une stupide extension de leur langage parent dans l'espace du problème qu'elles représentent conceptuellement. Une extension suffisamment intelligente nécessiterait un nouveau langage de programmation spécifique, et la plupart des gens ne voudront pas l'apprendre.

Une structure de données est une REPRÉSENTATION d'un langage de programmation. Mais pas particulièrement "pointu".

Cela peut être vu à partir d'un "diagramme de nœuds" comme celui de l'article wiki ci-dessous:

http://en.wikipedia.org/wiki/Root_node#Terminology

Néanmoins, une structure de données est INCOMPLETE en tant que langage de programmation, car elle manque de syntaxe et de pensées complètes qui seraient intelligibles pour un programmeur. Le «langage» d'une structure de données pourrait être comparé à un enfant qui a dit quelque chose comme «Moi, froid. Obtenez un manteau».

Le «langage» est fracturé, mais peut être compris. L'enfant dit qu'il "a froid et qu'il aimerait plus de vêtements comme couverture". L'énonciation de l'enfant est une version "stupide" de la langue anglaise, et de même la structure des données par rapport à un langage de programmation.

Je crois que ce que Bill Gosper voulait, c'est que toutes les structures de données ne soient que des constructions de programmation avec une applicabilité limitée . Ceci est également lié à l'idée que "la conception de langage est la conception de bibliothèque et la conception de bibliothèque est la conception de langage" [1].

Une façon de penser la question est de considérer les structures de données uniquement sur une base algorithmique. Oubliez les exigences de stockage ou tapez des annotations pour le moment car elles sont tout simplement accessoires.

Par exemple, vous pouvez codifier un tableau associatif (appelé a mapdans certaines langues) de deux manières: soit en utilisant une sorte d'index stocké en mémoire, soit en utilisant une simple expression de casse.

Dans Haskell, vous pouvez codifier un tableau associatif en tant que structure de données ...

let assocArray = [("a", 1),("b", 2),("c", 3)]
let key = "b"
lookup key assocArray

... ou en utilisant une expression de casse ...

let key = "b"
case key of 
  "a" -> 1
  "b" -> 2
  "c" -> 3

... ou encore plus directement ...

let key = "b"
if key == "a" 
  then 1 
  else if key == "b"
    then 2
    else if key == "c"
      then 3
      else undefined

Il est facile de voir que ce type de mise en miroir entre les structures de données et le code est possible en regardant le calcul lambda. Toute valeur peut être représentée par une fonction dans le calcul lambda et le calcul lui-même est universel (turing complet).

[1] La citation est due à Bjarne Stroustrup.

Considérez Javascript, où toutes les données sont du code. Considérez LISP, où toutes les données sont du code et tout le code sont des données.

Au début, à la fin et partout entre les deux, les données ne sont que des bits. Que nous tentions d'ontologiser des bits avec du texte et des symboles pour les rendre facilement lisibles et transformables par l'homme est une couche d'abstraction qui nécessite a) Vous apprenez le langage de définition et b) vous apprenez la fuite de l'abstraction.

Par exemple, en C #, pour apprendre la différence entre une structure et une classe, vous devez apprendre la différence de comparaison d'égalité entre les types de valeur et les types de référence. Chaque ontologie de données nécessite son propre ensemble de règles que vous devez apprendre et respecter. Et, comme n'importe quel langage, il vous permet de vous rendre rapidement à l'idée générale, mais plus vous voulez approcher la vérité réelle de la question, plus vous devez simplement regarder le binaire vous-même.

Enfin, lorsque l'on considère un arbre B ou une structure de données similaire, naviguer dans la structure de l'arbre et y effectuer d'autres types d'opérations nécessite un type de syntaxe spécialisé qui n'est pas nécessairement transférable entre les arbres, les structures ou les langages.