Mantenha uma linguagem de programação compatível com versões anteriores versus corrigindo suas falhas

Primeiro, algum contexto (coisas que a maioria de vocês conhece mesmo assim):

Toda linguagem de programação popular tem uma evolução clara, na maioria das vezes marcada por sua versão: você tem Java 5, 6, 7 etc., PHP 5.1, 5.2, 5.3 etc. O lançamento de uma nova versão disponibiliza novas APIs, corrige bugs, acrescenta novos recursos, novas estruturas etc. Então, em suma: é bom.

Mas e os problemas da linguagem (ou da plataforma)? Se e quando houver algo errado em um idioma, os desenvolvedores o evitam (se puderem) ou aprendem a conviver com ele.

Agora, os desenvolvedores dessas linguagens recebem muito feedback dos programadores que as utilizam. Portanto, faz sentido que, à medida que o tempo (e os números das versões) passem, os problemas nessas línguas vão desaparecer lenta mas seguramente. Bem, na verdade não. Por quê? Compatibilidade com versões anteriores, é por isso. Mas por que isso é assim? Leia abaixo para uma situação mais concreta.

A melhor maneira de explicar minha pergunta é usar o PHP como exemplo:

O PHP é amado e odiado por milhares de pessoas. Todas as línguas têm falhas, mas aparentemente o PHP é especial. Confira esta postagem no blog . Ele tem uma lista muito longa das chamadas falhas no PHP. Agora, não sou desenvolvedor de PHP (ainda não), mas li tudo e tenho certeza de que grande parte dessa lista é realmente um problema real. (Nem tudo, pois é potencialmente subjetivo).

Agora, se eu fosse um dos caras que desenvolve ativamente o PHP, certamente desejaria corrigir esses problemas, um por um. No entanto, se eu fizer isso, o código que depende de um comportamento específico do idioma será interrompido se for executado na nova versão. Resumindo em 2 palavras: compatibilidade com versões anteriores.

O que não entendo é: por que devo manter o PHP compatível com versões anteriores? Se eu lançar o PHP versão 8 com todos esses problemas corrigidos, não posso colocar um grande aviso dizendo: "Não execute código antigo nesta versão!"?

Há uma coisa chamada depreciação. Tivemos isso por anos e funciona. No contexto do PHP: veja como hoje em dia as pessoas desencorajam ativamente o uso das mysql_*funções (e recomendam mysqli_*e o DOP). A depreciação funciona. Nós podemos usá-lo. Nós devemos usá-lo. Se funciona para funções, por que não deveria funcionar para idiomas inteiros?

Digamos que eu (o desenvolvedor do PHP) faça o seguinte:

• Lance uma nova versão do PHP (digamos 8) com todas essas falhas corrigidas
• Novos projetos começarão a usar essa versão, pois é muito melhor, mais clara, mais segura etc.
• No entanto, para não abandonar as versões mais antigas do PHP, continuo lançando atualizações, corrigindo problemas de segurança, bugs etc. Isso faz sentido por razões que não estou listando aqui. É prática comum: veja, por exemplo, como a Oracle continuou atualizando a versão 5.1.x do MySQL, apesar de focada principalmente na versão 5.5.x.
• Após cerca de 3 ou 4 anos, paro de atualizar as versões antigas do PHP e as deixo morrer. Tudo bem, já que nesses 3 ou 4 anos, a maioria dos projetos mudou para o PHP 8 de qualquer maneira.

Minha pergunta é: todas essas etapas fazem sentido? Seria tão difícil de fazer? Se isso pode ser feito, por que não é feito?

Sim, a desvantagem é que você quebra a compatibilidade com versões anteriores. Mas esse preço não vale a pena? Como vantagem, em 3 ou 4 anos você terá uma linguagem com 90% dos problemas corrigidos ... uma linguagem muito mais agradável de se trabalhar. Seu nome garantirá sua popularidade.

