Como foi feita a programação há 20 anos? [fechadas]

Atualmente, temos muitos auxiliares de programação que facilitam o trabalho, incluindo:

• IDEs

• Depuradores (linha por linha, pontos de interrupção, etc.)

• Scripts Ant, etc para compilar

• Sites como o StackOverflow para ajudar se você estiver preso em um problema de programação

20 anos atrás, nada disso existia. Quais ferramentas as pessoas usaram para programar e como se saíram sem essas ferramentas mais novas? Estou interessado em aprender mais sobre como a programação foi feita naquela época.

Há 20 anos, isso é 1991. Foi nesse ano que o Borland C ++ 2.0 IDE foi lançado. Com depurador integrado (com linha por linha e pontos de interrupção), construção automatizada usando make.

Parecia este http://www.ee.oulu.fi/research/tklab/courses/521419A/tc201_compile.png

Você não tinha sites como o Stackoverflow, mas com o IDE você estava recebendo alguns milhares de páginas de documentação em livros bem impressos.

Há 20 anos ... 1991 ...

Vamos ver. Eu estava usando SunOS e VAX VMS.

Escrevemos código usando editores de texto (vi ou edit).

Eu - pessoalmente - não uso depuradores e nunca o fiz. Algumas pessoas usaram o depurador adb no SunOS. Na verdade, eu usei algumas vezes para recuperar um rastreamento de pilha de um arquivo de despejo de núcleo. Não faço ideia do que estava disponível no VAX VMS. Eu usei instruções de impressão no código.

Usamos make para compilar.

Lemos a documentação em papel, pensamos e fizemos experimentos. Na verdade, isso ainda funciona. O estouro de pilha é usado em excesso por algumas pessoas que - por razões inexplicáveis ​​- se recusam a executar experimentos ou pensar.

Há 30 anos ... 1981 ...

Vamos ver. Eu estava usando o Univac Exec 8 e o IBM OS.

Escrevemos código usando editores de texto (não me lembro do Univac, mas o IBM era o editor do ambiente TSO)

Eu - pessoalmente - não uso depuradores e nunca o fiz. Essas máquinas eram "mainframes" e não podiam ser executadas em etapas únicas. Não houve "depurador". Você precisava inserir instruções de impressão no seu código.

Nós escrevemos scripts para compilar.

Lemos a documentação em papel, pensamos e fizemos experimentos.

Há 40 anos ... 1971 ...

Vamos ver. Eu estava usando um IBM 1620 que não tinha sistema operacional.

Escrevemos código usando cartões de papel perfurados.

Depurar significava dar um passo no processador. Raramente era útil, então aprendi a inserir instruções "print" no meu código.

Executamos o compilador manualmente para produzir um baralho de cartões perfurados que, em seguida, executamos. "à mão" significava literalmente carregar cartões em um leitor de cartões para instalar o compilador ou montador. Em seguida, carregue o código-fonte em um leitor de cartão para produzir o código do objeto. Em seguida, carregue o código do objeto resultante no leitor de cartão para executar o programa.

Lemos a documentação em papel, pensamos e fizemos experimentos.

"Saia do meu gramado, crianças podres"

• IDEs. Quase inútil. O preenchimento de código pode ser divertido, mas não tão útil quanto algumas pessoas afirmam. Já me disseram que o VB é uma linguagem aceitável por causa do Visual Studio. A coloração da sintaxe é talvez o recurso mais útil já inventado. O restante deve ser complementos opcionais, para que possamos dispensá-los e liberar ciclos de memória e processador.

  Como muletas, há coisas piores para se depender.

• Depuradores. Sem utilidade. Exceto quando a definição de linguagem é tão ruim que a semântica é tão obscura que você não consegue entender o que deveria acontecer. Por exemplo, VB. Quando um depurador é necessário, é hora de obter um idioma melhor.

  Com base na minha experiência no ensino de programação, os depuradores podem ser inúteis. Para algumas pessoas, eles levam ao pensamento nublado e a um estilo empírico estranho de programação, onde não há significado semântico para o código - não há significado - apenas uma pura invasão.

