Ir para o conteúdo
CodeHero

dezenas de migrações

Java, Python, COBOL e VB6 reescritos em Go, Rust e TypeScript em 30 dias

Não só o mainframe. Um monólito Java espalhado por oito servidores, Python que esbarrou no GIL, um serviço Node que come memória mais rápido do que atende requisições — tudo isso vira Go e Rust, e a conta de infraestrutura cai junto. Também COBOL no z/OS, RPG no AS/400, VB6 e Delphi no desktop, ColdFusion e PHP na web, Perl, PL/SQL, Fortran e ABAP. Nossa plataforma lê a base de código inteira e reescreve, nossos engenheiros ficam com as partes em que errar sai caro, e o sistema antigo continua rodando esse tempo todo.

Pedir orçamentoFalar com um engenheiro

Quatro telas, uns dez minutos. Um engenheiro lê e volta com escopo, data e preço — sem demo e sem régua de e-mails.

30
dias, o teto de qualquer projeto
20
stacks legadas que migramos
10+
anos dentro de sistemas dos outros
1M+
linhas em uma única reescrita

Todo sistema que tiramos do respirador

Dezenas de migrações, em todas as stacks abaixo — do monólito Java que queima oito servidores ao COBOL que ninguém compila desde 2011. Cada uma entra em produção em trinta dias. Ache a sua e veja o que a mudança envolve.

Um grafo de dependências de verdade

Este é um serviço em Go rodando em produção, com os nomes dos pacotes trocados por M01 a M45 e a estrutura exatamente como ela é. Arraste o controle para levar o grafo de como o código está hoje até como ele se separa pelas fronteiras de domínio. A classe de cada nó sai do próprio grafo: um módulo que vive dentro de um domínio é reescrito de forma mecânica, e um que quatro domínios seguram precisa de um engenheiro para cortar a fronteira na mão.

Como está hoje

Reescrita mecânica60%

Fronteira cortada por engenheiro29%

Candidato a exclusão11%

45 módulos, 167 dependências e 45,990 linhas em 7 domínios. Grafo real de um serviço em produção, nomes de pacote removidos, nenhuma outra edição. As três classes são contadas a partir da estrutura do próprio grafo.
O mesmo grafo em tabela
Ordenado por tamanho. Um módulo é mecânico quando fica dentro de um domínio, vai para um engenheiro quando três ou mais domínios dependem dele ou quando está em um ciclo, e vira candidato a exclusão quando ninguém o importa e ele não é ponto de entrada.
MóduloLinhasImportado porImportaDomínioClasse
M01326loc010S01Reescrita mecânica
M02142loc03S02Reescrita mecânica
M0355loc03S02Reescrita mecânica
M0489loc03S02Reescrita mecânica
M055,194loc315S03Fronteira cortada por engenheiro
M06239loc51S03Fronteira cortada por engenheiro
M07884loc200S03Fronteira cortada por engenheiro
M08485loc46S03Reescrita mecânica
M099,835loc47S03Fronteira cortada por engenheiro
M10514loc20S03Reescrita mecânica
M11677loc15S03Reescrita mecânica
M12236loc411S03Fronteira cortada por engenheiro
M13187loc33S04Fronteira cortada por engenheiro
M14454loc11S05Reescrita mecânica
M1558loc31S05Reescrita mecânica
M16356loc42S05Reescrita mecânica
M17247loc42S05Reescrita mecânica
M1859loc31S04Fronteira cortada por engenheiro
M19139loc00S04Candidato a exclusão
M20330loc132S04Fronteira cortada por engenheiro
M21414loc11S06Reescrita mecânica
M221,670loc33S06Reescrita mecânica
M231,218loc180S06Fronteira cortada por engenheiro
M242,574loc153S06Fronteira cortada por engenheiro
M25163loc41S04Fronteira cortada por engenheiro
M26251loc25S04Reescrita mecânica
M27161loc12S04Reescrita mecânica
M2899loc20S04Reescrita mecânica
M2945loc00S04Candidato a exclusão
M3025loc00S04Candidato a exclusão
M311,417loc240S04Fronteira cortada por engenheiro
M3282loc10S04Reescrita mecânica
M3330loc41S04Fronteira cortada por engenheiro
M34141loc31S03Reescrita mecânica
M3579loc11S03Reescrita mecânica
M363,036loc310S03Reescrita mecânica
M37173loc11S03Reescrita mecânica
M382,501loc19S03Reescrita mecânica
M391,452loc34S03Reescrita mecânica
M4050loc11S03Reescrita mecânica
M412,148loc09S01Candidato a exclusão
M42167loc01S01Candidato a exclusão
M434,873loc215S07Reescrita mecânica
M442,241loc110S07Reescrita mecânica
M45474loc213S07Reescrita mecânica

