Existe alguma técnica na programação que você considera excessivamente usada (o IE usou muito mais do que deveria) ou abusou, ou usou um pouco para tudo, embora não seja uma solução realmente boa para muitos dos problemas que as pessoas tentam resolver resolver com isso.

Pode ser expressões regulares, algum tipo de padrão de design ou talvez um algoritmo, ou algo completamente diferente. Talvez você pense que as pessoas abusam de várias heranças etc.

Comentários no Código

Eu só gostaria que os professores da universidade entendessem que não precisam ensinar seus alunos a escrever 10 linhas de comentários dizendo que o código a seguir é um loop for, iterando de 1 a um número de x. Eu posso ver isso no código!

Ensine-os a escrever o código de auto-documentação primeiro e depois os comentários apropriados sobre o que não pode ser adequadamente a auto-documentação em segundo. O mundo do software seria um lugar melhor.

O padrão de design singleton.

Claro, é um padrão útil, mas toda vez que um novo programador aprende sobre esse padrão, ele começa a tentar aplicá-lo em todas as classes que cria.

A coisa mais má para proteger a programação idiota. colocando tudo em uma tentativa de pegar e não fazer nada com a captura

        try
        {
            int total = 1;
            int avg = 0;
            var answer = total/avg;
        }
        catch (Exception)
        {

        }

Estremeço quando vejo uma tentativa que não faz nada e foi projetada para lidar com lógica idiota. Em geral, as capturas por tentativa são muito usadas, no entanto, em alguns casos, são muito úteis.

Confie no StackOverflow para resolver seus problemas, em vez de descobrir da maneira mais difícil.

Novos programadores que encontram a riqueza de conhecimentos em SO (com muita frequência) publicam antes de pensar e experimentar.

Nos meus dias, tivemos que codificar livros, sem internet, sem SO. Agora saia do meu gramado.

OOP evidentemente. É muito valioso, mas quando mal utilizado , pode obscurecer o código claro com bastante facilidade (alguns exemplos de programação S4 em R vêm à mente) e pode gerar uma sobrecarga tremenda que é desnecessária e pode custar muito tempo no desempenho.

Outra coisa é que (em Perl, por exemplo) OOP geralmente se resume a escrever a mesma coisa de maneira inversa: em result = $object ->function(pars)vez de result = function(object, pars)Isso às vezes faz sentido, mas quando misturado à programação procedural, pode tornar a leitura do código bastante confusa. Além disso, você apenas introduz mais despesas gerais, onde não melhora o design. Tudo se resume ao que também é dito sobre o padrão singleton: deve ser usado, mas não em tudo.

Eu mesmo uso o OOP, mas no meu campo (computação científica) o desempenho é muito importante, e o OOP é frequentemente abusado lá, pois todos os alunos obtêm Java atualmente. É ótimo para lidar com problemas maiores, para conceituar e assim por diante. Mas se você trabalha com, por exemplo, seqüências de DNA no BioPerl, usar os objetos todas as vezes e trabalhar consistentemente com getters e setters pode aumentar o tempo de cálculo em dez vezes. Quando seu código está sendo executado por alguns dias, em vez de algumas horas, essa diferença realmente importa.

Tendo passado vários anos em ASP.NET Webforms, eu teria que dizer inequivocamente:

A interface do usuário inteligente

Embora seja perfeitamente possível criar aplicativos testáveis ​​em camadas em formulários da web, o Visual Studio facilita demais para os desenvolvedores clicarem em um caminho para formulários fortemente vinculados à fonte de dados, com a lógica do aplicativo espalhada por todo o código da interface do usuário.

Steve Sanderson explica esse anti-padrão muito melhor do que eu em seu livro do Pro ASP.NET MVC:

Para criar um aplicativo Smart UI, o desenvolvedor primeiro cria uma interface do usuário, geralmente arrastando uma série de widgets da interface do usuário para uma tela e preenche o código do manipulador de eventos para cada clique possível no botão ou outro evento da interface do usuário. Toda a lógica do aplicativo reside nesses manipuladores de eventos: lógica para aceitar e validar a entrada do usuário, executar acesso e armazenamento de dados e fornecer feedback atualizando a interface do usuário. Todo o aplicativo consiste nesses manipuladores de eventos. Essencialmente, é isso que tende a sair por padrão quando você coloca um iniciante na frente do Visual Studio. Nesse design, não há separação de preocupações. Tudo é fundido, organizado apenas em termos dos diferentes eventos da interface do usuário que podem ocorrer. Quando regras lógicas ou comerciais precisam ser aplicadas em mais de um manipulador, o código geralmente é copiado e colado, ou certos segmentos escolhidos aleatoriamente são fatorados em classes de utilidade estática. Por tantas razões óbvias, esse tipo de padrão de design é freqüentemente chamado de antipadrão.

Vejo isso ocasionalmente e geralmente resulta de não entender completamente as expressões booleanas.

if (someCondition == true)

Reimplementar a funcionalidade principal (ou de outra forma fornecida), devido à ignorância de sua existência ou devido a uma necessidade percebida de customizações.

Herança.

Não imponha um local onde não faça sentido.

Personalizando o software pronto para uso.

Embora reconheça que isso pode ser útil, pergunto-me quanto dinheiro é gasto na realização de pequenas coisas para obter ganhos questionáveis. É aqui que uma empresa pode gastar centenas de milhares, senão milhões de dólares, em licenças para alguns softwares que são personalizados porque são tão configuráveis, editáveis ​​e flexíveis que realmente não fazem muito por padrão. No final, é um aplicativo personalizado por causa de todo o novo código adicionado ao que foi comprado inicialmente.

Usando o complier como um depurador.

