Demasiado controle de versão e sobrecarga de rastreamento de erros por alteração?

Eu trabalho em um lugar que é louco por CVS e louco por Bugzilla.

1. Há tantas ramificações em cada versão que não se pode contá-las. Todo mundo está constantemente se mesclando automaticamente.

2. Não há fluidez neste trabalho. Tudo parece travar . São necessários 25 passos, mesmo para uma coisa simples. Não é como estar em uma linha de produção da fábrica: é como montar uma fábrica todos os dias.

Exemplo de situação:

Para corrigir um único erro, primeiro obtenho uma nova máquina virtual limpa. Em seguida, crio uma ramificação para essa única correção de bug, com base em outra ramificação descrita no relatório do Bugzilla. Eu instalo a filial na máquina, configure isso. Eu conserto o bug. Faço o check-in, deixando-o e a máquina para que outros possam testar. Então eu tenho que entrar no software de controle de bugs e explicar o que fiz e escrever um caso de teste, com todas as etapas. Eventualmente, alguém o mescla com um release.

Não importa o quão pequeno o bug seja, eu tenho que fazer todas essas coisas. Às vezes, as pessoas combinam o trabalho em vários bugs, mas como eu disse, existem tantos ramos que isso dificilmente é possível.

Em qualquer outro trabalho, eu apenas entrava e corrigia o bug. Eu nem me lembro de usar o SCM, embora todos os trabalhos que eu já tenha usado: porque em todos os outros trabalhos, eles de alguma forma mantiveram isso fora do caminho .

Existe um ponto em que o processo atrapalha e se torna um fim em si mesmo? Isso é mesmo engenharia?

Existe um ponto em que o processo atrapalha e se torna um fim em si mesmo?

Infelizmente, processos pesados ​​são comuns. Algumas pessoas - especialmente a administração - imaginam religiosamente que os processos produzem produtos. Então, eles exageram nos processos e esquecem que são realmente poucas pessoas inteligentes e trabalhadoras que realmente criam os produtos. Para a alta gerência, é assustador até pensar que seus negócios estão nas mãos de poucos geeks, e assim fechar os olhos da realidade e pensar em seu querido "processo", o que lhes dá a ilusão de controle.

É por isso que as startups ágeis com um punhado de bons engenheiros podem vencer grandes empresas estabelecidas, cujos funcionários gastam 95% de sua energia em processos e relatórios. Alguns exemplos de pequenas startups que venceram seus concorrentes e / ou criaram mercados completamente novos:

• Apple (Apple I foi criada por 1 engenheiro; havia 3 homens na empresa naquela época).
• Google (criado originalmente por 2 programadores).
• Facebook ( esforço de 1 homem originalmente).
• Microsoft ( empresa de 2 homens em 1975).

Pode-se dizer facilmente que essas são apenas discrepâncias, exceções extremas e, para fazer algo sério, é melhor você ser uma corporação grande e estabelecida. Mas a lista continua. E assim por diante. É embaraçosamente longo. Quase todas as grandes empresas de hoje começaram como uma oficina, o que fazia algo incomum. Algo estranho. Eles estavam fazendo errado. Você acha que eles estavam fazendo isso de acordo com o processo?

As empresas geralmente sofrem do que eu gostaria de chamar de dilema Controle-Flexibilidade. Quanto menos regras, estruturas e despesas burocráticas, mais fácil e rápido é realizar as coisas (também é mais divertido). No entanto, é igualmente fácil fazer coisas "ruins" como coisas "boas". Isso significa que você só está bem quando possui funcionários qualificados que cometem alguns erros não críticos.

Por outro lado, se você tem muitos funcionários de baixo a semi-qualificados e / ou o custo de cometer erros é muito alto (como o risco de detritos de ônibus espaciais no hemisfério norte), as empresas tendem a acumular mais e mais "regras" "e" processos "para tentar minimizá-los.

O único problema é que a sobrecarga cumulativa desses processos dificulta a realização de qualquer coisa que resulte na saída de funcionários mais talentosos. Isso resulta na habilidade média diminuindo ainda mais, exigindo ainda mais processos e burocracia. Portanto, a espiral da morte continua até que algo radical aconteça ou a empresa decaia.

Se você se encontra em uma empresa que parece ter passado do ponto de não retorno nesse aspecto, pode resolver-se a "não se importar" com o seu trabalho (que é o que a maioria dos que já fez) ou dar o fora. de lá com a sua alma intacta :)

