Come ha funzionato il controllo delle versioni sui microcomputer del giorno negli anni '80 e '90?

Sono curioso di sapere come i team di programmatori in genere hanno gestito lo sviluppo del loro software negli anni '80 e nei primi anni '90. Tutto il codice sorgente era semplicemente memorizzato su un computer su cui tutti lavoravano, oppure il codice sorgente veniva passato e copiato manualmente tramite floppy e unito manualmente, oppure utilizzavano effettivamente i sistemi di controllo delle revisioni su una rete (ad esempio CVS) come facciamo adesso? O forse veniva usato qualcosa come un CVS offline?

Oggi tutti dipendono dal controllo del codice sorgente ... è un gioco da ragazzi. Ma negli anni '80, le reti di computer non erano così facili da configurare, e cose come le migliori pratiche venivano ancora individuate ...

So che negli anni '70 e '60 la programmazione era piuttosto diversa, quindi il controllo di revisione non era necessario. Ma è negli anni '80 e '90 che le persone hanno iniziato a utilizzare i computer per scrivere il codice e le applicazioni hanno iniziato ad aumentare di dimensioni e portata, quindi mi chiedo come le persone abbiano gestito tutto ciò allora.

Inoltre, in che modo differisce tra le piattaforme? Dire Apple vs Commodore 64 vs Amiga vs MS-DOS vs Windows vs Atari

Nota: sto parlando principalmente di programmazione su microcomputer del giorno, non di grandi macchine UNIX.

Innanzitutto, quando i microcomputer sono usciti per la prima volta, il software è stato per lo più scritto su sistemi Unix o VMS e "cross-compilatore / assemblato" sul sistema di destinazione. Questi sistemi informatici erano spesso multiutente con molti terminali e avevano sistemi di controllo con codice sorgente come SCCS .

La rete era un'opzione per i microcomputer a partire dalla metà degli anni '80, spesso collegata a un sistema Unix come "file server" (forse usando semplicemente RS232 e Kermit per trasferire i file, con SCCS sul sistema Unix)

Vedi A History of Version Control di Eric Sink per avere una panoramica di come il sistema di controllo delle versioni è cambiato nel corso degli anni.

Ricordo di aver letto sul controllo del codice sorgente in "BYTE" alla fine degli anni '80, quindi a quel punto doveva essere stato utilizzato su "piccoli sistemi".

SourceSafe era ben noto alla metà degli anni '90 su Dos, Windows, ecc.

Questo link mostra un articolo sul PVC in esecuzione su PC dal 1994 , è alla versione 6.2, quindi era chiaramente in circolazione da qualche tempo, Wikipedia dice che risale al 1985 .

Tuttavia, i floppy disk numerati erano utilizzati dalla maggior parte dei programmatori che lavoravano su software di piccole dimensioni fino alla fine degli anni '90, per essere sostituiti con cartelle sul proprio disco rigido, facendo una copia del codice sorgente ogni giorno.

Ricordo di aver lavorato su un progetto porting di software da Unit a Windows NT 3.5. I programmatori che sanno come programmare per Windows spesso non avevano nemmeno sentito parlare del controllo del codice sorgente in quel momento.

Questa sequenza temporale è tratta da un post sul blog di codicesoftware , vendono Plastic SCM, tuttavia la panoramica della storia di altri sistemi sembra ragionevole, alcuni sistemi più vecchi prima che RCS rimanga dell'immagine.

Questo probabilmente non è rappresentativo per l'industria dei giochi in generale, ma ha funzionato bene nella nostra piccola società di giochi. Non ha mai lavorato con software aziendali, che probabilmente aveva altri requisiti.

Dalla metà degli anni '80 alla metà degli anni '90 ho spesso usato un numero di versione alla fine del nome del file, ad esempio "game.003". All'epoca stavo programmando il 90% in assembler e tutto il codice era in un unico enorme file, possibilmente con uno o due include, dove avrei dovuto aggiornare manualmente il numero di versione quando le cose cambiano. Incrementerei il numero solo dopo aver avuto una versione stabile che ero sicuro di voler mantenere.

Questo alla fine è stato ridimensionato in qualche modo comodamente a circa 3 persone. Dopo di che abbiamo fatto crescere il team e abbiamo finito per avere un casino di file in tutto il luogo per circa un anno o giù di lì fino a quando non mi sono stufato di provare a rintracciare i cambiamenti delle singole persone e abbiamo iniziato a utilizzare Perforce tra il 1997 e il 1998.

