Como o controle de versão funcionou nos microcomputadores do dia nos anos 80 e 90?

Estou curioso para saber como as equipes de programadores geralmente gerenciavam seu desenvolvimento de software nos anos 80 e início dos 90. Todo o código-fonte foi simplesmente armazenado em uma máquina na qual todos trabalharam ou a fonte foi passada e copiada manualmente via disquete e mesclada manualmente ou eles realmente usaram sistemas de controle de revisão em uma rede (CVS, por exemplo), como fazemos? agora? Ou talvez algo como um CVS offline estivesse sendo usado?

Hoje em dia todo mundo depende do controle da fonte ... é um acéfalo. Mas nos anos 80, as redes de computadores não eram fáceis de configurar e coisas como as melhores práticas ainda estavam sendo descobertas ...

Eu sei que nos anos 70 e 60 a programação era bem diferente, portanto o controle de revisão não era necessário. Mas é nos anos 80 e 90 que as pessoas começaram a usar computadores para escrever código, e os aplicativos começaram a aumentar em tamanho e escopo, por isso estou me perguntando como as pessoas gerenciavam tudo isso naquela época.

Além disso, como isso difere entre plataformas? Dizer Apple vs Commodore 64 vs Amiga vs MS-DOS vs Windows vs Atari

Nota: estou falando principalmente de programação em microcomputadores do dia, não em grandes máquinas UNIX.

Primeiramente, quando os microcomputadores foram lançados, o software foi gravado principalmente em sistemas Unix ou VMS e "compilador cruzado / montado" no sistema de destino. Esses sistemas de computador eram multiusuários frequentemente com muitos terminais e tinham sistemas de controle codificados como o SCCS .

A rede era uma opção em microcomputadores de meados da década de 1980, geralmente conectada a um sistema Unix como o "servidor de arquivos" (talvez apenas usando RS232 e Kermit para transferir os arquivos, com o SCCS no sistema Unix)

Consulte A History of Version Control, de Eric Sink, para obter uma visão geral de como o sistema de controle de versão mudou ao longo dos anos.

Lembro-me de ler sobre o controle do código-fonte no "BYTE" no final dos anos 80, então ele deveria estar em uso em "pequenos sistemas" até então.

O SourceSafe foi bem estabelecido em meados dos anos 90, rodando em Dos, Windows, etc.

Este link mostra um artigo sobre o PVCS em execução no PC desde 1994 , está na versão 6.2, portanto já existia há algum tempo, segundo a Wikipedia, datado de 1985 .

No entanto, os disquetes numerados foram usados ​​pela maioria dos programadores que trabalham em software de pequena escala até o final dos anos 90, para serem substituídos por pastas em seu disco rígido, fazendo uma cópia do código-fonte todos os dias.

Lembro-me de trabalhar em um projeto de portabilidade de software do Unit para o Windows NT 3.5. Os programadores que sabem programar para o Windows nem ouviram falar do controle do código-fonte naquele momento.

Essa linha do tempo é retirada de um post do blog da codicesoftware , eles vendem o Plastic SCM; no entanto, a visão geral da história de outros sistemas parece razoável, alguns sistemas mais antigos antes que o RCS permaneça fora da imagem.

Provavelmente isso não é representativo para a indústria de jogos em geral, mas funcionou bem em nossa empresa de jogos pequenos. Nunca trabalhou com software comercial, que provavelmente tinha outros requisitos.

De meados dos anos 80 até meados dos anos 90, eu costumava usar um número de versão no final do nome do arquivo, por exemplo, "game.003". Naquela época, eu estava programando 90% no assembler e todo o código estava em um único arquivo enorme, possivelmente com uma ou duas inclusões, onde eu teria que atualizar manualmente o número da versão conforme as coisas mudassem. Eu aumentaria o número apenas depois de ter uma versão estável que eu tinha certeza que queria manter.

Isso acabou se expandindo de maneira confortável para cerca de três pessoas. Depois disso, aumentamos a equipe e acabamos tendo uma bagunça de arquivos em todo o lugar por um ano ou mais, até que me cansei de tentar rastrear as mudanças individuais e começamos a usar o Perforce por volta de 1997-98.

Você precisa ver isso no contexto de infraestruturas comuns da época. No início dos anos 80, a IBM lançou o "computador pessoal" e você pode entender isso literalmente. A maneira mais comum de desenvolver aplicativos para um PC era um cara criando algo e tentando vendê-lo. Portanto, um disquete por versão lançada provavelmente seria comum. Você pode comprar etiquetas coloridas bonitas e escrever o nome do seu produto e a versão. Na maioria dos produtos de sucesso daqueles dias, você sabia o nome do cara que o escreveu.

