I CSS minimizzati dovrebbero essere archiviati in Git?


10

Uso Gulp per generare CSS minimizzati dal mio codice SASS per un progetto a cui sto lavorando.

Mi chiedevo se fosse considerata la migliore pratica per rigenerare questo CSS minimizzato quando si spingeva dal vivo da Git ...

o

Memorizzare i file CSS minimizzati in Git in modo che vengano automaticamente inviati alla produzione senza ulteriore lavoro da parte del server?

Apprezzerei le idee delle persone su questo. Grazie!


C'è solo un posto minimizzato css / js / etc. deve essere conservato: /dev/null.
R .. GitHub FERMA DI AIUTARE ICE

(Questo perché il tuo server web è perfettamente in grado di utilizzare il trasporto gzip.)
R .. GitHub

La memorizzazione di CSS sia compressi che non compressi significa che ora hai due versioni della stessa cosa. Qual è la versione canonica? È facile immaginare lo scenario in cui uno sviluppatore aggiorna il CSS compresso e un altro aggiorna il CSS non compresso. I tuoi due asset sono ora divergenti. Naturalmente il processo dovrebbe impedirlo, ma è una prospettiva realistica con ad esempio un nuovo sviluppatore nel team.
Qwerky,

Risposte:


13

"Dipende." Per il normale monitoraggio dello sviluppo, no. Per le distribuzioni cloud e DevOps, tuttavia, è spesso conveniente o addirittura richiesto.

Il più delle volte, @ptyx è corretto . In effetti, il suo "no" potrebbe essere dichiarato in modo un po 'più enfatico. Qualcosa del tipo "No. No! OMG NO! "

Perché non archiviare risorse minimizzate o compresse nel sistema di controllo del codice sorgente come Git?

  1. Possono essere quasi banalmente rigenerati dal tuo processo di compilazione al volo dal codice sorgente. L'archiviazione di risorse compresse comporta sostanzialmente la memorizzazione dello stesso contenuto logico due volte. Infrange il principio "non ripetere te stesso" (noto anche come DRY ).

  2. Una ragione meno filosofica ma più pratica è che le risorse minimizzate / ottimizzate hanno una compressibilità molto scarsa se conservate in Git. I sistemi di controllo del codice sorgente funzionano riconoscendo le modifiche ("delta") tra le diverse versioni di ciascun file memorizzato. Per fare ciò, "diff" il file più recente con la versione precedente e usano questi delta per evitare di memorizzare una copia completa di ogni versione del file. Ma le trasformazioni effettuate nella fase di minimizzazione / ottimizzazione spesso rimuovono le somiglianze e i waypoint utilizzati dagli algoritmi diff / delta . L'esempio più banale è la rimozione di interruzioni di riga e altri spazi bianchi; l'attività risultante è spesso solo una linea lunga. Molte parti del processo di creazione Web: strumenti come Babel , UglifyJS , Browserify ,Meno e Sass / SCSS : trasformano aggressivamente le risorse. La loro uscita è perturbabile; piccoli cambiamenti nell'input possono portare a grandi cambiamenti nell'output. Di conseguenza, l'algoritmo diff crederà spesso di vedere quasi sempre un file completamente diverso. Di conseguenza, i tuoi repository cresceranno più rapidamente. I tuoi dischi potrebbero essere abbastanza grandi e le tue reti abbastanza veloci da non essere un grosso problema, specialmente se ci fosse un valore per archiviare due volte le risorse minimizzate / ottimizzate, anche se in base al punto 1, le copie extra potrebbero essere inutili al 100% gonfiare.

C'è una grande eccezione a questo, tuttavia: distribuzioni DevOps / cloud. Numerosi fornitori di cloud e team DevOps utilizzano Git e simili non solo per tenere traccia degli aggiornamenti di sviluppo, ma anche per distribuire attivamente le loro applicazioni e risorse su server di test e produzione. In questo ruolo, la capacità di Git di determinare in modo efficiente "quali file sono cambiati?" è importante quanto la sua capacità più granulare di determinare "cosa è cambiato all'interno di ciascun file?" Se Git deve fare una copia del file quasi completa per risorse minimizzate / ottimizzate, ci vuole un po 'più di quanto farebbe altrimenti, ma non è un grosso problema dato che sta ancora facendo un lavoro eccellente aiutando a evitare una copia di "ogni file nel progetto" su ogni distribuire il ciclo.

