Standard di codifica più elevati per le lingue dinamiche?

La tua domanda contiene due elementi contraddittori:

1. che qualcuno userebbe la lingua con noncuranza e

2. che avrebbero seguito gli standard per il codice di produzione.

Qualsiasi programmatore che fa parte di una squadra che abbia degli standard per il codice di produzione non dovrebbe usare un linguaggio, dinamico o meno, incautamente. C'è molta esperienza con la scrittura di codice in linguaggio dinamico, a partire da Lisp molti, molti anni prima che Java fosse pensato.

Mentre i linguaggi non dinamici possono catturare degli errori in fase di compilazione, non catturerebbero errori come conversione errata da unità SI a unità inglesi, ecc. Per quanto ne so (e mi piacerebbe essere smentito ...) non esiste nessuno studio che abbia dimostrato che l'uso di linguaggi dinamici per scrivere programmi porti a più errori.

Molti programmatori che scrivono su questo, e su altri forum, esprimono opinioni forti in un modo o nell'altro, ma sospetto (nessuna prova, scusa ...) che ci sono molte più variazioni nelle abilità del programmatore e nella padronanza nell'usare buoni test che lì proviene dall'uso del linguaggio X sul linguaggio Y. (con la possibile eccezione di Ada ...)

Gli standard di codifica dovrebbero essere il più semplici possibile e, si spera, limitati ad evitare le caratteristiche linguistiche e gli idiomi che sono noti per essere problematici o guasti.

Troppe regole negli standard del programma possono indurre i programmatori a codificare codice sub-ottimale e illeggibile perché la soluzione migliore è stata dichiarata "cattiva" nel documento standard.

I linguaggi dinamici richiedono realmente standard di test più elevati . Poiché sono possibili più errori di runtime, e la natura tollerante dei linguaggi significa che errori di codifica semplici possono causare comportamenti strani in componenti apparentemente non correlati. Hai davvero bisogno di un buon set di test unitari per ogni singolo componente, oltre a un set completo di test di integrazione che dovrebbero essere eseguiti ogni volta che ogni pezzo di codice è cambiato.

Non tanto uno standard di codifica come una buona pratica, direi test aggressivi.

Come hai detto, ci sono rischi intrinseci con i linguaggi dinamici. Questioni che non sarebbero mai esistite nemmeno in un linguaggio statico possono e risulteranno in codice mal progettato o scritto in un linguaggio dinamico. L'applicazione di test unitari completi e ben scritti come parte del tuo processo ti aiuterà a garantire che il tuo codice sia corretto e privo di errori.

A quali "rischi intrinseci" stai pensando? Non riesco a pensare a nessun errore di runtime che possa verificarsi in Python o Ruby che non possa verificarsi in C # o Java. Le eccezioni del puntatore nullo, le eccezioni dei metodi mancanti e gli errori di conversione del tipo sono tutti possibili in C # e Java. In Java, aggiungiamo di nuovo tutto il comportamento dinamico mancante attraverso Spring e altri pacchetti stratificati su reflection. Questo abilita tutti gli errori di run-time inerenti i linguaggi tipizzati dinamicamente, tranne per il fatto che per correggerli devi setacciare attraverso diciassette strati di file di configurazione XML.

Connessione di linguaggi strongmente tipizzati al protocollo HTTP non tipizzato e il database SQL tipizzato in modo diverso in qualsiasi modo ragionevole richiede conversioni di tipi che non possono essere convalidati in fase di compilazione. Non credo che le lingue digitate dinamicamente richiedano una cura speciale. Indipendentemente dalla lingua, fornire codice affidabile richiederà test approfonditi.