Como assumo a responsabilidade pelo meu código quando um colega faz melhorias desnecessárias sem aviso prévio?

Um dos meus colegas de equipe é especialista em toda a loja de TI e eu respeito sua visão.

No entanto, às vezes ele analisa meu código (ele é o segundo em comando do líder da nossa equipe, então isso é esperado) sem aviso prévio. Então, às vezes, ele revisa minhas alterações antes que elas concluam o objetivo final e faça alterações imediatamente ... e até interrompeu meu trabalho uma vez.

Outras vezes, ele fez melhorias desnecessárias em alguns dos meus códigos com mais de 3 meses de idade.

Isso me irrita por alguns motivos:

1. Nem sempre tenho a chance de corrigir meus erros
2. Ele não teve tempo para me perguntar o que eu estava tentando realizar quando estava confuso, o que poderia afetar seus testes ou alterações.
3. Eu nem sempre acho que o código dele é legível
4. Os prazos não são um problema e sua carga de trabalho atual não exige nenhum trabalho em meus projetos além de revisar minhas alterações de código.

De qualquer forma, eu disse a ele no passado para me manter informado se ele vê algo no meu trabalho que ele quer mudar para que eu possa tomar posse do meu código (talvez eu devesse ter dito "deficiências") e ele não tenha respondido bem. .

Temo que possa parecer agressivo quando lhe pedir que me explique suas mudanças.

Ele é apenas uma pessoa quieta que se mantém calada, mas suas ações continuam. Não quero bani-lo de fazer alterações no código (não como eu poderia), porque somos uma equipe - mas quero fazer minha parte para ajudar nossa equipe.

Esclarecimentos adicionados:

• Compartilhamos 1 ramo de desenvolvimento. Não espero até que todas as minhas alterações concluam uma única tarefa, pois correrei o risco de perder um trabalho significativo - por isso, garanto que minhas alterações sejam construídas e que não quebrem nada.
• Minha preocupação é que meu colega de equipe não explique a razão ou o objetivo por trás de suas alterações. Eu não acho que ele precise da minha bênção, mas se discordarmos de uma abordagem, achei melhor discutir os prós e contras e tomar uma decisão depois que ambos entendermos o que está acontecendo.
• Ainda não discuti isso com o líder da nossa equipe, pois preferiria resolver desacordos pessoais sem envolver a gerência, a menos que seja necessário. Como minha preocupação parecia mais um problema pessoal do que uma ameaça ao nosso trabalho, optei por não incomodar o líder da equipe. Estou trabalhando nas idéias do processo de revisão de código - para ajudar a promover os benefícios de revisões de código mais organizadas, sem expor tudo sobre minhas irritações.

Acho que a maioria dos desenvolvedores se encontra nessa posição em algum momento, e espero que todo desenvolvedor que se sentiu vitimado perceba o quão frustrante será quando ele ou ela se tornar o mais velho e se sentir compelido a limpar o código escrito pelos juniores.

Para mim, evitar conflitos nessa situação se resume a duas coisas:

1. Cortesia . Conversar com alguém sobre seu código permite que um desenvolvedor saiba que você está interessado e pode discuti-lo como profissionais adultos.

2. Esqueça a "propriedade do código" - a equipe é proprietária do código . Outras pessoas que desejam fazer as alterações são boas. Se um desenvolvedor sênior fizer alterações "ilegíveis" ou piores, faça o backup. Você não precisa ser agressivo, deixe um editor saber que suas alterações não funcionaram e você fica feliz em discutir sua reversão.

Lembre-se de que a propriedade do código pela equipe é excelente e funciona nos dois sentidos. Se você vir algo que não faz sentido no código de outra pessoa, corrija-o. Ser excessivamente possessivo e inadequadamente comunicativo é uma maneira infalível de criar um ambiente de desenvolvimento venenoso.

Você e a maioria dos respondentes abordam isso como um problema de comunicação entre dois colegas, mas eu realmente não acho que seja. O que você descreve parece mais um processo de revisão de código horrivelmente quebrado do que qualquer outra coisa.

Primeiro, você menciona que seu colega é o segundo em comando e espera-se que ele revise seu código. Isso está errado. Por definição, as revisões de código por pares não são hierárquicas e, certamente, não são apenas para encontrar defeitos. Eles também podem fornecer experiências de aprendizado (para todos os envolvidos), uma oportunidade de interação social e provar uma ferramenta valiosa para a criação de propriedade coletiva do código. Você também deve revisar o código dele de tempos em tempos, aprender com ele e corrigi-lo quando ele estiver errado (ninguém faz o certo toda vez).

