Qual è il consenso generale su "L'uso inutile del gatto"?


41

Quando installo più comandi unix come grep, sed, tr ecc. Tendo a specificare il file di input che viene elaborato usando cat. Quindi qualcosa del genere cat file | grep ... | awk ... | sed ....

Ma recentemente dopo un paio di commenti lasciati sulle mie risposte che indicano che questo era un uso inutile del gatto, ho pensato di porre la domanda qui.

Ho esaminato il problema e mi sono imbattuto nell'articolo di Wikipedia su UUOC e The Useless Use of Cat Award e mi sembra che le argomentazioni fatte siano dal punto di vista dell'efficienza.

La domanda più vicina che ho incontrato qui è stata questa: è dispendioso chiamare gatto? - ma non è proprio quello che sto chiedendo.

Suppongo che ciò che il campo UUOC suggerisce sia di usare cmd1 args < file | cmd2 args | cmd3 ..o se il comando ha un'opzione per leggere da un file, quindi passare il file come argomento.

Ma a me cat file | cmd1 ... | cmd2sembra molto più facile da leggere e capire. Non devo ricordare modi diversi di inviare file di input a comandi diversi e il processo scorre logicamente da sinistra a destra. Primo input, poi il primo processo ... e così via.

Non riesco a capire quali argomenti vengono fatti sull'uso inutile di cat? Capisco che se sto eseguendo un lavoro cron che viene eseguito ogni 2 secondi e che fa molta elaborazione, allora in questo caso cat potrebbe essere uno spreco. Ma altrimenti qual è il consenso generale sull'uso del gatto?


16
Sono d'accordo, qui, la chiamata a cat può essere inefficiente, ma rende il comando molto più facile da capire e modificare in seguito, e (soprattutto, IMO) separa ogni comando diverso da avere un solo lavoro, rendendo il tutto molto più facile da gestire con.
Foshi,

4
Il consenso generale è che non esiste consenso.
jwg,

2
Questo in gran parte duplica stackoverflow.com/questions/11710552/useless-use-of-cat (anche se lo precede).
triplo il

1
Non dimenticare che < file cmd1 args | cmd2 args ...funziona anche ... quindi la tua argomentazione di "da sinistra a destra " è nulla. Lo uso spesso per chiarezza: l'ordine che ho mostrato può causare la pausa delle persone, il che non è buono. Con un numero di thread più elevato che diventa la norma, questo sta diventando meno un problema IMO ...
Attie

Risposte:


21

È inutile nel senso che usarlo in quel modo non compie nulla dell'altro, possibilmente opzioni più efficienti non possono (cioè produrre risultati corretti).

Ma catè molto più potente del semplice cat somefile. Consulta man cato leggi cosa ho scritto in questa risposta . Ma se hai assolutamente assolutamente bisogno solo del contenuto di un singolo file, potresti ottenere qualche vantaggio in termini di prestazioni dal non utilizzarlo catper accedere al contenuto del file.

Per quanto riguarda la leggibilità, questo dipende dai tuoi gusti personali. Mi piace catinserire i file in altri comandi per lo stesso motivo, soprattutto se gli aspetti relativi alle prestazioni sono trascurabili.

Dipende anche da cosa stai scrivendo. Se è la tua shell e i tuoi metodi di convenienza per la tua macchina desktop, nessuno tranne te ne importerà. Se ti imbatti in un caso in cui il prossimo strumento nella catena sarebbe meglio essere in grado di cercare e distribuire questo come un pezzo di software di uso frequente su un sistema Linux minimale su un router a basse prestazioni o un dispositivo simile con limiti reali su capacità di elaborazione, è diverso. Dipende sempre dal contesto.


3
I costi di performance sono trascurabili? In molti casi sono: oletange.blogspot.dk/2013/10/useless-use-of-cat.html
Ole Tange

15