• Scripts Ant, etc para compilar. Compilação e vinculação incrementais não são realmente uma ótima idéia. Com linguagens hiper-complexas, é um hack necessário, mas realmente precisa ser visto como um hack. Não é necessário nem desejável.

  Uma linguagem melhor com menos dependência da compilação incremental parece uma coisa muito, muito melhor do que scripts Ant sofisticados.

• Sites como o Stackoverflow para ajudar se você estiver preso demais em um bug. Às vezes útil.

  Tal como acontece com os depuradores, existe a possibilidade de algumas pessoas parecerem bem-sucedidas através de uma simples sorte. Isso é uma coisa ruim.

Hmm, sua premissa não é bem verdadeira. Os dois últimos itens estão corretos, mas há 20 anos tivemos IDEs e Debuggers.

De fato, os depuradores sempre existiram. Seu design e uso evoluíram desde que a equipe da Brooks construiu os antigos mainframes da IBM, pois todos temos nossas próprias máquinas dedicadas. No entanto, agora podemos fazer com que o mesmo depurador funcione para vários idiomas diferentes (consulte o projeto GCC ou o MS Visual Studio para exemplos).

Há 20 anos, não tínhamos ANT, mas definitivamente tínhamos o Make. Havia até algumas versões incompatíveis da ferramenta. Isso é o que as pessoas costumavam criar seus projetos.

E embora a web não estivesse prontamente disponível (ainda era um projeto de pesquisa nas universidades e nas forças armadas), tínhamos livros e revistas. As revistas forneceram as informações mais atualizadas e os livros trataram da teoria.

Malditos garotos. 1991? Sério? O que você acha que estava acontecendo naquela época? Quero dizer, o Turbo Pascal ainda era meio sexy, o Netware ainda era um concorrente válido para o Windows, os computadores velozes ainda eram medidos em mhz, mas fora isso, não era muito diferente. Volte mais 10 anos e você estará falando de tela verde, mas também existem IDEs para esses sistemas.

Você tem que voltar a meados dos anos 70 para encontrar cartões perfurados e porcaria assim.

Há 20 anos, tivemos o Borland Turbo Pascal e o Turbo C ++, IDEs bastante potentes com depuradores, criadores de perfil, etc.

Havia muitas ótimas ferramentas. Como você acha que o kernel do Unix foi construído? e compilado? e todos os outros aplicativos enormes, como Lotus 123, Corel Draw, Wordperfect, Xenix, MS Windows, X Windows, gnu, Kings Quest, Flight Simulator etc.

O Unix tinha muitas ferramentas de produtividade para programadores, como o fiapo para análise de código, compilação para compilação e vi ou emacs para edição. Com o shell Korn (e provavelmente outros), você pode suspender um editor e pular para outro editor em 0,5 segundos e fazê-lo em um modem dial-up lento com uma tela verde ("observando a grama crescer"). Você pode depurar com o dbx ou apenas ler o dump principal.

Se você tivesse dinheiro para um terminal gráfico, poderia usar o X Windows e o xdbx para uma depuração realmente sofisticada.

A internet estava lá, mas não a WWW. Tínhamos FTP anônimo, Gopher e WAIS. E os grupos de notícias da rede, como comp.lang.c, para postar perguntas (agora são principalmente spam).

Essas ferramentas eram poderosas. Já assistiu a uma reconstrução do kernel por um dia ou dois? Construiria makefile após makefile, construindo todas essas dependências. E havia até pmake que podia detectar quais alvos poderiam ser construídos em paralelo. Formiga ainda pode fazer isso?

No PC, havia os incríveis produtos Borland, como o Turbo Pascal (a v4 foi uma grande mudança quando saiu em meados dos anos 80).