por dentro

Um milhão de linhas é o tamanho normal

Nossa plataforma lê a base de código inteira de uma vez — cada linguagem da árvore, em paralelo — e a reconstrói como sistema moderno, não como transliteração do antigo. O comportamento fica igual ao original e é conferido contra o seu tráfego gravado. A arquitetura não: você recebe serviços, um esquema de verdade e um deploy à altura de como se escreve software hoje.

  • Todas as linguagens da árvore, ao mesmo tempo

    Sistema nenhum é de uma linguagem só. COBOL chama JCL, JCL dispara um utilitário em C, um script Perl conserta o arquivo antes de o PL/SQL carregar. A plataforma lê tudo em paralelo e mantém um único grafo sobre o conjunto: nada cai nas emendas entre linguagens.

  • Menos máquinas para a mesma carga

    Um serviço Java ou Python reescrito em Go costuma precisar de uma fração da memória e uma fração das instâncias, e um núcleo em Rust transforma uma janela de batch em uma pausa para o café. É essa a razão inteira para mexer em código que não está quebrado: o mesmo comportamento com uma conta menor, e folga que você não precisa mais comprar.

  • Um milhão de linhas e acima

    Esse é o tamanho com que planejamos, não o teto. Acima disso dividimos a estimativa e precificamos a primeira parte sozinha. Aqui escala é questão de agenda, não de viabilidade.

  • Mesmo comportamento, arquitetura nova

    Uma bancada de comparação reproduz o seu tráfego de produção gravado contra o antigo e o novo e compara até o centavo. O que muda é a forma: serviços com donos, um esquema legível, testes que nasceram junto com o código e um deploy que dispensa janela de manutenção.

  • Air gap, no seu hardware ou no nosso

    Para ambiente regulado os modelos são nossos e rodam dentro do seu perímetro, sem nenhuma conexão de saída. Se você não tem máquinas que aguentem, alugamos as nossas e elas ficam na sua sala. Nada do seu código precisa sair do prédio.

Sua nuvem, seu data center, uma VPN do cliente ou uma sala sem rede nenhuma — cada uma dessas opções tem uma montagem que roda, e o detalhe vai para o contrato.

O que a gente pega

Oito páginas, porque esse trabalho é comprado com oito nomes diferentes. Pegamos todas elas, e o serviço embaixo é o mesmo.

Como o trabalho anda

Quatro etapas, as mesmas em um milhão de linhas de COBOL e em um monólito PHP. As duas primeiras são o diagnóstico, e o mapa fica com você de qualquer jeito.
  1. 01

    Acesso de leitura

    Uma cópia somente leitura do repositório, os scripts de build e os runbooks que sobreviveram. Assinamos seu NDA antes, se é assim que sua empresa funciona.

  2. 02

    O mapa

    A plataforma lê tudo isso e relata o que existe de fato: módulos e suas dependências, código que ninguém chama mais, jobs agendados que ninguém documentou e o ponto onde o build só funciona em uma máquina. Isso chega antes de qualquer reescrita.

  3. 03

    Reescrita em fatias

    Um módulo delimitado por vez, com testes escritos contra o comportamento do original. O antigo e o novo rodam sobre as mesmas entradas até as saídas baterem, e só então o tráfego muda. Nada é virado em uma data única.

  4. 04

    Entrega

    Seus engenheiros recebem o repositório, os testes escritos no caminho e o mapa mantido atualizado. Depois disso respondemos dúvidas, e não ficamos com nenhuma chave que você não possa revogar.

Peça o mapa primeiro

O mapa é a coisa mais barata que vendemos e a única base sólida para precificar o resto. Conte o que você roda e voltamos com o que existe lá dentro, quanto tempo uma reescrita leva e quanto custa.

O formulário chega até nós, não para uma régua de e-mails. Você não precisa assistir a uma demo para ter uma resposta.

Pedir orçamento