EDIT : OK, então não me expressei corretamente quando disse que em 3 ou 4 anos as pessoas passarão para o hipotético PHP 8. O que eu quis dizer foi: em 3 ou 4 anos, as pessoas usarão o PHP 8 se iniciarem um novo projeto.

Parece bom, mas raramente funciona na prática; as pessoas são extremamente relutantes em mudar o código em execução e, mesmo em projetos novos, eles relutam em mudar de idioma / versão que já conhecem.

Mudar o código existente em execução que "funciona bem" não é algo que está no topo da lista de prioridades de qualquer projeto. Em vez de aplicar esforços nas coisas pelas quais os gerentes pensavam já terem sido pagos, apenas para poder atualizar para uma versão mais recente de um idioma ou plataforma, eles decretam que os desenvolvedores devem permanecer na versão antiga "por enquanto". Você pode tentar atrair seus usuários com ótimos recursos disponíveis apenas na nova versão, mas é uma aposta em que você corre o risco de diminuir sua base de usuários sem nenhum ganho claro para o idioma; recursos modernos e legais não podem ser facilmente pesados ​​contra o preço da base de instalação fragmentada, na opinião popular, e você corre o risco de obter uma reputação de ser uma "esteira de atualização"

(Obviamente, a maior parte disso não se aplica a projetos escritos por entusiastas apenas para o seu próprio prazer. No entanto (aqui seja um flamebait ...), o PHP é desproporcionalmente raramente escolhido por hackers, porque é um prazer escrever com ele em primeiro lugar. )

Você está subestimando o impacto da compatibilidade com versões anteriores; sua estimativa de que todos os projetos ativos migrariam em 3 ou 4 anos é otimista demais.

Suponha que eu sou desenvolvedor de PHP. O PHP tem falhas, mas eu sei como solucionar essas falhas - isso é parte do motivo pelo qual sou pago como desenvolvedor de PHP. Agora, suponha que o PHP 8 saia e corrija essas falhas, mas não é compatível com versões anteriores. Como um resultado:

• Eu tenho que gastar um tempo atualizando meu código para o PHP 8. É o tempo que eu poderia gastar respondendo às solicitações dos clientes, implementando novos recursos, acompanhando a concorrência.
• Mesmo depois de fazer isso , há uma boa chance de que eu tenha perdido algum caso de esquina ou problema imprevisto de compatibilidade, introduzindo erros no meu código.

Diante disso, há um forte incentivo para nunca migrar para o PHP 8, mesmo que seja "melhor, mais claro, mais seguro etc." Estima-se que ainda existam bilhões de linhas de COBOL (!) - embora obviamente existam tecnologias muito melhores disponíveis, o custo de uma atualização, combinado com o risco de bugs, não vale a pena.

Segundo, mesmo se eu decidir migrar meu próprio código, qualquer aplicativo não trivial depende de bibliotecas de terceiros, e não há garantia de que as bibliotecas de terceiros migrarão. Por exemplo, o Python 3 foi lançado em dezembro de 2008, mas o Django (provavelmente o principal framework da Web para Python) não teve suporte estável ao Python 3 pronto para produção por quase cinco anos (veja aqui e aqui ).

Você está fazendo muitas suposições sobre o comportamento humano. Se você mudar demais, as pessoas avaliarão seus concorrentes, pois terão que gastar um esforço significativo para trocar de qualquer maneira. Para idiomas de código aberto, as pessoas simplesmente bifurcam a versão antiga.

Veja python para um exemplo. 3.x está disponível há quatro anos e ainda não é amplamente adotado. As pessoas tentam usá-lo para novos projetos, mas acho que você está subestimando quanto trabalho de código é manutenção.