Tempos interessantes eles eram. E preços interessantes. A caixa SDK do Windows 3 tinha uma alça de transporte, mas precisa de duas mãos para levantar, muitos discos e uma pilha de manuais com 1 pé de altura. Os bancos de dados relacionais custam milhares de dólares por usuário, guerras no Unix, guerras em planilhas sobre a barra. Estou impressionado com as ferramentas que posso obter agora por preços tão loucos e baixos / grátis.

A parte mais engraçada de tudo isso é que alguns dos comandos de pressionamento de tecla do Visual Studio (CTRL-K + CTRL-C) são comandos antigos do Wordstar. Um pouco de nostalgia toda vez que eu o uso.

Há 20 anos, eu estava programando no GFA Basic em um Atari ST 1040 :

Mais teclado, menos mouse.

Obrigado por fazer um cara se sentir velho :-)

Depuradores e makefiles estavam por aí naquela época. Os compiladores vieram com livros grossos ou, para o Unix, um grande conjunto de páginas de manual. A maioria dos desenvolvedores do Unix usava vi ou emacs. Eu não fiz nenhuma programação de desktop na época, mas tenho certeza que eles usaram editores que vieram com o compilador que eram essencialmente IDEs com menos recursos. Você recebeu ajuda de colegas, livros ou revistas.

20 anos atrás eu estava programando em BASIC. Eu não tinha IDE porque BASICA e GW BASIC não são IDEs. Quando vi o Quick BASIC mais tarde, fiquei muito feliz. Fiquei muito animado quando usei o recurso Copiar e Colar pela primeira vez no desenvolvimento. Mais tarde, eles fizeram o compilador QBASIC não interpretar como costumava ser e também foi ótimo, mas depois mudei para C e usei o Turbo C IDE da Borland. Note que eu estou no Egito e naquela época não havia internet e estávamos um ano atrasados ​​em software. Quero dizer, se uma versão for lançada hoje, chegará à minha mão cerca de um ano depois. Agora é muito mais fácil, mas a alegria de programar na época era incomparável :)

Acho que o fenômeno "ano da web" influenciou seus cálculos de datas.

Há 20 anos, eu estava programando em Smalltalk - um dos primeiros idiomas orientados a objetos baseados em GUI em um Mac IIe com uma tela de 20 polegadas, então acho que você precisa voltar mais alguns anos para obter as peles de urso e as pedras -facas era da programação.

Agora, há 40 anos, eu estava programando de maneira básica usando um terminal de teletipo que possuía um modem acústico (110 Baud baby!) - você sabe o tipo que discou no telefone e enfiou a mão nos copos de borracha do modem .

Aqui está um formulário padrão para ajudá-lo a escrever seus programas FORTRAN antes de estragar um monte de cartões perfurados.

