Os padrões de design são desaprovados?

Tive uma discussão com um de nossos desenvolvedores seniores que atua no ramo há 20 anos. Ele é muito conhecido em Ontário por um blog que escreve.

O mais estranho é o que ele me disse: ele disse que há um código que é um pesadelo para se trabalhar, porque foi escrito em um livro didático e não dá conta do mundo real. Adicionar um novo campo à interface do usuário / banco de dados / camada de dados leva de duas a três horas, enquanto no código dele são necessários 30 minutos.

A outra coisa também é que ele evita padrões de design porque a maioria dos programadores não os entende e eles não são bons do ponto de vista de manutenção.

Depois, há também a ideia de que a maioria dos desenvolvedores da Web no Canadá prefere herdar seu modelo de dados das classes da camada de dados, em vez de mantê-lo isolado. Perguntei-lhe: "Não é padrão da indústria separar o modelo da camada de dados?" Ele disse algumas vezes, mas a maioria das pessoas aqui prefere não fazer isso porque é muito trabalho.

Parece que o raciocínio dele para não codificar usando as práticas recomendadas é porque é um pesadelo de manutenção, poucos de nossos funcionários o entendem (além de mim) e é lento trabalhar com isso, se você precisar adotar novos recursos ou campos em alguns dias ' Tempo.

É tão estranho ouvir uma opinião como essa, considerando que o Stack Overflow encoraja as pessoas a seguir os padrões da indústria. O problema é que somos constantemente forçados a criar novos campos e recursos em questão de dias, que não é possível deduzir um padrão sólido que seja suficientemente flexível? Essa parece ser a essência do que eu entendo disso.

O que você faz dessas declarações?

Essas são as palavras de alguém que encontrou sucesso e ignora as pessoas que tentam dizer a ele o que fazer no jargão padrão que ele não entende.

Padrões de design e práticas recomendadas não são a mesma coisa. Algumas pessoas pensam que são e levam as pessoas que sabem o que estão fazendo a loucura. Mesmo que eles não saibam o nome apropriado para o que estão fazendo.

Os padrões de design existiam antes de terem nomes. Nós demos nomes a eles para facilitar a conversa sobre eles. Um padrão que tem um nome não o torna uma coisa boa. Isso torna uma coisa reconhecível.

Esse cara provavelmente está usando padrões dos quais nenhum de vocês já ouviu falar. Tudo bem, até que você precise conversar com ele sobre como algo é feito. Ele terá que aprender a falar com você ou você terá que aprender a conversar com ele. Não tem nada a ver com quem está "certo".

Muitos padrões de design, do tipo que você e seu amigo estão descrevendo, são realmente apenas soluções alternativas para deficiências nas linguagens de programação . Use uma linguagem de programação mais expressiva e a maioria desses padrões de design desaparece.

Como são necessários bons padrões de design para atender a muitos cenários de uso possíveis, eles tendem a ser excessivamente projetados. O código com excesso de engenharia tem um custo: você precisa lê-lo, entender o que faz e entender como ele funciona no contexto de todo o sistema de software. Consequentemente, como em qualquer outra técnica de desenvolvimento de software, você deve avaliar a técnica em relação ao custo de uso da técnica e decidir se os benefícios excederão o custo.

Sendo todas as outras coisas iguais, menos código é sempre melhor. Eu já passei por arquiteturas em camadas nas quais você literalmente precisa fazer de três a seis saltos em vários projetos para encontrar qualquer código que seja interessante, ou seja, código que realmente realize algo além de adicionar sobrecarga.

Padrões de software conhecidos devem fornecer um vocabulário comum pelo qual você pode comunicar estratégias de design. Infelizmente, muitos desenvolvedores de software não entendem o vocabulário de padrão de software suficientemente bem para aplicá-lo adequadamente a seus problemas de programação. Desenvolvedores inexperientes veem esses padrões como estando no domínio de especialistas; eles querem ser vistos como especialistas e, portanto, tentam aprender e aplicar os padrões cedo demais, antes de estarem prontos. Em vez disso, o que eles realmente devem fazer é se concentrar em aprender os fundamentos da programação e depois tentar resolver o problema que cada padrão se resolve. Se eles fizerem isso, estarão em uma posição muito melhor para entender e aplicar os padrões corretamente.

Stackoverflow.SE e Programmers.SE incentivam principalmente as pessoas a seguir as melhores práticas, como o SOLID, não os padrões do setor . E, acredite ou não, o padrão de fato da indústria costuma ser a arquitetura da "grande bola de barro" - a sério.

