Ponto de complexidade sem retorno. Como você chama isso?

Como desenvolvedor de software, uma das minhas principais tarefas é manter a complexidade sob controle.

No entanto, em alguns projetos, há um momento em que o nível de complexidade cresce tão alto que atinge algum tipo de ponto "sem retorno". Após esse momento, você nunca poderá retornar o projeto a um nível aceitável de complexidade em menos tempo do que seria necessário reescrever tudo do zero.

Esse momento em particular tem um nome no dialeto dos programadores (algo semelhante à lei de Godwin para trolls)?

--editar--

Desculpe se não estou claro. Não acho que esse "momento" tenha um nome oficial ou seja uma métrica séria. Eu estava pensando em algo no espírito do "pico Ballmer" no xkcd .

É mais uma questão de manutenção do que de complexidade.

O fenômeno é chamado de "dívida técnica" e, quando atinge um nível crítico, o projeto está a caminho da falência.

É isso que você quis dizer?

O "ponto de excesso de complexidade" é referido em inglês como:

OH MEU DEUS O QUE É ESSE CRAP.

O problema é que isso pode se aplicar a algo realmente simples, mas é implementado de maneira tão horrível que você tem a mesma reação.

Então, separar algo muito complexo de algo muito horrível pode ser difícil.

NO ENTANTO: O que realmente tende a acontecer com todos os softwares é um processo assim:

Etapa 1: tenha uma boa especificação, faça um bom design, implemente coisas legais. Todo mundo feliz.

No final da etapa 1: os desenvolvedores se parabenizam pela maravilhosa elegância de seu design e vão embora pensando felizes "Eu tenho um legado maravilhoso aqui para que outros possam adicionar coisas no futuro, será maravilhoso e o mundo será um melhor lugar."

Etapa 2: Algumas alterações são feitas, as coisas são adicionadas, novas funções estão incluídas. A arquitetura e a estrutura da Etapa 1 tornaram esse processo bastante indolor. [Opa, o "fator cruft" aumentou um pouco.]

No final da etapa 2: os desenvolvedores se parabenizam pela maravilhosa elegância de seu design e vão embora pensando felizes "Nossa, sou tão esperto por ter feito todas essas concessões na Etapa 1. Isso foi tão bom. Tenho um legado maravilhoso aqui para que outros possam adicionar coisas no futuro, será maravilhoso e o mundo será um lugar melhor ".

Etapa 3: Mais alterações são feitas, mais coisas são adicionadas, mais novas funções, várias coisas são alteradas, o feedback do usuário está realmente sendo ouvido.

No final da etapa 3: os desenvolvedores se parabenizam pela maravilhosa elegância de seu design e se afastam com um pensamento bastante feliz "Nossa essa arquitetura é muito boa para permitir que tantas mudanças se encaixem facilmente. Mas estou um pouco infeliz sobre X e Y e Z. Eles podem ser limpos um pouco agora. Mas !!! Ahhh! Eu sou tão esperto por ter feito todos aqueles subsídios na Etapa 1. Isso foi tão bom. Tenho um legado maravilhoso aqui para outros para adicionar coisas no futuro, será maravilhoso e o mundo será um lugar melhor ".

Etapa 4: assim como a etapa 3. Exceto:

No final da etapa 4: os desenvolvedores pensam: "Esse material que é tão bom está deixando o FEIO manter. Ele realmente precisa de algumas mudanças sérias. Não estou gostando muito de trabalhar nisso. Precisa de refatoração. Gostaria de saber o que o chefe dirá que quando eu disser a ele que precisa de 6 semanas e não haverá nada para os usuários verem no final disso ... mas terei outros 5 anos de escopo de modificação futura saboroso fazendo isso .... hmmm .. tempo para ir ao pub tomar um pouco de cerveja ".

Etapa 5: É necessário fazer várias alterações.

E DURANTE a etapa 5, os desenvolvedores dizem um para o outro: "Esse código é péssimo. Quem escreveu isso? Eles devem levar um tiro. É horrível. Temos que reescrevê-lo".

O passo 5 é fatal. É aqui que o fator de falha se torna tão ruim que o código não pode apenas ter mais algumas alterações, ele precisa ter algumas grandes alterações.

O problema na Etapa 5 é o desejo de jogá-lo fora e começar de novo. A razão disso ser fatal é "O fator Netscape". Vá para o Google. As empresas morrem nesse momento, porque começar de novo significa que você começa com cerca de 50% de premissas em vez de fatos, 150% de entusiasmo em vez de conhecimento, 200% de arrogância em vez de humildade ("Esses caras eram tão estúpidos!"). E você apresenta um monte de novos bugs.