Ignorando avisos complementares ou desativando-os completamente.

Variáveis ​​globais.

Todos os padrões de design.

Eles são como sal ou açúcar. Alguns deles na sua comida tornam ótima, muitos deles fazem sua comida ser uma merda.

Não me interpretem mal. Padrões de design são técnicas maravilhosas. Eu os usei bastante. Mas, às vezes, encontro programadores (alguns deles meus ex-chefes), que tiveram esses "você precisa usar um padrão de design", mesmo que não corresponda ao problema !!!

Um exemplo é o "Padrão do visitante", que é mais direcionado para "Coleções lineares / sequenciais". Eu tive que trabalhar com uma estrutura de dados em árvore, uma vez. Para "visitar" cada item, codifico um método sem padrão de design, e um ex-chefe insiste em usar ou adaptar o "Padrão de Visitante". Então, eu navego na net, para uma segunda opinião. Bem, outros programadores tiveram a mesma situação e a mesma solução. E chame-o de "Padrão de Árvore / Visitante Hierárquico"., Como um NOVO Padrão de Design

Espero que seja adicionado como um novo padrão aos existentes, em uma nova versão do livro "Design Patterns".

Usando exceções como controle de fluxo. Tipo de semelhante a esta resposta , mas diferente.

A deglutição de exceções é incorreta porque introduz erros misteriosos e difíceis de encontrar no código. O uso de exceções como controle de fluxo, por outro lado, é ruim porque torna o código muito mais ineficiente do que poderia ser e é conceitualmente desleixado.

O tratamento de exceções deve ser usado apenas para lidar com cenários realmente excepcionais (duh) e imprevistos, não com coisas como um usuário digitando um caractere alfabético em que um número é esperado. Esse tipo de abuso de exceção é extremamente comum entre programadores ruins no mundo Java.

Eu irei com inflexibilidade através da ocultação excessiva de dados.

Todos sabemos que a abstração e a ocultação da implementação são boas, mas nem sempre mais é melhor. Exagerado, você pode obter um resultado inflexível que não pode lidar com alterações nos requisitos. Para lidar com a mudança, você não apenas precisa modificar a classe que precisa lidar com essa mudança, mas também precisa criar um caminho para que as informações que elas nunca precisavam antes sejam acessíveis, apesar das camadas ocultas de dados.

O problema é que, como em todos os problemas para encontrar o equilíbrio certo para cada contexto, é preciso experiência.

Expondo matrizes internas

    public class Data {
    int[] x;

    public void setArray(int[] x) {

        this.x = x;
    }

    public int[] getArray() {

        return x;
    }
}

De acordo com http://www.oracle.com/technetwork/java/seccodeguide-139067.html

copie objetos mutáveis ​​antes de retornar, a menos que a intenção seja compartilhar estado.

Estado mutável e loops. Você quase nunca precisa deles e quase sempre obtém um código melhor sem eles.

Por exemplo, isso é obtido diretamente de um thread StackOverflow:

// ECMAScript
var thing, things_by_type = {};
for (var i = 0; i < things.length; i++) {
    thing = things[i];
    if(things_by_type[thing.type]) {
        things_by_type[thing.type].push(thing);
    } else {
        things_by_type[thing.type] = [thing];
    }
}

# Ruby
things_by_type = {}
things.each do |thing|
  (things_by_type[thing.type] ||= []) << thing
end

Ambos estão fazendo a mesma coisa. Mas não tenho ideia do que eles estão fazendo. Felizmente, a pergunta realmente explica o que eles estão fazendo, então pude reescrevê-los da seguinte maneira:

// ECMAScript
things.reduce(function (acc, thing) {
    (acc[thing.type] || (acc[thing.type] = [])).push(thing);
    return acc;
}, {});

# Ruby
things.group_by(&:type)

// Scala
things groupBy(_.type)

// C#
from thing in things group thing by thing.Type // or
things.GroupBy(thing => thing.Type);

Não há loops nem estado mutável. Bem, ok, não explícito loops e sem contadores de loop.

O código tornou-se muito mais curto, muito mais simples, muito mais como uma descrição do que o código deveria fazer (especialmente no caso do Ruby, ele diz diretamente "agrupar as coisas por tipo") e muito menos propenso a erros. Não há perigo de executar o final da matriz, erros de barreira ou erros de um por um com os índices de loop e condições de finalização, porque não há índices de loop e condições de finalização.

Zombando. Introduz muitos requisitos artificiais para dissociação excessiva no seu código, leva a códigos de ravioli superengenharia e força o design no estilo OO pela garganta quando um design mais processual ou funcional pode ser uma solução mais simples para o seu problema.

Programadores Delphi em todo o mundo descobriram nos últimos dois anos o quão ruim é usar matrizes de caracteres para armazenar bytes devido à conversão Unicode em adolescentes

E, "em breve", aprenderemos o quão ruim é armazenar números inteiros em listas quando queremos fazer a alteração para 64 bits.

Propriedades. Sei que isso é controverso, mas sinto que as propriedades são amplamente usadas no .net.

Qual é a diferença entre essas duas linhas?

public string Property { get; set; }

public string Field;

Para o desenvolvedor, a diferença é: absolutamente nada. O formulário compilado é um pouco diferente; portanto, se você estiver escrevendo uma biblioteca, e essa biblioteca for atualizada em programas e não puder recompilar os programas (por exemplo, se estiver escrevendo uma interface para plugins que deve funcionar em versões do seu software), então você não deve usar campos públicos porque não pode substituí-los por propriedades. Em qualquer outro caso, não há absolutamente nenhuma diferença entre usar um campo ou uma propriedade automática sem modificadores.