Obviamente, a maioria das pessoas não considerava o python 2.x "defeituoso". Eles não tiveram queixas como usuários de php. O php está em uma posição muito mais precária, porque muitas pessoas só o mantêm por causa de sua grande base de códigos existente. Se você perdesse a compatibilidade com versões anteriores, muitas pessoas aproveitariam a oportunidade que estavam esperando para mudar para o python.

Para qualquer linguagem que não seja o PHP, eu diria que sim, isso faz sentido! É exatamente isso que o Python está fazendo com a mudança para o Python 3.

No entanto, o problema com o PHP é que existem muitas falhas no design da linguagem, portanto, o que você está chamando de "PHP 8" seria uma linguagem completamente diferente. E se você tivesse que mudar para uma linguagem diferente, por que seguiria o novo PHP, em vez de qualquer uma das alternativas existentes e estáveis ​​atualmente?

Também a comunidade PHP é extremamente lenta para adaptar qualquer coisa nova. Veja quanto tempo levou para se livrar register_globals. É conhecido por ser um risco de segurança desde o ano 2000. Foi finalmente removido apenas 12 anos depois. Outro exemplo, quando o PHP5 foi introduzido, houve uma enorme melhoria em relação ao PHP4, mas a comunidade não o adaptou. Levei 4 anos e ações maciças como o GoPHP5 para alavancar a adoção. E isso nem teve uma quantidade significativa de alterações incompatíveis com versões anteriores.

Isenção de responsabilidade: gerencio um grupo de usuários do ColdFusion.

O ColdFusion sofre os mesmos problemas: amado por muitos, desprezado por muitos. Além disso, toneladas e toneladas de FUD com base nas versões pré-Java. O ColdFusion 10 foi lançado no ano passado, é um grande vendedor e, na semana passada, me inscrevi para testar o pré-lançamento da versão 11. Além disso, existem duas principais alternativas de código aberto, uma suportada pelo JBoss.

Há toneladas de novas funções no CF10 que eu adoraria implementar, mas a migração do CF 7 ou 8 pode ser difícil, dependendo do tamanho da sua base de código, do número de projetos futuros e dos recursos necessários para a regressão testar tudo quando você está na versão mais recente. Corri para uma série de pequenas diferenças sintáticas entre 8 e 9, bem como casos extremos onde o código não é compilado da mesma maneira. Uma vez encontrados, eu os documentei em nossos Padrões de codificação para que não sejam usados ​​em projetos futuros ou por novos desenvolvedores.

Dito isso, se o ColdFusion 11 (ou qualquer linguagem de programação) depreciar completamente certas funções e sintaxes, o nível de esforço para encontrar e substituir a funcionalidade pode ser enorme. O esforço de teste pode ser gigantesco. As empresas pagarão a seus desenvolvedores, controle de qualidade e gerentes de projeto para encontrar, substituir e testar todas essas coisas obsoletas? Duvidoso.

Se a versão mais recente de um idioma é compatível com versões anteriores, mas introduz um aumento no desempenho sem alterações de código (o CF9 é cerca de 30% mais rápido que o CF8 e o CF10 é muito mais rápido que o CF9), quem se importa em alterar as chamadas de função, se elas ainda funcionam?

Como empresa, precisamos nos preocupar em agradar nossos clientes e em fornecer suas necessidades, a fim de cobrar serviços, criar negócios e recrutar mais clientes.

FWIW, eu adoraria nos colocar na versão mais recente do jQuery em algum momento, mas como certas funções foram preteridas algumas versões depois do que usamos, e dado o volume de JavaScript que temos no sistema, não sei como nós vamos conseguir isso.

Há uma troca aqui; alguns erros REALMENTE precisam ser corrigidos, mas algumas coisas não podem ser alteradas sem a quebra do código de alguém em algum lugar. Parece que me lembro de alguém afirmando como uma "regra" que toda correção de bug interrompe o projeto de alguém, não importa quão obscuro ou obviamente quebrado o bug seja, alguém o usará para alguma coisa. Essa é a natureza dos programadores.

