Quale linguaggio di programmazione genera minor numero di bug difficile da trovare? [chiuso]

Question

Quale lingua, a suo parere, permette al programmatore media per uscita dispone con il minor numero di bug difficile da trovare? Questo è, naturalmente, una domanda molto ampia, e mi interessa molto ampio e risposte generali e saggezze.

Personalmente trovo che spendere molto poco tempo alla ricerca di strani bug in Java e C programmi #, mentre il codice C ++ ha una serie distinta di bug ricorrenti, e Python / simile ha una propria serie di comuni e gli insetti stupide che verrebbe rilevato dal compilatore in altre lingue.

Anche io trovo difficile considerare linguaggi funzionali a questo proposito, perché non ho mai visto un grande e complesso programma scritto in codice del tutto funzionale. Il vostro contributo per favore.

Modifica: Chiarimento del tutto arbitraria di bug difficili da trovare:. Prende più di 15 minuti a riprodurre, o più di 1 ora di trovare la causa di e fix

Perdonami se questo è un duplicato, ma non ho trovato nulla su questo argomento specifico.

Answer 1

Il più potente sistema tipo di linguaggio, i più bug saranno catturati al momento della compilazione stesso.

La figura seguente confronta alcuni dei linguaggi di programmazione ben noti in termini di potenza, semplicità e sicurezza dei sistemi di tipo. [ Fonte ]

* Factoring nella capacità di utilizzare costrutti non sicuri.

C # viene farcito nella fila non sicuri a causa della parola chiave "non sicuro" e macchinari puntatore associato. Ma se si vuole pensare a questi come una sorta di linea funzione estera sensazione meccanismo libero di imbattersi C # verso il cielo.

Ho segnato Haskell '98 come pura, ma GHC Haskell come non dovuta puro al pericoloso * famiglia di funzioni. Se si disattiva * non sicuri poi saltate GHC Haskell di conseguenza.

Answer 2

A mio parere Haskell consente di evitare alcune fonti comuni di errori:

• è puramente funzionale: funzioni non possono avere (involontarie) effetti collaterali e questo rende multicore programmazione più semplice e meno soggetto a errori
• è fortemente tipizzato: non è possibile per esempio accidentalmente mescolare bool, char, int e valori float
• è staticamente tipizzato: molti errori di programmazione vengono catturati al momento della compilazione
• null non fa parte del definizioni del tipo di valore: da questo si evita il miliardi di dollari errore
• ci sono un sacco di funzioni di ordine superiore ready-made, che è possibile riutilizzare invece di scrivere il proprio, probabilmente difettosa, implementazioni
• ha spazzino: errori di memoria sono quasi eliminate (eccetto "fughe spaziali" grazie alla sua strategia di valutazione pigra)

Answer 3

Tradizionalmente i più difficili da trovare insetti sono race-condizioni di applicazioni multi-threaded in quanto sono

• quasi impossibile da riprodurre
• può essere molto sottile

Quindi è necessario lingue che gestiscono il parallism per voi tanto e unintrusively possibile. Queste non sono ancora mainstream. Java fa alcuni, ma vi lascio con la parte difficile.

Per la mia comprensione, è necessario un linguaggio funzionale dal momento che i "no effetti secondari" è la cosa che in primo luogo rende i due punti elenco andare via. Ho visto che il lavoro è in corso in modo trasparente rendendo Haskell un linguaggio multi-thread efficiente, e credo Fortezza è stato progettato da zero per essere un linguaggio parallelo efficiente.

---

Edit: In Java maniglia Executors ancora di più delle parti dure. Hai bisogno di fare i singoli compiti sono conformi all'interfaccia Callable.

Answer 4

Ada è progettato in modo che, per quanto possibile e 'colto al momento della compilazione, piuttosto che in fase di esecuzione. Che cosa questo significa è che spesso ci vogliono circa 10 volte più a lungo per ottenere un programma in Ada per la compilazione che l'equivalente sarebbe di esempio Java, ma quando lo fa compilare si può essere molto più sicuri che intere classi di bug non si manifesterà se stessi quando il programma di run.

Answer 5

In primo luogo una definizione:. Un bug difficile da trovare, se ho capito bene, è un bug che può essere riprodotta, ma la causa è difficile da trovare