Além disso, você menciona que seu colega faz alterações imediatamente. Isso também está errado, mas é claro que você já sabe; você não teria feito essa pergunta se a abordagem dele não fosse um problema. No entanto, acho que você está procurando uma solução no lugar errado. Para ser perfeitamente honesto, seu colega me lembra um pouco de ... eu, e o que funcionou para mim em situações semelhantes foi um processo de revisão sólido e bem definido e um conjunto de ferramentas impressionantes. Você realmente não quer impedir seu colega de revisar seu código e pedir que ele pare e fale com você antes que todas as pequenas mudanças não funcionem. Pode demorar um pouco, mas em breve ele chegará a um ponto em que tudo ficará muito irritante e você voltará aonde começou, ou pior: ele simplesmente deixará de revisar seu código.

Uma chave para uma resolução aqui pode ser uma ferramenta de revisão de código por pares. Normalmente evito recomendações de produtos, mas para revisões de código Crisol de Atlassiané realmente um salva-vidas. O que ele faz pode parecer muito simples, e é, mas isso não significa que não é incrivelmente incrível. Ele se conecta ao seu repositório e oferece a oportunidade de revisar conjuntos de alterações individuais, arquivos ou grupo de arquivos. Você não pode alterar nenhum código, mas comentar sobre tudo que não parece certo. E se você absolutamente precisar alterar o código de outra pessoa, basta deixar um comentário com o conjunto de alterações explicando suas alterações. Vale a pena assistir ao vídeo introdutório na página do produto do Crisol, se você quiser mais detalhes. Os preços do Crisol não são para todos, mas existem inúmeras ferramentas de revisão por pares disponíveis gratuitamente. Com quem trabalhei e gostei foi o Painel de Revisão e tenho certeza de que você encontrará muitos outros com uma simples pesquisa no Google.

Qualquer que seja a ferramenta que você escolher, ela mudará completamente seu processo. Não há necessidade de parar, levantar da cadeira, interromper a outra pessoa e discutir as mudanças; tudo o que você precisa fazer é dar um tempo toda semana e passar pelos comentários (uma vez por semana é apenas uma sugestão. Você conhece melhor sua programação e rotina diária do que eu). Mais importante, as análises principais são armazenadas em um banco de dados em algum lugar e você pode recuperá-las a qualquer momento. Eles não são discussões efêmeras em torno do bebedouro. Meu caso de uso favorito para revisões antigas é ao apresentar um novo membro da equipe à nossa base de código. É sempre bom quando eu posso orientar alguém novo na base de código, apontando onde exatamente estávamos presos, onde tínhamos opiniões diferentes etc.

Seguindo em frente, você menciona que nem sempre acha o código desse colega legível. Isso me permite saber que você não possui um conjunto comum de padrões de codificação, e isso é uma coisa ruim. Novamente, você pode abordar isso como um problema de pessoas ou como um problema de processo e, novamente, sugiro fortemente o último. Reúna sua equipe e adote um estilo comum de codificação e um conjunto de padrões o mais rápido possível. Realmente não importa se você escolheu um conjunto de padrões comuns no seu ecossistema de desenvolvimento ou se criou o seu próprio. O que realmente importa é que seus padrões sejam consistentes e que você os cumpra. Muitas e muitas ferramentas por aí podem ajudá-lo, mas essa é uma discussão totalmente diferente. Apenas para você começar, uma coisa muito simples de fazer é ter um gancho de pré-confirmação executando algum tipo de formatador de estilo no seu código. Você pode continuar escrevendo seu código da maneira que desejar e deixar a ferramenta "corrigi-lo" automaticamente, antes que alguém o veja.

Por fim, você menciona em um comentário que a gerência não acredita que sejam necessários ramos de desenvolvimento individuais. Bem, há uma razão para chamá-los de "ramificações de desenvolvimento" e não "ramificações de gerenciamento". Vou parar por aqui, pois não há razão para o discurso retórico que está se formando em minha cabeça sair.

Tudo isso dito, saiba que não duvido que seu colega esteja (um pouco) culpado aqui. Esse não é o meu ponto, meu argumento é que todo o seu processo de desenvolvimento também está errado, e isso é algo mais fácil de corrigir. Arme-se com as ferramentas adequadas, explore os inúmeros processos formais e informais e escolha aqueles que se encaixam na sua equipe. Em breve você chegará a um ponto em que perceberá que a maioria dos seus "problemas com as pessoas" não existe mais. E, por favor, não ouça ninguém (inclusive você) que traga a desculpa de "somos uma equipe pequena, não precisamos de tudo isso". Uma equipe de desenvolvedores competentes pode configurar as ferramentas necessárias em menos de uma semana, automatizar tudo o que pode ser automatizado e nunca olhar para trás novamente.