Essa é (na minha opinião) a diferença entre os principais lançamentos, lançamentos menores e revisões. Como princípio geral:

• Presume-se que os principais lançamentos contenham alterações recentes.
• Versões menores podem alterar um pouco o comportamento.
• As revisões devem ser praticamente compatíveis.

Por exemplo, se eu estiver escrevendo algo na v2.3 de um idioma, não esperaria notar nenhuma diferença se atualizar para a v2.3.2. Se eu atualizar para a v2.4, algumas coisas podem mudar - pequenos ajustes de sintaxe, algumas funções se comportam de maneira um pouco diferente, então eu tenho que ajustar a lógica etc. Se eu atualizar para a v3.0, não ficaria surpreso se ele quebrasse inteiramente - funções obsoletas ou ausentes, operações não suportadas ou alteradas tanto que não consigo ajustá-las novamente, na verdade, preciso reescrever algumas funções para dar conta das novas alterações.

Editar:

O artigo de Steve Vance, Advanced SCM Branching Strategies, tem o seguinte a dizer:

Normalmente, existem dois a três níveis de liberação, nomeados por números conectados a pontos (por exemplo, 1.2.3). [...] Nesta estrutura, o primeiro número está associado a uma versão principal, indicando que possui recursos significativos e aprimoramentos funcionais em relação à anterior; também pode haver incompatibilidades significativas que exijam migração. O segundo número representa uma versão secundária, que contém menos aprimoramentos de recursos e funções, um número significativo de correções de bugs e nenhuma incompatibilidade. O terceiro número refere-se a um nível de patch, significando quase exclusivamente uma coleção de correções de bugs; nenhum aprimoramento de recurso ou função e incompatibilidades são permitidos entre os níveis de patch.

A única alteração que eu faria a isso é o princípio acima mencionado de que os programadores costumam encontrar maneiras de "usar" bugs, portanto uma versão menor com "um número significativo de correções de bugs e sem incompatibilidades" pode ser difícil, porque é provável que essas os bugs quebram algo que os usou ou causam uma solução alternativa desnecessária e começam a causar problemas.

Realmente depende do objetivo do idioma - que tipos de aplicativos devem ser criados com o idioma.

Por exemplo, ignorando o Android, o Java é usado principalmente em grandes sistemas corporativos e middleware; esses tipos de aplicativos tendem a se tornar muito grandes, tanto em tamanho quanto em tempo. Isso tem algumas implicações; imagine um sistema com 500K + LoC no qual o trabalhador com mais de 50 engenheiros na fase de desenvolvimento. Normalmente, esse tipo de sistema entra em manutenção depois disso com, digamos, 10 desenvolvedores; agora, se o idioma mudar e as alterações não forem compatíveis com versões anteriores, o projeto não poderá ser facilmente migrado para uma nova versão porque os programadores que escreveram algumas partes se foram e ninguém quer tocá-lo. Esse é o problema menor, o maior problema consiste no fato de ser um pouco caro adaptar um aplicativo LoC 500 a novas restrições de idioma. Por exemplo, se os genéricos não foram implementados com apagamento de tipo eList list = new List(); para compilar, milhões de linhas de código precisariam ser reescritas - o que tem um grande custo.

Por outro lado, o PHP tende a ser usado na web para aplicativos mais simples; geralmente é desenvolvido por um único programador ou uma equipe pequena. A idéia é que os desenvolvedores meio que saibam que todo o projeto pode integrar mudanças de linguagem mais facilmente. Além disso, seu objetivo é criar um site muito rápido, e quanto mais rápido, melhor, se um novo recurso de idioma puder fazer isso melhor, ele será implementado mesmo com alguns custos de compatibilidade com versões anteriores.

Pode-se argumentar que a Microsoft realizou uma alteração semelhante com o ASP.NET (como sucessor do ASP clássico) ou com o VB.NET (embora eles tenham feito tantas concessões com o último que a maioria dos benefícios da "reinicialização" do idioma foram perdidos).