Se a empresa não foi longe demais e você tem os meios, pode tentar reverter o curso por pura determinação e força de vontade. Cuidado, porém, que isso pode exigir uma quantidade enorme de trabalho e energia pessoal sem garantia de sucesso; portanto, tenha certeza de que vale a pena. Às vezes, é melhor reduzir a perda e contar uma experiência mais rica.

Há apenas uma razão válida para esse estilo de desenvolvimento: o software desenvolvido é absolutamente essencial para a missão e não deve, em hipótese alguma, conter bugs. Pense no firmware de injeção de combustível do motor a jato nos aviões de passageiros, no firmware do marcapasso cardíaco ou no sistema de lançamento de mísseis nucleares.

Em todas as outras situações, o custo adicional matará o negócio. Hora de seguir em frente.

Esta pergunta realmente contém duas perguntas, que precisam ser abordadas separadamente:

Por que algumas equipes têm um processo de desenvolvimento rigoroso?

A resposta simples é porque, se não o fazem, erros acontecem. Erros caros. Isso vale para o desenvolvimento e também para o restante do campo de TI (administradores de sistemas, DBAs etc.).

É muito difícil para muitos desenvolvedores e profissionais de TI entenderem porque a maioria de nós já trabalhou em um dos "extremos" - grandes empresas do estilo Fortune, com pelo menos uma dúzia de desenvolvedores e processos rigorosos a seguir, ou pequenos, micro-ISVs ou até trabalhos freelancers, onde as pessoas simplesmente não estragam muito, ou o custo de um estrago é baixo.

Mas se você já viu uma empresa entre essas fases - mesmo uma empresa com uma equipe de TI brilhante e talentosa -, entenderá os perigos de não ter nenhum processo ou de ter um processo pela metade. Veja bem, a comunicação entre funcionários sofre de um problema de explosão combinatória ; Depois de atingir o nível de 6 a 10 desenvolvedores em uma única equipe, a principal causa de defeitos graves ou críticos não é a falta de talento ou conhecimento, mas a falta de comunicação.

Alice pergunta na segunda-feira de manhã e decide que não há problema em fazer uma cirurgia reconstrutiva no porta-malas, porque ninguém mais está trabalhando nessa parte. Bob chega uma hora depois, de volta de suas férias e cheio de energia e decide que ele implementará um novo recurso importante exatamente na mesma área, e por que se preocupar com um ramo, porque ninguém nunca toca nesse código? Então Alice paga essa "dívida técnica", Bob implementa seu recurso matador que está em segundo plano há 6 meses, e quando eles finalmente verificam seu código (logo antes do fechamento da sexta-feira, é claro!), Todo A equipe precisa ficar para trás e tentar lidar com o inferno de pesadelos de conflitos que continuam a viver como bugs e regressões ao longo das próximas semanas.

Alice e Bob Ambos fizeram um ótimo trabalho nas tarefas de codificação, mas ambos começaram com uma má decisão ("o que de pior pode acontecer?"). O líder da equipe ou o gerente de projetos os conduz a um post-mortem e elabora uma lista de verificação para impedir que isso aconteça novamente:

• Os check-ins devem ser diários para minimizar o impacto dos conflitos;
• Alterações que levarão significativamente mais de um dia devem ser feitas nas filiais;
• Todas as tarefas significativas (incluindo trabalhos que não são de recursos, como refatoração) devem ser adequadamente rastreadas e atribuídas no rastreador de erros.

Aposto que, para muitos de nós, esse "processo" parece apenas senso comum. É chapéu velho. Mas você sabia que muitas equipes menores não fazem isso? Uma equipe de dois homens pode nem se importar com o controle de origem. Quem se importa? Honestamente, não é necessário. Os problemas só começam a acontecer quando a equipe cresce, mas o processo não.

Obviamente, a otimização de processos é como a otimização de desempenho; segue uma curva exponencial inversa. A lista de verificação acima pode eliminar 80% dos defeitos, mas depois de implementada, você descobre que outra coisa é responsável pelos 80% restantes . Em nosso exemplo fictício, mas familiar, pode haver erros de compilação devido a diferentes ambientes de compilação, o que é devido ao fato de que não há hardware padrão e os desenvolvedores estão usando bibliotecas de código aberto que são atualizadas a cada 2 semanas.

