Sistema * Proprietário do código *: é uma maneira eficiente? [fechadas]

Há um novo desenvolvedor em nossa equipe. Uma metodologia ágil está em uso em nossa empresa. Mas o desenvolvedor tem outra experiência: ele considera que partes específicas do código devem ser atribuídas a desenvolvedores específicos. Portanto, se um desenvolvedor tivesse criado um procedimento ou módulo de programa, seria considerado normal que todas as alterações do procedimento / módulo fossem feitas apenas por ele.

No lado positivo, supostamente com a abordagem proposta, economizamos tempo de desenvolvimento comum, porque cada desenvolvedor conhece bem sua parte do código e faz as correções rapidamente. A desvantagem é que os desenvolvedores não conhecem o sistema completamente.

Você acha que a abordagem funcionará bem para um sistema de tamanho médio (desenvolvimento de um site de rede social)?

Como muitas dessas perguntas, acho que a resposta é:

Depende

Há razões para acreditar que assumir a posição de que todo programador deve conhecer todas as linhas de código está equivocado.

Se assumirmos por um momento que alguém com um entendimento profundo de um pedaço de código fará alterações 5 vezes mais rápido do que alguém que não o conhece (nem um grande salto de fé na minha experiência) e leva cerca de um mês de experiência em codificação para obter uma compreensão realmente boa de um módulo de tamanho significativo (também não irracional), podemos executar alguns números (completamente falsos e fictícios):

• Programador A: possui profundo entendimento
• Programador B: nenhum

Digamos que o programador A obtenha 1 unidade de trabalho por dia. Em 4 semanas de 5 dias úteis, ele / ela pode realizar 20 unidades de trabalho.

Assim, o programador B, começando com 0,2 unidades de trabalho por dia e terminando com 0,96 unidades de trabalho em seu 20º dia (no 21º dia eles são tão bons quanto o programador A), realizará 11,6 unidades de trabalho no mesmo Período de 20 dias. Durante esse mês, o programador B alcançou 58% de eficiência em comparação com o programador A. No entanto, agora você tem outro programador que conhece esse módulo, bem como o primeiro.

Claro, em um projeto de tamanho decente, você pode ter ... 50 módulos? Portanto, familiarizar-se com todos eles leva cerca de 4 anos, e isso significa que o programador de aprendizado está, em média, trabalhando com 58% de eficiência em comparação com o programador A ... hmmm.

Portanto, considere este cenário: mesmos programadores, mesmo projeto (A sabe tudo e B não sabe disso). Digamos que existem 250 dias úteis no ano. Vamos supor que a carga de trabalho seja distribuída aleatoriamente pelos 50 módulos. Se dividirmos os dois programadores igualmente, A e B recebem 5 dias úteis em cada módulo. A pode realizar 5 unidades de trabalho em cada módulo, mas B só obtém, de acordo com minha pequena simulação do Excel, 1,4 unidades de trabalho realizadas em cada módulo. O total (A + B) é de 6,4 unidades de trabalho por módulo. Isso ocorre porque B passa a maior parte do tempo sem nenhuma habilidade com o módulo em que está trabalhando.

Nessa situação, é mais ideal focar B em um subconjunto menor de módulos. Se B se concentrar em apenas 25 módulos, eles terão 10 dias em cada um, totalizando 3,8 unidades de trabalho em cada um. O programador A pode passar 7 dias cada um nos 25 módulos em que B não está trabalhando e 3 dias trabalhando nos mesmos módulos B. A produtividade total varia de 6,8 a 7 unidades por módulo, com média de 6,9, e é significativamente maior do que as 6,4 unidades por módulo que fizemos quando A e B espalharam o trabalho uniformemente.

À medida que reduzimos o escopo dos módulos nos quais B trabalha, obtemos ainda mais eficiência (até certo ponto).

Treinamento

Eu também argumentaria que alguém que não conhece muito sobre um módulo interromperá a pessoa que faz muito mais do que alguém com mais experiência. Portanto, esses números acima não levam em consideração que quanto mais tempo B passa no código que eles não entendem, mais tempo eles gastam fazendo perguntas e, às vezes, A precisando ajudar a corrigir ou solucionar o que B fez. Treinar alguém é uma atividade demorada.