PS. "Propriedade do código" é um termo nebuloso, constantemente debatido, e significa coisas diferentes para pessoas diferentes. Você pode encontrar uma coleção brilhante da maioria das opiniões diferentes (e às vezes antitéticas) sobre C2 .

Qual é o processo que faz você querer assumir a responsabilidade por "seu código"? Você tem a responsabilidade exclusiva de manter certos recursos funcionando? O líder disse "Michael, quero que você assuma a responsabilidade por ..."? Ou sua responsabilidade está implícita, na medida em que o líder e o restante da equipe olham para você toda vez que certos recursos são desfeitos?

De qualquer forma, se você tiver a responsabilidade, precisará de autoridade sobre o código. Na próxima vez que o outro sujeito fizer mudanças unilaterais e o líder voltar para você para corrigi-lo, sente-se e peça para alinhar sua autoridade e responsabilidade.

Não que isso resolva toda a situação, mas você pode tentar adicionar mais comentários ao seu código-fonte.

1. Se o código não estiver completo, poderá ser marcado como tal.
2. Se o objetivo de um bloco de código não for auto-documentado, você deve documentá-lo.

Tudo e todos, tente fazer limonada, em vez de perder tempo chupando limões. Como Michael disse, em geral, os colegas de equipe não querem fazer você parecer mal. Tente aprender com seus erros e aplicá-los a futuras revisões.

Se você acredita que as mudanças dele estão tendo um impacto negativo, exprima isso (diplomaticamente). Se fosse eu, eu simplesmente perguntaria por que alterações específicas foram feitas e verificamos se você pode defender suas alterações originais. Seus colegas de trabalho seniores também são humanos. É bem possível que ele tenha perdido algo e / ou não tenha conhecimento de qualquer impacto negativo que esteja causando.

Todos implicitamente 'possuem seu próprio código', independentemente da política, legalismo ou economia - é a 'natureza das coisas' - você naturalmente sente uma conexão pessoal com seu próprio trabalho.

Se o seu colega de trabalho está se engajando no comportamento que você descreveu e permanece indiferente ao pedir um alerta , esse colega de trabalho é descortês, para dizer o mínimo, e pode estar tentando prejudicá-lo (para dizer o pior .. .) - NÃO soa como um jogador da equipe.

Um bom colega de trabalho iria tocar na base com você e apontar o problema com o seu código para você - e deixou fixar / alterá-lo ou responder apropriadamente. Sou muito grata por, mesmo quando eu era recém-nascida, meus mentores sempre apontarem para mim o que eu estava fazendo de errado, explicar o porquê e me deixar (ou me fazer ) consertá-lo. Isso me fez um programador melhor e todos se beneficiaram. E é isso que sempre fiz ao revisar o trabalho realizado por outras pessoas. Então você (ou quem quer que seja) aprende alguma coisa com o seu 'pau para toda obra', e o código e a equipe ficam melhores, incluindo o professor: o ensino ajuda a entender.

Se for possível, eu discutirei o assunto em particular com o líder da equipe. Com base na sua descrição da situação, um bom líder de equipe vai ficar do seu lado - um ruim não. ... Obviamente, isso requer cautela - você terá que julgar por si mesmo.

Se você escrever um código, eu devo revisá-lo.

Se eu alterar o seu código durante a revisão, o código não será mais o código que eu revisei, mas o código que eu alterei. Portanto, ele precisa ser revisto. Provavelmente por você.

Se eu confirmar seu novo código com minhas alterações sem que alguém as revise, cometi (1) uma alteração não revisada e (2) o pior pecado possível se as revisões de código forem levadas a sério.

Eu acho que você está lidando com isso da maneira certa por enquanto - mas em breve haverá um ponto de inflexão em que isso o distrai a ponto de você não ser feliz em codificar dessa maneira.

Se eu fosse você, solicitaria um rápido contato individual com essa pessoa e explicaria meu ponto de vista com calma e firmeza. A propriedade do código da equipe etc. é boa, mas, a menos que você ofereça espaço suficiente a todos os desenvolvedores para realizar seu trabalho, cometer erros e melhorar, você nunca criará um bom código. Esta pode ser uma área de atrito mais cedo ou mais tarde.

(Existe uma resposta totalmente diferente se isso ocorreu no local de trabalho. Troca de pilha. Descobrir a maneira correta de fazer revisões de código é a parte mais fácil. Convencer seu colega de trabalho a cumprir isso é muito mais difícil).