Probabilmente la più importante aspetto è quello che chiamerei ristrettezza , vale a dire fino a che punto può una fuga bug, quanto grande è la portata di un problema potenzialmente in grado di influenzare. In linguaggi come C, un bug, per esempio un indice di matrice negativa o puntatore non inizializzato, possono influenzare letteralmente tutto ovunque in tutto il programma, così nel peggiore dei casi, si controlla tutto dappertutto per trovare la fonte del problema.

Buone lingue in che modificatori di accesso di supporto per quanto riguarda e farle rispettare in un modo che rende difficile o impossibile bypass loro. Buone lingue vi incoraggio a limitare l'ambito delle variabili, invece di rendere troppo facile avere le variabili globali (ad esempio, "tutto ciò che non esplicitamente dichiarato è una variabile globale con un tipo di default e il valore").

Il secondo aspetto importante è concorrenza . condizioni di gara sono generalmente difficili da riprodurre e quindi difficile da trovare. Buone lingue offrono meccanismi di sincronizzazione facile da usare, e le loro librerie standard sono thread-safe, se necessario.

Questo completa già mia lista; altre cose come forte aiuto tipizzazione per i bug di cattura in fase di compilazione, ma questi bug, probabilmente non sarebbe difficile trovare in seguito.

Considerando tutto questo, direi che Java e C #, e molte altre lingue in JVM e mondo .net, sono adatti per evitare bug difficile da trovare.

Answer 6

Dal momento che Excel è il DSL più utilizzato, andrò con Excel. (Escludendo ovviamente VBA)

Si adatta il disegno di legge:

• E 'sempre facile da riprodurre (qui è un foglio di calcolo - non funziona)
• E 'abbastanza facile da trovare il bug, come è del tutto "funzionale" - inizia con la cella che è sbagliato e risalire tutte le sue dipendenze
.

Answer 7

Questa è una domanda difficile, perché la maggior parte dei bug non sono colpa del linguaggio stesso -. Anzi sono colpa degli sviluppatori commettere errori nel modo in cui utilizzano il linguaggio

Credo che ci sono diversi aspetti di funzionalità del linguaggio che influenzano la probabilità di bug:

• Interattività - linguaggi dinamici con REPLs incoraggiano l'interazione / sperimentazione di programmi in esecuzione e molto più piccoli cicli di codice / test. Se credi che l'iterazione è un buon modo per scoprire soluzioni semplici pulite e rilevare / eliminare i bug allora questo tenderebbe a favorire lingue interattivo.

• Espressività -. Se il codice è più corto e ha meno boilerplate / complessità incidentale allora è più facile vedere gli errori bug / logici

• di sicurezza di tipo - la verifica più tempo di compilazione, i più bug saranno catturati dal compilatore così in sicurezza generale tipo è una buona cosa. Tuttavia questi di solito non sono è difficile trovare bug - anche in una lingua totalmente dinamico il tipo sbagliato in una struttura dati di solito causare un errore di runtime molto evidente, e TDD raccoglie quasi sempre questo tipo di bug .

• Immutabilità - un sacco di bug duri sono dovuti a interazioni complesse di stato mutevole. Lingue che sottolineano l'immutabilità (Haskell, Clojure, Erlang) hanno un enorme vantaggio evitando mutevolezza

• Programmazione funzionale - approcci funzionali a scrivere codice tendono ad essere più "dimostrabilmente corretto" di codice orientato agli oggetti con sequenze complesse di effetti / interazioni. La mia esperienza è che FP aiuta a evitare errori difficili -. Credo che ci sia un po 'accademica da qualche parte la ricerca che non riesco a trovare attualmente che esegue questa up

• Supporto concorrenza - problemi di concorrenza sono particolari difficili da individuare e mettere a punto, che è il motivo per cui questo è così importante. Tutto ciò che richiede bloccaggio manuale definitiva destinata a fallire (e questo include praticamente ogni object oriented approccio alla concorrenza). Miglior lingua che conosco in questo senso è Clojure - ha un approccio unico alla gestione concorrenza che il software combina la memoria transazionale con strutture di dati immutabili per ottenere un romanzo, quadro concorrenza affidabile e componibile. Vedere http://www.infoq.com/presentations/Value-Identity- Stato-Rich-Hickey per ulteriori delucidazioni