Mas, para responder diretamente à sua pergunta: o problema com os padrões de design é semelhante ao da herança - muitos desenvolvedores medíocres os usam demais, o que tem um certo risco de criar código com engenharia e difícil de manter. Mas a resposta para isso é certamente não evitar ou proibir completamente o uso de padrões de design (ou herança); a resposta é aprender a usar essas ferramentas em situações em que elas fazem sentido e somente lá. E isso é totalmente independente do trabalho "ágil" ou não.

1. Padrões de design são apenas nomes usados ​​para comunicar idéias. Muitas vezes me vi fazendo coisas que depois achei que tinham um nome. Portanto, não existe uma "maneira de padrão de design" em oposição a uma "maneira de padrão sem design".

2. Padrões de design são diretrizes. Como tudo, cada um deles tem vantagens e desvantagens. A chave não é aprender o padrão e aplicá-lo onde ele se encaixa, mas entender a idéia do padrão, as vantagens e desvantagens que ele possui e usá-lo para obter inspiração para a solução do seu problema.

3. Todas as melhores práticas e diretrizes podem ser ignoradas se houver um motivo suficientemente bom. Os motivos válidos incluem o tempo de desenvolvimento e as expectativas do aplicativo. Por exemplo, eu sei que é ruim codificar valores (exemplo estúpido), mas para uma prova de conceito, as vantagens podem superar os custos (nesse caso, principalmente o tempo de desenvolvimento). No entanto, se uma decisão como essa for tomada, ela poderá sair pela culatra e, em algum momento, poderá ser necessária uma refatoração.

Para adicionar outra metáfora à sopa, os padrões de design são Clippy, o auxiliar do Microsoft Office. "Você parece estar fazendo a mesma coisa com um monte de coisas. Posso ajudá-lo com isso oferecendo-lhe Iterator ou Visitante?"

Uma boa redação desses padrões indicará quando é útil fazer algo da mesma maneira que foi feito muitas vezes antes, quais erros você cometerá na primeira vez em que tentar e quais maneiras comuns foram encontradas para evitar esses erros . Então você lê o padrão de design (ou revisa-o de memória) e depois continua seu trabalho. O que você não pode fazer é usar apenas o Clippy e os assistentes.

Onde pessoas inexperientes podem dar errado e escrever código que não leva em conta a realidade é quando acham que sua lista de padrões de design é uma lista completa de todas as abordagens possíveis para resolver problemas em software e tentam criar código vinculando design padrões até terminar. Outra tática ruim observada na natureza é colocar um padrão de design em uma situação para a qual não é realmente adequado, com base no fato de que o padrão de design "é uma prática recomendada". Não, pode ou não ser a melhor prática para a classe de problema que realmente resolve , mas certamente não é uma boa prática para problemas que ela não resolve, ou para problemas que ela resolve apenas introduzindo uma complexidade desnecessária quando há uma solução mais simples .

É claro que também é possível que alguém evite um padrão com base no YAGNI, depois perceba que ele precisa e tateia em direção à solução normal. Isso geralmente é (mas nem sempre) pior do que cumprir o requisito desde o início e é por isso que mesmo no desenvolvimento ágil é frustrante quando requisitos totalmente previsíveis não são descobertos cedo. Não posso ter sido o único programador de C ++ que se divertiu ao ver que o Java inicialmente rejeitava contêineres genéricos como desnecessariamente complexos e depois os trancou mais tarde.

Portanto, é quase certamente um erro evitar escrever um Iterator por princípio, porque você prefere evitar padrões de design.

A adição de um novo campo à camada UI / banco de dados / Dados leva de duas a três horas para ser executada, enquanto no código dele são necessários 30 minutos.

Você realmente não pode argumentar com isso: por essa métrica, o design dele é muito melhor que o outro. Seja porque ele evitou os padrões de design, é questionável, acho que é mais provável porque ele considerou os problemas "do mundo real" certos ao projetá-lo e, com o benefício da experiência, é melhor em seu trabalho do que alguém armado apenas com um livro e altos ideais.

Então, ele reconheceu que qualquer padrão que requer que você toque em muitos pontos diferentes no código para adicionar um campo é um padrão ruim para o trabalho, "facilite a adição de campos" e ele não os usou. As arquiteturas em camadas podem de fato sofrer nesse aspecto, e é errado usar padrões de design sem apreciar suas desvantagens.