Solução ideal

É por isso que acho que a solução ideal deve se basear em perguntas como:

• Qual é o tamanho da sua equipe? Faz sentido ter todo mundo treinado em todas as partes, ou se tivermos uma equipe de 10 pessoas, podemos apenas garantir que cada módulo seja conhecido por pelo menos três pessoas? (Com 10 programadores e 50 módulos, cada programador precisa conhecer 15 módulos para obter cobertura 3x).
• Como está a rotatividade de funcionários? Se você está contratando funcionários em média a cada 3 anos e leva mais tempo para conhecer realmente todos os cantos do sistema, eles não estarão disponíveis o tempo suficiente para que o treinamento seja recompensado.
• Você realmente precisa de um especialista para diagnosticar um problema? Muitas pessoas usam a desculpa "e se essa pessoa sai de férias", mas eu fui chamado várias vezes para diagnosticar um problema em um sistema com o qual eu não tinha experiência. Pode ser verdade que a pessoa experiente possa encontrá-la muito mais rapidamente, mas isso não significa que você não possa viver sem ela por uma semana ou duas. Poucos sistemas de software são tão críticos que o problema precisa ser diagnosticado em 1 hora em vez de 5 horas ou o mundo terminará. Você tem que pesar esses riscos.

Por isso acho que "depende". Você não deseja dividir 20 módulos entre dois programadores no meio (10 cada), porque não tem flexibilidade, mas também não deseja treinar 10 programadores em todos os 50 módulos, pois perde muito eficiência e você não precisa de muita redundância.

É uma péssima ideia . Pode ser mais rápido a curto prazo, mas incentiva códigos mal documentados e difíceis de entender, pois apenas o codificador que os escreveu é responsável por mantê-lo. Quando alguém sai da empresa ou sai de férias, todo o plano fica estragado. Também torna muito difícil alocar cargas de trabalho; o que acontece quando dois bugs urgentes criam o código que um codificador "possui"?

Você deve codificar em equipe . Naturalmente, as pessoas receberão tarefas alocadas e se concentrarão em determinadas áreas, mas o compartilhamento da carga de trabalho e o trabalho conjunto devem ser incentivados, e não desencorajados.

Depende de qual é o domínio do problema.

Se são coisas gerais (por exemplo, ações simples de CRUD, etc.), concordo com Tom Squires (qualquer pessoa deve poder trabalhar com ela e editá-la).

No entanto ...

Se a solução em questão exigir experiência no domínio (muito tempo foi investido no passado ou muita pesquisa precisa ser feita antes da implementação, pois isso é algo que você listaria em um requisito de trabalho como conhecimento especializado que nem todo mundo no projeto tem), então um proprietário deve ser definitivamente atribuído a essa parte do código. Dito isto, qualquer pessoa deve poder fazer modificações conforme necessário, mas sempre deve ser revisada pela pessoa que possui a área do projeto.

Você não quer que sua equipe inteira (ou várias pessoas na equipe) pesquise e aprenda o mesmo assunto (ciclos desperdiçados). Designe um proprietário, mas peça que ele documente seus aprendizados e projetos e talvez faça com que eles realizem sessões de treinamento informais (ou formais, realmente não importam) sobre a tecnologia.

Essa é uma ideia horrível . Eu trabalhei em uma empresa que usou essa abordagem e é praticamente uma receita para montes de dívida técnica . A conclusão é que duas cabeças quase sempre são melhores que uma. Por quê? Porque, a menos que você seja um idiota, sabe que não é um programador perfeito e não vai perceber todos os erros que cometer. É por isso que você precisa de uma equipe - mais olhos olhando para o mesmo código de diferentes perspectivas.

Tudo se resume a uma coisa: disciplina . Quantos programadores solitários você conhece verdadeiramente disciplinados em seu estilo de codificação? Quando você não codifica com disciplina, toma atalhos (porque você "corrige mais tarde") e a manutenção do código é prejudicada. Todos sabemos que "mais tarde" nunca chega. Fato : é mais difícil usar atalhos quando você é imediatamente responsável perante os colegas de uma equipe. Por quê? Porque suas decisões serão questionadas e é sempre mais difícil justificar atalhos. Resultado final? Você produz um código melhor e mais sustentável que também é mais robusto.