Portanto, você tem três opções: (a) padronizar o hardware e restringir severamente o uso de bibliotecas de terceiros, o que é caro e pode prejudicar significativamente a produtividade ou (b) configurar um servidor de compilação, que requer a cooperação do grupo sysadmin e de um desenvolvedor em tempo integral para mantê-lo, ou (c) permitir que os desenvolvedores façam isso eles mesmos distribuindo uma máquina virtual padrão e instruindo os desenvolvedores a desenvolverem isso. Claramente (b) é a melhor solução a longo prazo, mas (c) possui um melhor equilíbrio a curto prazo de confiabilidade e conveniência.

O ciclo continua e continua. Todas as "políticas" que você vê geralmente foram instituídas para resolver um problema real. Como Joel Spolsky escreveu em 2000 (em um tópico completamente diferente, lembre-se, mas relevante, no entanto):

Quando você entra em um restaurante e vê uma placa que diz "Não são permitidos cães", você pode pensar que a placa é puramente proscritiva: o Sr. Restaurant não gosta de cachorros por perto, então quando ele construiu o restaurante, ele colocou a placa.

Se isso era tudo o que estava acontecendo, também haveria um sinal de "No Snakes"; afinal, ninguém gosta de cobras. E um sinal de "sem elefantes", porque eles quebram as cadeiras quando se sentam.

A verdadeira razão pela qual esse sinal existe é histórico: é um marcador histórico que indica que as pessoas costumavam tentar trazer seus cães para o restaurante.

É o mesmo na maioria das equipes de software (não direi todas): políticas como "Você precisa adicionar um caso de teste para cada correção de bug" quase sempre indicam que a equipe historicamente teve problemas com regressões. Regressões são outro daqueles problemas que são mais frequentemente causados ​​por falhas na comunicação do que por incompetência. Desde que você entenda a política, poderá usar atalhos legítimos (por exemplo, eu tive que corrigir 6 pequenos bugs, mas todos estavam no mesmo recurso, para que eu possa escrever apenas um caso de teste para todos os 9).

Isso explica por que os processos estão lá, mas não é a história toda. A outra metade é:

Por que o processo é tão difícil de seguir?

Esta é realmente a pergunta mais simples a ser respondida: é porque a equipe (ou seu gerenciamento) está focada em resultados repetíveis e na minimização de defeitos (como acima), mas não deu atenção suficiente à otimização e automação desse processo.

Por exemplo, na pergunta original, vejo vários problemas:

• O sistema de controle de revisão (CVS) é legado pelos padrões atuais. Para novos projetos, ele foi substituído quase inteiramente pelo subversion (SVN), que está rapidamente se eclipsando por sistemas distribuídos como o Mercurial (Hg). Mudar para Hg tornaria a ramificação e a fusão muito mais simples e, mesmo no meu exemplo hipotético acima, o requisito de confirmação diária se tornaria muito menos doloroso. O código nem precisa ser compilado, porque o repositório é local; - de fato, os desenvolvedores mais preguiçosos poderiam até automatizar esta etapa, se quisessem, configurando um script de logoff para confirmar automaticamente as alterações no repositório local.

• Não houve tempo para automatizar o processo da Máquina Virtual. Todo o processo de obtenção, configuração e download de fontes / bibliotecas para uma máquina virtual pode ser 100% automatizado. Pode ser um processo autônomo que você executa em um servidor central em algum lugar enquanto trabalha na correção de bugs em sua máquina local (e usa apenas a VM para garantir uma compilação limpa).

• Por outro lado, em uma certa escala, a solução VM por desenvolvedor começa a ficar boba e você deve ter apenas um servidor de Integração Contínua. É aí que surgem os reais benefícios da produtividade, porque (principalmente) libera os desenvolvedores individuais de terem que se preocupar com as construções. Não é necessário se preocupar em configurar máquinas virtuais limpas, porque o servidor de compilação está sempre limpo.

• A redação da pergunta ("caso de teste com todas as etapas") implica que há algum teste manual em andamento. Isso, novamente, pode funcionar para equipes pequenas com uma carga de trabalho relativamente baixa, mas não faz sentido em escala maior. Os testes de regressão podem e devem ser automatizados; não há "etapas", apenas uma classe ou método adicionado ao conjunto de testes de unidade / integração.

• Escusado será dizer que a mudança do Bugzilla para um novo (melhor) sistema de rastreamento de bugs tornaria essa parte da experiência muito menos dolorosa.

As empresas não são necessariamente baratas ou estúpidas só porque não resolveram esses problemas. Tudo o que sabem é que o processo atual funciona e, em alguns casos, são avessos ao risco e relutam em mudar alguma coisa. Mas, na verdade, eles só precisam se convencer dos benefícios .