De qualquer forma, se alguém se lembra do pesadelo da migração do código VB6 para o VB.NET, mesmo com a ajuda de uma ferramenta de migração, concorda imediatamente que as ferramentas de migração de idiomas não funcionam muito bem nas principais atualizações de idiomas.

Pode ser possível avançar a plataforma, mas você ainda deve fornecer suporte para APIs "obsoletas" por pelo menos algumas revisões.

Muitas das "falhas" sobre as quais as pessoas gritam nas linguagens de programação populares não são, são coisas que o brinquedo favorito do dia dos gritadores tem que falta nessa linguagem; portanto, a linguagem é fundamentalmente falha porque falta isso.
O próximo hype chega, o idioma é repentinamente defeituoso porque não adere a esse hype.

A falta de fechamento em Java é um exemplo clássico. Isso não é uma falha no idioma, e mudar o idioma (como infelizmente está na agenda) para incluí-los, será IMO fundamentalmente prejudicado ou, pelo menos, tornado muito mais difícil de ler e compreender.

O que muitas pessoas perdem de vista é que cada idioma tem seus pontos fortes e fracos e que tentar criar algo que combine as forças de tudo e evitar todas as fraquezas criará apenas um monstro totalmente inutilizável que não é bom em nada, incrivelmente difícil de realizar, impossível de ser use efetivamente.

Acrescente, como outros salientaram, que a compatibilidade com versões anteriores é vital para reter os usuários existentes, muitos dos quais NÃO gastarão milhares de horas e milhões de dólares / euros para adaptar suas bases de códigos de um milhão de linhas ao que você acha que é "melhor" do que a versão da linguagem que eles usam há anos, e você tem uma série de argumentos muito bons para se deixar em paz o suficiente e se quiser brincar com alguma nova idéia exagerada que supostamente é o próximo "java killer" que você ' d melhor brincar com esse brinquedo do que gritar "Java iz ded", a menos que "seja corrigido" para ser um clone desse brinquedo.

Sugiro que as versões mais recentes de um idioma se esforcem para garantir que 99,9999999% do código compilado nas versões antiga e nova do idioma funcionem de forma idêntica nos dois, a menos que seja deliberadamente projetado para não fazê-lo e que na maioria das vezes quando a nova versão recusar o código que foi compilado na versão antiga, será porque o código era - na melhor das hipóteses - desonesto e deveria ter sido escrito de uma maneira diferente que seria compilada no compilador antigo e no novo.

Por exemplo, se eu estivesse projetando uma nova linguagem semelhante a Java ou C #, proibiria conversões de tipo implícitas em alguns contextos em que essas linguagens permitirem. Como um exemplo simples em C #, dado

int someInt;
double someDouble;

someInt.Equals(someDouble)é garantido que a expressão retorne false, independentemente do conteúdo das variáveis. Ele é compilado porque doublepode ser convertido em Objecte inttem uma Equalssobrecarga para esse tipo; portanto, o compilador faz a conversão e faz a chamada. Se eu estivesse projetando uma nova versão do C # e do .NET Framework, proibiria a conversão de boxe, pois ela não pode fazer nada de útil. É possível que exista algum programa que faça essa comparação de uma maneira que seja inútil, mas inofensiva, e fazer com que o compilador rejeite esse código pode interromper esse programa, mas corrigir ou remover esse código inútil seria uma melhoria.

Como um exemplo um pouco menos claro, assuma

float f=16777216f;
int i=16777217;

e considere a expressão f==i. É possível que algum código faz comparações float / inteiro e funciona corretamente, mas o código deve ser reescrito como quer f==(float)i, (double)f==i;ou (double)f==(double)i;[ inta doublepromoção é sem perdas, por isso os dois últimos seria equivalente]. Algum código que compara directamente floate integervalores podem sempre lidar com números que são suficientemente pequenas que floate doublecomparações iria se comportar de forma idêntica, mas um compilador geralmente não pode saber que; O código deve deixar claro que tipo de comparação é necessária, em vez de esperar que as regras da linguagem correspondam à intenção do programador.