Por outro lado, quanto tempo leva para escrever uma nova interface do usuário em seu design e quanto tempo leva em uma arquitetura em camadas? Se o projeto o pedisse para criar e implantar constantemente novas interfaces de usuário em um modelo de dados fixo, em vez de adicionar campos constantemente, esperançosamente ele teria criado isso. Ou também. Mas, apesar de todos os seus benefícios, dizer que "estamos agilizando" infelizmente não significa que você nunca precisará fazer outra troca!

A seleção de um menu de padrões de design certamente pode impedi-lo de pensar nas preocupações mais importantes. Mas reconhecer quando você está escrevendo um Visitante e documentá-lo ou nomeá-lo como "Visitante" para ajudar os leitores a obtê-lo rapidamente, não atrapalha muito em nada. Escrever "este é um visitante" em vez de documentá-lo corretamente é um erro terrível pela razão que seu desenvolvedor sênior fornece - os programadores não entenderão. Até os programadores que sabem o que é um visitante precisam de mais informações do que apenas "este é um visitante".

Seu colega parece sofrer da síndrome do NIH ("Não inventado aqui").

É perfeitamente plausível que o código dele facilite a adição de novos campos: também sou muito mais rápido para atualizar meu próprio código do que o código escrito por outros caras. Mas essa velocidade de curto prazo não diz nada sobre a capacidade de manutenção e portabilidade do código. Darei a ele o benefício da dúvida: o código existente pode de fato ser mal estruturado se tiver seguido mal um livro ou uma boa receita no contexto errado.

Evitar padrões de design é realmente surpreendente. Nos meus últimos 30 anos de codificação e gerenciamento de codificadores, os padrões de design ajudaram a colocar palavras em coisas que foram feitas instintivamente, ajudando a entender mais rapidamente a intenção, as vantagens, os inconvenientes, os riscos, as oportunidades e os padrões relacionados. Os padrões de design provaram ser verdadeiros aceleradores para dominar a complexidade!

• Talvez o seu colega seja realmente muito mais inteligente do que a maioria de nós e possa arcar com a sobrecarga de reinventar padrões sem uma diminuição perceptível da produtividade?

• Os argumentos de que "programadores não entendem padrões de design" parecem "Não consigo explicar o que estou fazendo". Ou "Eu não quero discutir sobre o meu próprio design". Eu realmente acho que a padronização poderia alavancar o entendimento geral e permitir que colegas menos experientes compartilhem opiniões valiosas. Mas talvez seu colega sênior queira evitar exatamente isso.

As abordagens em camadas provaram ser superiores a outras arquiteturas na maioria dos aplicativos corporativos. Os pacotes líderes de classe mundial são estruturados em torno dessa idéia e superam as arquiteturas artesanais por ordens de magnitude. Martin Fowler apresenta essa abordagem em seu excelente livro "Padrões da arquitetura corporativa". Oh! Desculpe novamente: trata-se de padrões comprovados; sem chance na visão NIH do seu colega ;-)

Um insight importante que muitas pessoas sentem falta é que o design de software é contextual. Ele existe para atingir objetivos de negócios, e objetivos diferentes podem exigir abordagens diferentes. Em outras palavras, não existe um design que seja sempre melhor, mesmo que sempre exista um design melhor.

Os padrões de design são soluções padrão para problemas padrão. No entanto, se você não tiver o problema, resolvê-lo é um desperdício de esforço.

A principal diferença entre o design em cascata e o software ágil é quando as decisões de design são tomadas. Em cascata, reunimos todos os requisitos, identificamos quais padrões de design precisamos e só então começamos a codificar. Na arquitetura ágil, seguimos o princípio YAGNI para adiar as decisões de design até o último momento responsável, quando sabemos o máximo possível sobre a escolha.

Ou seja, em cascata, os padrões de design tendem a ser aplicados se sua necessidade for antecipada , em modo ágil, quando forem realmente necessários . Como conseqüência, projetos ágeis tendem a aplicar padrões de design com menos frequência, porque nem todas as necessidades previstas são reais.

Os padrões de design não são realmente chamados de padrões de design porque prescrevem o que fazer. Padrões de design são padrões de design porque descrevem o que foi feito antes . Alguns desenvolvedores projetaram um método que executou bem uma tarefa específica e foram capazes de aplicá-lo a situações semelhantes com resultados semelhantes. É só isso. Muitos padrões têm pontos fortes e fracos inerentes, e cabe ao desenvolvedor instruído avaliar as necessidades tecnológicas e comerciais para determinar um padrão apropriado a ser aplicado.

