Quais foram os padrões de design da era da programação processual? [fechadas]

Similar: Como foi feita a programação há 20 anos?

OOP está na moda hoje em dia, tendo suas raízes no Simula 67 na década de 1960 e, posteriormente, popularizado por Smalltalk e C ++ . Temos muitos livros secos e sólidos sobre padrões de design no mundo orientado a objetos.

Mas quais foram os principais princípios da programação antes da adoção ampla do paradigma OOP? E quais foram os principais padrões de design?

Eu era desenvolvedor da Cobol antes de aprender Java. Eu desenvolvo há mais de 35 anos.

Nos dias das linguagens processuais, a maior parte do processamento era feita em lote. Volte o suficiente na história e até a compilação do programa foi feita com um baralho de cartões perfurados em lote.

Ao contrário da afirmação de Kilian Foth , tínhamos padrões de design nas décadas de 1970 e 1980. Havia uma certa maneira de codificar uma correspondência / mesclagem de vários arquivos no Cobol. Havia uma certa maneira de codificar a adição de transações ao arquivo mestre (fita) no Cobol. Havia uma certa maneira de codificar a geração de relatórios em Cobol. É por isso que o Report Writer da IBM nunca ganhou força em muitas lojas Cobol.

Houve uma aplicação antecipada do princípio DRY. Crie muitos parágrafos para não se repetir. As técnicas de codificação estruturada foram desenvolvidas na década de 1970 e Cobol adicionou palavras estruturadas (verbos) ao idioma em 1985.

Geralmente, quando escrevíamos um novo programa Cobol, copiávamos um antigo programa Cobol e alterávamos os nomes para proteger os inocentes. Quase nunca codificamos um programa Cobol a partir de uma folha de papel em branco ou uma tela em branco. Esse é um grande padrão de design quando você pode copiar e colar programas inteiros.

Havia tantos padrões de design Cobol que levou anos para um programador Cobol aprender todos eles. Essa é uma das razões pelas quais os programadores de Cobol hoje ainda estão, na maioria das vezes, usando a sintaxe de 1985.

"Padrões de design" em software não existiam na época em que você fala, porque o conceito não havia sido inventado. Isto não é eu ser irreverente - ele realmente é a razão; ser chamado de nome reconhecível é o que torna um padrão de Design um "padrão de Design", em vez de apenas o código que você continua usando de um formulário ou de outro (por exemplo, "Fábrica" ​​em vez de "o tipo de classe estática que eu gosto de usar, em vez de uma variedade de construtores ") e o próprio conceito não é exceção.

Dito isto, é claro que havia coisas que cumpriam exatamente o mesmo papel no trabalho dos profissionais que os padrões de design agora. Mas você ficará desapontado ao ouvir sobre eles: o típico "truque dos gurus" naquela época era algo muito chato para nós agora - por exemplo, listas com links individuais, loops controlados por um índice incrementado em cada iteração, acessador inteligente " "métodos que parecem não fazer nada além de dar margem de manobra para mudar de idéia sobre os detalhes da implementação posteriormente.

É isso mesmo, coisas que agora tomamos como garantidas - que às vezes fazem parte das linguagens que usamos - costumavam ser conceitos avançados (e às vezes protegidos com zelo) conhecidos apenas por codificadores mais experientes. As chances são de que quase tudo que não é totalmente trivial que você aprende em um curso básico de programação hoje passou por uma fase em que era o equivalente moral de um "padrão de design" para os praticantes da época. A construção de software pode ainda não ser uma disciplina rigorosa de engenharia, mas se você estuda o estado da arte dos anos 50 e 60, não pode negar que ele percorreu um caminho enorme desde o início.