É melhor nunca quebrar a compatibilidade com versões anteriores.

A Microsoft substituiu a linguagem de programação VB6 por uma nova linguagem que quebrou totalmente a compatibilidade. Ainda hoje, o VB6 de 16 anos ainda é mais popular que a versão dotNet (índice Tiobe em agosto de 2014). E o Gartner estima que ainda existam 14 bilhões de linhas de código VB6.

Em 2014, a Microsoft novamente teve que anunciar que não atualizará ou VB6 de código aberto, apesar das demandas da comunidade de programação do Visual Basic. Mas eles estenderam o suporte ao VB6 até 'pelo menos' 2024, e funciona bem no Windows 7 e 8. Serão mais de 26 anos de suporte para a mesma versão do VB6.

Por que o software em funcionamento existente deve ser reescrito, até a Microsoft nunca "atualizou" o Office para usar o dotNet?

Existem alguns problemas diferentes com a quebra da compatibilidade com versões anteriores. Alguns dos problemas decorrem do fato de que a maioria das linguagens de programação também são plataformas (intérpretes / durações), outros problemas decorrem de uma suposição da natureza humana.

R. O código escrito em versões mais antigas não beneficiaria de novos lançamentos que melhoram o desempenho, a segurança ou os recursos. Você pode atenuar esse problema oferecendo suporte a várias versões principais do compilador / intérprete, mas isso é um grande esgotamento de recursos (ou seja, é caro ou leva muito tempo e é uma chatice).

B. O código escrito para as versões mais recentes pode não ser compatível com o código escrito nas versões mais antigas. Você pode contornar isso com um intérprete / compilador que pode lidar com várias versões principais do idioma, mas isso é mais complicado do que oferecer suporte a intérpretes / compiladores separados (a solução alternativa para A).

C. Grandes mudanças, se elas acontecem com muita frequência / rapidez, também tornam o idioma mais difícil de usar, pois você tem mais para aprender e desaprender. Alterações em um idioma podem levar as pessoas a mudar para um novo idioma ou fazer com que as pessoas continuem a usar versões desatualizadas do idioma e nunca mudem para a nova versão (como aconteceu com o python). Por outro lado, as mudanças também podem atrair novos usuários e excitar os antigos.

D. A nova documentação precisa ser mantida e mantida. É sempre uma experiência bastante confusa procurar informações no google e descobrir que você está lendo os documentos para uma versão diferente da que está usando no momento.

Em geral, se você criar uma linguagem de programação em que os módulos externos não precisem se importar com a versão que está usando, quebrar a compatibilidade com versões anteriores pelos motivos certos (para corrigir grandes falhas na linguagem) é quase definitivamente a coisa certa a ser feita. . É provável que o principal motivo para isso não ser feito é que os designers da linguagem de programação superestimam ( para contradizer a resposta de outra pessoa ) os custos de quebrar a compatibilidade, especialmente no início. O fato é que os problemas de quebrar a compatibilidade podem ser contornados ou alimentados pelos usuários desse idioma. E isso não se aplica apenas às linguagens de programação; isso se aplica a APIs, interfaces de usuário - realmente qualquer interface em qualquer situação.

O Facebook irrita muito as pessoas quando altera sua interface do usuário ou suas APIs de desenvolvedor. No passado, tornava a plataforma difícil de trabalhar. Em alguns casos, as APIs simplesmente pararam de funcionar do nada. Mas as pessoas continuaram a usá-lo, e agora as APIs e as UIs estão aos trancos e barrancos melhores do que eram há 5 anos. As pessoas reclamarão da mudança, seja boa ou ruim para elas, mas isso (reclamar) não é um bom motivo para renunciar a essa mudança. Infelizmente, os desenvolvedores da linguagem de programação usam isso como uma razão para manter intactos os problemas de sua linguagem.

