it-swarm.it

Quali sono le cinque cose che odi della tua lingua preferita?

Di recente c'è stato un gruppo di Perl-odio su Stack Overflow, quindi ho pensato di portare la mia domanda " Cinque cose che odi della tua lingua preferita " a Stack Overflow. Prendi la tua lingua preferita e dimmi cinque cose che odi di essa. Queste potrebbero essere cose che ti infastidiscono, hanno ammesso difetti di progettazione, problemi di prestazioni riconosciuti o qualsiasi altra categoria. Devi solo odiarlo e deve essere la tua lingua preferita.

Non confrontarlo con un'altra lingua e non parlare di lingue che odi già. Non parlare delle cose che ti piacciono nella tua lingua preferita. Voglio solo sentire le cose che odi, ma tollero in modo da poter usare tutte le altre cose, e voglio ascoltarle sulla lingua che avresti voluto che altre persone usassero.

Lo chiedo ogni volta che qualcuno cerca di spingere la mia lingua preferita su di me, e talvolta come domanda per l'intervista. Se qualcuno non riesce a trovare cinque cose da odiare per il suo strumento preferito, non lo conosce abbastanza bene né per sostenerlo né per ottenere i grandi dollari che lo usano. Non l'ha usato in abbastanza situazioni diverse per esplorarlo completamente. Lo sta sostenendo come cultura o religione, il che significa che se non scelgo la sua tecnologia preferita, mi sbaglio.

Non mi interessa molto quale lingua usi. Non vuoi usare una lingua particolare? Allora no. Passi la dovuta diligenza per fare una scelta informata e ancora non la usi? Belle. A volte la risposta giusta è "Hai un forte team di programmazione con buone pratiche e molta esperienza in Bar. Passare a Foo sarebbe stupido".


Questa è una buona domanda anche per le revisioni del codice. Le persone che conoscono davvero una base di codice avranno tutti i tipi di suggerimenti per esso, e coloro che non lo conoscono così bene hanno lamentele non specifiche. Chiedo cose del tipo "Se potessi ricominciare da capo in questo progetto, cosa faresti diversamente?" In questa terra fantastica, gli utenti e i programmatori possono lamentarsi di tutto ciò che non gli piace. "Voglio un'interfaccia migliore", "Voglio separare il modello dalla vista", "Utilizzerei questo modulo invece di questo altro", "Rinominerei questo insieme di metodi", o qualunque cosa essi realmente donino mi piace la situazione attuale. Ecco come ottengo un controllo su quanto un particolare sviluppatore sa della base di codice. È anche un indizio su quanto dell'ego del programmatore sia legato a ciò che mi sta dicendo.

L'odio non è l'unica dimensione di capire quante persone sanno, ma l'ho trovato abbastanza buono. Le cose che odiano mi danno anche un'idea di quanto bene stiano pensando all'argomento.

403
brian d foy

[~ ~ #] php [~ ~ #]

  • Quasi tutte le funzioni standard rientrano nell'ambito globale
  • Ordine degli argomenti delle funzioni incoerente
  • Denominazione di funzioni incoerente
  • Funzioni insensibili alle maiuscole
  • Lo script può comportarsi diversamente a seconda del file php.ini
  • Essere in grado di usare variabili indefinite
  • In alcuni casi è necessario assegnare un risultato a una variabile prima che possa essere utilizzato in una funzione

E molto più soggettivamente:

  • Digitazione dinamica
2
Yacoby

Python

  1. Non esiste Django per Python 3.
  2. Digitazione statica Sì, la digitazione dinamica è ottima, ma a volte a volte voglio renderla statica.
  3. Supporto unicode corretto (risolto in Python 3)
  4. Denominazione dei costruttori. Odio tutto questo sottolinea __in__ il mio codice.
  5. Le discussioni non sono molto efficienti
2
Davinel

LISP comune

  • le condizioni non sono classi (poiché le classi sono arrivate dopo), anche se la loro interfaccia è quasi identica
  • alcuni dei nomi sono semplicemente strani, ad es. flet/labels (unica differenza: scope) e defvar/defparameter (unica differenza: comportamento quando già definito) o una qualsiasi delle funzioni di bit-twiddling (dpb, ldb, ecc.)
  • i pacchetti sono ... davvero difficili da ottenere bene - ogni volta che penso di capirli, non fanno quello che voglio
  • le strutture e le funzioni di dati integrate non sono così generiche come potrebbero essere (ad esempio, perché non posso definire la mia funzione hash in modo portabile?)
  • più spazi dei nomi per funzioni, variabili, ecc. (Non sono contrario a questo in linea di principio, ma CL lo ha reso troppo complesso; Norvig ha detto che non può dirlo dalle specifiche ma sembra che ci siano almeno 7 spazi dei nomi)
2
Ken

Di gran lunga la cosa che odio di più della mia lingua preferita è che la mia scelta continua a cambiare. Ogni volta che penso di aver trovato The One, trovo cinque (o più) cose che odio al riguardo. E poi l'erba sembra più verde laggiù ...

2
WReach

Pitone:

Sono ancora un utente moderato per Python, quindi le mie lamentele potrebbero essere solo il blocco della conoscenza o l'uso improprio. I commenti sono ben accetti Adoro questa lingua.

  1. Supporto thread scadente e GIL. Se desideri utilizzare la piattaforma multicore, la maggior parte dei programmatori python probabilmente consigliano il multiprocessing o una sorta di ordinamento, non utilizzare il threading. Non ti darebbe le prestazioni che sei aspettando.
  2. proprietà solo per variabile d'istanza. _class_var = property (classmethod (some_method)) non funzionerebbe. Come posso ottenere una variabile di classe con wrapping di proprietà?
  3. nessun controllo di accesso. Tutti i controlli di accesso sono mangling di sintassi. Come privato è __privato, proteggere è _protetto, ecc ... E spero che tutti i programmi python segua la convenzione di denominazione. Dai, possiamo fare di meglio.
  4. Concordo con la filosofia python di essere sintassi semplice e chiara, ma alcune sintassi semplici e chiare non supportate sembrano blocco di buon senso, secondo me. Come, a ++, ++ a, a- - e --a, auto-de/incremento, cosa c'è di sbagliato in quelle? foo = (a> b? a: b) operazione unaria, cosa c'è di sbagliato in quelle? (So che py2.6 ha introdotto qualcosa di simile, ma dato il supporto massiccio di quasi ogni altra lingua per quella semplice sintassi, perché reinventare la ruota? perché non seguire semplicemente le migliori pratiche? Non dovrebbe essere una cosa buona mantenersi nella sua "forma"?)
  5. Programma per l'interfaccia. Python non ha interfaccia o concetto di classe astratta (py3k ha qualcosa chiamato abc), tutto è concreto. Fornire una parola chiave "interfaccia" o "astratta" per costruire scheletro di classe e proteggere ereditarietà ed estensione della classe penso che sia una cattiva idea. Aiuta a progettare dall'alto verso il basso. Attualmente, devo solo riempire ciascuno dei metodi con NotImplementedError, un lavoro piuttosto noioso.
  6. Devo aggiungere questo la versione inferiore a 3.x ha tipi str e unicode. Questo è un vero incubo. Fa in modo che la miscelazione ascii e non ascii/unicode abbia più probabilità di fallire (cattivo, cattivo)

Ho visto persone lamentarsi della velocità. Non capisco. È un linguaggio di interpretazione, il codice non viene compilato in codice macchina fino al runtime, questa è solo la sua natura. Non è possibile confrontare la velocità da un linguaggio interpretativo a uno compilato. Per quanto posso vedere, tra i linguaggi di interpretazione/scripting, python non è lento.

2
jimx

PHP:

  • Funzione assurd assert () ... esegue eval () sul codice all'interno
  • ?> Il tag rimuove eventuali newline che lo seguono ?!
  • Strana gestione delle stringhe numeriche (provale come chiavi dell'array)
  • Il supporto unicode doloroso che sembra non più sarà risolto da PHP 6
  • Il basso costo di iscrizione significa che il 95% dà a PHP un programmatore un nome orribile - e cercare di trovare qualcuno nel 5% da assumere è pazzesco.
2
user350443

LISP comune

  • Mancanza di librerie standard per funzionalità più moderne (socket, thread, ...)
  • Potrebbe utilizzare un'interfaccia utente standardizzata che si associa al sistema di finestre nativo
  • La capacità dello schema di assegnare un'espressione lambda a una variabile e di utilizzare la variabile direttamente come una chiamata di funzione sembra più ordinata che SI APPLICA per FUNCALL. Effetto collaterale di avere più spazi dei nomi, immagino
  • Sistema di packaging standardizzato a livello di sorgente per le biblioteche in modo che possano essere facilmente utilizzati da più implementazioni

Mi chiedo come sarebbe un LISP fortemente tipizzato

2

Sto andando fuori di testa dal momento che non posso davvero usarlo a tempo pieno, ma ci proverò comunque!

Perl 6

  1. func ("frew")! = func ("frew")
    • Mi dà fastidio, ma c'è una buona ragione per farlo. In Perl 5 print (5 + 6) * 10 ancora mi prende ogni tanto
  2. Potrebbe essere più semplice analizzare il Perl 5 in molti punti, ma a volte uccide ancora il mio editor
  3. Ha ancora un sacco di rumore di linea Perl 5 che spaventa molte persone. Ciò significa che è più difficile eccitarli ecc.
  4. Non ci sono ancora librerie.
    • Questo non sarà un problema se Perl 6 finirà per supportare Perl 5, ma potrebbe essere un onere che non vale la pena sopportare.
  5. Non c'è REPL, o ciò che i rubyisti chiamerebbero irb.
    • Un solido Perl 6 interattivo con completamento della scheda, codice colore, ecc., Renderebbe l'utilizzo e l'apprendimento molto più piacevole.
  6. Attualmente documentazione è sostanzialmente la specifica inglese. Non esattamente una lettura facile.
  7. So che è un cliché stupido, ma non è ancora uscito!
    • (Mi è permesso lamentarmi perché sto aiutando :-P)

I primi tre sono la lingua; il resto non è proprio la lingua stessa ma il fatto che non è ancora uscito.

2
Frew Schmidt

Perl

Adoro questa lingua e non voglio aggiungere cose che sono già state usate, ma nessuno lo ha ancora menzionato, quindi lo lancerò sul piatto. Quando ho usato questa funzione, l'ho trovata l'esperienza più orribile della mia vita (e ho lavorato in linguaggio Assembly):

  • Le funzioni write() e format().

Hanno la sintassi peggiore, più brutta e più terrificante che si possa immaginare, eppure non riescono a darti qualsiasi più funzionalità di quelle che potresti già ottenere con alcuni (infinitamente più carini) printf() lavoro. Nessuno non dovrebbe mai mai provare a usare queste due funzioni per eseguire qualsiasi output , semplicemente per quanto sono cattivi.

Sono sicuro che qualcuno non sarà d'accordo, ma quando ho guardato dentro di loro, sperando che potessero risolvere il mio problema, ho scoperto che erano un "mondo di dolore" (per citare il Grande Lebowski) e spero che Perl6 abbia eliminato o, meglio, riscritto completamente per renderlo un po 'più utilizzabile e utile.

2
Chris Lutz

Python

  1. La libreria standard non rispetta le proprie linee guida di stile in molti luoghi. (PEP-8)
  2. La super parola chiave di Py3k è piena di magia indesiderata (non puoi assegnarla a un nome diverso, funziona senza self , perché abbiamo questo parametro esplicito su tutti?)
  3. Il supporto Unicode è incompleto in Py2k e risucchia in Py3k (input standard in Unicode, nessun dato binario! WTF? La creazione di un nuovo standard WSGI è hacky.)
  4. The GIL. Supporto multi-threading molto limitato (con CPython)
  5. PyPI (Python Package Index) fa schifo. Sguardo invidioso ai rubygems
2
passy

Haskell

  1. A volte il sistema dei tipi si sente al contrario. Cosa succede se non desidero che il compilatore deduca i tipi per le mie variabili? E se volessi l'opposto, dove controlla i vincoli su dette variabili? Ad esempio, invece di inferire il tipo degli elementi di un elenco, si assicura invece che appartengano tutti a una particolare classe di caratteri. Questa è una differenza sottile ma enorme che mi rende difficile programmare le interfacce utente. Può essere fatto, ma richiede più sforzo di quanto non faccia in altre lingue. Haskell oscilla per le parti non UI, ma l'interfaccia utente lascio a un linguaggio non tipizzato.

  2. Consentire la costruzione di valori infiniti porta a volte ad alcuni errori davvero frustranti.

  3. NoMonomorphismRestriction.

  4. La manipolazione distruttiva mi morde nel culo a volte e non lo sai fino a quando il programma non si blocca perché li hai mescolati in modo improprio. Qualcosa non va qui, quando stiamo perdendo informazioni di tipo che avrebbero dovuto impedirlo.

  5. Le macchine da scrivere dovrebbero essere derivate automaticamente per casi banali, come i tipi di testimoni, ma c'è un forte potenziale di abuso lì.

2
user350201

[~ ~ #] c [~ ~ #]

  • È così flessibile e potente che è davvero facile scrivere codice davvero orribile o decisamente pericoloso (o, se preferisci, "con un grande potere derivano grandi responsabilità").
  • '=' per assegnazione e '==' per uguaglianza; facile da confondere nelle dichiarazioni "if".
  • L'implementazione di un numero di parti fondamentali della lingua dipende dal compilatore; per esempio. la dimensione dei tipi di base, l'ordine dei bit nei campi bit, il riempimento e l'ordine dei byte nei sindacati.
  • I campi di bit non sono parametrizzabili (vale a dire è possibile un array di ints, ma non è possibile avere un array di bit).
  • La gestione delle stringhe potrebbe essere migliorata.
2
Steve Melnikoff

c #:

1) i metodi statici devono essere membri di una classe

2) i metodi di estensione statica possono essere aggiunti solo alle classi statiche

3) L'implementazione delle funzioni dell'interfaccia non è contrassegnata da qualcosa come 'override' per mostrare che provengono da una classe o interfaccia base (rendendo difficile assicurarti di sovrascrivere il metodo che ti aspetti (con la firma corretta) con solo la revisione del codice) .