Answer 8

La lingua di una meno potente, meno opzioni ti dà per riprendere il proprio piede.

I linguaggi di alto livello come Java e C # produrrà meno bug di linguaggi di basso livello come il C ++.

Detto questo credo che Java è più sicuro di C #. Java è artificialmente limitato in modo che un programmatore medio senza conoscenze avanzate in grado di dominarlo e programmi stabili produrre.

Answer 9

Quale lingua, secondo lei, permette il programmatore medio di uscita Caratteristiche con la minor quantità di difficile da trovare bug?

A mio parere, Delphi. Essendo basato su Pascal, il linguaggio è abbastanza semplice ed intuitiva per il programmatore medio (o anche programmatori inesperti) per prendere facilmente, e il suo strumento ricco e libreria di supporto make maggior numero di bug facile da trovare.

• tipizzazione forte e un compilatore rigorosa che cattura molti errori comuni.
• sintassi intuitiva che non incoraggia gli errori più comuni. ( "Il Mondo nell'ultimo Bug," if (alert = RED) {LaunchNukes;}, sarà non compilare, per esempio.)
• Un modello a oggetti ben progettato che elimina molti dei comuni C ++ errori OOP.
• controllo dei limiti e la gamma checking costruiti per la lingua, drasticamente riducendo le possibilità di problemi di sicurezza.
• Probabilmente il compilatore più veloce che l'uomo conosca, che aumenta la produttività e rende più difficile perdere il filo del discorso, mentre in attesa di una generazione.
• debugger Il debugger di Visual Studio vuole essere come quando si cresce.
monitoraggio
• Perdita costruita direttamente dentro al gestore di memoria, facendo trovare e la memoria di fissaggio trapela banale.
• Un grande, maturo libreria standard fornisce precompilati e modi per realizzare attività comuni senza dover costruire il proprio, implementazioni possibilmente buggy pre-testati.
• Le navi con strumenti utili, come un potente sistema di registrazione e un profiler, per rendere più facile rintracciare i problemi.
• il sostegno della comunità forte per problemi comuni che non sono nella libreria standard, tra cui un potente di terze parti biblioteca concorrenza .

Answer 10

Una cosa da tenere in considerazione è il tempo di girarsi.

Per gli ultimi cinque anni o giù di lì, ho principalmente sviluppato applicazioni web in Java (JSF, Seam, etc.). Recentemente ho ottenuto un nuovo lavoro, e stiamo utilizzando Perl (con catalizzatore e Moose).

Sono modo più produttivo in Perl, che ero in Java.

Non dover compilare e distribuire (caldo), è uno dei motivi. Trovo anche che la scrittura casi d'uso è più semplice, in quanto può essere fatto in un modo più iterativo. E i quadri in Java sembrano essere inutili complessa, almeno per i progetti sono stato coinvolto in.

Credo che il numero di bug nel mio codice Perl è più o meno lo stesso del numero di bug nel mio codice Java, potrebbe anche essere superiore. Ma, trovo et più facile e veloce per trovare e correggere questi bug.

Answer 11

Forse rilevazione del numero di strumenti disponibili per statica e analisi del codice dinamico per ogni linguaggio di programmazione potrebbe dare un'idea. I più strumenti per una lingua, è più probabile che il linguaggio è sia molto popolare tra gli utenti o molto popolare nel generare difficile trovare bug. Ma io sono in grado di ottenere Google mi puntare a qualsiasi studio su questo argomento. Va inoltre notato che alcuni linguaggi come C possono essere utilizzati per aggirare il bug hardware sottostanti, così come il lavoro intorno l'usura dei componenti hardware con l'invecchiamento.

Answer 12

Invece di parlare lingue che dire parlando la lingua-caratteristiche

• java forze di pensare a eccezioni (tiri ...) e dovete o publisch o gestire queste eccezioni. Non che davvero mi impediscono di dimenticare errorsituations o sto utilizzando più eccezioni che sono derivati ??da SystemException che non hanno bisogno di questo trattamento?
• A proposito di "progettazione per contratto" (http://en.wikipedia.org/wiki/Design_by_contract) che le forze me pensare a pre e post-condizioni. Ho letto che è ora possibile con c # -4.0.