L'uso quotidiano della riga di comando non è molto diverso. Soprattutto non noterai alcuna differenza di velocità poiché il tempo sulla CPU evitato non usando cat, la tua CPU sarà solo inattiva. Anche se esegui il ciclo tra centinaia o migliaia (o anche centinaia di migliaia) di elementi in tutta praticità, non farà molta differenza, a meno che tu non sia su un sistema molto carico (Load Average / N CPU> 1).

Il punto in cui la gomma incontra la strada sta nel formare buone abitudini e scoraggiare quelle cattive. Per trascinare fuori un cliché ammuffito, il diavolo è nei dettagli. Ed è dettagli come questo che separano il mediocre dal grande.

È come guidare una macchina, perché girare a sinistra quando invece puoi fare solo tre diritti? Certo che puoi, e funziona perfettamente. Ma se hai capito il potere delle curve a sinistra, allora tre diritti sembrano sciocchi.

Non si tratta di salvare un handle di file, 17k di RAM e 0,004 secondi di tempo CPU. Riguarda l'intera filosofia dell'utilizzo di UNIX. Il "potere delle svolte a sinistra" nella mia illustrazione non è semplicemente reindirizzare l'input, è la filosofia UNIX. Completamente grokking questo ti farà eccellere molto meglio di quelli che ti circondano e guadagnerai rispetto da quelli che capiscono.


2
Se stai pensando di svoltare a sinistra su un'autostrada trafficata a 6 corsie senza semaforo, allora potresti doverti considerare di svoltare a destra o prendere un percorso diverso. * nix ti offre la possibilità di scegliere tra diversi percorsi. È una questione di preferenze personali e leggibilità. Se vuoi "file cat | cmd1 | cat | cmd2 | altro", vai avanti. (A volte è utile se cmd1 impagina - cat lo eliminerà.) $ CPU time << $ Brain time.
MikeP,

1
@MikeP The catnon eliminerà alcuna impaginazione, sebbene il piping a qualcosa potrebbe eliminare il paging da alcune applicazioni.
triplo il

14

Uso spesso cat file | myprogramnegli esempi. A volte sono accusato dell'uso inutile di cat ( http://www.iki.fi/era/unix/award.html ). Non sono d'accordo per i seguenti motivi:

È facile capire cosa sta succedendo.

Quando leggi un comando UNIX ti aspetti un comando seguito da argomenti seguiti da reindirizzamento. Si è possibile mettere il reindirizzamento da nessuna parte, ma è raramente visto - così le persone avranno più difficoltà a leggere l'esempio. Credo

    cat foo | program1 -o option -b option | program2

è più facile da leggere di

    program1 -o option -b option < foo | program2

Se sposti il ​​reindirizzamento all'inizio stai confondendo le persone che non sono abituate a questa sintassi:

    < foo program1 -o option -b option | program2

e gli esempi dovrebbero essere facili da capire.

È facile da cambiare.

Se sai che il programma è in grado di leggere da cat, puoi normalmente supporre che sia in grado di leggere l'output da qualsiasi programma che emette su STDOUT, quindi puoi adattarlo alle tue esigenze e ottenere risultati prevedibili.

Sottolinea che il programma non fallisce, se STDIN non è un file normale.

Non è sicuro supporre che se program1 < foofunziona allora cat foo | program1funzionerà anche. Tuttavia, è in pratica sicuro assumere il contrario. Questo programma funziona se STDIN è un file, ma non riesce se l'input è una pipe, perché utilizza seek:

    # works
    < foo perl -e 'seek(STDIN,1,1) || die;print <STDIN>'

    # fails
    cat foo | perl -e 'seek(STDIN,1,1) || die;print <STDIN>'

Ho esaminato la penalità delle prestazioni su http://oletange.blogspot.dk/2013/10/useless-use-of-cat.html La conclusione è non usare cat file |se la complessità dell'elaborazione è simile a un semplice grep e le prestazioni contano più della leggibilità. Per altre situazioni cat file |va bene.