(de: http://www.w3.org/2010/Talks/01-08-steven-ten-euro-computer/ )

Certifique-se de usar um lápis para apagar seus erros e deixe algumas linhas em branco entre as instruções impressas, caso esqueça algumas etapas.

(OK, talvez isso seja um pouco antes de 1991, mas não muito ...)

Bem, tudo começou em cartões perfurados , mas tenho certeza que você pelo menos ouviu falar dessa lição de história. Isso remonta a mais de 20 anos atrás, no entanto.

Para depuração? Muitas caixas de mensagens, arquivos de log e outros métodos de saída para ajudar a verificar e ver o que aconteceu.

20 anos atrás, 4GL's eram toda a raiva.

Surpreendentemente, 20 anos atrás as coisas não estavam todos que diferente. Agora há 30 anos ...

Agora, enquanto escrevo esta resposta, lembre-se de que eu tinha apenas 10 anos de idade naquela época, mas ainda assim os discos flexíveis de 5,25 "no meu disco rígido de 1 MB habilitaram o IBM Headstart XT / AT PC. Por que responder a esta pergunta?

Como onde trabalho, mantemos um sistema e uma base de código de 20 anos, por isso ainda estamos em um período de tempo ao trabalhar com sistemas legados, ambientes de desenvolvimento e código.

20 anos atrás eu estava codificando, principalmente em C, Pascal. Para a plataforma DOS, havia o Turbo C, o Turbo Pascal, que eram na sua maioria editores completos com depuradores, permitindo a passagem. Para programação real , sinto que a maioria dos programadores como eu usava o compilador vi +, executado a partir de prompts de comando.

A programação era um pouco mais difícil na época, especialmente para algumas linguagens de programação. Ainda vejo vestígios disso em minha própria programação: acho que executar meus testes com printinstruções é mais fácil do que passar por instruções.

Eu posso falar pela Bulgária.

Ao contrário do que você imagina, a Bulgária estava entre os principais países em tecnologias de computador. Como parte do bloco comunista, a URSS investiu uma grande quantia de dinheiro em nossa ciência da computação, tornando-a líder na indústria no bloco comunista. No entanto, os comunistas não toleravam empresas privadas e tudo nessa área era gerenciado pelo governo. Assim, o recente colapso do bloco comunista há alguns anos deixou o país sem negócios estáveis ​​para manter a indústria em boas condições. No entanto, um bom legado de conhecimento deixou para a próxima geração de especialistas. Portanto, nunca paramos para ter acesso às mais recentes tecnologias e o desenvolvimento de software não diferia dos países ocidentais. Usamos as mais recentes ferramentas de ponta e conceitos de programação.

Portanto, não repetirei tudo o que os outros dizem, mas sim, havia IDE e depuradores muito bons naquele momento (correspondendo à natureza do software que estava sendo desenvolvido naquela época).

Lembro que usei pessoalmente o Turbo Pascal e o Turbo C (da Borland). Também o software da Autodesk para gráficos (como 3d Studio e Animator).

No entanto, a fonte de conhecimento era mais limitada - principalmente livros, revistas, colegas e raramente revistas eletrônicas via BBS. Internet era principalmente um objeto antigo. Alguns tiveram acesso à Usenet, mas raramente a utilizam para o trabalho.

Apenas 20 anos atrás. Você só pode estar brincando. Eu estava usando depuradores em 1972 quando estava aprendendo programação. É certo que os que eu pude usar não eram tão bons quanto hoje. Eu suspeito que eles existiam muito antes disso.
As ferramentas mudaram ao longo dos anos e melhoraram, mas nem pense que não tínhamos ferramentas naquela época.
Eu suspeito que você precisaria voltar aos anos 50 para chegar ao nível em que não havia depuradores.
O primeiro depurador realmente bom que usei foi em um VAX com VMS nos anos 80. Tudo subiu de lá.

Até agora você deve ver que versões simples da maioria das ferramentas que você gosta estavam presentes em 1991, embora distribuídas de maneira desigual.

As comparações mais interessantes são com 1981: o início de processos sociais amplamente disponíveis envolvendo as redes USENET e UUCP e ARPANET. (O dia da bandeira do TCP na Internet foi em 1983.)

Comparações ainda mais interessantes são com 1971: versões iniciais dos sistemas operacionais que você conhece e ama, processos sociais baseados na publicação (boletins em papel, conferências presenciais, compartilhamento de código com contatos pessoais, grupos de usuários, usando mídias como fitas magnéticas )

Há 20 anos, eu estava codificando um 386 no Borland C ++ usando a programação OWL para Windows.

Minha máquina tinha alguns MB de RAM e um disco rígido de 200 MB. Eu poderia instalar a maioria dos softwares a partir de disquetes - mas cada vez mais softwares vinham em CD.

Quando pressionei F8 para "Executar" meu projeto na Borland, o compilador funcionaria rapidamente e eu pude brincar instantaneamente com os resultados.

Tínhamos um PC no escritório que a cada poucas horas se conectava ruidosamente ao Demon (usando o Trumpet WinSock) e baixava o e-mail de todos.

Quando não podíamos descobrir como programar algo, geralmente procurávamos a resposta em um livro - os livros da API do Win32 eram particularmente úteis.

Na verdade, éramos bastante produtivos ... e os IDE funcionavam muito rapidamente naquela época! Mas eles não tinham boas ferramentas de refatoração e testes integrados.

20 anos atras? Eu estava usando um bom IDE com um fantástico construtor de UI de arrastar e soltar e gerente de projeto. Havia uma linguagem OO bastante boa, um conjunto de objetos GUI realmente bons, vários aplicativos excelentes e uma janela de terminal que me dava um sólido shell Unix. E um depurador, mas eu concordo que são para pessoas de mente fraca (ou lidando com seu código hediondo).

Se isso soa como o Mac, é porque estou falando sobre o ambiente de desenvolvimento NeXT, que foi o que se transformou no Mac OS moderno. Para os whippersnappers, você pode ler a história aqui:

• http://en.wikipedia.org/wiki/NeXT
• http://en.wikipedia.org/wiki/Interface_Builder
• http://en.wikipedia.org/wiki/Project_Builder

Como uma observação lateral, direi que a incrível construção de GUI lá me arruinou totalmente. Quando comecei a desenvolver aplicativos Swing em Java, era como se o cachorro de alguém tivesse comido um documento obsoleto da API da GUI e vomitado novamente e a Sun o tivesse enviado. Graças a Deus a web está finalmente chegando a algum lugar.

Comecei a programar em 1981, chegando a 30 anos atrás neste outono.

Em 1991, eu trabalhava na Apple Computer (também conhecida como "Apple" atualmente) e trabalhava em estreita colaboração com uma pequena empresa canadense chamada Metrowerks.

A Metrowerks estava construindo um IDE excelente para C, C ++ e Pascal. Esse ambiente teve um papel importante na transição bem-sucedida da Apple para o processador PowerPC a partir dos 68K.

Embora eu fosse funcionário da Apple, durante vários anos fui efetivamente gerente de produto da Metrowerks, trabalhando em estreita colaboração com Greg Galanos e Jean Belanger na estratégia de produtos, etc. Foi essa estreita parceria entre a Apple e um desenvolvedor de terceiros que habilitou o Power Macintosh transição, a Apple primeira grande transição para Mac (a segunda sendo a transição para o OS X).

Em 1981, eu estava entrando no meu primeiro ano na UCSC e tive a oportunidade de começar a trabalhar no Unix Release 7 (não na Versão 7) rodando no PDP-11/70.

Não há IDEs aqui! Caramba, não tínhamos controle de versão até alguns anos depois!

Era vi (e vim não era uma escolha), cc, ln e make. Ele estava escrevendo scripts C Shell e hackeando a fonte para C Shell para aumentar o tamanho das variáveis ​​de ambiente de 512 caracteres para 1024 caracteres, a fim de acomodar os TERMCAPS mais e mais complexos de nossos "terminais inteligentes"

Estava tendo a oportunidade de ler uma cópia pirata do Livro Leonístico no chão do condomínio fora do campus de um estudante da CIS de classe alta, Ted Goldstein. Ted iniciou uma carreira muito completa, incluindo o vice-presidente de ferramentas da Apple.

Ele colocou minhas mãos em um Mac em 1984 e uma edição inicial do MDS (Macintosh Development System) e aprendeu a programar essa nova e maravilhosa fera.

Foi muito divertido. Era muito mais fácil começar a trabalhar. Mas o poder que temos com idiomas como Ruby é incrível. Em vez de escrever uma tabela de hash para minha tabela de símbolos de compiladores, estou usando-as à direita e à esquerda como um tipo de dados básico!

Sim, foi muito divertido, mas eu não voltaria ...

Há 20 anos, eu estava escrevendo código no AMOS , que tinha um IDE e um depurador bastante decente.

Em 1991, usei um IDE / Framework chamado UIMX em um terminal X, criando aplicativos baseados em Motif que acessavam um RDBMS da Informatix. O idioma era C.

Havia SCCS para versão, marca para construção.

Olhando para trás, não muito diferente de como trabalho hoje.

28 anos atrás, eu estava escrevendo código de montagem em hexadecimal, manualmente, para o processador 6809 (no Dragon 32 para aqueles que se lembram dele) - acabei escrevendo um montador decente para ele, o que ajudou.

Não havia depurador - se não funcionasse, você adicionaria o código de impressão para dar uma olhada na pilha. Noites longas! Código eficiente ajudou, pois havia menos linhas para dar errado

E hoje em dia estou tendo que aprender Clearcase, Maven, Ant e VS - tudo muito divertido (mas sinto falta dos velhos tempos)

20 anos, eh? Eu estava operando apenas na terra dos PC naquele momento em particular depois de ter deixado a terra da Apple pouco antes disso. Naquela época, lembro que os garotos ricos tinham IDEs completos com depuração integrada (Borland e Microsoft). O resto de nós trabalhava junto com marcas de baixo preço que funcionavam bem, mas não eram tão "integradas" (Mix Software, vários fornecedores de compiladores de shareware). Mouse estava sobre a mesa, mas raramente tocava. 90% do tempo gasto no modo de texto. As configurações de dois monitores estavam começando a desaparecer (antes disso, era comum haver um monitor de codificação monocromático e um monitor "em execução" colorido no mesmo sistema em que as placas MDA e CGA usavam diferentes locais de E / S / memória e podiam tanto ser executado ao mesmo tempo no DOS). As primeiras versões do Windows não estavam satisfeitas com vários monitores.

Os idiomas populares foram C, Pascal e Modula-2. As pessoas ainda usavam Logo e BASIC. "Visual BASIC" estava finalmente começando a acabar com o BASIC. COBOL e RPG estavam sendo ensinados na faculdade.

As crianças ricas usavam a USEnet na Internet, as crianças pobres ainda discavam no BBS local e usavam os grupos FIDOnet (geralmente em 1200-2400bps, um modem de 9600bps ainda não era acessível para a maioria das pessoas, custando quase o mesmo que o resto do mundo). computador).