Redes foram introduzidas como complementos. As APIs do cliente foram invadidas pelo DOS e as partes do servidor foram sistemas operacionais proprietários e dedicados em uma máquina separada. Normalmente caro (não para as massas) e basicamente oferecendo apenas compartilhamento de arquivos e impressoras. No mundo dos PCs, as coisas começaram a mudar com a introdução do Windows for Workgroups e Windows NT. Isso abriu muitas possibilidades. A rede foi finalmente integrada ao ambiente com o qual um programador estava familiarizado e um programador do Windows poderia escrever aplicativos que pudessem se comunicar pela rede. Este foi o fim do NetWare como o sistema operacional de rede dominante.

Em breve, vários sistemas de controle de versão surgiram com componentes de cliente e servidor que você pode instalar facilmente em qualquer combinação de máquinas. Com plug-ins para IDE e componentes do cliente, oferecendo suporte a opções de linha de comando que permitiram a integração em um sistema de construção.

Depois que a Web decolou e o acesso do PC à Internet se tornou onipresente, você obteve o movimento de código aberto e os sistemas de controle de fonte baseados na Web. O engraçado é que, quando o PC foi introduzido, isso foi visto como uma mudança ousada da computação centralizada para a computação distribuída. Mas a definição de central versus distribuído ficou turva. A nuvem é a distribuição final ou é apenas o novo computador central monstro que detém todo o poder, como o mainframe da IBM costumava ser?

Nos anos 90, definitivamente usei software para controle de versão. Havia o SCCS, e o MPW da Apple possuía controle de versão interno (projetor). E acho que usei o Projector por volta de 1992. Em uma empresa, o sistema de controle de versão era um armário grande com disquetes de todas as versões, tiradas uma vez por semana.

Meu primeiro trabalho de programação de verão enquanto eu ainda estava na escola (isso seria em torno de 91, eu acho) foi implementar um sistema automatizado de gerenciamento e backup de versão para a pequena empresa em que estava trabalhando. Tínhamos 3 PCs conectados a um servidor NetWare, e o proprietário finalmente se cansou de lidar com conflitos de versão e resolver o que era necessário fazer backup em disquetes, então fizemos os desenvolvedores trabalharem em seu próprio PC, em vez de diretamente nos arquivos armazenados no servidor. como haviam feito até agora, e eu escrevi um sistema que mantinha todos os arquivos configurados para serem lidos somente até que eles executassem um programa que verificasse que ninguém mais os estava usando e depois registrasse o uso em um banco de dados central btrieve (um banco de dados relacional com uma consulta simples API em vez de sql completo, que era executado no servidor NetWare). Outro programa verificou as alterações modificadas e as copiou para o servidor,

Embora esse sistema tenha sido construído sob medida para a pequena empresa em que trabalhei, imagino que muitas lojas semelhantes tenham processos semelhantes.

Por experiência pessoal: 1985 O desenvolvimento em rede do MS-DOS PVCS estava disponível e muito caro. Para Apple e todos os PCs não MSDOS: nada. Usei o T-lib (US $ 50) a partir de 1987. As portas Unix (SCCS), começaram a filtrar por volta de 1990, o SourceSafe por volta de 1992.

Em 1995, se você não estava usando um VC, não estava falando sério.

Em 1993-1995, eu estava com um gerente de pensão com 15 desenvolvedores desenvolvendo C / C ++ no SunOS com SPARCStation 20s e Sun IPX. Nossa base de código estava em diretórios montados em NFS. Inicialmente, estávamos executando o Copy Folder Versioning , mas em algum momento fomos para o SCCS e algumas equipes começaram a usar o RCS .

Em 1995, mudei para outra empresa com mais de 80 desenvolvedores desenvolvendo C / C ++ em Nova York, Londres e Hong Kong. Usamos o ClearCase com o complemento de vários sites para gerenciar o ambiente de desenvolvimento.

O ClearCase era bom em sincronizar a base de código entre sites, mas na época exigia quase um administrador em tempo integral para manter as coisas funcionando. Também foi muito mais lento porque o ClearCase apresenta arquivos em um sistema de arquivos virtual, com uma configuração que especifica versões de diretórios e nomes de arquivos curinga com base em ramificações, hora e / ou tags. Em um caso patológico, pode-se especificar cada arquivo individual para ter uma versão diferente.