1
Finalmente una risposta con benchmark reali. Ho anche notato sul mio commento qui che il gatto "a volte" può essere più veloce. L'unica volta in cui riesco a immaginare che "l'uso inutile di cat" sia un vero svantaggio è se stai eseguendo un'elaborazione banale per i file huuuge (o se il processo può fare un uso speciale di stdin come il comando tail) ... unix.stackexchange. com / a / 225608/8337
rogerdpack

12

Penso che la posizione presa da alcuni di quei commentatori su qualcosa che è un UUOC è che se si capisce davvero la sintassi di Unix e shell, non si userebbe cat in quel contesto. È visto come usare una grammatica scadente: posso scrivere una frase usando una grammatica scadente e ottenere ancora il mio punto di vista, ma dimostro anche la mia scarsa comprensione della lingua e, per estensione, la mia scarsa istruzione. Quindi dire che qualcosa è un UUOC è un altro modo di dire che qualcuno non capisce cosa sta facendo.

Per quanto riguarda l'efficienza, se si sta eseguendo una pipeline dalla riga di comando, ci vuole meno tempo per l'esecuzione della macchina di cat somefile |quanto non faccia per pensare se potrebbe essere più efficiente da usare < somefile. Non importa.


6
Per un bel po 'di tempo ho saputo che c'erano altri modi per esprimere cat somefile | progin shell senza gatto, come, prog < somefilema mi sono sempre sembrati nell'ordine sbagliato, in particolare con una catena di comandi collegati. Ora vedo qualcosa di elegante come < somefile progil trucco, grazie. Ho esaurito le scuse che mi erano rimaste per usare il gatto.
Alex,

4

Non ero a conoscenza del premio fino ad oggi quando un novellino ha cercato di appuntare l'UUOC su di me per una delle mie risposte. Era un cat file.txt | grep foo | cut ... | cut .... Gli ho dato un pezzo della mia mente, e solo dopo aver visitato il link mi ha fatto riferimento alle origini del premio e alla pratica di farlo. Ulteriori ricerche mi hanno portato a questa domanda. Un po 'sfortunatamente, nonostante la considerazione consapevole, nessuna delle risposte includeva la mia logica.

Non intendevo essere difensivo quando lo educavo. Dopotutto, nei miei anni più giovani avrei scritto il comando come grep foo file.txt | cut ... | cut ...perché ogni volta che fai i singoli frequenti grepimpari il posizionamento dell'argomento file ed è subito noto che il primo è lo schema e quelli successivi sono i nomi dei file.

È stata una scelta consapevole quando ho risposto alla domanda con il catprefisso in parte a causa di un motivo di "buon gusto" (nelle parole di Linus Torvalds) ma principalmente per un motivo convincente di funzione.

Quest'ultimo motivo è più importante, quindi lo pubblicherò per primo. Quando offro una pipeline come soluzione, mi aspetto che sia riutilizzabile. È molto probabile che una pipeline venga aggiunta alla fine o giunta in un'altra pipeline. In tal caso, avere un argomento file per grep rovina la riusabilità e molto probabilmente lo fa silenziosamente senza un messaggio di errore se esiste l'argomento file. I. e. grep foo xyz | grep bar xyz | wcti fornirà quante righe xyzcontengono barmentre ti aspetti il ​​numero di righe che contengono sia fooe bar. Dover cambiare argomenti in un comando in una pipeline prima di usarlo è soggetto a errori. Aggiungi ad esso la possibilità di fallimenti silenziosi e diventa una pratica particolarmente insidiosa.

La prima ragione non è irrilevante, poiché un sacco di "buon gusto" è semplicemente una logica subconscia intuitiva per cose come i silenziosi fallimenti di cui non si può pensare proprio nel momento in cui una persona bisognosa di istruzione dice "ma non lo è quel gatto inutile ".