Ne ho solo 3. Immagino che sia abbastanza buono.

2

C #

So che è stupido, ma vorrei che i tipi di dati si convertissero in quello che volevo da solo, senza che io dovessi aggiungere (int) o Convert.ToInt32 o qualunque altra cosa. Mi farebbe solo risparmiare tempo. E mi dà fastidio che se scrivo qualcosa per produrre un int e poi mi risulta che ho bisogno di un long, allora spesso devo passare e cambiare tutto quello che ho fatto per fare funziona. Fallo solo per me!

Scusa, non potrei pensare a cinque, ma sono nuovo, quindi forse tornerò e ne aggiungerò altri più avanti: P

2
Sir Graystar

Cinque cose che odio del C++

  • Tempi di collegamento. Con build distribuite posso ricostruire il nostro intero progetto nello stesso tempo in cui il nostro linker deve funzionare.
  • Nessun modo standard per impedire il riordino delle operazioni di memoria. L'uso della memoria combinata in scrittura richiede in genere l'abuso della parola chiave volatile. La prevenzione del riordino in lettura (spesso fondamentale per l'ottimizzazione quando si ha a che fare con pipeline matematiche SIMD) viene in genere ottenuta tramite l'iniezione di un blocco ASM nullo nel mezzo di una routine.
  • Macro in più passaggi per aggirare i problemi di stringificazione:
#define STR_LINE2(x) #x#define STR_LINE(x)   STR_LINE2(x)#define LINE_NUMBER STR_LINE(__LINE__)
  • È generalmente doloroso eseguire la manipolazione delle stringhe.
  • Proliferazione di varianti di stampa non standardizzate (vsnprintf_s vs _vsnprintf_s).
2
Vorlauf

Python, di nuovo:

  1. Nessuna parola chiave switch. E NO, il dizionario non è un sostituto per questo. Neanche un mucchio di istruzioni Elif.

  2. Gestione ininterrotta della linea di interruzione. Perché posso fare:

     test = (1,
             2,
             3)
    

    E non:

    from itertools import cycle,
                          islice,
                          izip
    

    Perché non posso fare:

    if stuff \
       and foo \
       or bar:
        return "Formated string with %(arg)s" % \
               {'arg': "bloody slash"}
    

    senza usare le barre?

  3. Non esiste un modo ovvio e solo un modo per farlo. Python fallisce nel suo motto proprio come Java non è riuscito su "Scrivi una volta eseguito ovunque".

    # what somebody from an another language would do
    if not test.has_key('foo'):
        test['foo'] = 0
    n = test['foo'] = test['foo'] + 1
    

    vs

    # what an agnostic beginer would do 
    try:
        test['foo'] += 1
    except KeyError:
        test['foo'] = 1
    n = test['foo']
    

    vs

    # what you end up after looking for dictionary default value in the python doc
    test.setdefault('foo', 0)
    n = test['foo'] = test['foo'] + 1
    

    vs

    # what I would do
    n = test['foo'] = test.get('foo', 0) + 1
    

    E il peggio è che non fanno esattamente la stessa cosa. Ci sono sottili differenze.

  4. Scelta tra spazi e schede. Non ci dovrebbe essere scelta. Continua, mettilo nella pietra e smetti di combattere.

  5. Perché puoi farlo:

    test = {}
    test['foo'] = 0
    

    ma no:

    test = []
    test[] = 0
    

P.S: " ".join(l) è brava gente. Smetti di lamentarti, non è ovvio, ma con lo schema iteratore in mente, è solo il modo giusto per farlo.

2
e-satis

C #

  • Mancanza di invio multiplo in base al tipo di runtime degli argomenti del metodo. dynamic dovrebbe risolvere la maggior parte di questo, ma non è stato ancora rilasciato.
    • L'implementazione dell'interfaccia è dichiarativa e non strutturale. Mi piace molto il modo in cui la lingua Vai di Google sta facendo i tipi
    • Effettuare chiamate di metodo asincrone è davvero ingombrante (e sono abbastanza sicuro che tutti i thread siano thread del sistema operativo, non thread leggeri)
    • Nessun sistema macro. Non sto parlando di macro in stile C qui; Sto parlando di macro in stile LISP/Scheme
    • Gli operatori sono metodi statici e le loro firme sono eccessivamente vincolate (e non puoi crearne di nuove).
  • 2
    Robert Davis

    EL - Expression Language, il ${...} e #{...} cosa nelle pagine JSP e nelle facelet JSF 2.0 che viene utilizzato per estrarre i dati dal sottostante Java.

    • Tutte le cose divertenti, come le chiamate di metodo con parametri e la denominazione basata su annotazioni sono presenti solo in EL in Java EE 6 che è disponibile solo in Glassfish v3.
    • È una vera seccatura 1) ottenere i barattoli giusti per un precedente contenitore Servlet 2.5 e 2) farli funzionare senza interferire con nessuna precedente implementazione disponibile nel contenitore.
    • Avere solo una versione precedente di JSF come 1.2, elimina le chiamate di metodo e ti lascia lavorare con f: setPropertyActionListener - http://weblogs.Java.net/blog/2009/07/22/say-sayonara -spal - che, fidati di me, non è molto bello.
    • Il parser EL ha nessuna idea di dove provenga lo snippet da analizzare e interpretare, quindi tendi a dare a tutto un ID in modo da poter almeno identificare quale tag lo ha reso scontroso.
    • Eclipse avvisa ad ogni chiamata del metodo EL in quanto è JSF 1.2. solo troppo.

    C #

    • I tipi di riferimento sono nullable per impostazione predefinita; la parola chiave null in lingua non è tipizzata.
    • Mancanza di sindacati discriminati
    • Eccezioni come default , metodo di gestione degli errori non eccezionale - non c'è molta alternativa.
    • sintassi e limitazioni dell'istruzione switch arcaico
    • Inutile distinzione tra costruttori + metodi statici
    • I metodi statici non possono far parte di un'interfaccia
    • Mancanza di implementazione dell'interfaccia per forma piuttosto che dell'implementazione esplicita dell'interfaccia - che porta a numerosi hack di progettazione del linguaggio come la sintassi della query linq, foreach, collection e inizializzatori di oggetti - nessuno dei quali può essere riutilizzato in modo flessibile. Ad esempio, la sintassi dell'inizializzatore di oggetti può essere Nice, ma gioca male con oggetti immutabili.
    • Non è possibile ereditare "l'interfaccia" di una classe indipendentemente dall'implementazione, portando a duplicazioni di codice e codice sovra-progettato che fornisce interfacce, classi di base astratte, alcune implementazioni comuni e nessun modo per scegliere i bit di ciascuno da utilizzare. Anche; porta a troppi codici strettamente associati a un'implementazione particolare poiché è comune fare riferimento esplicitamente al tipo di implementazione piuttosto che a un'interfaccia.
    • Impossibile moltiplicare l'ereditarietà tramite composizione poiché una "interfaccia" di classi è strettamente associata alla sua implementazione; effettivamente mancanza di mixin.
    • Le suddette limitazioni delle interfacce portano a una proliferazione di interfacce praticamente identiche che non si sovrappongono naturalmente in alcun tipo di gerarchia di tipi. IComparable vs. IEquatable vs. IComparable<T> vs object.Equals vs. operator == ecc. ecc. Per estensione, creare un tipo personalizzato che soddisfi tutte queste cose è molto più lavoro del necessario (in particolare per le classi di raccolta). Ovviamente, i progettisti linguistici se ne rendono conto, quindi le varie soluzioni alternative per cose come linq, foreach e inizializzatori di raccolte che funzionano per forma piuttosto che per interfaccia.
    • Uso ridondante di parentesi e parentesi graffe piuttosto che layout-is-struttura.
    • I valori di ritorno possono essere ignorati, limitando l'efficacia dell'inferenza di tipo.
    • Gli enum non sono un tipo normale e non possono avere metodi. Inoltre, i valori enum non sono di tipo typesafe e possono essere inizializzati su 0 pur non avendo un valore 0. Mescolando metafore aggregando enumerazioni bandiera e non bandiera.
    • Mancanza di supporto del tipo di valore adeguato. I tipi di valore non possono essere ereditati, hanno una semantica del costruttore diversa e funzionano male a causa delle limitazioni del CLR. Inoltre, semantica confusa riguardo ai tipi di valore: alcuni valori sono in realtà valori (e non possono essere modificati), e altri sono riferimenti (variabili) non alias, non nulli. Ciò diventa particolarmente confuso per quanto riguarda il prossimo numero:
    • Distinzione semantica tra campi e proprietà, in particolare in combinazione con la mancanza di modificatore della mutabilità (ala C++ di const)
    • Non posso specializzare i generici
    • Impossibile fornire parametri di tipo generico predefiniti (ad es. Generici di fabbrica)
    • la mancanza di typedef rende i generici un problema da usare (using è un sostituto limitato ma utile!)
    • Non è possibile generarsi su cose diverse dai tipi (ad es. Funzioni, valori semplici o nomi). Ciò significa che non si può fare qualcosa come realizzare un'implementazione generica di una proprietà di dipendenza che porta, di conseguenza, a cattive implementazioni di cose come le proprietà di dipendenza e l'uso eccessivo di frammenti di codice e codice scarsamente leggibile.
    • Capacità limitata di specificare requisiti di tipo generico, ad es. metodo di somma generico che accetta sia int, double che bigint (senza hack complicati e spesso lenti).
    • L'implementazione di un metodo di interfaccia o l'override di un metodo virtuale non possono restituire un tipo più specifico o accettare un tipo più generale; vale a dire supporto limitato di co/contravarianza anche in C # 4.
    2
    Eamon Nerbonne

    Cinque cose in cui mi risento Nemerle:

    • Le funzioni locali non possono cedere
    • La capacità di compilare una lambda a volte dipende dal fatto che venga allineato
    • Semantica incoerente del valore/tipo di riferimento per le tuple
    • Ambiguità occasionale tra indici di array e argomenti di tipo
    • Mancanza di adozione generale
    2
    Don Reba

    C++

    • messaggi di errore criptici quando sono coinvolti modelli
    • mancanza di vincoli del modello (molti casi possono essere risolti con la metaprogrammazione del modello, ma ciò comporterà un codice illeggibile (almeno per i programmatori medi) nella maggior parte dei casi)
    • puntatore alla sintassi della funzione membro
    • il comitato per gli standard c ++ dovrebbe rilasciare standard ufficiali più spesso (o almeno rilasciare aggiornamenti separati alla libreria standard stessa), intendo davvero TR1 è stato rilasciato nel 2005 e non abbiamo ancora un common_ptr, bind e allo stesso modo nella libreria standard.
    • -
    2
    smerlin

    C

    1. campi bit: non sono ben specificati dalla lingua e dal modo in cui funzionano dipende dal compilatore e dall'architettura.
    2. Spesso è difficile trovare dove un particolare simbolo è definito in una grande massa di codice, esp. se quel simbolo è prodotto da una macro. Il che mi ricorda ...
    3. Il preprocessore è un trucco piuttosto brutto, suscettibile di ogni sorta di abuso.
    4. mancanza di numeri interi di dimensioni standard (risolto recentemente da uint * _t, ma c'è un sacco di vecchio codice che fluttua là fuori con typedef personalizzati o #define per DWORD, Word, BYTE, ecc.)
    5. Mancanza di qualcosa di simile al cpan.org di Perl (mi piacerebbe sbagliarmi su quello.)

    Modifica: Mentre pensavo a un CPAN per C, ho pensato ... come avrei chiamato una cosa del genere, e ho pensato di "ccan", e cercandolo su Google, mi sono imbattuto in questo: http: //ccan.ozlabs .org /

    Sembra essere ancora agli inizi.

    2
    smcameron

    R (Progetto R per statistiche)

    1. Supporto stringa terribile, terribile
    2. Sorprendentemente difficile per alcuni semplici compiti descrittivi, come la tabulazione incrociata
    3. La manipolazione di set di dati di grandi dimensioni viene eseguita in memoria.
    2
    Gregg Lind

    VBA (perché pensavi che la tua lingua fosse pessima)

    1. Lo spazio bianco all'interno di una linea viene applicato rigidamente.
    2. Le istruzioni terminano e richiedono un "_" per passare alla riga successiva, ma non tutte le righe possono essere interrotte.
    3. No ++, -, + =, - = istruzioni. Sul serio?
    4. Le matrici possono iniziare da qualsiasi indice, non solo da 0.
    5. Alcuni tipi (ovvero: valore "Decimale" in virgola fissa) devono essere sottotipi di Variante e non sono disponibili come tipo proprio.
    6. ! = e <>.
    7. "=" viene utilizzato sia come comparatore che come assegnazione, anziché dividere in "=" e "==".
    8. "Opzione esplicita".
    9. L'interfaccia utente non è stata aggiornata dal 2000.
    10. Office2k7 non si è aggiornato a VB.NET
    11. La maggior parte dei modelli di oggetti sono non sensuali e eccessivamente prolissi.
    2

    Python

    • Nessuna istruzione in lambdas. GRRRR
    • foo( a for b in c if d ) si sente male, mi sorprende ogni volta che me ne vado. Non dovrebbe essere foo( (a for b in c if d) )?
    • Posso avere una comprensione dettata?
    • gli operatori di mappe e filtri hanno una sintassi speciale nella comprensione degli elenchi, che ne dici di qualcosa da ridurre? o ordinare?
    • Solo avendo un'istruzione yield, una funzione viene magicamente trasformata in un generatore e la sua interfaccia cambia completamente. Inoltre, quel generatore non può fare alcun lavoro prima del primo next(). almeno, non senza usare una funzione che restituisce un generatore.

    JavaScript

    • Nessuna sintassi breve per creare librerie di codici modulari. Devi chiamare una funzione che restituisce un dizionario di metodi pubblici. E devi modificarlo in (almeno) due posizioni ogni volta che modifichi l'interfaccia del tuo modulo.
    • La creazione di chiusure comporta il ritorno da una funzione che restituisce una funzione dalla funzione ('sup dog) yo'. Ingombrare!
    • for each ( foo ) sintassi e comportamento sembrano ripensamenti.
    • Sapere quando verrà effettivamente eseguito il codice (e in quale ordine) è più di un'arte oscura. L'unico modo per farlo bene è mettere tutto (sì, anche quello) in un unico file di grandi dimensioni. e anche allora devi ancora aspettare un document.onload
    • Mi sto perdendo qualcosa? non esiste un modo banale per ottenere valori serializzati json senza crearli manualmente? (sì, jQuery può farlo, in un certo senso).

    Clojure

    • Mancanza di sintassi integrata per parametri facoltativi e di parole chiave nelle definizioni delle funzioni. Certo, puoi aggiungerlo abbastanza facilmente, ma ciò significa che gli scrittori di biblioteche non lo usano. La destrutturazione pervasiva non ha ancora dimostrato di essere un buon sostituto
    • Mancanza di combinazione di metodi (metodi prima/dopo/intorno all'ordinamento trovato in LISP comune)
    • Troppa dipendenza da Java interop, ad esempio non esiste un file IO incorporato
    • A volte voglio una digitazione statica. Questo non è puro odio; Di solito preferisco la dinamica e i tentativi di mescolare i due sono stati in gran parte insoddisfacenti
    • Non esiste un formato di serializzazione binaria veloce incorporato per le strutture di dati integrate, anche se ho sentito che ci stanno lavorando
    2
    Zak

    Per quanto riguarda C #:

    1. Odio che non ci sia una parola chiave per specificare quali eccezioni vengono generate da un metodo come in Java. È un modo molto migliore per documentare le eccezioni rispetto all'utilizzo di un commento XML.
    2. Vorrei anche una sintassi molto migliore per vincoli generici come oring e anding di vincoli.
    3. Perché un metodo non può restituire più di un valore?
    4. Mancanza di supporto per la programmazione orientata all'aspetto nella lingua.
    5. Perché non è possibile annotare ognuno degli accessori di proprietà con un attributo?
    6. Mancanza di supporto regexp incorporato come in Perl.
    2
    Ikaso

    C++ mancanza di buoni strumenti di refactoring, mancanza di eccezioni verificate

    Java mancanza di modelli, mancanza di const parola chiave

    2
    quant_dev

    Java - nessun supporto per la composizione a livello di lingua

    1
    Rostislav Matl

    C #

    1. Nessun modo semplice per verificare se un tipo è numerico
    2. Significa che probabilmente sei bloccato usando gran parte dello stack Microsoft, IIS e MSSQL
    3. Invece di essere uno strumento specifico per un problema specifico, C # cerca di essere un linguaggio per ogni paradigma.
    4. Mancanza di comunità. Certo, stanno iniziando a essere framework e librerie open source per C #. Gli stessi che sono stati disponibili per Java per anni.
    5. Difficile trovare un buon aiuto. Internet è disseminata di scarsi esempi di come risolvere i problemi con C #. Questo risale al problema n. 3.
    1
    CountCet

    [~ ~ #] Rebol [~ ~ #]

    REBOL è tra le mie lingue preferite. Non posso dire di avere un favorito, anche se Haskell è piuttosto alto.

    1. La sua strana sintassi spaventa molti sviluppatori prima ancora di provare.

      usa [url regole email] 
       
      
      ; A small DSL that sends email to people about URLs.
      rules: [
          some [
              into [
                  set email email!
                  set url url!
                  (send/subject email url reform [ "Check Out" url ])
              ]
          ]
      ]
      
      ; Global context
      notify: func [ [catch] dsl [block!] ] [
          unless parse dsl rules [
              throw make error! "You screwed up somehow."
          ]
      ]
      
       
       
       
       notifica [[[email protected] http://www.google.com] [[email protected] http: // www .yahoo.com]]
    2. I dialetti ricorsivi sono molto facili da convalidare con PARSE ma molto difficili da valutare. (Le pile possono essere utili qui.)

    3. REBOL ha un'integrazione molto scarsa con molte tecnologie popolari, in particolare XML. Sospetto che ciò sia in parte arroganza, perché REBOL BLOCK! tipo di dati può fare quasi tutto ciò che XML può fare. Tuttavia, il mondo reale ha XML.
    4. Nessun Unicode.
    5. Grazie ad AltMe, la comunità di utenti di REBOL è molto insulare. Posso capire perché vogliono usare AltMe. È scritto in REBOL e mostra i suoi punti di forza. Purtroppo li rimanda anche sulla loro piccola isola.

    Il prossimo REBOL 3 risolverà, si spera, molti di questi problemi, tranne l'ultimo.

    1
    Gregory Higley

    Sento che è impossibile scegliere una lingua preferita. La tipizzazione dinamica e la tipizzazione statica non possono essere paragonate, quindi elencherò solo quale delle quali utilizzo

    C++:

    • La sintassi della metaprogrammazione del modello è brutta. Un implicito ::value lo renderebbe molto più conciso
    • ->. Perché il compilatore non riesce a capire che sto facendo un ptr.thing e fai semplicemente -> per me?
    • Odio gli spazi bianchi. Quindi l'intero vector<vector<int>> deve essere vector<vector<int> > mi fa prendere i nervosismi e quindi non riesco a concentrarmi ogni volta che vedo quella riga di codice e finisco per provare a trovare un modo di usare int[][] o qualcosa
    • Macro. Personalmente adoro il concetto di macro. Ma con C++, I che il sistema è un hack
    • Sono un odio di ;

    Pitone:

    • Le stringhe sono immutabili. Lo rende quindi non posso semplicemente fare string [4] = "b"
    • Elenca la copia implicita per riferimento. Che perde in [[0] * larghezza] * problemi di altezza
    • Mancanza di ricorsione della coda (ho dovuto rigare IDLE per non sputare migliaia di messaggi di errore ogni volta che ho sbagliato a digitare una funzione ricorsiva)
    • Chiavi dei dizionari che non accettano liste/dadi
    • Mancanza di scopi profondi. Quando faccio una comprensione della lista, non voglio che la variabile in essa influisca sull'ambito esterno
    1
    Demur Rumed

    Python: la selezione delle parti di array non ti dà quello che hai richiesto.

    a [1] ti dà un elemento
    a [1: 2] ti dà un elemento, non [a [1], a [2]]
    a [1: 3] fornisce 2 elementi

    Lo odio, ma forse è solo perché lavoro principalmente in Verilog.

    1
    Marty

    Java è lento secondo molti, ma sono d'accordo con un certo grado di utilizzo.

    Java è drammatica. Hanno un sacco di lezioni solo per una sola cosa che vorresti fare. Ma conosci la proprietà di flessibilità XD.

    All'inizio Java è difficile ma divertente come sempre.

    Quando scrivi un semplice codice per stampare "Hello, World!" PER FAVORE NON USARE Java! XD Sono sicuro di essere giustificato.

    Java è una miscela, quindi non dire che è puramente un linguaggio OOP.

    Ce ne sono molti altri ma sono limitato a cinque XD. Grazie!

    1
    Richeve Bebedor

    C #

    L'odio numero uno per tutti gli animali domestici di C # deve essere:

    (1) Gli eventi hanno forti riferimenti a tutti gli ascoltatori, evitando così la garbage collection di tutto ciò che ascolta un evento. Se vuoi vedere i problemi che ciò ha causato, cerca semplicemente in rete tutte le persone che hanno cercato di risolvere il problema creando una sorta di "gestore di eventi con riferimenti deboli".

    (2) La necessità di verificare se un evento è uguale a null prima di chiamarlo sembra qualcosa che dovrebbe essere gestito dalla lingua.

    (3) Il serializzatore XML non ha modo di leggere/scrivere commenti in un file XML. Non eccezionale in un ambiente in cui i file XML vengono modificati sia manualmente che dallo strumento scritto in C #. Può essere aggirato semplicemente usando un XmlDocument non elaborato, ma sarebbe meglio essere in grado di sottrarlo a una classe.

    (4) Il processo di compilazione non ti consente di accedere direttamente a cose come i file xsd, invece hai bisogno di un passaggio intermedio in cui crei una classe parziale C #. Ciò causa anche problemi con i file XAML in cui è necessario ricostruire due volte a volte per consentire alle modifiche di fluire correttamente.

    (5) Nessun supporto per elementi intrinseci della CPU come MMX e SSE 1,2,3,4 e quindi queste preziose funzionalità della CPU non vengono utilizzate quando si eseguono app C #.

    Altri che non hanno fatto la mia top 5:

    (6) Impossibile contrassegnare i campi come proprietà, tutte le proprietà devono essere esplicitamente implementate dall'inizio:

    Per esempio. attualmente ha:

    public class MyClass {
        private int someInt;
    
        public int SomeInt {
            get {
                    return someInt;
            }
            set {
                    someInt = value;
            }
        }
    }
    

    Piacerebbe

    public class MyClass {
        [IsProperty(public, get, set)]
        private int someInt;
    }
    

    (7) Nessun supporto per più valori di ritorno, ad esempio:

    public int, string, double MyFunction()
    {
        ....
        return x,y,z;
    }
    
    
    public void TestMyFunction()
    {
        int x, string y, double z = MyFunction();
    }
    

    (8) Nessun supporto per i tipi di ritorno covarianti

    Ho qualche lamentela sull'implementazione generica, ma la taglierò lì. Penso che C # sia un ottimo linguaggio per eseguire tutte le GUI, le connessioni di rete e idrauliche di configurazione ed è la mia lingua numero uno per alzare le cose e andare velocemente in un modo che può essere supportato a lungo termine.

    1
    John Stewien

    C++

    1. Ci vuole così tanto tempo per creare un semplice frammento di codice.
    2. per (std :: vector :: const_iterator iter = [...]
    3. vector.remove () non viene rimosso.
    4. vector.Push_front () non esiste.
    5. file di intestazione
    6. No lambda
    7. Nessun distruttore virtuale vuoto automatico se esiste almeno una funzione virtuale.
    1
    user35978

    MEL (Maya Expression Language):

    • Matrici a dimensioni singole: Mi impone di sincronizzare manualmente due o più elenchi o utilizzare stringhe delimitate per simulare strutture di dati più complesse. Naturalmente sono anche immutabili.
    • Single threaded e slow: Causando il blocco dell'intera applicazione Maya mentre completa un'attività. Punti bonus per non poter uccidere operazioni lunghe, invece di dover chiudere e riaprire Maya.
    • I percorsi di approvvigionamento degli script non sono ricorsivi: Significa che tutte le directory in cui si desidera archiviare gli script devono essere tutte aggiunte al percorso degli script.
    • No namespace: Forzare l'uso incoerente delle convenzioni di denominazione per assicurarsi che le procedure globali non si scontrino.
    • Comandi modali: Ogni comando è modale, il che significa che le operazioni Crea, Modifica e Query sono tutte gestite impostando i flag. Ciò ha anche costretto gli sviluppatori a far restituire array alla maggior parte dei comandi
    • Stile di comando incoerente: La maggior parte dei comandi di array in realtà restituisce array, ma il comando Tokenize deve prendere un array come riferimento che poi popola, anziché sputare un array. Questo tra le altre incoerenze.

    Questi e molti altri motivi sono il motivo per cui AutoDesk ha adottato Python come linguaggio di scripting secondario, che fa apparire alcuni altri fattori fastidiosi:

    • Non tutti i comandi MEL sono supportati: Molti lo sono, ma ogni tanto ti ritrovi a dover usare la funzione mel () per eseguire un codice arbitrario. Quel che è peggio è tutta la fastidiosa fuga che devi fare per farlo.
    • Ereditato dallo stile di comando modale: Devo usare lo stesso create = True, query = True, edit = True stuff.
    1
    Soviut

    Pitone:

    • velocità
    • analisi statica (mancanza di)
    • funzioni anonime limitate a una espressione
    1
    orip

    My 5 for Delphi:

    1. Le procedure e le funzioni non sono necessariamente distinte dalle variabili se non parametrizzate (ad esempio, posso avere istruzioni come x: = GetPositionOnScreen; anziché x: = GetPositionOnScreen ();)
    2. Try/Infine e Try/Tranne devono essere nidificati (dichiarato una volta prima, ma è anche uno dei miei).
    3. Non sensibile a maiuscole e minuscole.
    4. Può avere più oggetti (funzioni, variabili globali, variabili locali) con lo stesso nome e Delphi cercherà felicemente di capire cosa intendi. i nomi dovrebbero essere univoci.
    5. Regole dispari se condizionate. un singolo controllo condizionale non richiede un () attorno ad esso, ma se eseguo più controlli, ho bisogno di un () attorno a ciascuno, e talvolta più set nidificati per controlli più grandi.
    6. Nessuna eredità inclusa. Se devo fare riferimento alla funzionalità dall'unità Windows in una base e in una forma ereditata, devo includere Windows in entrambi.
    1
    Tom A

    Quenya

    • La comunità è troppo piccola. È quasi impossibile avviare un buon programma di immersione linguistica quando non è facile trovare un altro oratore nelle vicinanze.
    • Verbi irregolari. Sì, so che anche l'inglese e lo spagnolo ne hanno parlato, ma il Quenya era inventato. Perché devono ancora esserci verbi irregolari?
    • Nessun supporto Unicode. Devo avere tre diversi tipi di carattere Tengwar sul mio computer prima di poter leggere la maggior parte dei messaggi e molti di essi sono mal studiati. Questo non sarebbe davvero un grosso problema data l'esistenza di una trascrizione romanizzata, ma Tengwar è così bello che non vuoi usarlo.
    • Non tutti i concetti possono essere facilmente citati in Quenya, portando a fastidiose circonlocuzioni o ricorrendo a Sindarin, Númenórean o (Manwë salvami) Klingon per ottenere il mio punto di vista.

    1
    user218368

    JavaScript

    Dalle specifiche ECMAScript 5:

    • 7.6.1.2 Parole riservate future:

      classe, enum, extends, super, const, export, import

      In modalità rigorosa: implementa, let, privato, pubblico, interfaccia, pacchetto, protetto, statico, rendimento

    • 11.9.4 The Strict Equals Operator (===) vs. 11.9.1 TheEqualsOperator (==)
    • 11.9.6 Algoritmo di confronto sull'uguaglianza rigorosa (NaN === NaN è falso)
    • 8.5 Il tipo di numero - Nessun numero intero reale, tutto è un float.
    • 4.2.1 Oggetti - eredità prototipale

    OK, mi piace un po 'l'ultimo, ma sono 7 tipi di confusione

    1
    thejefflarson

    C #

    1) Mancanza di capacità pratica di scrivere generici per tipi di valore. Ad esempio, qualsiasi idiota (bene la maggior parte degli idioti) può scrivere una routine che calcola la deviazione standard di un elenco di int, float, double, ecc. In C++, è semplice da scrivere, facile da leggere ed esegue come veloce codice non generico . Penso che se riesci a scrivere qualcosa in C # che è vicino a colpire uno di questi 3 senza essere ridicolo sugli altri 2, sei un programmatore davvero eccezionale.

    2) Covarianza e contro-varianza, sebbene questa sia aggiunta a 4.

    3) Documentazione estremamente scadente di LINQ (va bene, non proprio parte della lingua).

    4) Cercare di usare foreach/iterators quando voglio fare la stessa cosa ogni volta tranne qualcosa di leggermente diverso l'ultima volta (come concaticare un mucchio di stringhe con virgole tra loro e la Parola e tra le ultime due). Se lo scrivo con un IEnumerable, è difficile da scrivere e leggere, e con un for (int i = 0 i <...) non è molto meglio ed è meno efficiente.

    5) So che avrò lamentele a riguardo, ma mancanza di eccezioni verificate. Questo non ha bisogno di essere implementato così com'è in Java (Gli sviluppatori del framework fanno alcuni ottimi punti sul perché non lo hanno fatto), ma sarei felice con un compilatore avvertendo gli utenti a cui non piacciono le eccezioni controllate possono essere disattivati.

    1
    Brad

    Dobbiamo presumere che abbiamo una lingua. Noi?

    1

    Python

    Quelli che non capisco ...

    • math.ceil() e math.floor() restituiscono float, non numeri interi (probabilmente per evitare un overflow di numeri interi nella funzione C sottostante), ma perché non eseguire il cast in a Python long ?)
    • len() è una funzione non un metodo
    • reload() è molto limitato, non ricarica un modulo 9 volte su 10, ricarica un'etichetta importata solo se si tratta di un modulo - cioè non può fare from bar import foo; reload(foo) se foo non è esso stesso un modulo
    • Gli argomenti predefiniti mutabili hanno un unico riferimento (perché non una nuova istanza che ogni funzione chiama ?!)
    • Tutte queste variabili sottolineate: se sono così private, come mai ne vediamo così tante nel codice? Ottieni uno spazio dei nomi!
    • Le stringhe non sono modificabili - forse c'è una buona ragione per questo, ma mi sono imbattuto in molte situazioni in cui vorrei modificare un personaggio in particolare ...

    Quelli che hanno senso in base all'implementazione ma sono fastidiosi ...

    • array.sort() non restituisce un array (suppongo che avvenga sul posto)
    • La comprensione dell'elenco/generatore non definisce un nuovo ambito (è solo zucchero sintattico per un ciclo for, giusto?)

    e un paio che sono stati corretti in Python 3

    • Divisione intera per impostazione predefinita
    • global può fare riferimento solo allo spazio dei nomi di livello superiore
    1
    Brendan

    Pitone:

    1. Nessun toolkit GUI standard (la community gira e rigira su questo, ma sembra non accontentarsi mai di nulla).

    2. L'evoluzione di strumenti e metodi per distribuire e installare Python sono state, beh, rocciose. (Anche se ultimamente questo sembra avvicinarsi alla correzione).

    3. CPython è ancora lento come vanno gli interpreti (anche se PyPy sembra piuttosto buono in questi giorni, se diventa "standard" Python questo problema scompare).

    4. Non è possibile sottoclassare le classi integrate (ad esempio, list e dict) senza sovrascrivere molti metodi, anche se tutto ciò che si desidera fare è un semplice hook in un evento (ad esempio, hook in un elemento che viene aggiunto o rimosso dall'elenco, è necessario sovrascrivere delitem, aggiungere, estendere, inserire, pop e rimuovere - non esiste una notifica di evento "modifica" subclassabile, né alcun metodo "protetto" che elimini il codice comune utilizzato con tutti i metodi sopra indicati).

    5. Fino a quando virtualenv è stato inventato, tenere separati Python per scopi diversi su una macchina era un vero dolore.

    1
    user350432

    C #

    Sono molto contento di C # ma questi due mi danno davvero fastidio:

    • L'inizializzazione basata sul costruttore per le classi immutabili è meno conveniente, meno intuitiva (quando leggi il codice non capisci cosa assegni a cosa), ha meno IDE dell'inizializzazione di oggetti in linea. ti rende inevitabilmente incline alle classi mutabili. So che questo è stato menzionato prima, ma ho rigorosamente problemi con la sintassi di inizializzazione per le classi immutabili.

    • switch è troppo dettagliato. Ogni volta che vedo una situazione in cui un interruttore sarebbe corretto, sono davvero propenso a utilizzare un if..else if.. solo perché è più conciso (~ 30% in meno di battitura). Penso che non ci dovrebbero essere fallimenti per switch, break dovrebbe essere implicito e case dovrebbe consentire un elenco di valori separati da virgole.

    1
    Sedat Kapanoglu

    Scala:

    • stranezze di libreria standard: non mostra sempre le migliori pratiche ed è molto poco documentato
    • le classi FunctionX, TupleX codificate
    • mancanza di proprietà: getter e setter sono separati, il che viola il DRY e rende quasi impossibili cose come FRP
    • necessità di = _ per inizializzare le proprietà
    1
    thSoft

    Rubino:

    • Spazi significativi. Per l'interprete, end of line = end of statement, a meno che non sembri che l'istruzione debba continuare (o sfuggire esplicitamente alla nuova riga).
    • Lento
    • La documentazione online non è buona come quella di Python (in difesa, Python è eccellente)
    • Ho detto lento?
    1
    Joshua Swink

    Giava:

    1. Incoerente.
    2. Le API grafiche a volte sono difficili da usare
    3. NullPointerExceptions non ti dice cosa è null
    4. I programmi che scrivo a volte non funzionano su una JVM diversa, il che è una vera seccatura e contraddice l'affermazione "Scrivi una volta, corri ovunque" di Java.
    5. Swing non è buono come dovrebbe essere.
    1
    TomLisankie

    VB .NET, ma solo perché VB6 ha avvelenato un'intera generazione di programmatori

    Lavoro in un VB. Negozio .NET che era un negozio VB6, e ogni persona che lavora qui che era sviluppatori VB6 rifiuta ostinatamente di imparare qualcosa su .NET. Codificano come se fosse ancora VB6 e le loro app fanno schifo proprio come le app VB6. Il mio capo scoraggia attivamente qualsiasi uso di LINQ perché teme che sia troppo difficile da capire per gli altri, il che è vero perché nessuno vuole capirlo.

    Penso che staremmo tutti meglio se MS andasse con C #, il che mi uccide a dirlo perché penso che le parentesi graffe siano di gran lunga inferiori alle dichiarazioni verbali di chiusura di VB.

    1
    Bremer

    Rubino.

    1. Regole di scoping strane: variabili, costanti e metodi si comportano in modo diverso l'uno dall'altro. Le regole cambiano anche in base alla parola chiave utilizzata per creare una chiusura. O che tu sia in una classe, in una classe di oggetti, oggetto, modulo o modulo. Quindi c'è instance_eval, che cambia le regole in un diverso insieme di regole. E cambiano di nuovo quando un modulo è "incluso" o "esteso", che a loro volta fanno cose diverse per ambito. E alcune serie di regole non possono essere emulate dalla metaprogrammazione, quindi devi usare eval. A meno che tu non sia su Ruby 1,9, dove tutto questo è diverso.
    2. Il namespace è sostanzialmente inutile. Se hai Foo :: File, il file stdlib è probabilmente rotto per tutto Foo.
    3. l'istruzione obbligatoria è interrotta. Se due file si richiedono a vicenda, il comportamento di tali file può cambiare radicalmente a seconda di quale viene caricato per primo da altrove.
    4. le biblioteche cambiano le API in modo drammatico e improvviso, quindi è necessario richiedere specifici numeri di revisione minori di tutte le dipendenze. Per ogni singolo Ruby sul tuo sistema.
    5. Il sistema del pacchetto rubygems sostituisce "richiedi" anziché inserire i file nel percorso di ricerca, perché perché usare un sistema quando è possibile sostituirlo?
    1
    jes5199

    Python 3

    • sia schede che spazi consentiti per il rientro
      E pensi che le persone imparino dal passato (Makefile). Basta scegliere spazi e vietare le schede. YAML ha capito bene.
    • mancanza di librerie di terze parti popolari
      La libreria standard è fantastica, ma molto di ciò che rende Python 2 così potente si trova nel regno di terze parti. Python 2 ha ottenuto questo diritto: -).
    • IEEE float
      I punti fluttuanti nei linguaggi di programmazione sono confusi perché sono diversi dal modo in cui li usiamo in matematica. Al contrario, le operazioni numeriche devono essere visualizzate come espressioni che vengono convertite in un formato punto decimale solo quando necessario (ovvero stampa su uno schermo). Maple e Mathematica hanno fatto bene, credo.
    • il set di caratteri per gli identificatori è troppo limitato
      list.empty? È meglio di list.is_empty O addirittura len(list) != 0. Allo stesso modo, process.kill! Sarebbe meglio di process.kill. Ruby e LISP hanno capito bene.
    • quando si chiama una funzione è necessario sempre scrivere parentesi
      Sarebbe bello se potessimo ometterli in casi inequivocabili. Come è di nuovo? dict.items O dict.items()? Anche Ruby ha capito bene.
    1
    Tomas Sedovic

    Ruby

    1. Nessuna deduzione di tipo
    2. I metodi/le funzioni non sono oggetti di prima classe
    3. L'ambito delle variabili non è lessicale sebbene l'ambito delle variabili di blocco sia lessicale
    4. def dentro def
    5. la differenza tra super e super ()
    1
    jmuk

    Riscritto dopo qualche altro pensiero ...

    Cinque cose che odio di PHP anche se lo adoro (in nessun ordine particolare):

    • Denominazione incoerente e ordine dei parametri nelle funzioni integrate.
    • Approccio agli array orientato agli oggetti grazie a SPL ma purtroppo non alle stringhe (ancora).
    • Nessuna reale concorrenza in PHP stesso, solo tramite il multiprocessing dei server web di hosting
    • Nessuna chiamata asincrona come in JavaScript
    • Memorizzazione nella cache del codice operativo solo tramite estensioni. Non proprio male ma solo fastidioso.

    Quelle sono le caratteristiche del linguaggio (o la mancanza di) che mi infastidiscono, ma i problemi molto più grandi sono queste cose più legate alla gente/alla comunità:

    1. Il fatto che molte persone che usano PHP, non sanno nulla di programmazione e buone pratiche in generale e producono codice davvero disordinato. JavaScript ha lo stesso problema.

    2. L'enorme quantità di tutorial/libri che insegnano cattive pratiche e stile. Questa potrebbe essere la causa principale di # 3.

    3. La cattiva reputazione si è sviluppata principalmente a causa di # 3 e # 4.

    1
    selfawaresoup

    C #

    • I parametri generici sono invarianti C # 4.0 ha introdotto covarianza e contraddizione per tipi generici
    • I membri della classe sostituibili devono essere esplicitamente contrassegnati come virtuale

    Java

    • Tipi di dati numerici non firmati mancanti
    • I tipi di dati primitivi non sono oggetti
    1

    C è il mio preferito ma è anche orribile.

    • Ha il pre-processore peggiore di sempre. Perché non hanno usato qualcosa come m4?
    • L'intero modello di intestazione vs file di origine è rotto. Pascal ha capito bene con le unità.
    • Ha bisogno di intervalli di maiuscole nell'istruzione switch.
    • I sindacati e i cast di void * infrangono il sistema dei tipi. Questo rende impossibile la raccolta dei rifiuti.
    • Nessuna funzione nidificata. GNU C ha questo, ma dovrebbe essere standard.
    • Nessun controllo dei limiti per la memoria allocata. Ci sono strumenti che lo scoprono ma non rilevano errori in cui un pezzo di codice calcola erroneamente un indirizzo e scrive in un'area allocata che non è affatto correlata. Odio l'intera aritmetica del puntatore.
    • Nessun limite per la verifica di array.
    • Troppi problemi riguardanti la portabilità. Anche wchar_t differisce tra le piattaforme.
    1
    ahmet demir

    Posso aggiungerne un altro per Python:

    Dato un elenco l = [l1, l2, ..., ln], Quindi repr(l) = [repr(l1), repr(l2), ..., repr(ln)], ma str(l) != [str(l1), str(l2), ..., str(ln)] (str(l) = repr(l)). Questo è stato deciso perché ci sono potrebbe voci oscure nell'elenco come l = ["foo], [bar,", "],["] E str(l) restituirebbe "[foo], [bar, ], []" Che "potrebbe confondere gli utenti". Tuttavia, ciò rende impossibile utilizzare str solo per il dumping dei dati, poiché l'elenco elimina i "dati di dump in un formato leggibile". Augh!

    1
    Tetha

    Objective-C 2.0

    Attenersi strettamente alla lingua e al runtime, e non alle librerie, e non in alcun ordine particolare:

    1. Mancanza di cVars.
    2. Nessun modulo Non sono terribilmente scontento della mancanza di spazi dei nomi, ma i moduli sarebbero belli da avere.
    3. La sintassi della proprietà basata su Ivar richiede dichiarazioni che utilizzano il nome della variabile in 3 punti. È abbastanza orribile.
    4. C patrimonio. È presente qualsiasi cosa che odi del linguaggio C, ad eccezione di OO e GC, è presente.
    5. Gli oggetti non possono vivere in pila. Non è un problema con Obj-C tanto quanto ciò che fa per le pratiche di programmazione in altre lingue. Lo trovo strano quando ottengo un valore di ritorno nello stack in C++, per esempio. Se in realtà non sto guardando la documentazione della libreria quando scrivo il codice, suppongo che ogni funzione restituisca un puntatore, il che spesso rende necessaria una pulizia originale in seguito.
    0
    icodestuff
    • La proprietà length è facilmente confusa con la funzione length (); usa size () invece
    • La sintassi per interpolare la variabile nelle stringhe del selettore ('"+ $. Mese +"') puzza
    • $ (event.currentTarget) non funziona sempre per il bubbling e l'acquisizione
    • la sintassi dell'attributo funziona ("[class = 'foot']") in luoghi in cui la sintassi del selettore (".foot") non restituisce nulla
    • Contiene il selettore ([class ~ = done]) a volte non riesce dove JavaScript (this.className.search ("done")> 0) funziona
    0
    user350176

    Pitone:

    1) È un linguaggio di scripting e non completamente compilato (preferirei essere in grado di compilare binari, non mi interessa il bytecode). Questo è molto fastidioso se devo usare molte librerie (cioè tutti coloro che usano il mio programma devono installare tutte le librerie, e questo in pratica significa che nessuna persona normale sarà in grado, o avrà la pazienza, di configurarlo correttamente — a meno Faccio un sacco di lavoro che dovrebbe essere inutile). Conosco modi per creare binari, ma non sempre funzionano, e immagino comunque che raggruppino l'interprete nei binari (e non lo voglio). Ora, se potessi ottenere un compilatore bytecode che includa copie di tutti i file che ho importato (e solo quelli) da inserire nella cartella del mio programma, questo potrebbe essere un compromesso adeguato (quindi nessuno dovrebbe scaricare librerie extra e come). Sarebbe anche bello se i file compilati python potessero essere compressi in un singolo file con uno specificato come file per eseguire il programma prima di farlo.

    2) A volte sembra un po 'difettoso; ci sono state alcune volte in cui il codice che avrebbe dovuto funzionare semplicemente non ha funzionato (non c'erano errori del programmatore), in particolare codice relativo a "from moduleX import *" e altri problemi relativi all'importazione, nonché alcuni problemi relativi alle variabili globali e locali.

    3) La profondità massima di ricorsione potrebbe essere maggiore. C'è stato almeno una volta in cui ho sentito che ne avevo bisogno per andare più in alto.

    4) Nessuna istruzione switch (per non parlare di quella che consente numeri, stringhe e intervalli)

    5) Le più recenti Python sembrano eliminare molte utili operazioni sulle stringhe e non sembrano avere una semplice documentazione su come fare le stesse cose senza di esse.

    6) Garbage collection automatica forzata (vorrei essere capace per farlo manualmente, anche se non necessariamente costretto a farlo).

    7) Nessuna classe Timer preimpostata senza l'uso di una GUI (beh, potrebbe essercene una, ma dopo tutta la ricerca che ho fatto, sicuramente non è conveniente da trovare! In realtà ho trovato qualcosa, ma non l'ha fatto funziona affatto quando l'ho provato.) Per timer, intendo il tipo che eseguirà una funzione specificata ogni x secondi, con la possibilità di spegnerlo quando lo si desidera, ecc.

    8) Le persone nella comunità che danno esempi raramente raccontano quali moduli hanno importato e come li hanno importati.

    9) Non c'è molto supporto per l'integrazione con Lua.

    10) Non sembra esserci un modo per aggiungere una funzione extra a una particolare istanza di una classe (e non l'intera classe in generale), a meno che non si aggiunga dinamicamente una variabile oggetto a quella classe con l'oggetto che ha la funzione necessaria (ma comunque, devi fare un'altra lezione solo per quello).

    0
    Cordilow

    Pitone:

    • nessun delimitatore che segnala la fine dei blocchi introduce ambiguità in modo tale che il rientro automatico non funzionerà con codice mal formattato.
    • nessuna macro (i decoratori non contano)
    • nessuna libreria si carica automaticamente come la cabala di haskell o il CPAN di Perl
    • non posso dichiarare variabili const (sì, è possibile fare il proprio ruolo ma ...)
    • la meta-programmazione è nerfata
    • quasi dimenticato il Global Interpreter Lock
    0
    drhodes

    La mancanza di un preprocessore in C #.

    So che l'hanno lasciato fuori perché alcune persone possono abusarne, ma penso che abbiano buttato il bambino fuori con l'acqua del bagno. La generazione del codice è considerata una buona cosa, e in C++ il preprocessore era il mio generatore di codice di prima linea.

    0
    Mike Dunlavey

    C #

    5. L'operatore a coalescenza nulla

    Il ?? operatore ti permette di scrivere:

    x = y ?? z;
    

    invece di:

    x = (y == null) ? y : z;
    

    Mi piace questo operatore, ma ne voglio un altro:

    x = y ??? y.foo() : z.foo();
    

    invece di

    x = (y == null) ? y.foo() : z.foo();
    

    Uso sempre questo genere di cose e trovo fastidioso digitare la parte == null.


    4. Gli uguali dovrebbero avere un supporto migliore

    Devo iniziare ogni metodo Equals(object obj) con: MyClass other = obj come MyClass; se (altro == null) restituisce false;

    Dovresti solo scrivere:

    public override bool Equals(MyClass other) {...}
    

    E la lingua dovrebbe occuparsi di fornire il metodo Equals(object obj).
    NOTA: altro deve essere garantito per non essere nullo.


    . Non è possibile utilizzare l'operatore ternario con tipi diversi

    Questo non si compila e penso che dovrebbe!

    string foo = "hello";
    int bar = 4;
    object baz = foo == null ? foo : bar;
    

    2. Mancanza di spazio dei nomi privato

    Mi piace la protezione internal, ma vorrei che esistesse una protezione che consentisse l'accesso solo dallo stesso spazio dei nomi. Sarebbe bello controllare meglio l'accesso nelle librerie di grandi classi.


    1. Nessuna eredità multipla

    Uso l'ereditarietà dell'implementazione (di classe) solo per implementazioni predefinite di un'interfaccia, ma ci sono molte volte in cui voglio farlo.

    0
    tster

    VB.NET

    1) If Not x Is "foo" (invece di <> "foo")
    2) Cortocircuito "OrElse" e "AndAlso" (anziché semplicemente "Or" e "And", che agiscono diversamente)
    3) Nulla (anziché Null)

    0
    Techgration

    Ho appena scoperto che non posso usare Enum come vincolo di tipo durante la creazione di un metodo generico in c #.

    Microsoft ha una spiegazione abbastanza valida sul perché, ma comunque. Sono matto

    public static T MyFunc<T>(string arg) where T:Enum //wont work :(
    
    0
    Midhat

    Ne ho solo uno ma credo che valga la pena condividerlo.

    CSharp/.NET

    Abbiamo la proprietà Length per ottenere il numero di elementi nell'array e la proprietà Count per ottenere il numero di elementi nella raccolta. Sembra più strano se si considera il fatto che CLR aggiunge automaticamente IList, ICollection, IEnumerable alle matrici unidimensionali a base zero dietro la scena.

    Credo che il team CLR e il team BCL abbiano avuto difficoltà a discutere di questo argomento;)

    0
    Andrey Taptunov

    C

    • Gestione delle stringhe
    • Gestione della memoria (prendere una decisione su chi dovrebbe allocare e chi dovrebbe liberarlo)
    • Nessuno spazio dei nomi (il più grande)
    • Nessun elenco/array e altri di base DS nella libreria standard


    JavaScript

    • L'uso di una variabile senza var la rende automaticamente globale
    • I punti e virgola non sono obbligatori
    • Operatori di confronto "==" e "===" e confusioni sul loro utilizzo
    • Nessun supporto adeguato per lavorare su dati binari
    • Ancora .. Nessuno spazio dei nomi
    • Le variabili non hanno ambito di blocco. (Abbastanza irritante proveniente dal mondo C)
    0
    Manish

    Python

    • Nessuno spazio dei nomi.
    • Attributi pseudo-privati ​​/ manipolazione dei nomi (principalmente con getattr).
    • La manipolazione del percorso di file è distribuita su più moduli. Mettere insieme le chiamate os.path è brutto, difficile da leggere e, nella maggior parte dei casi, viola DRY. Le operazioni di percorsi di file comuni non hanno ancora funzioni utili, come ottenere un elenco di file in una directory. Il modulo path - type per risolvere questo problema è stato rifiutato.

    ([f for f in os.listdir('/file/path') if os.path.isfile(os.path.join('/file/path', f))])

    • Documentazione di Python (sono molto, molto, molto grato che ci sia della documentazione e che sia formattata in modo così gradevole, ma odio passare in rassegna 5000 linee di esempi di utilizzo con avvio rapido per trovare la documentazione delle singole funzioni per determinati moduli (I ti sto guardando optparse e registrazione)). I tipi incorporati sono documentati frammentariamente in quasi 10 luoghi diversi.
    0
    user297250

    HyperTalk:

    • È morto molto tempo fa
    • Nessun semplice compito (non puoi semplicemente dire a := 3, devi dire put 3 into a
    • Nessuna funzione nidificata
    • Nessuna vera struttura dati, solo stringhe. Per creare "elenchi", delimitare gli elementi con itemDelimiter e fuggirli manualmente. Puoi anche ottenere righe e parole come get Word 2 of line 5 of txt

    A parte questo, penso che una delle caratteristiche più interessanti esclusive di HyperTalk sia la speciale variabile it:

    ask "How many years old are you?"
    answer "You are " & it*12 & " months old."
    
    0
    Joey Adams

    JavaFX

    • L'inferenza del tipo a volte non si comporta come ci si aspetterebbe, quindi spesso è necessario dichiarare esplicitamente il tipo.
    • def si comporta come const in C e non definitivo in Java
    • puoi inserire un valore in una sequenza accedendo a un indice> = seq.length, che dovrebbe effettivamente generare un errore del compilatore (secondo il riferimento).
    • se si assegna null a una stringa, il valore predefinito è "". Se si assegna null a un numero intero, viene generato un errore del compilatore (contrariamente a quanto dice il riferimento).
    • gestisce CheckedExceptions allo stesso modo di RuntimeExceptions
    0
    helpermethod

    Lua

    • Se si esegue foo.bar (1,2), 'self' è nullo all'interno del metodo bar. Devi invece ricordare di fare foo: bar (1,2). Preferirei che fosse cambiato ('self' dovrebbe essere definito di default a meno che tu non usi l'operatore ':' o chiami una funzione che non è un metodo).
    • Le variabili sono globali per impostazione predefinita. Preferirei abbandonare la parola chiave "locale" e preferirne una "globale".
    • Alle variabili non dichiarate viene assegnato il valore zero. Preferirei ricevere un messaggio di errore. Puoi evitarlo manipolando la metafora dell'env globale, ma preferirei che fosse implementato per impostazione predefinita ed essere in grado di disattivarlo.
    • I valori multipli restituiti sui parametri non vengono gestiti molto bene. Supponi di avere una funzione foo () che restituisce 1,2,3 (tre valori) e bar () restituisce 4,5 (due valori). Se stampi (foo (), bar ()) otterrai "1,4,5" ... solo l'ultima "Tupla" viene espansa durante le chiamate.
    • L'operatore # (lunghezza tabella) funziona solo in tabelle indicizzate con numeri interi continui. Se la tua tabella non è così e vuoi sapere quanti elementi ha, devi analizzarla con un ciclo o aggiornare un contatore ogni volta che inserisci/rimuovi un elemento da esso.
    0
    kikito

    Giava:

    • Nessuna codifica procedurale, si compila in codice procedurale, quindi lasciatemi usare!
    • Nessuna eredità multipla, cercando di fare la stessa cosa con 15.000 interfacce succhiate.
    • Data classe, devo aggiungere altro.
    • Che non posso usare il polimorfismo fino in fondo. Java non sovrascriverà con diversi tipi di parametri da attivare.
    • Non riesco a pensare a un quinto motivo, se lo faccio torno a modificare questo post.
    0
    WolfmanDragon

    C #

    • Impossibile creare un riferimento (var & t = struct)
    • Nessun distruttore di portata locale (IDispose si avvicina ma non è lo stesso)
    • ToString, quasi non mi piace il fatto che ogni oggetto lo abbia, ma si scopre che non mi piace tutto quello che lo usa come string.format. Preferisco avere cose che accettano un certo tipo (come ints, float, text, solo caratteri). Quindi, invece di passare qualsiasi oggetto, devo passare qualcosa con un'interfaccia o un typecast implicito. Ho finito per scrivere qualcosa del genere per sfuggire in sicurezza al testo per HTML che funzionava alla grande.
    • Impossibile utilizzare un typecast virtuale (blah) obj; non funziona se obj non eredita/ha un'interfaccia di blah. Una semplice soluzione consiste nel fornire un'interfaccia con una funzione di conversione.
    • Non ha creazione locale. Invece di scrivere var o = new Item (); vorrei scrivere (qualcosa del genere) Item o() (con uno smaltimento automatico se ne ha uno).
    0
    user34537

    Pitone:

    1) sintassi di continuazione della linea: "... \" funziona, ma "... \" no, e quello spazio finale è generalmente invisibile, senza insolite marcature eol da editer.
    2) un 'rilancio' nudo è invisibile nella traccia dello stack, poiché la traccia dello stack sembra la precedente eccezione sollevata.
    3) lento
    4) scarsa integrazione nei web server (mod_python: dead, mod_wsgi: ambito operativo limitato). Questo è complicato da 3], che richiede una demonizzazione o una sorta di persistenza della memoria per funzionare bene.
    5) eccessivamente tollerante nei confronti di schede e spazi misti, consentendo a volte che le modifiche al controllo del flusso rimangano nascoste. (forse risolto nelle versioni recenti)

    0
    Rdbhost

    Lua:

    • Il sistema di errore integrato è assolutamente orrendo

      È possibile implementare un sistema try-catch modificando l'interprete Lua; ma non ha compatibilità con gli errori generati dalle funzioni integrate.

    • Il fatto che hanno __newindex invece di __setindex come setter

      ... e __newindex viene attivato solo quando la chiave non esiste già. In tal caso, nessun metametodo viene chiamato affatto.

    • Nessun buon sistema di confronto dei tipi.

      C'è la funzione type () ma gestisce solo i tipi di base (tutte le tabelle sono tabelle). Deve davvero avere un metametodo per i confronti dei tipi. L'ho già implementato prima con un operatore 'is' e un metametodo __type e funziona davvero bene.

    • È una cagna per definire nuove parole chiave.

      Puoi farlo, ma il codice all'interno di Lua non è ben documentato, quindi è una specie di prova ed errore scoprire come ottenere il risultato desiderato. Questo è un grosso problema quando vuoi implementare le cose che ho menzionato sopra di te (non tanto __setindex, questa è una semplice modifica).

    • Non posso usarlo in un browser web.

      Sì, non è davvero un problema con la lingua stessa, ma accidenti, mi piacerebbe poter usare Lua invece di Javascript ... :)

    0
    June Rhodes

    Oggetto Pascal:

    • C'è un sacco di salti avanti e indietro nel file che stai modificando poiché l'interfaccia e l'implementazione sono divise in due parti ma ancora bloccate nello stesso file.
    • Indicizzazione dinamica di array, le stringhe iniziano da 1, si specifica l'indice iniziale quando si dichiarano array fissi e gli array allocati dinamicamente iniziano sempre da 0.
    • Classi e oggetti (per non parlare delle interfacce) sono fissati in cima al linguaggio e, tra le altre cose, non possono essere allocati in pila come fanno i record.
    • Quando si chiamano funzioni senza parametri, il simbolo () è facoltativo, causando molto dolore quando si ha a che fare con i puntatori a funzione o si cerca di fare riferimento al risultato di una funzione usando il nome della funzione.
    • Gli elenchi di parametri non possono gestire tipi di array fissi o tipi di puntatori a funzione senza definizioni di tipi esterne.

    Questa è solo la lingua, la scusa scusa per una libreria standard e traballante IDE merita i propri elenchi.

    0
    user350677