O primeiro computador que programei nos anos setenta foi o Univac 1218 . O 1218 tinha um executivo minimalista e 16K de memória de núcleo de ferrite orientada a palavras de 18 bits (daí o termo "core dump"). O armazenamento secundário foi realizado por meio de fita magnética e cartões perfurados de 80 colunas codificados por Hollerith. A máquina usava o complemento de alguém para aritmética e o complemento de dois para endereçamento. Ele pode ser programado e depurado usando o painel frontal no qual o conteúdo de todos os registros é exibido usando interruptores de botão iluminados. Essa CPU pode parecer primitiva para os padrões modernos, mas era muito legal para mim na época.

De volta ao tópico: Eu estava usando IDEs há vinte anos na maior parte do meu desenvolvimento. Eu não sou um daqueles caras durões que acreditam que os IDEs são para mentes fracas. Um bom IDE é um amplificador de produtividade.

Há 20 anos, eu era estudante de programação RMCOBOL-85.

Eu estava usando um terminal verde conectado a um servidor de arquivos.

A interface era um editor de texto no estilo de bloco de notas. Nada de fantasia. Também tivemos a opção de usar o VI. Nunca fiz isso.

Ah, bons dias. :)

Há quase 20 anos, eu estava usando um PC IBM e um Amiga 1000 para cruzar código C de compilação e montagem para algo chamado Atari Lynx. O programa em questão executou 5 jogos de cassino em 47K (ou seja, kilobytes) de espaço com 1K para algumas variáveis ​​do sistema. Um 16K enorme foi reservado para vídeo com buffer duplo. Quando o sistema de "desenvolvimento" chegou, havia exemplos de rotinas de montagem para transformar a tela em uma cor e clicar no alto-falante. Foi isso. Se você queria texto, bem, você precisava criar uma fonte e suas próprias rotinas de texto. Networking? Vá em frente, basta escrever seus próprios drivers. Não sei por que, mas a dificuldade disso fazia parte da diversão. É incrível que tudo tenha funcionado.