O grande paradigma anterior era a programação estruturada . Em vez da UML, havia uma variedade de diagramas diferentes (fluxogramas, diagramas de fluxo de dados, gráficos de estrutura etc.). O desenvolvimento foi principalmente de cima para baixo e seguiu um processo de decomposição funcional. Uma das idéias básicas era que a estrutura do seu programa se assemelhasse a um diamante: o módulo principal na parte superior, expandindo-se para os módulos de controle de alto nível, que invocavam rotinas nos módulos de nível inferior. Esses módulos de nível inferior construídos em módulos de nível ainda inferior, todos (teoricamente) eventualmente convergiram para várias rotinas de E / S básicas. Os módulos de alto nível deveriam conter a lógica do programa; os de nível inferior estavam mais preocupados com a integridade dos dados e o tratamento de erros.

Os conceitos importantes introduzidos durante esse período foram ocultação de informações, modularidade e alta coesão / baixo acoplamento. Veja os trabalhos de Dave Parnas para alguns documentos seminais sobre esses tópicos. Confira também o trabalho de Larry Constantine, Tom DeMarco e Ed Yourdon.

Suponho que um grande (além da própria programação estruturada) fosse o conceito de passar um identificador - no OO você tem um objeto e ele contém estado e funcionalidade. Antes do OO, você tinha várias funções independentes e passava um identificador para algum estado entre elas - um cookie, se quiser. Isso deu a você princípios de OO sem realmente ter OO.

Você pode ver isso muito no código antigo do Win32, passaria um HANDLE que seria um tipo opaco que representa algum estado alocado no kernel do Windows. Você mesmo poderia passar um ponteiro para uma estrutura que você alocou anteriormente como o primeiro parâmetro para funções que operavam nesses dados.

Como ninguém mencionou o óbvio ainda: um grande padrão de design na era processual foi o Object. Como muitos padrões de design populares antes (por exemplo, sub-rotina) e depois (por exemplo, Iterator), tornou-se tão popular que até recebeu suporte de idioma.

Uma "máquina de estados finitos" pode contar como um padrão, e os FSMs foram gravados (por exemplo, para protocolos de comunicação) usando linguagens pré-OO.

Também "manipuladores de interrupção" e TSRs costumavam ser populares, por exemplo, no DOS.

Termos como "Spaghetti Code" e "Single Point of Exit" são realmente retrocessos nessa época. Atualmente, chamamos código que não gostamos de "código espaguete", mas na verdade essa é uma referência ao código vinculado (mal) a GOTOs e JMPs.

(Hoje sofremos "código ravioli", no qual o código é como um monte de classes não relacionadas e fortemente compactadas, como um prato de ravioli. No entanto, alguns especialistas em OO perguntam justificadamente: "Mas não é isso que o OO deve parece?")

Hoje, o "Ponto Único de Saída" é apenas um obstáculo frustrante à refatoração. Muitos desenvolvedores com quem converso nem ouviram falar e ficam horrorizados quando explico. Mas antigamente isso significava não pular de um bloco de código repentinamente e entrar no código de espaguete. Avance para o final da lógica e saia normalmente.

Ampliando minha memória, há muito tempo, me lembro que a ideia de agrupar código em procedimentos foi um grande salto em frente. A idéia de que você poderia empacotar procedimentos em módulos interoperáveis ​​e reutilizáveis ​​era uma espécie do Santo Graal da programação.

EDIT: "Código de modificação automática" também era um padrão usado notavelmente no Doom original. É aí que o programa sobrescreve suas instruções por instruções mais rápidas, com base em seu estado. Quando eu era aluno de um curso de programação no Museu de Ciências, meu instrutor nos advertiu severamente: "Não escreva código auto-modificador!"

EDIT EDIT: No entanto, antes da Internet, as palavras viajavam muito mais devagar. A idéia de implementar algoritmos e estruturas de dados costumava ser um negócio muito maior. Hoje eu ordeno o tempo todo, mesmo sem saber que tipo estou usando. Mas naquela época você tinha que codificá-lo. Lembro-me de um artigo falando sobre desafios de programação que costumavam levar dias que hoje terminamos em meia hora ou menos. Uma programação realmente "algorítmica" e "estrutura de dados" realmente consciente provavelmente estaria na lista, muito mais do que hoje.