Arguments de la fonction de typage dynamique - Comment maintenir la lisibilité élevée?

Question

Dynamique à taper le débutant ici, espérant des mots de sagesse sortis.

Je suis curieux de savoir s'il existe un ensemble de meilleures pratiques pour gérer les arguments de fonction (et soyons honnêtes, variables en général) dans des langages dynamiquement typés tels que JavaScript. Le problème que je rencontre souvent est en ce qui concerne la lisibilité du code: je regarde une fonction que j'ai écrite il y a quelque temps et je n'ai aucune idée de la structure des variables d'argument. C'est généralement OK au moment du développement d'un nouveau code: tout est frais dans ma tête, chaque variable et paramètre est logique parce que je viens de les écrire. Une semaine plus tard? Pas tellement.

Par exemple, disons que j'essaie de croquer un tas de données sur les séances d'utilisateur sur un site Web et d'obtenir quelque chose d'utile:

var crunchSomeSessionData = function(sessionsMap, options) {
    [...]
}

Sans tenir compte du fait que le nom de la fonction n'est pas utile - c'est évidemment une affaire énorme - je ne sais en fait rien du tout sur la structure de SessionsMap ou des options. OK .. J'ai K / V paires l'objet SessionsMap, car il s'appelle Map, mais la valeur est-elle primitive, un tableau, un autre hachage de choses? Qu'est-ce que les options? Un tableau? Une chaîne séparée dans l'espace blanc?

J'ai quelques options:

• Clarifiez la structure exactement dans l'en-tête de commentaire de la fonction. Le problème est que maintenant je dois maintenir le code à deux endroits.
• avoir un nom aussi utile que possible. Par exemple, userdoArrayoftimestampsmap ou même avoir une sorte de dialecte pseudo-hongrois pour la dénomination variable que je ne parle que ce que sont les types et comment ils sont imbriqués. Cela conduit à un code vraiment verbeux, et je suis fan de garder des trucs sous 80 col.
• Fonctionnera les fonctions jusqu'à ce que je ne passe que des primitives ou des collections de primitives. J'imagine que cela pourrait fonctionner, mais je finirais probablement avec des micro-fonctions qui ont une ou deux lignes au maximum, des fonctions qui n'existent qu'à des fins de lisibilité. Maintenant, je dois sauter partout dans le fichier et recomposer la fonction dans ma tête, ce qui a juste aggravé la lisibilité.
• Certaines langues offrent une détraction, ce qui, dans une certaine mesure, peut presque être considérée comme une documentation supplémentaire pour ce que le type d'argument va contenir.
• pourrait créer une "classe" pour le type d'objet spécifique, même si cela ne ferait pas une énorme différence dans un langage prototypal comme JS, et ajouterait probablement plus de frais de maintenance que nécessaire. Alternativement, si disponible, on peut essayer d'utiliser des protocoles, peut-être quelque chose dans le sens du deftype / defrecord de Clojure, etc.

Dans le monde dactylographié statiquement, ce n'est pas autant un problème. En C # par exemple, vous obtenez un:

public void DoStuff(Dictionary<string, string> foo) {[...]};

Ok, facile Peasy, je sais exactement ce que je reçois, pas besoin de lire l'en-tête de la fonction, ou de retourner à l'appelant et de déterminer ce qu'il conçoit, etc.

Quelle est la solution ici? Toutes les personnes se développent-elles dans des langues dynamiquement typées en permanence en permanence par quels types de leurs sous-programmes obtiennent? Y a-t-il des stratégies d'atténuation?