A vantagem é que nem todo mundo precisa pesquisar e entender tudo. A desvantagem é que isso torna cada pessoa necessária para sua própria área de código, e ninguém mais sabe como mantê-la.

Um compromisso seria ter pelo menos 2 proprietários para cada área de código. Então, alguém pode sair de férias, arrumar um novo emprego ou se aposentar, e ainda existe alguém que conhece o código (e pode treinar a nova segunda pessoa). Nem todo mundo precisa aprender tudo, o que é um pouco mais eficiente.

Não tenha as mesmas 2 (ou 3) pessoas que trabalham juntas o tempo todo. Troque pares para áreas diferentes, para que o conhecimento também seja compartilhado inadvertidamente ao trabalhar com uma pessoa diferente em uma área de programa relacionada.

Sim, é um pouco mais eficiente, a curto prazo. E aí termina os benefícios. Isso nem chega a compensar o custo.

O que acontece quando ele está de férias, ou inesperadamente doente, ou sai, ou é atropelado pelo ônibus proverbial? O que acontece quando você deseja flexibilizar recursos para realizar um trabalho mais rapidamente que outro? Qual a eficácia das revisões de código? Como um gerente, especialmente um que não está na base de códigos, pode saber se o desenvolvedor está trabalhando duro ou puxando a lã sobre os olhos? Quem notará se a dívida técnica começar a aumentar?

Na minha experiência, as pessoas que gostam de trabalhar dessa maneira são caçadoras de glória, na melhor das hipóteses, preguiçosas na pior. Eles gostam de ser a única pessoa para quem você pode ir com um determinado problema e gostam que seu código permaneça privado. E eles geralmente gostam de codificar rapidamente, sem levar em consideração a legibilidade.

Isso não quer dizer que, em uma equipe de 50 desenvolvedores, todos devam conhecer todo o código, mas uma equipe de 5 a 7 deve possuir um módulo grande o suficiente para manter essas pessoas trabalhando. Nenhum indivíduo deve possuir nada.

Há pelo menos três questões que as outras respostas apontam; mas eu gostaria de tentar tratar os dois juntos. Os dois problemas são:

• experiência : alguém da equipe possui conhecimento detalhado sobre um campo específico; esse conhecimento é independente da implementação específica desse domínio no projeto
• liderança : Embora o trabalho de construção do projeto possa ser compartilhado por muitos desenvolvedores; o roteiro, bem como as decisões imediatas sobre detalhes importantes da implementação, estão nas mãos de um membro específico da equipe ou apenas de alguns membros da equipe.
• código sem ego : A maneira particular como o projeto é implementado não depende dos estilos, práticas ou conhecimentos de codificação de qualquer desenvolvedor em particular na equipe; e pela estrita adesão a um estilo de codificação conhecido ou a uma especificação bem mantida, qualquer novo membro da equipe tem a mesma chance de entender os comos e os porquês do projeto como os desenvolvedores experientes.

Quando o tópico é puramente de especialização, o sucesso do projeto pode depender de um alto nível de conhecimento sobre o domínio; mas não depende do conhecimento de um especialista específico desse domínio. Os especialistas, embora talvez raros e valiosos, ainda são essencialmente intercambiáveis; um contador tributário experiente é tão útil para um projeto de software de planejamento tributário quanto outro, do ponto de vista do conhecimento do domínio. O problema passa a ser o quão bem o especialista é capaz de transferir seu conhecimento para o projeto.

Quando o tópico é puramente de liderança, o sucesso do projeto depende principalmente da consistência e percepção das decisões tomadas pelo líder do projeto; embora tendamos a favorecer leads de projetos com experiência no domínio ou que sejam comprovados como líderes de projetos, isso às vezes é secundário à função. O "líder" pode mudar de um dia para o outro se as decisões tomadas forem consistentes de um caso para o outro e cada decisão for rapidamente executada pela equipe. Se isso estiver funcionando corretamente; muitas decisões não precisam ser "tomadas" pelo líder do projeto, porque a equipe já entende quais decisões serão tomadas.