Se stai usando Git come motore di distribuzione, la memorizzazione di risorse minimizzate / ottimizzate in Git potrebbe passare da "no!" desiderabile. In effetti, potrebbe essere necessario, ad esempio, se mancano solide opportunità di compilazione / post-elaborazione sui server / servizi su cui si distribuisce. (Come segmentare le risorse di sviluppo e distribuzione in quel caso è una lattina separata di worm. Per ora, è sufficiente sapere che può essere gestita in diversi modi, incluso un singolo repository unificato, più filiali, sottorepository o anche più repository sovrapposti. )


1
Grazie per questo! Molto apprezzato. L'ho contrassegnata come risposta, in quanto sembra molto meglio spiegata.
Connor Gurney,

1
git non memorizza solo delta. SVN lo fa, ma git usa un meccanismo molto più complesso per archiviare i file. Alcune persone ti dicono che memorizza una copia completa di ogni file, ma da quello che ho capito, anche questo è errato. Non proverò ad entrare in quello che fa, dal momento che non ne sono completamente chiaro.
jpmc26

Penso che potresti ottenere la sfumatura semplicemente cambiando "e archiviare solo i nuovi delta" in qualcosa lungo le linee di "e utilizzare questi delta per evitare di memorizzare una copia completa di ogni versione del file". Ciò renderebbe il tuo punto di vista corretto, evitando di approfondire il problema di come è stato fatto per un determinato sistema di controllo del codice sorgente.
jpmc26

DevOps potrebbe semplicemente usare git hook per attivare automaticamente la minificazione sul server distribuito, ottenendo il meglio da entrambi i mondi?
Buttle Butkus,

@ButtleButkus Dipende dal server distribuito. Per dipendere dai ganci postali è necessario 1 / assumere i transpiler, i minificatori e gli ottimizzatori appropriati presenti sulla destinazione, oppure 2 / caricarli prima di eseguire i ganci postali. 1 / è rischioso. 2 / impone un costo / latenza di caricamento su ogni distribuzione. Presenta inoltre nuove possibili modalità di errore e un requisito per il debug di hook post in un ambiente remoto, opaco e transitorio. Non ideale Quindi i ganci non sono un proiettile d'argento. La pre-conversione / ottimizzazione delle risorse può essere inelegante, ma è solida e pragmatica.
Jonathan Eunice,

17

No.

Il controllo del codice sorgente deve contenere solo il codice sorgente. Se è generato dalla fonte, non appartiene a questo - e dovrebbe essere generato dal processo di compilazione.

Il motivo fondamentale per cui non si desidera controllare gli artefatti di build intermedi è che, se lo si fa, diventa davvero difficile fidarsi se ciò che si sta eseguendo proviene dalla sorgente appena modificata o da un prodotto intermedio che non è stato possibile ricostruire .


3
Pensa al codice generato nel modo in cui pensi al codice eseguibile.
candied_orange,

3
Questo principio non è sempre vero. Se hai file generati con strumenti pesanti che non puoi aspettarti che un utente abbia, può avere senso mettere i file generati in git. Molte persone hanno persino messo gli configurescript autoconf generati in git per questo motivo.
R .. GitHub smette di aiutare ICE il

@R ..: Idealmente, mantieni un repository di artefatti separato per quelle cose, ma la realtà è raramente ideale.
Kevin,

@R puoi scendere a compromessi, ma è solo quello. E nel caso della minificazione CSS, non credo che gli strumenti si qualifichino come "pesi massimi" o "lenti" o "scomodi". Inoltre, ci sono meccanismi di iniezione di dipendenza alternativa (maven, edera ...) che funzionano bene e non richiedono di inserire il codice generato nel controllo del codice sorgente.
ptyx,

1
@ButtleButkus Non ho molta esperienza sul caso Devops. Quello che ho visto è git usato come meccanismo di trasporto / rilascio / distribuzione (molto conveniente e flessibile), piuttosto che come puro controllo del codice sorgente. A meno che il git 'source' e il git 'delivery' non siano separati (repository separati o rami separati), questo significa che devi compromettere in qualche modo la catena source-> build-> deliverable - per esempio finirai con una produzione con codice sorgente e rami extra in giro, e lo sviluppo con prodotti binari inutilizzati. È un compromesso pragmatico, ma preferisco separare le preoccupazioni quando posso.
ptyx,
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.