Você está de brincadeira? Eu estava balançando meu 80286 no Turbo Pascal em meados / final dos anos 80.

Há 20 anos, eu fazia parte de uma equipe usando o Interface Builder e o Objective-C para criar um aplicativo de editoração eletrônica para o NeXTstep OS. E, sim, a Internet estava disponível , era um pouco mais difícil de usar - mas eu consegui encontrar e postar respostas em comp.sys.next.

Eu estava depurando depuradores na Sun em 1989 como uma pessoa de suporte técnico de desenvolvedor de contrato.

Eu estava usando IDEs há quase 30 anos - o UCSD p-System / Apple Pascal. Escreveu Sundog: Frozen Legacy para Apple II com Apple Pascal e montagem 6502 (1982-84). Também escrevi meu próprio desmontador p-code / 6502. Na verdade, eu estava usando o UCSD p-System em um microcomputador Northstar Horizon (Z-80) no Instituto Lunar e Planetário em 1981.

Em 1963, eu estava trabalhando em um emprego de verão no campus. Estava no computador PDP-1, fabricado pela Digital (DEC).

E sim, tinha um depurador interativo, chamado DDT. Você pode definir um ponto de interrupção, examinar e alterar variáveis, código de correção. O editor de texto era bastante primitivo, e geralmente usamos uma máquina de fita de papel offline.