Eu não acho que a pergunta fosse realmente sobre código sem ego, mas é difícil falar sobre propriedade de código sem discutir também a importância desse problema. Manter um projeto é provavelmente a maior parte do ciclo de desenvolvimento. A maneira de entender esse problema é imaginar o que aconteceria se alguns desenvolvedores tivessem que abandoná-lo imediatamente. O que aconteceria se toda a equipe tivesse que ser substituída? Se o projeto for colocado em dúvida porque depende de alguns atores importantes, você corre um alto risco de falha. Mesmo que você nunca perca um único membro da equipe, o simples fato de que um ou alguns desenvolvedores são necessários para avançar no projeto significa que você pode não estar trabalhando tão eficientemente quanto faria se houvesse mais desenvolvedores.

A propriedade do código tende a impedir a refatoração, criar gargalos de desenvolvimento e causar problemas de ego quando o código tem problemas que devem ser tratados.

Eu recomendo consultar os autores do código antes de alterar, mesmo que o código de alto padrão deva ser suficientemente documentado, testado por unidade, testado por integração e testado pelo sistema para tornar isso redundante, mas não custa nada obter outra opinião.

Isso é ruim por várias razões, eu trabalhei em uma loja onde eles tentaram mudar isso para algo mais razoável e era feio.

As razões pelas quais isso é ruim:

• Se o proprietário do código tirar férias e aparecer algum bug grande, será muito difícil e demorado tentar aprender o código E consertar o bug
• Se o proprietário do código deixar a empresa, seus projetos serão severamente atrasados, pois todo o patrimônio e conhecimento tribal acabaram de sair da empresa
• A documentação é ruim. Se eu sou a única pessoa a codificar nele, por que documentá-lo? Relacionado é o problema de que qualquer documentação forçada a ser criada também provavelmente será ruim, porque ninguém saberá o suficiente sobre o código para realmente dizer se a documentação está completa ou mesmo precisa.
• As guerras santas do código podem facilmente se inflamar quando todo mundo tem sua própria pequena caixa de areia, pois outros mencionaram que isso pode se tornar realmente estúpido rapidamente. Onde esse é um problema é quando duas pessoas precisam trabalhar juntas, nenhuma delas está acostumada a comprometer nada.
• Por causa do ponto acima, as habilidades de trabalho em equipe nunca se formam - as pessoas nunca precisam trabalhar com outras pessoas.
• Os feudos podem se formar facilmente, pequenos reinos feitos de bolsões de lixo que não compram nada para a empresa. Você não sabe que isso está acontecendo até que seja tarde demais, porque o módulo ou a ferramenta X é responsabilidade de Bob, e ai de você que deve até perguntar o que Bob está fazendo em seu código.
• As revisões de código e as revisões por pares sofrem, pois ninguém sabe nada sobre o código. Se você não conhece o código, não consegue identificar os lugares que não estão certos e se limita a comentar apenas as convenções de formatação e nomeação de texto.
• E se você trabalha para mim ... a empresa possui o código, não você. Temos orgulho do que fazemos, do que realizamos e do que escrevemos, mas é uma coisa de grupo, como quando seu time vence uma partida difícil. Qualquer funcionário que trabalha para a empresa possui o código da mesma forma e, no decorrer de seu trabalho, é permitido editá-lo da maneira que desejar, para realizar seu trabalho, que é encaminhar os objetivos da empresa.

Os maiores são realmente os problemas de pessoal e a documentação. Essa pessoa sairá algum dia, e garoto, você estará pressionando a agenda para a esquerda por algumas semanas.

A melhor abordagem é fazer com que todos estejam familiarizados com todas as partes da base de código (ou meia dúzia de partes, se é realmente grande e diversificada), a ponto de poderem

• Corrija qualquer defeito nessa área
• Adicione novos recursos ou aprimoramentos menores ou moderados

Cada pessoa tende a conhecer um pouco mais sobre algumas coisas do que outras, portanto, para os problemas difíceis, dois ou três podem se unir, ou o especialista em defacto pode enfrentá-lo. Eu trabalhei em grupos onde esse era o caso e funcionou muito bem. Não apenas não havia nenhum dos contras listados acima, a equipe era muito mais previsível, já que não estávamos procurando especialistas.