Cercherò comunque di rendere consapevole anche l'ex "buon gusto" che ho citato. Questa ragione ha a che fare con lo spirito progettuale ortogonale di Unix. grepnon lo fa cute lsnon lo fa grep. Quindi almeno grep foo file1 file2 file3va contro lo spirito del design. Il modo ortogonale di farlo è cat file1 file2 file3 | grep foo. Ora, grep foo file1è semplicemente un caso speciale di grep foo file1 file2 file3, e se non lo tratti allo stesso modo, stai almeno utilizzando cicli di clock del cervello che cercano di evitare l'inutile premio del gatto.

Questo ci porta all'argomentazione che grep foo file1 file2 file3sta concatenando e catconcatena, quindi è giusto, cat file1 file2 file3ma poiché catnon si sta concatenando, cat file1 | grep fooquindi stiamo violando lo spirito sia dell'uno catche dell'onnipotente Unix. Bene, se così fosse, allora Unix avrebbe bisogno di un comando diverso per leggere l'output di un file e sputarlo su stdout (non impaginarlo o altro solo uno sputo puro su stdout). Quindi avresti la situazione in cui dici cat file1 file2o dici dog file1e ricordi coscienziosamente di evitare cat file1di evitare di ottenere il premio, evitando anche dog file1 file2dal momento che si spera che la progettazione di dogavrebbe generato un errore se vengono specificati più file.