Se os desenvolvedores passassem uma semana monitorando seu tempo em todas as tarefas que não são de codificação, você poderia facilmente adicioná-lo, mostrar à gerência que (por exemplo) um investimento de capital zero e 100 horas por homem em uma atualização para o Mercurial eliminar até 10 horas-homem por semana na resolução de conflitos de mesclagem, então isso é um pagamento de 10 semanas e eles certamente concordarão com isso. Mesma idéia com servidores de construção (CI) ou melhor rastreamento de erros.

Para recapitular: As equipes ainda não fizeram essas coisas porque ninguém convenceu a gerência de que é importante o suficiente para fazer hoje . Portanto, tome a iniciativa e transforme-a em uma equação de custo-benefício; descubra quanto tempo é gasto em tarefas que podem ser simplificadas / automatizadas com risco mínimo e calcule o ponto de equilíbrio e o retorno final de uma nova ferramenta ou técnica. Se eles ainda não escutarem, você já sabe quais são as opções restantes.

Se os desenvolvedores passaram uma semana rastreando seu tempo em todas as tarefas que não são de codificação, você pode adicioná-lo facilmente, mostrar o gerenciamento ... e transformá-lo em uma equação de custo-benefício, etc.

A parte acima parece valer a pena expandir ainda mais.

Eu posso confirmar que funciona. Os programadores o usaram algumas vezes em um dos projetos nos quais trabalhei e toda vez que levava às alterações desejadas.

Minha impressão geral foi que, se bem feito, esse truque pode anular quantidades bastante pesadas de ignorância e inércia da gerência.

Gostaria de observar que a empresa em que nós (desenvolvedores) tivemos que recorrer a esse tipo de abordagem DIY era muito imatura em termos de TI. Em fornecedores de software mais experientes, vi coisas assim sendo feitas principalmente pelos próprios gerentes. E, como regra, eles eram mais produtivos nisso do que nós, programadores. Muito mais produtivo.

Se você estiver trabalhando em um setor fortemente regulamentado, pode haver alguma razão para esse processo complicado: um dia você poderá ser auditado e terá que mostrar todos os seus registros para explicar quem corrigiu esse erro, como, quem o revisou, quem testou etc ...

Portanto, pode ser um mal necessário.

Por outro lado, se não houver justificativa para esse processo, além da falta de confiança da gerência, tente conversar com seu gerente e dizer-lhe como economizar tempo (e, portanto, dinheiro) para a empresa.

Ninguém em sã consciência recusará um processo mais rápido e melhor, se explicado corretamente.

Mas esteja pronto para defender seu argumento para justificar a mudança.

Metade do problema é que você está usando ferramentas obsoletas em um processo, para as quais elas não foram projetadas. O que você descreve é ​​muito fácil de ter nos DVCSes modernos, sem a tarefa tediosa de criar ramificação por bug.

Outro problema é que você claramente não está na linha de trabalho de que gosta. Você trabalha em manutenção enquanto deseja desenvolvimento. Pouco se pode fazer sobre isso além de mudar de emprego.

A disciplina da engenharia de software é inerentemente "toda sobre o processo", de modo que saber se "se tornou" dessa maneira está meio que perdendo o objetivo.

Enquanto a maioria dos programadores prefere se incomodar com o mínimo absoluto de processo, na medida em que alguns advogam por metodologias ágeis mesmo quando não resolvem os problemas que sua organização está enfrentando, é perfeitamente possível para uma empresa decidir usar " processos pesados ​​por boas razões comerciais, como "o cliente exige". Isso é comum se seus clientes são empresas, universidades ou agências governamentais da Fortune 500. As recompensas da venda para esses clientes podem ser suficientemente grandes para justificar a sobrecarga adicional do processo.

Sua empresa é um ponto de dados e é impossível generalizar sua experiência em uma tendência de todo o setor, na direção ou fora de processos mais pesados. A verdadeira questão é: qual equilíbrio funciona melhor para sua empresa, seus produtos, seus clientes e você, pessoalmente, como programador? Se você não gosta de trabalhar para essa empresa, instale mudanças ou arrume outro emprego.

Da outra pergunta que vi de você hoje, você parece bastante infeliz com seu trabalho. Você não está lá há muito tempo, basta dizer ao seu supervisor que acha que cometeu um erro e que é hora de se separar mais cedo do que o esperado.