Portanto, outras razões pelas quais os idiomas não fazem alterações significativas para melhorar a si mesmos são:

E. Os desenvolvedores de idiomas acham que seus usuários têm medo de mudar é um bom motivo para estagnar seu idioma

F. Os desenvolvedores de idiomas meio que gostaram de seu idioma quando o criaram, e provavelmente acham que está tudo bem com suas falhas.

G. Os idiomas à medida que envelhecem geralmente deixam de ter um pequeno conjunto de desenvolvedores e se transformam em bestas criadas por comitês. Isso significa que as decisões sobre esses idiomas são lentas, geralmente conservadoras e não criativas.

H. A última razão é que algumas mudanças recentes exigem uma reavaliação significativa das decisões de design tomadas para o intérprete / tempo de execução. Às vezes, as melhorias no idioma simplesmente exigem muito trabalho para serem possíveis. Eu acho que este é um problema mais raro do que a maioria.

Frequentemente, os designers de linguagem não são necessariamente designers de ferramentas e, portanto, não pensam em boas soluções para esse problema ou não as executam bem. Aqui estão algumas soluções em que posso pensar para resolver o problema das mudanças:

1. Preterir as coisas bem antes de serem removidas.

2. Forneça uma boa ferramenta de conversão padrão. O Python forneceu a ferramenta 2to3, mas não foi bem anunciada, não veio como padrão com o python 3, pelo que me lembro, e nem funcionou muito bem (eu lembro de ter que passar manualmente pelos programas gerados pelo 2to3 para corrigir os problemas. não consertou). Essa ferramenta de conversão pode até ser executada automaticamente se o compilador / intérprete detectar uma versão mais antiga. O que poderia ser mais fácil?

Não sei se isso é um problema para o código PHP, mas em muitos idiomas antigos, o código legado nunca é atualizado depois de anos ou, às vezes, até décadas, porque funciona, é crítico para os negócios que o executam e é muito grande (por exemplo, milhões de SLOC), então não faria sentido reescrevê-lo. Essa é a razão pela qual o java tornou a compatibilidade com versões anteriores um problema quase religioso, apesar de conhecer problemas antigos, especialmente em bibliotecas (mesmo que sejam mais fáceis de atualizar). Eu acho que muitos códigos do kernel Linux não foram atualizados por décadas também, apesar da adoção de padrões como C99 e C11.

Mesmo em idiomas menos "empreendedores", quebrar o código funcional antigo pode ser um problema. Foi o que aconteceu com o Python 2 -> 3. Um monte de bibliotecas e scripts do sistema estavam estáveis ​​e não foram mais mantidos, não porque foram abandonados, mas porque estavam estáveis ​​e fazendo seu trabalho. A adaptação deles leva alguns anos. Portanto, como desenvolvedor, você não pode necessariamente pular para o python 3 se sua biblioteca favorita ainda não fez a mudança, portanto seu próprio código também não funcionará no python 3, resultando em fragmentação da comunidade.

O problema está no problema de compatibilidade com versões anteriores. A maioria dos scripts PHP que executo estão em execução em um servidor RedHat mais antigo. Se eu usasse a versão mais recente da linguagem para scripts futuros, teria que atualizar o PHP neste servidor - e correr o risco de interromper meus scripts antigos / demorar algumas horas para reescrever todo o código antigo com o comando novo padrão. Além disso, todos os meus desenvolvedores estão acostumados a reagir do PHP de uma certa maneira (seja dessa forma 'quebrada' ou não). Se ele não reagir mais dessa maneira, pode ser um grande obstáculo para a produtividade, pois os desenvolvedores podem ter que basicamente se re-ensinar PHP.