Devi vederlo nel contesto delle infrastrutture comuni al momento. All'inizio degli anni '80 IBM ha rilasciato il "personal computer" e puoi prenderlo alla lettera. Il modo più comune per sviluppare applicazioni per un PC era un ragazzo che creava qualcosa e cercava di venderlo. Quindi un floppy per versione rilasciata sarebbe probabilmente comune. Puoi comprare delle belle etichette colorate e scrivere il nome del tuo prodotto e la versione su di esso. Per la maggior parte dei prodotti di successo di quei giorni hai conosciuto il nome del ragazzo che lo ha scritto.

Le reti sono state introdotte come componenti aggiuntivi. Le API del client sono state hackerate in DOS e le parti del server erano sistemi operativi dedicati e dedicati su una macchina separata. Tipicamente costoso (non per le masse) e fondamentalmente offre solo la condivisione di file e stampanti. Nel mondo dei PC le cose hanno iniziato a cambiare con l'introduzione di Windows for Workgroups e Windows NT. Ciò ha aperto molte possibilità. Il networking è stato infine integrato nell'ambiente che un programmatore conosceva e un programmatore di Windows poteva scrivere applicazioni in grado di comunicare tra loro sulla rete. Questa era la fine di NetWare come sistema operativo di rete dominante.

Presto sono comparsi diversi sistemi di controllo della versione con componenti client e server che è possibile installare facilmente su qualsiasi combinazione di macchine. Con plug-in per IDE e componenti client che supportano le opzioni della riga di comando che hanno consentito l'integrazione in un sistema di generazione.

Dopo che il web è decollato e l'accesso al PC a Internet è diventato onnipresente, hai il movimento open source e i sistemi di controllo del codice sorgente basati sul web. La cosa divertente è che, quando fu introdotto il PC, questo fu visto come un passaggio audace dal calcolo centralizzato al calcolo distribuito. Ma la definizione di centrale rispetto a distribuita è sfocata. Il cloud è la distribuzione definitiva o è solo il nuovo monster computer centrale che detiene tutta la potenza, proprio come una volta era il mainframe IBM?

Negli anni '90 ho sicuramente usato il software per il controllo della versione. C'era SCCS e l'MPW di Apple aveva il controllo della versione integrato (proiettore). E penso di aver usato Projector intorno al 1992. In una società il sistema di controllo della versione era un grande armadio con floppy disk di ogni versione, preso una volta alla settimana.

Il mio primo lavoro di programmazione estiva mentre ero ancora a scuola (credo che sarebbe stato circa 91) è stato implementare un sistema automatizzato di gestione delle versioni e di backup per la piccola azienda in cui lavoravo. Avevamo 3 PC collegati a un server netware e il proprietario si era finalmente stancato di gestire i conflitti di versione e di elaborare ciò che era necessario eseguire il backup su floppy, quindi abbiamo fatto lavorare gli sviluppatori sul proprio PC anziché direttamente nei file memorizzati sul server come avevano fatto fino ad ora, e ho scritto un sistema che ha tenuto tutti i loro file impostati per la lettura solo fino a quando non hanno eseguito un programma che ha verificato che nessun altro li stava usando, quindi ho registrato l'uso su un database centrale btrieve (un database relazionale con una semplice query api anziché full sql eseguito sul server netware). Un altro programma ha verificato le modifiche modificate e le ha copiate sul server,

Mentre questo sistema è stato creato su misura per la piccola azienda in cui ho lavorato, immagino che molti negozi simili abbiano avuto processi simili.

Per esperienza personale: lo sviluppo in rete MSS-DOS del 1985 era disponibile e troppo costoso. Per Apple e tutti i PC non MSDOS: niente. Ho usato T-lib ($ 50) dal 1987. Unix porti (SCCS), ho iniziato a filtrare verso il 1990, SourceSafe intorno al 1992.

Nel 1995, se non stavi usando un VCS, non eri serio.

Nel 1993-1995 ero con un gestore delle pensioni con 15 sviluppatori che sviluppavano C / C ++ in SunOS con SPARCStation 20s e Sun IPX. La nostra base di codice era nelle directory montate su NFS. Inizialmente stavamo eseguendo il Copying Versioning delle cartelle , ma a un certo punto ci siamo trasferiti in SCCS e alcuni team hanno iniziato a utilizzare RCS .

Nel 1995 mi sono trasferito in un'altra società con oltre 80 sviluppatori che hanno sviluppato C / C ++ a New York, Londra e Hong Kong. Abbiamo usato ClearCase con il componente aggiuntivo multi-sito per gestire l'ambiente di sviluppo.

ClearCase era bravo a sincronizzare la base di codice tra i siti, ma al momento richiedeva quasi un amministratore a tempo pieno per mantenere le cose in esecuzione. È stato anche molto più lento perché ClearCase presenta i file in un filesystem virtuale, con una configurazione che specifica le versioni di directory e nomi di file jolly basati su rami, tempo e / o tag. In un caso patologico, si potrebbe specificare ogni singolo file per avere una versione diversa.