A linguagem era montadora. A máquina tinha algo como 4k de palavras de 18 bits. Nenhum sistema operacional.

Em 1971, eu estava em um PDP-10 com 262.144 palavras de 36 bits cada. Um sistema interativo de compartilhamento de tempo que suporta talvez 10 usuários simultâneos, um editor de texto chamado TECO, um depurador ainda chamado DDT e idiomas como Lisp, Fortran, Basic e Algol. O TECO foi realmente poderoso. Você pode escrever programas de manipulação de texto nele.

O PDP-10 foi a base de uma máquina semelhante fabricada na Palo Alto Research, onde nasceu o escritório do futuro. Ethernet, mouse e GUI, email, impressora a laser e programação orientada a objetos. Palo Alto tinha tudo isso. Dez anos antes do PC.

Muitas dessas coisas foram esquecidas e depois reinventadas várias vezes nos anos desde então. E, claro, também há muitas coisas novas.

Avançando para 1991, eu estava trabalhando em um VAX. Minha linguagem principal era SQL, embora eu escrevesse coisas no PASCAL quando necessário. Também usei o DCL e o Datatrieve como linguagens de script, embora não tenhamos usado esse termo.

O VAX não tinha um IDE naquele momento, pelo menos não onde eu trabalhava. Mas o editor de texto, os compiladores, o vinculador, o depurador e a linguagem de comando foram todos criados com a idéia de que o desenvolvedor usaria todos eles. Eles trabalharam juntos bem. Lembrar um punhado de comandos não foi mais difícil do que lembrar onde uma determinada ferramenta está em uma barra de ferramentas. A redigitação dos comandos foi facilitada pelo recall de comandos.

O VAX tinha um excelente depurador, mas nunca o aprendi. O PASCAL facilitou bastante o início dos programas, e a programação estruturada facilitou a localização de um bug sem o uso de um depurador. Depurar SQL é um jogo totalmente diferente.

Além de trabalhar no VAX, usei ferramentas da área de trabalho para manipular dados localmente. Essas eram ferramentas do MS Office ou seus precursores, não me lembro. A parte difícil foi vincular as ferramentas da área de trabalho aos dados armazenados em um banco de dados no VAX.