Se você é bom no seu trabalho, não terá muita dificuldade em encontrar um novo e, honestamente, se não houver uma boa razão para esse processo existir, eu provavelmente consideraria mudar também. Usar o CVS seria realmente um divisor de águas para mim, mas eu sempre faço a pergunta do controle de origem na entrevista. Obviamente, não conheço sua situação e pode ser impossível deixar um emprego se você tiver outras obrigações.

Eu ia falar sobre como a engenharia de software está sendo inundada por programadores muito ruins, mas a situação que você descreve é ​​terrível.

Na minha experiência pessoal, parte desse "processo" que você descreve é ​​acompanhada pelo gerenciamento e administração do sistema, completamente inconscientes das ineficiências dos sistemas que estão impondo aos programadores. Os exemplos incluem restringir a escolha do sistema operacional, restringir o software usado, acesso à Internet, privilégios administrativos da área de trabalho pessoal; todas essas coisas são essenciais para o bom desenvolvimento.

Além disso, requisitos de compatibilidade entre as "soluções mágicas" empregadas por diferentes ramos da empresa. Os exemplos incluem escritórios centrais que impõem controle de fonte centralizado, servidores Outlook externos e diretrizes de codificação ou idiomas que podem não ser apropriados para todos os problemas.

Não é muito divertido manter as rodas dos gigantescos empreendedores, mas descobri que existem pequenas bolhas de inovação, criatividade e brilhantismo em algumas empresas.

Você provavelmente trabalha em uma empresa orientada a processos . Em vez disso, tentaria encontrar uma empresa orientada para resultados , onde importa o que você não faz e como faz.

Na minha empresa, também temos um "processo" (mas é muito simples). Mas quando entra no caminho, eu quebro as regras e pulo as etapas. Ninguém nunca vai me dizer nada, desde que eu não quebre nada tomando atalhos porque eu obtenho resultados.

Existe um ponto em que o processo atrapalha e se torna um fim em si mesmo? Isso é mesmo engenharia?

Literalmente, a maior parte da engenharia está reunindo peças bem estabelecidas em uma ordem definida em resposta a um problema específico. Isso é mais óbvio se você perguntar a um ME o que eles fazem o dia todo. Você está confundindo engenharia com arquitetura ou desenvolvimento de produto em estágio inicial (em qualquer campo). Eu tenho duas observações sobre sua pergunta.

1. Você parece ter sido atribuído ao trabalho de correção de bugs, não ao trabalho de arquitetura ou design.
2. Seus colegas de trabalho parecem ter soluções alternativas limitadas (combinando VMs de correção de bugs) para torná-las mais eficientes; parece que você não segue o exemplo sensato deles.

É simplesmente um fato que, em qualquer empreendimento construtivo que leve um grande número de pessoas, algumas pessoas conseguem fazer o design e um grupo maior "consegue" fazer a implementação. Desculpe, mas você está nesse segundo grupo.

Como outros comentadores observaram, o CVS não é a melhor ferramenta para o trabalho de um modelo de desenvolvimento altamente ramificado, mas também observo que você não é responsável pela fusão ... portanto, não se preocupe.

A maioria das suas queixas parece essencialmente "Não quero testar antes, durante ou após o desenvolvimento!" Vamos detalhar seus passos, ponto por ponto.

• Para corrigir um único erro, primeiro obtenho uma nova máquina virtual limpa. Um ambiente de teste
• Em seguida, crio um ramo para essa única correção de bug, com base em outro ramo descrito no relatório do Bugzilla. - Você duplica o ambiente em que o bug foi encontrado ... como isso é irracional?
• Eu instalo a filial na máquina, configure isso. Eu conserto o bug. Eu verifico - O processo básico de desenvolvimento
• ... deixando-o e a máquina para outros testarem. - Sua equipe de mesclagem provavelmente deseja que seja possível verificar a correção se a mesclagem for para o sul.
• Então eu tenho que entrar no software de controle de bugs e explicar o que fiz - se você está em uma loja que não faz isso ... por que está rastreando bugs?
• e escreva um caso de teste com todas as etapas. - Eu posso estar errado, mas essa parece ser a direção que todos os 'garotos legais' estão seguindo de qualquer maneira
• Eventualmente, alguém o mescla com um release. - E várias das etapas acima são para facilitar o trabalho deles

Outra pessoa à sua frente obviamente faz a triagem de erros para garantir que um erro encontrado não seja corrigido em outra versão ou quebrado em uma versão posterior (é para isso que servem os casos de teste).

