Eficiência x reaproveitamento em linguagens de Script

Primeiramente preciso esclarescer o porque deste tópico. Dedico o mesmo aos meus colegas de trabalho, pois diariamente temos que nos entender com alguns (vários) scripts em C (vulgo "Czão") estruturado. Acredito que os pensamentos expressos aqui também são válidos para outras linguagens mais novas, tais como PHP (ainda que estruturado) e alguns príncipios para Ruby e Python (embora eu não conheça muito bem ainda estas tecnologias). E deixo bem claro que ainda sou do time do pessoal de OO =D.

A discussão é a seguinte: Como avaliar/garantir performance, escalabilidade, reaproveitamento, manutenção, usabilidade em um ambiente tão hostil e precário que é a programação estruturada?

Com a experiência que vim adquirindo, comecei a me questionar se eu poderia usar algumas boas práticas que a metodologia de OO prega, já que ela nasceu de códigos estruturados e de uma necessidade de evolução. Acompanho de perto várias opiniões, sobre o uso ou não uso de funções separadas, includes, algoritmos com maior ou menor complexidade e etc.

Vamos considerar a pirâmide abaixo com 3 variáveis para facilitar o entendimento:



O desafio é: Como manter o equilíbrio da pirâmide? Analisando cada extremidade pode-se concluir:

Manutenção:

• Para que eu torne mais fácil de ser alterado, eu posso evitar o uso de funções, includes e algoritmos de alta complexidade. Crio tudo em um único método [main()], não individualizo cada regra de negócio ou cada passo da rotina. LOGO:
• Não é possível reaproveitar nenhuma regra de negócio;
• Perco performance, pois ao invés de utilizar um algoritmo ou uma query cabeluda, faço vários "nós" de fácil entendimento para qualquer um e resolvo o problema;

Performance:

• Para que eu torne meu código mais performático, eu me esforço ao máximo, passando horas para desenvolver aquela algoritmo que utiliza todo o conceito de ponteiros, estrutura de dados, busca binárias, algoritmos de ordenação ou então para fazer aquela belíssima Query de 300 linhas. LOGO:
• Meu código comprovadamente roda muito mais rápido agora, porém o único "mágico" capaz de entender o mesmo é danado do filho da minha mãe (detalhe: ela só tem um);
• Meu algoritmo/procedure/query é tão específica que só atende à aquele passo do fluxo, logo não aproveito nem com um CTRL+C e CTRL+V;

Reaproveitamento

• Para que eu possa aproveitar as regras de negócio que talvez possam existir em mais de um domínio, eu crio vários arquivos de código fonte (#includes), destrincho algumas funcionalidades em funções que depois poderei ainda no pior caso aproveitar no CTRL+C e CTRL+V. LOGO:
• Para cada "main()" precisarei de vários arquivos para garantir sua execução, ta, tudo bem... EU SEI quais são. Será que o filho da mãe do outro vai saber no dia que eu não mexer mais com isso?
• Lembrem-se do DEBUG com #includes? Dispensa comentários =D
• Minha função que calcula A+B também por acaso divide A/B, mas neste caso só preciso do primeiro cálculo... hum... performance....

Enfim, entre outros casos, logo temos a figura da pirâmide um pouco mais ilustrada:



O próximo passo é tentar provar o contrário da figura, ou seja, estressar um dos lados sem afetar o outro. Missão difícil na minha opinião, a melhor maneira, é saber dosar e tentar encontrar o equilíbrio.

Bom, acho que isso é um bom início de discussão. Comentários e opiniões são bem vindos :)

Abraços!