Spero che a questo punto simpatizzi con i progettisti Unix per non aver incluso un comando separato per sputare un file su stdout, nominando anche catconcatenare invece di dargli un altro nome. <edit>c'è un cane del genere, lo sfortunato <operatore. È sfortunato il suo posizionamento alla fine della pipeline che impedisce una facile componibilità. Non esiste un modo sintatticamente o esteticamente pulito di posizionarlo all'inizio. È anche sfortunato non essere abbastanza generale, quindi inizi con il cane ma aggiungi semplicemente un altro nome file se vuoi che sia elaborato dopo quello precedente. ( >D'altra parte non è male la metà. Ha un posizionamento quasi perfetto alla fine. In genere non è una parte riutilizzabile di una tubazione, e di conseguenza si distingue simbolicamente.)</edit>

La prossima domanda è: perché è importante avere comandi che sputano semplicemente un file o la concatenazione di più file su stdout, senza ulteriori elaborazioni? Un motivo è quello di evitare di avere ogni singolo comando Unix che opera su input standard per sapere come analizzare almeno un argomento del file della riga di comando e usarlo come input se esiste. Il secondo motivo è evitare che gli utenti debbano ricordare: (a) dove vanno gli argomenti del nome file; e (b) evitare il bug della pipeline silenziosa come menzionato sopra.

Questo ci porta al perché grepha la logica in più. La logica è consentire la fluidità dell'utente per i comandi che vengono utilizzati frequentemente e su base autonoma (anziché come pipeline). È un leggero compromesso dell'ortogonalità per un significativo guadagno nell'usabilità. Non tutti i comandi dovrebbero essere progettati in questo modo e i comandi che non vengono utilizzati di frequente dovrebbero evitare completamente la logica aggiuntiva degli argomenti dei file (ricordare che la logica aggiuntiva porta a una fragilità non necessaria (la possibilità di un bug)). L'eccezione è consentire argomenti di file come nel caso di grep. (a proposito, nota che lsha un motivo completamente diverso per non solo accettare ma praticamente richiedere argomenti sui file)

Infine, ciò che avrebbe potuto essere fatto meglio è se comandi eccezionali come grep(ma non necessariamente ls) generano un errore se è disponibile l'input standard. Ciò è ragionevole perché i comandi includono una logica che viola lo spirito ortogonale dell'onnipotente Unix per comodità dell'utente. Per ulteriore comodità dell'utente, vale a dire per prevenire la sofferenza causata da un guasto silenzioso, tali comandi non dovrebbero esitare a violare la propria violazione avvisando l'utente se esiste la possibilità di un guasto silenzioso.


1
Come discusso sul duplicato cross-site di questa risposta e domanda, grep pattern f1 f2 f3non è semplice concatenazione . grepconosce i file e stampa i nomi dei file (e facoltativamente i numeri di riga e quant'altro). grep . /sys/kernel/mm/transparent_hugepage/*è un bel trucco per stampare il nome del file: file-content con molti file a riga singola. Il classico design Unix prevede che la maggior parte delle utility funzioni *.txtsenza necessità cat. catserve per appiattire più file in un flusso.
Peter Cordes,

@PeterCordes Non ho scritto molto solo su grep. Vi sono problemi sostanziali che ho riscontrato in merito alla solidità agli errori / copia-incolla; correttezza vs prestazione, che hai comodamente scelto di ignorare a favore di alcune preoccupazioni meschine / periferiche.
randomstring

Fai alcuni punti interessanti e validi, in particolare sugli errori che puoi ottenere durante la copia / incolla delle pipeline. Suggerirei di sostituire il tuo grepesempio con un programma del genere cutche non ha alcun motivo di preoccuparsi di più file e potrebbe sempre essere alimentato dal suo stdin. Alcune utility, come tr, non accettano affatto i file arg e funzionano solo come filtro, quindi la scelta è tra cate <.
Peter Cordes,

1
Il mio più grande problema con il tuo post è che sconto reindirizzamento input. <file cmd1 | cmd2 >outnon è meraviglioso, lo ammetto, ma è del tutto possibile abituarsi. Continui a parlare dello "spirito dell'onnipotente Unix" in un modo beffardo, il che mi crolla totalmente perché sembra che tu non capisca o non desideri come pensavano davvero i designer di Unix. Va bene se non ti piace il design Unix, ma non è intrinsecamente stupido. Non sono sicuro che il design del sistema operativo preceda la sintassi della shell e come si sia evoluto tutto, ma catvale la pena evitare un extra nel 1970!
Peter Cordes,

1
@PeterCordes Con il senno di poi ero piuttosto prolisso nella mia risposta, che toglie il punto più importante: la correttezza prima, l'ottimizzazione in secondo luogo. Il supplemento cataiuta a riutilizzare e giuntare tubazioni, mentre senza di essa è possibile ottenere guasti silenziosi (cercare "silenziosamente" nella mia risposta).
randomstring

2

In difesa degli Usi Inutili del Gatto

(Alcuni paragrafi per aiutare a bilanciare lo tsunami di commenti assillanti contro questa pratica)

Sto usando bash da troppi anni sia come shell che come linguaggio di scripting per script piccoli (e talvolta con rammarico per quelli non così piccoli). Molto tempo fa ho imparato a conoscere "Useless Use of Cat" (UUoC). Ne sono ancora colpevole almeno ogni settimana, ma sinceramente mi sento raramente obbligato a evitarlo. Credo che usare catvs < filesia più legato al gusto che alle differenze tecniche e ho scritto questa risposta per proteggere le persone nuove di Linux per le quali condivido il mio gustocatdal pensare che ci sia qualcosa di gravemente sbagliato nella loro strada (e notare le poche occasioni in cui c'è). Come Linus Torvalds, credo anche che spesso il gusto sia più importante dell'abilità. Ciò non significa che i miei gusti siano migliori dei tuoi, ma significa che se qualcosa ha un cattivo sapore non lo farò senza guadagnare qualcosa di degno.

È già ovvio che come l'autore della domanda ritengo che l'uso di cat sia molto naturale quando si lavora su un REPL come bash in cui sto esplorando un problema costruendo in modo incrementale comandi complessi. Ecco un esempio molto tipico: ho un file di testo e non ne so molto. Scriverò cat fileper avere un assaggio dei contenuti. Se l'uscita è troppo mi ha colpito la mia freccia e, a seconda delle circostanze io aggiungo | heado | grep fooo | what_everestendere il mio comando precedente aggiungendo fasi di lavorazione. Questo modo di passare gradualmente da un semplice comando a uno più complesso aggiungendo una fase di elaborazione dopo l'altra mi sembra molto naturale (sto facendo lo stesso su ipython e adoro il modo in cuipyfunctionale strumenti di programmazione simili comprendono questo stile). Quindi, quando lavoro sulla shell bash, sono fiducioso che interrompere il mio flusso per rimuovere catè più inutile di quanto non lo sia e soffrire ... beh, nessuna conseguenza del 99,9% dei casi.

Naturalmente quando si scrivono script le cose potrebbero cambiare. Ma anche quando scrivo sceneggiature, penso che le persone che deridono l'UUoC ignorino queste importanti lezioni con una grande mente: "L'ottimizzazione precoce è la radice di tutti i mali" . E se non stai facendo qualcosa di atipico, è davvero difficile per UUoC essere il luogo in cui sarà necessaria l'ottimizzazione. Ovviamente devi assolutamente sapere cosa c'è di inefficiente al riguardo (è l'invocazione di processo extra BTW poiché pochi sembrano menzionarlo). Avendo questa conoscenza se ti capita di lavorare su quei rari sistemi in cui invocare un processo è costoso (ad esempio alcuni sistemi embedded o CygWin in misura minore) saprai cosa fare se una situazione speciale lo richiede. Ad esempio se ti trovi a chiamarecatmolte volte al secondo in un ciclo (a proposito se ti trovi in ​​quella posizione chiediti se bash è lo strumento giusto per il lavoro). Ancora una volta: "prima fallo funzionare correttamente, quindi ottimizzalo se necessario" .

E come spieghi lo tsunami delle lamentele su UUoC Nick?

Oltre a non tutti i miei gusti, credo che una parte importante del motivo per cui così tante persone si lamentano dell'UUoC non sia tecnica ma umana: la maggior parte dei neofiti di Unix non conosceranno il < file commandlinguaggio, quindi è allettante per una persona più esperta interpretare il "Vecchio Guru" " a loro. Avrà anche l'opportunità di usare parole fantasiose ("invocazione di processo") e toccare il caro argomento di "ottimizzazione". Una buona impressione è garantita, quindi è molto difficile resistere. Quindi i nuovi arrivati ​​prenderanno il consiglio del Guru a valore nominale e per lungo tempo lo ripeteranno ad altri come "L'unica verità" (e voteranno in basso questa risposta :-). Nota divertente: probabilmente è così facile risolvere bash per evitare inefficienze di UUoC che ci si deve chiedere perché nessuno abbia aggiunto questa funzionalità o fatto< filenamecat un file dopo tanti anni. Un'anima oscura suggerirebbe che ad alcuni hacker colpiti con la barba grigia piace lasciare opportunità per deriderci ;-)


+1 Adoro l'ultimo paragrafo sul perché i fattori antropologici che propagano questa pratica :-)
randomstring

1

Ciò che sarebbe davvero bello è una shell che supporta la sintassi come:

< filename cmd | cmd2 cmd2arg1... | cmd3

Nel frattempo, penso cat filename | realcmd1...sia accettabile, poiché mantiene la sintassi standardizzata con comandi iniziali che richiedono il nome file come argomento.


17
Supporto di bash e shell simili < filename cmd | cmd2 .... È abbastanza vicino?
garyjohn,

@garyjohn: penso che dovresti pubblicarlo come risposta.
Kevin Reid,

14
Commento obbligatorio del vecchio hacker di shell: le shell in stile Bourne hanno supportato < file command ...almeno la metà degli anni '80 e probabilmente fino agli anni '70 quando è shstato scritto l'originale . Più in generale, i reindirizzamenti di I / o vengono analizzati da sinistra a destra e possono essere intervallati in qualsiasi ordine all'interno della riga di comando. Quindi, cmd <file arg arg...sarebbe anche valido.
Dale Hagglund,

3
Sì, è in parte a causa di quanto sia facile digitare quello che ho inventato l'UUOC.
Randal Schwartz,

2
Un personaggio spostato contro quattro non spostato non è una grande differenza, e preferirei generare un processo aggiuntivo, che persino il mio telefono nota a malapena, piuttosto che reindirizzare un file nel mio prompt, che mi dà mal di testa ogni volta che lo vedo .
Aaron Miller,

0

Per tutti coloro che dicono che il gatto è accettabile da usare perché "profuma di meglio" o "è più leggibile" Direi solo questo:

A te forse ... ma non agli altri che potrebbero leggere o provare a capire il tuo codice. Se non proverai mai ad istruire gli altri con i tuoi esempi o a condividere il tuo codice, allora per favore usalo a tuo piacimento.

Aggiungerò anche questo commento, da tempo utente Linux e amministratore / ingegnere ... (e ce ne sono molti) che ci fa sanguinare gli occhi nel vederlo. Perché? Perché utilizza risorse su sistemi su cui controlliamo strettamente le risorse. Il comando cat e la pipe stessa utilizzano memoria aggiuntiva e handle di file completamente inutili. Hai legato risorse di cui il mio sistema ha bisogno gratuitamente e non hai guadagnato NIENTE che possa spiegare l'utilizzo di queste risorse. Questo è un enorme no no.

Ora posso sedermi qui e discutere tutto il giorno con odore di codice o leggibilità, ma alla fine è una questione di scrittura o di errore e ogni volta che usi le risorse su un sistema e non guadagni nulla per questo ... è sbagliato.

Come utente domestico puoi imparare dai miei consigli e imparare modi migliori di fare le cose o puoi scegliere di essere accecato dall '"odore" dei gatti, dalla tua scelta ... ma sappi che se usi apertamente questa pratica verrai chiamato su questa pratica per tutto il tempo e dovrai ammettere silenziosamente che hanno ragione e sei testardo perché è vero. :-)


Sono anche uno sviluppatore di software e utenti Linux (e precedenti * nix) di vecchia data. Non parli per me quando dici "ci fa sanguinare gli occhi" per vedere cat foo.txt | .... L'altra risposta spiega bene perché può essere un buon uso. Il semplice riassunto del caso a favore è: "$ CPU time << $ Brain time" (come ha commentato @MikeP sopra).
Jim DeLaHunt

In primo luogo, questa è stata una risposta dal 2017 (modo per far rivivere i morti lol). In secondo luogo, nota che come amministratore o sviluppatore dovremmo sempre cercare di ridurre al minimo l'utilizzo delle risorse, ove possibile. Quando si scrivono app e servizi, si tenta di controllare se la memoria o gli scarichi della CPU offrono un vantaggio scarso o nullo all'app / al servizio? Bene, UUOC è esattamente questo. Ora, ci sono usi perfettamente validi di cat, sono sicuro che comportano il piping per comandare ... ma non spesso. Quindi potrei non parlare per te, come dici tu ... ma se sei un professionista, mi chiedo perché non sei più facilmente d'accordo (dato un vero scenario UUOC).
David Dreggors, il

Il problema è che gli scarichi di memoria o CPU non sono l'unico costo per uno sviluppatore da ottimizzare. Anche il costo del tempo umano, per comprendere il problema e scrivere ed eseguire il debug di un'implementazione, fanno parte del compromesso. Alcune delle risposte qui si basano sul giudizio secondo cui il tempo umano è molto più scarso e costoso della memoria o della CPU. . ... Ma questo sta diventando una discussione, che è contro le regole. Lascia che i voti sulle risposte parlino per quale prospettiva è approvata dai Super Utenti.
Jim DeLaHunt
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.