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

31

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.

9a3eedi
fonte
3
RCS foi inicialmente lançado em 1982.
5gon12eder
11
Mas quantas pessoas o usaram? O RCS foi fabricado pela AFAIK para máquinas Unix e similares, que não rodavam em microcomputadores.
9a3eedi
2
Tínhamos sistemas em rede. Apenas não foi resolvido em TCP / IP, havia outros, também como decnet. O compartilhamento de arquivos estava disponível em vários protocolos. E as equipes desenvolveram minis mesmo para micros, embora alguns pequenos desenvolvedores independentes (não em equipes) apenas fizessem backups em vez de versão usando controle formal. Alguns podem emular o controle de versão com backups manuais rigorosos.
Erik Eidt 14/02
2
Fizemos isso com muito cuidado, principalmente em wetware, porque o que você considera controle de versão não existe nas plataformas mencionadas.
Blrfl
2
No meu caso, usamos baralhos de cartões perfurados para mini-computadores no início dos anos 80. Às vezes, salvávamos os decks de código-fonte em arquivos de cartões perfurados.
Gilbert Le Blanc

Respostas:

22

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.

Linha do tempo do histórico de controle de versão

Ian
fonte
11
Quando comecei a trabalhar, estava usando o VSS. Gosto do comentário de boas-vindas ao inferno . Lembro-me de ter sido perguntado pelo líder da minha equipe se valeria a pena mudar por força ... diabos, sim!
draeron
@ Draeron, eu achei o VSS estava OK se você não esperava ser capaz de mesclar ramos E estava em um servidor de arquivos estável. Uma empresa em que trabalhei o possuía em um servidor com chips de ram ruins, e assim corrompeu o banco de dados! No entanto dar-me forçosamente ao invés qualquer dia da semana ....
Ian
"Bem-vindo ao inferno" também pode se aplicar ao Clearcase ... estremecer
Andrew Kennan
13

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.

axl
fonte
6

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?

Martin Maat
fonte
11
O Netware ainda era bastante dominante até o Active Directory ser lançado com o win2k. Ainda há muitas coisas que a Netware fez bem que o AD não pode fazer sem quebras sérias.
Wyatt Barnett
Então, o que você está dizendo é que na época as pessoas com microcomputadores não usavam o controle de origem porque não precisavam dele? ou seja, era apenas um cara fazendo programas em sua casa normalmente, então não há necessidade de compartilhar código ou fazer mesclagens?
9a3eedi
2
@ 9a3eedi: Estou pintando uma imagem típica. As pessoas podem ter sentido a necessidade, mas ela simplesmente não estava lá, então você viveu por seus meios. Mesclando você diz? Isso soa como um grande programa complicado. Quanta memória esse animal precisa? O que resta para o código ser mesclado? Posso trocar disquetes, mas se minha memória estiver cheia, para onde vou ?! Somente quando as pessoas tinham "toda a memória de que precisariam" (como 640K) é que isso era possível.
Martin Maat
5

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.

gnasher729
fonte
O SCCS não funcionou em microcomputadores. E não podia trabalhar, porque se baseou em uma característica puramente específico para Solaris (nem mesmo genérico Unix) filesystem
mosquito
11
@gnat - você está falando sobre o mesmo SCCS ? Sei que o usei no Next em meados dos anos 90 e acredito que o usei em vários Unices que não são Solaris no final dos anos 80. E o artigo vinculado da Wikipedia parece concordar que não era apenas Solaris.
kdgregory
3
Tenho certeza de que usei o SCCS em um 3B2-400 executando o Sys V por volta de 1986. ISTR que o usamos em vez do RCS porque estávamos trabalhando com um consultor cuja empresa o utilizava em seu sistema Xenix baseado no Z8000 e ele tinha alguns makefiles que o assumiram foi usado.
TMN
11
Eu definitivamente usei o SCCS em 1984 no Microsoft Xenix rodando nos processadores Motorola 68000.
Charles E. Grant
2
É verdade que o Linux não suportava o SCCS nos anos 80. Na verdade, também faltava suporte ao Linux para o SCCS na década de 1880. O SCCS e outros programas (por exemplo, rn newsreader), nos anos 80, o Unix usava o open (2) para criar arquivos de bloqueio consultivos que funcionavam se todos os usuários obedecessem ao mesmo protocolo. Como o SCCS foi quem criou os bloqueios consultivos, pode ser certo respeitá-los.
RSU
1

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.

Jules
fonte
1

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.

david.pfx
fonte
Gostaria de mudar a última frase para 1985 :( Mas depois trabalhei em finanças
user151019
@mark: Duvido muito que isso acontecesse no desenvolvimento de PCs. Corporates PCs ignorado até que o Windows 3.
david.pfx
Havia um monte de programação DOS e em 86 eu estava usando PVCS e novos jogadores tinha Unix fundo, mas como observado foi em bancos e finanças, para que possam ter estado à frente
user151019
@mark: O PVCS estava definitivamente disponível em 1985, mas muito caro para a maioria (US $ 000). Somente aqueles que se deslocam de sistemas maiores e com dinheiro para queimar o usariam.
David.pfx
-1

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.

Ed Griebel
fonte
11
A pergunta pede especificamente informações sobre micro sistemas não-unix, mas os sistemas que você descreveu estavam (na época) disponíveis apenas em estações de trabalho unix.
Jules