Nessa perspectiva, a menos que você esteja realmente comprometido em escrever um código único de 100%, onde nenhum conceito ou implementação é utilizável de um caso de uso para o outro, você certamente está usando pelo menos alguns padrões de design. Eles podem não ter nomes chamativos e comuns, como "Repositório" ou "Unidade de Trabalho" ou mesmo "MVC", mas isso não os torna "não um padrão de design".

Eu geralmente gosto de pensar na maneira de - digamos - "navegação" usando o GPS. Ao aprender as "melhores práticas" e os "padrões de design" - você aprende a seguir a rota de navegação GPS. Mas quando você conhece a área, geralmente aprende que dirigir por uma estrada secundária o levará a áreas problemáticas passadas, a chegar mais rápido e / ou melhor. É o mesmo quando se trata dessas coisas - a experiência permite desconstruir sua caixa de ferramentas e tomar atalhos.

Aprender padrões de design e aprender "práticas recomendadas" significa que você entende melhor a ideia por trás, para poder escolher em uma determinada situação. Como as situações da vida real costumam ser mais complexas em comparação com as situações teóricas - você frequentemente terá restrições e problemas não encontrados nos livros didáticos. Clientes / clientes querem seu produto rápido e geralmente barato; Você precisa trabalhar com código legado; Você precisa interagir com ferramentas de terceiros que podem muito bem ser caixas pretas e ineficazes; e todo tipo de coisas. Sua situação é específica - as melhores práticas e padrões são mais gerais.

Um dos principais motivos pelos quais muitas pessoas em sites como o SE fornecerão respostas de "melhores práticas" e respostas de "padrão de design" é o fato de estarem respondendo com soluções gerais e abstratas e, assim, ajuda a fornecer um idioma comum para resolver um tipo de problemas E para você aprender.

Portanto, os padrões de design não são desaprovados nos ambientes de desenvolvimento Agile; entretanto, o desenvolvimento raramente é geral e abstrato o suficiente para se encaixar perfeitamente em um padrão, e o desenvolvedor (experiente) sabe disso.

A adição de um novo campo à camada UI / banco de dados / Dados leva de duas a três horas para ser executada, enquanto no código dele são necessários 30 minutos.

Se você deseja "otimizar" um design, precisa dizer o que está tentando otimizar.

Por exemplo, uma bicicleta de corrida é um veículo otimizado ... e um Boeing 747 também é um veículo otimizado ... mas eles são otimizados para um conjunto diferente de requisitos.

A ideia do padrão "MVC", por exemplo, otimiza para coisas como:

• Vistas diferentes do mesmo modelo (a vista é independente do modelo)
• Cada camada pode ser desenvolvida separadamente (por exemplo, por equipes diferentes) e testada separadamente (testes de unidade) antes da integração
• etc.

Enquanto o código dele pode estar otimizando para outra coisa, por exemplo:

• Linhas mínimas de código
• Fácil para uma pessoa fazer uma alteração que afeta todas as camadas (por não ter camadas realmente distintas)
• etc.

As descrições de padrões começam com uma descrição do problema que o padrão se destina a resolver. Se ele acha que é "melhor prática" não usar um padrão específico, então (assumindo que não seja um padrão estúpido, assumindo que seja um padrão que às vezes é útil), suponho que ele não tenha / tenha o problema específico que esse padrão alega. para resolver e / ou ele tem um problema diferente (maior ou mais urgente, concorrente), que ele está tentando otimizar.

Padrões de design são ferramentas. Como as ferramentas, existem duas maneiras de usá-las: a maneira correta e a maneira incorreta. Por exemplo, se eu lhe dar uma chave de fenda e um prego, e pedir-lhe para se juntar dois pedaços de madeira juntos, você deve me pedir um martelo. Martelos são usados ​​para pregos, enquanto chaves de fenda são usadas para parafusos.

Com muita frequência, um padrão de design é anunciado como o Único Caminho Verdadeiro, que geralmente é verdadeiro apenas quando surgem problemas específicos. Os desenvolvedores juniores geralmente são como crianças quando encontram algo novo para brincar; eles querem aplicar esse padrão de design a tudo . E não há nada de errado com isso, desde que eles aprendam que o Padrão A se aplica ao Problema B e o Padrão C se aplica ao Problema D. Assim como você não usa uma chave de fenda para pregar pregos, você não usa uma determinada padrão apenas porque existe; você usa o padrão porque é a melhor ferramenta (conhecida) para o trabalho.

