melhor maneira de "apresentar" OOP / OOD à equipe de engenheiros experientes em C ++

Estou procurando uma maneira eficiente, que também não seja um insulto, de introduzir conceitos de POO aos membros da equipe existentes? Meus colegas de equipe não são novos nos idiomas OO. Fazemos C ++ / C # há muito tempo, de modo que a própria tecnologia é familiar.

No entanto, olho em volta e sem grande infusão de esforço (principalmente na forma de revisões de código), parece que estamos produzindo um código C que, por acaso, está dentro de classes. Quase não há uso de princípio de responsabilidade única, abstrações ou tentativas de minimizar o acoplamento, apenas para citar alguns. Eu já vi classes que não têm um construtor, mas obtêm o memset como 0 toda vez que são instanciadas.

Mas toda vez que eu mostro OOP, todos sempre concordam e fazem parecer que sabem exatamente do que estou falando. Conhecer os conceitos é bom, mas nós (alguns mais que outros) parecemos ter muita dificuldade em aplicá-los quando se trata de entregar um trabalho real.

As revisões de código têm sido muito úteis, mas o problema com as revisões de código é que elas ocorrem apenas após o fato; portanto, para alguns, parece que acabamos reescrevendo (é principalmente refatoração, mas ainda leva muito tempo) o código que acabou de ser escrito. As revisões de código também fornecem feedback para um engenheiro individual, não para toda a equipe.

Estou brincando com a idéia de fazer uma apresentação (ou uma série) e tentar abrir o OOP novamente, juntamente com alguns exemplos de código existente que poderiam ter sido escritos melhor e que poderiam ser refatorados. Eu poderia usar alguns projetos realmente antigos que ninguém possui mais, pelo menos essa parte não deve ser uma questão delicada. No entanto, isso vai funcionar? Como eu disse, a maioria das pessoas faz C ++ há muito tempo, então meu palpite é que: a) elas ficam lá pensando por que estou dizendo coisas que já sabem ou b) elas podem realmente encarar isso como um insulto, porque dizendo que eles não sabem como fazer o trabalho que vêm realizando há anos, senão décadas.

Existe outra abordagem que atingiria um público mais amplo do que uma revisão de código, mas ao mesmo tempo não pareceria uma palestra de punição?

Eu não sou um garoto recém-formado que tem ideais utópicos de código perfeitamente projetado e não espero isso de ninguém. A razão pela qual estou escrevendo isso é porque fiz uma revisão de uma pessoa que realmente tinha um design decente de alto nível no papel. No entanto, se você imaginar as classes: A -> B -> C -> D, no código B, C e D implementam quase a mesma interface pública e o B / C tem funções de um liner, de modo que a classe A superior está fazendo absolutamente todo o trabalho (até gerenciamento de memória, análise de strings, negociações de configuração ...) principalmente nos métodos 4 mongo e, para todos os efeitos, chama quase diretamente para o D.

Atualização: Sou líder técnico (6 meses nessa função) e tenho total suporte do gerente do grupo. Estamos trabalhando em um produto muito maduro e os custos de manutenção estão definitivamente se tornando conhecidos.

Por que você não desenvolve um treinamento curto nos princípios do SOLID e oferece a eles esse treinamento? Parece ter funcionado muito bem para mim na minha organização atual e acho que dar treinamentos curtos é realmente divertido (para todos os envolvidos).

Quando dei meu treinamento, levei algum tempo para procurar exemplos "ruins" patológicos no código existente (de vários projetos) e os refatorei na apresentação, passo a passo, usando os princípios. Isso demonstrou que

1. Não é tão difícil fazer essas refatorações
2. Não demora muito
3. O resultado final (cuidadosamente escolhido ;-)) é claramente melhor que o código original.

As revisões de código foram muito úteis, mas o problema com as revisões de código é que elas ocorrem somente após o fato.

Em um projeto, fizemos revisões de design.

15 minutos. No quadro branco. Fale sobre o design antes da codificação.

A parte mais importante é agendar a revisão do design antes de qualquer trabalho de implementação.

Também tivemos "Critical Design Reviews", que foram um grande negócio. Eles envolveram muitos documentos e uma longa apresentação. Eles eram difíceis de programar e quase sempre eram adiados até o início da codificação, reduzindo seu valor a zero.

As revisões informais do projeto - antes da codificação - sem pressão - sem documentação - permitem uma melhor discussão sobre como as responsabilidades são atribuídas e como os objetos colaborarão.

Suponho que você seja mais jovem do que alguns dos desenvolvedores, mas mais alto na cadeia alimentar.

Correndo o risco de ser enterrado em votos negativos, pode ser que os 'engenheiros experientes' estejam de fato fazendo a coisa certa - ou como esse é um produto maduro que já existe há décadas, o que já foi a coisa certa.

O código mais antigo tende a ter sido otimizado para executar rapidamente no hardware da época; entre outras coisas, isso significa reduzir os níveis de herança e evitar funções / métodos que exigem operações triviais.

Os compiladores ficaram muito mais inteligentes ao longo dos anos, então nem tudo o que era verdade agora é - por exemplo, um compilador pode optar por incorporar uma pequena função.

Talvez um caminho a seguir seria adotar uma abordagem diferente - peça aos desenvolvedores que expliquem como / por que o método deles é melhor do que a teoria que você aprendeu - e sejam sinceros.

Pressionar para testes de unidade com uma cobertura de 100% de ramificação de cada método novo / alterado não levaria a minimizar o acoplamento entre os métodos.

Convém pegar o livro "Design Patterns" da Gang of Four. Não é específico para C ++, portanto você não está criticando abertamente o conhecimento de C ++ de seus colegas quando se refere a ele. No entanto, ao mesmo tempo, aborda tópicos que você considera relevantes. Além disso, o livro é amplamente aceito como relevante, então eles não podem facilmente descartá-lo como teórico ou impraticável.

Por outro lado, considere que o C ++ não é uma linguagem OO pura, nem no design nem na prática. Toda a história do construtor / memset parece que você deve apresentar o RAII, que não é uma técnica de OO, mas é específico para C ++ (infelizmente - o IDispose do .Net mostra o que acontece quando o RAII é uma reflexão tardia). Os livros relevantes aqui são (Mais) C ++ Efetivo e (Mais) C ++ Excepcional.