A melhor coisa a fazer é refatorar. Mude um pouco de cada vez. Se a arquitetura estiver ficando um pouco cansada, corrija-a. Adicione, estenda, melhore. Gradualmente. Em cada etapa do processo, teste, teste e teste um pouco mais. Mudanças incrementais como essa significam que, dez anos depois, o código atual e o original são como o machado do avô ("ele tinha 10 cabeças novas e 3 alças novas, mas ainda é o machado do avô"). Em outras palavras, não resta muito em comum. Mas você mudou do antigo para o novo de forma gradual e cuidadosa. Isso reduz o risco e, para os clientes, reduz o fator de irritação.

Concordo que o momento é difícil de reconhecer e pode ser evitado por processos adequados. No entanto, a pergunta era sobre como chamá-lo. Na economia real, existe o conceito de "retornos decrescentes": o ponto em que o aumento da entrada de um recurso em um processo diminui seu lucro geral por unidade. Isso certamente se aplica à codificação, e até coisas boas como abstração, reutilização etc. têm um ponto de retorno decrescente. O termo geral específico de programação é "superengenharia". Para alguém que é propenso a fazer isso, gosto do termo de Joel " astronauta da arquitetura ".

Muitas vezes, um bom código é descartado sob a falsa impressão de que a nova equipe com novas ferramentas pode fazer isso mais barato, mais rápido e com mais confiabilidade, apenas para descobrir que

• A complexidade está nos requisitos não documentados
• As novas ferramentas são mais difíceis de usar do que o site em flash prometido
• A nova equipe não é tão "gostosa" quanto eles pensavam

Possivelmente o tempo que você descreveu chega com algumas bases de código (eu pensava assim). Eu nunca experimentei pessoalmente um caso de código antigo causando um projeto no estômago ou reescrevendo o código salvando um projeto.

Não incluo nesses casos as métricas que foram usadas para identificar módulos ou projetos problemáticos específicos, que foram selecionados e substituídos.

O verdadeiro problema com esse "momento" teórico é que ele só é reconhecido depois do fato. A menos que seus colegas sejam psicopatas, todos os commit na base de código são feitos com a crença de que é uma melhoria nessa base de código. É apenas olhando para trás, para a bagunça que se segue, que você pode ver que passou nesse "momento".

Mas eu gosto que poderíamos dar um nome. "Senhores", você poderia dizer, atraindo seus colegas desenvolvedores ao seu redor, "Atravessamos a Hellespont de Manutenção. Envie uma mensagem para sua esposa e avise que você não a verá por um tempo".

Não sei se existe um nome, mas se não houver, proponho chamá-lo de "ponto de fusão"

Esta não é uma pergunta muito interessante.

Na verdade, é trivial.

É tão trivial que desenvolvemos várias maneiras de lidar com isso.

1. Metodologias em cascata. Muitas pessoas passam muito tempo revisando requisitos e projetando documentos para garantir que a complexidade seja gerenciada.

2. Metodologias ágeis. Menos pessoas passam menos tempo discutindo o que é imediatamente aplicável para resolver o problema de alguém e lançar o software para eles. A complexidade é gerenciada porque todos estão focados em obter algo liberado.

A única vez em que alguém luta com "complexidade" é devido a uma falha em seguir a metodologia e gerenciar seu tempo adequadamente.

• Nenhuma supervisão detalhada em uma metodologia em cascata. Eles não são forçados a revisar produtos de trabalho intermediários em requisitos, arquitetura, design de alto nível ou revisões detalhadas de design.

• Não há prazo de sprint ou prioridades de caso de uso adequadas em uma metodologia Agile. Eles não estão focados em obter algo liberado para o usuário o mais rápido possível.

A complexidade deve ser limitada pelo estabelecimento de metas.

Lutar com a complexidade significa que as metas não são definidas ou não são recompensadas adequadamente.

Não há "ponto de virada". Se o gerenciamento da complexidade é de alguma forma um problema, algo já está errado na organização.

Existem métodos para visualizar e monitorar o risco de aumentar a complexidade de projetos e códigos (grandes). Quando eles são aplicados razoavelmente, espero que um novo nome para o ponto de não retorno não seja necessário. (Existe um MOOC relacionado no openHPI: https://open.hpi.de/courses/softwareanalytics2015/ )

Complexidade estrutural é um problema geral de design - não apenas para design de software em grandes equipes. A visualização é o primeiro passo no gerenciamento da complexidade estrutural. Matrizes e gráficos direcionados também podem ser usados ​​para essa finalidade.

Os alguns métodos para reduzir a complexidade estrutural são http://www.buch.de/shop/home/suche/?fq=3540878890 :

• modularização
• evitar loops de feedback
• triangulação

Além disso, existe o conceito de projeto axiomático: https: \ en.wikipedia.org \ wiki \ Axiomatic_design \ Com esse conceito, problemas confiáveis ​​devido à complexidade desnecessária podem ser evitados.

Portanto, existem vários métodos disponíveis. No final, é sempre uma decisão pensar neles, porque um projeto é grande o suficiente.