O outro lado dos padrões são anti-padrões. Coisas que provaram ser repetidas vezes ruins, geralmente em termos de tempo de execução ou memória. No entanto, padrões e antipadrões não são bons para o desenvolvedor que não entende por que eles existem. Os desenvolvedores gostam de pensar que o que estão fazendo é novo e inventivo, mas na maioria das vezes não. Provavelmente já foi pensado antes. As pessoas antes deles criaram os padrões por causa da experiência.

É claro que os desenvolvedores juniores geralmente parecem ter novas maneiras de fazer coisas antigas, e às vezes essas maneiras são melhores. No entanto, muitas vezes acaba sendo um caso do efeito Dunning-Kruger; o desenvolvedor sabe o suficiente para criar um programa funcional, mas não entende suas próprias limitações. A única maneira de superar isso parece ser através da experiência, tanto positiva quanto negativa. Eles ignoram os padrões porque se consideram superiores, mas não sabem que, na realidade, 10.000 desenvolvedores já usaram um design específico e o descartaram porque era realmente ruim.

O Agile é a favor de "fazer as coisas de maneira responsiva" no que diz respeito ao rápido ajuste à evolução das necessidades do cliente. Não favorece os padrões de design nem os despreza. Se um padrão é o método mais rápido e confiável, o desenvolvedor deve usá-lo. Se um padrão em particular custaria mais tempo do que simplesmente "fazê-lo", é provável que usar algo que não seja um padrão (supondo, é claro, que o desempenho não seja severamente degradado, etc.). Se nenhum padrão conhecido puder ser encontrado, é preferível criar um design próprio do que dizer ao cliente "não". Clientes, especialmente clientes pagantes, geralmente têm razão.

Qualquer um que afirme que os padrões são o Caminho, ou que os padrões sejam o Dilema da Existência, está errado. Padrões são ferramentas, destinadas a serem aplicadas a situações específicas e têm graus variados de sucesso com base nas circunstâncias. Essa é uma verdade, que não depende de você escolher o MVC ou não, se você usa objetos de transferência de dados ou não, etc. O que importa é implementar código em um período de tempo razoavelmente curto, com desempenho razoável para os usuários, e é razoavelmente livre de erros lógicos.

Normalmente , os padrões permitirão uma forma coerente de design e terão um desempenho melhor do que ignorar todos os padrões em favor de escrever idéias 100% originais, mas você não poderá evitar todos os padrões. Por exemplo, se y = x + 5, você realmente escreverá y = x + (5 * 3 + 15/3) / 4, apenas para evitar o padrão de escrever x + 5? Não, você não é. Você vai escrever y = x + 5 e seguir para o próximo problema.

As pessoas usam padrões todos os dias, e tudo bem . O que mais importa é ter um código que seja logicamente funcional, que raramente trava e seja fácil de usar. Nada mais importa mais do que isso.

Você não pode 'evitar padrões de design', exceto que eu acho que evito projetar duas partes do seu sistema da mesma maneira (o que eu não recomendo e duvido que seu desenvolvedor sênior esteja fazendo). O que ele provavelmente quer dizer é 'evitar usar cegamente um design apenas porque ele adere a um padrão de design'. Pensar no que você está fazendo é definitivamente uma 'melhor prática', e uma universidade deve existir para ensinar; infelizmente, isso não parece estar acontecendo.

Os padrões de design não são antitéticos às práticas ágeis. O que é antitético às práticas ágeis é o uso de padrões de design, a fim de usar padrões de design, a prática comum entre recém-formados e estudantes de pensar na linha de "como vamos resolver esse problema usando um padrão de fábrica".

Agile significa escolher a melhor ferramenta para o trabalho, NÃO tentar moldá-lo para se adequar à ferramenta que você selecionou.
E é isso que TODAS as práticas de desenvolvimento do senso comum se resumem (embora muitas vezes você precise fazer compromissos, porque a seleção de ferramentas que você pode escolher é geralmente restrita aos padrões corporativos, restrições de licença (como a GPL e às vezes outras ferramentas de código aberto) não pode ser usado, especialmente na criação de software para revenda) e coisas assim.

Seu colega / amigo provavelmente se opôs ao seu código não porque ele usa padrões de design em si, mas porque é uma construção artificial projetada para mostrar o uso de um padrão específico quando outro design seria melhor (embora muitas vezes subjetivo, eu (e muitos comigo, sem dúvida) viram muitos exemplos em que o uso forçado de um padrão de design específico levou a códigos feios, difíceis de manter e altamente ineficientes).