A única coisa remotamente incomum ou zelosa demais sobre esse processo é a coisa da VM. Há uma boa chance de que isso seria considerado razoável se soubéssemos em que domínio você estava trabalhando.

Interessante. Você tem testadores? Eles deveriam estar fazendo isso. Sou um e, onde trabalho, temos uma solução decente.

Para um defeito funcional, como você está explicando, nosso processo é assim:

1. Testo o defeito em uma VM (relatada por um cliente ou durante meus testes exploratórios ou em /)
2. O erro foi encontrado / reproduzido.
3. Eu crio o bug. Os erros incluem:
   • Repro completo, do ponto de instalação ao ponto de ver o bug.
   • Um link para um instantâneo da VM (se eu acho que o desenvolvedor precisará dele ... eu instantaneamente, de qualquer maneira, caso eles solicitem).
   • Informações do sistema, todas as configurações especiais que eu precisei fazer.
4. Esse bug é atribuído ao desenvolvedor. Enquanto eles estão trabalhando em uma correção, eu:
   • Crie um caso de teste
   • Escreva (ou converta) o teste manual em um teste automatizado

Então espero uma resolução e ajudo o desenvolvedor da maneira que ele precisar. Quando volta como resolvido, eu:

1. Execute o caso de teste automatizado e uma versão manual (às vezes) para confirmar a correção.
2. Feche o bug.

TL; DR: Se você não possui testadores, precisa de alguns. Se você tem alguns, eles não estão "fazendo a parte deles".

Tom DeMarco:

... Meu primeiro livro de métricas ... a linha mais citada é sua primeira frase: "Você não pode controlar o que não pode medir". Essa linha contém uma verdade real, mas eu me sinto cada vez mais desconfortável com o uso dela. Está implícito na citação (e de fato no título do livro) que o controle é um aspecto importante, talvez o mais importante, de qualquer projeto de software. Mas não é.

... quanto mais você se concentrar no controle, maior a probabilidade de estar trabalhando em um projeto que se esforça para oferecer algo de valor relativamente menor.

Na minha opinião, a pergunta que é muito mais importante do que como controlar um projeto de software é: por que diabos estamos fazendo tantos projetos que entregam esse valor marginal? ...

Engenharia de software: uma idéia de quem chegou a hora?

"Então, crio um ramo para essa única correção de bug"

Não há necessidade de criar uma ramificação para a única correção de bug. Primeiro crie o bug no bugzilla. Confira o ramo de lançamento. Faça a correção. Execute a confirmação com a mensagem de confirmação que contém o número do erro, que atualiza o erro e o marca "corrigido, precisa de teste" ou "corrigido, testado, precisa ser mesclado" adequadamente, dependendo das palavras-chave de texto escritas na mensagem de confirmação. O banco de dados de erros é o mecanismo de rastreamento perfeito para todas as alterações feitas e por que elas foram feitas; relatórios podem ser executados no banco de dados de erros para extrair essas informações.

Acho que a maior parte do processo pode ser automatizada , de modo que a criação da máquina virtual e da ramificação (incluindo a compilação de código, a configuração de depuradores etc.) foi feita antes de você começar a trabalhar no bug.

Descrever o que você fez e como deve ser testado vale a pena para todas as correções de bugs. Descobri que escrever o texto pode causar problemas , pois me faz pensar em riscos, etc.

Então, acho que o processo pode ser um pouco "exagerado", mas que o verdadeiro problema é a falta de ferramentas automatizadas personalizadas para dar suporte ao processo.

Cara, seu processo de pensamento está certo, pois o que você descreveu é totalmente ruim e uma demonstração verdadeira de como as coisas podem estar erradas no software. Aqui estão as boas notícias, porém, existem muitas empresas por aí praticando o Agile de bom humor. A empresa em que trabalho é uma delas. Hoje em dia, existem muitas e boas notícias.

Quando você sente que as coisas realmente não estão certas no seu local de trabalho, há duas coisas que você pode fazer - ou pode influenciar uma mudança positiva ou deixar esse lugar e se juntar a uma melhor.

O CVS ou qualquer sistema de gerenciamento de configuração não é ruim. Infelizmente, a maneira como é usada, sem realmente conhecer seu objetivo, causa esse tipo de dor no! @ # $ Para toda a organização.

Para entender rapidamente o que é realmente o Agile, leia o livro "Práticas de um desenvolvedor Agile", de Venkata Subramaniam. É bem escrito em linguagem facilmente compreensível.

Desejo boa sorte!