O profissional da propriedade exclusiva do código é que o "proprietário do código" provavelmente pode fazer as coisas mais rapidamente do que outros, mas isso só é válido se todo mundo for um "proprietário do código" em projetos não sobrepostos. Em outras palavras, se as pessoas girarem em torno da vantagem do "único proprietário do código" desaparecerá.

Veja o número do caminhão, também conhecido como fator de ônibus

fator de ônibus (também conhecido como fator de caminhão ou número de ônibus / caminhão ) é uma medida da concentração de informações em membros individuais da equipe. O fator de barramento é o número total de desenvolvedores importantes que precisariam ser incapacitados (como serem atropelados por um ônibus / caminhão) para enviar o projeto a uma confusão tão grande que ele não seria capaz de prosseguir; o projeto reteria informações (como código fonte ) com as quais nenhum membro restante da equipe está familiarizado. Um fator de barramento alto significa que muitos desenvolvedores precisariam ser removidos antes que o projeto necessariamente falhasse.

"Ser atropelado por um ônibus" pode assumir muitas formas diferentes. Pode ser uma pessoa aceitando um novo emprego, tendo um bebê, mudando seu estilo de vida ou status de vida ou literalmente sendo atropelada por um ônibus: o efeito seria o mesmo ...

Como em muitas coisas, é um grande "depende". Se for um estrito "ninguém mais pode trabalhar no código", provavelmente está muito ruim. Se for "o proprietário deve fazer uma revisão de código antes de aceitar uma alteração", está indo muito bem, dependendo da disposição do proprietário em aceitar alterações externas.

A desvantagem é grave; o "número do caminhão" da sua equipe se torna praticamente 1.

Para revisar, o "número do caminhão" é definido simplesmente como "quantos membros da equipe, na pior das hipóteses, podem ser atingidos por um caminhão antes que o conhecimento necessário para executar alguma tarefa crítica seja perdido para a equipe".

É natural, e de certa forma, encorajado, que os desenvolvedores se concentrem nas sub-disciplinas; se todos tivessem que saber tudo sobre o projeto, nada seria feito porque todos aprenderiam o que todos haviam feito, por que funciona e como pode ser alterado sem quebrá-lo. Além disso, se os desenvolvedores estão fazendo coisas diferentes em diferentes áreas, é menos provável que as mudanças colidam. Portanto, geralmente é bom ter dois ou três desenvolvedores ou pares de desenvolvedores que trabalham principalmente em um subsistema específico do projeto e o conhecem bem.

No entanto, se apenas uma pessoa toca em uma linha de código específica, quando esse cara sai, é demitido, sai de férias ou acaba no hospital, e essa linha de código é demonstrada como a causa de um bug isso deve ser corrigido, alguém precisa entrar e entender o código. Se ninguém mais, além do cara que o escreveu, já viu, isso levará tempo para chegar a um nível de entendimento que permita ao desenvolvedor fazer a alteração que corrige o bug sem fazer mais. O TDD pode ajudar, mas apenas informando ao desenvolvedor que eles fizeram a alteração "errada"; novamente, o desenvolvedor deve entender quais testes estão exercitando qual código para garantir que os testes que falham não estejam tentando fazer afirmações erradas.

Não levo ao extremo, mas prefiro a responsabilidade pelo código . Você escreve código quebrado, deve corrigi-lo. Isso pode ser feito no nível individual, par ou equipe. Impede passar sua bagunça para outra pessoa para limpar. Isso vale para mudanças também.

Problemas de carga de trabalho e agendamento substituirão isso. Seria tolice adiar a correção de um erro grave, porque o culpado está de férias de duas semanas.

O objetivo não é ter sua equipe jogando "o jogo da culpa" ou levar a contagem de bugs muito longe (eles não são todos iguais de qualquer maneira). Baseie-se em quem verificou o código por último ou peça a um supervisor para tomar a decisão e atribuí-lo a alguém em vez de passar por todas as partes de cada linha de código.

Programadores melhores provavelmente acabam consertando muitos códigos de outras pessoas, não importa como você o atribua.