Voltar para o blog
BunProdutividadeFerramentas

Banir celular melhora notas. E o que o Bun tem com isso?

18 de novembro de 2026·6 min de leitura·Diego Horvatti

Escolas que tiraram o celular da sala de aula estão vendo as notas subirem. Sem salto milagroso: é uma melhora pequena, que cresce a cada ano. Quem trouxe os dados novos foi o Upshot, do New York Times. Parece notícia de educação, e é. Só que eu li pensando no meu terminal, e no Bun, e vou explicar o porquê.

O que o estudo sobre celular na escola encontrou

A ideia é simples. Várias escolas e estados americanos proibiram o celular durante as aulas. Agora já dá para comparar o antes e o depois com dados de prova padronizada.

O resultado não é uma virada da noite para o dia. É gradual. No primeiro ano o efeito é tímido. Com o tempo, a diferença aparece. O aluno passa a ficar mais tempo numa tarefa sem ser puxado para fora dela.

Esse "gradual" é a parte que me interessa. Ninguém fica mais inteligente porque largou o celular. O que muda é que a pessoa para de ser interrompida o tempo todo. E ficar menos interrompido, somado ao longo de meses, vira resultado.

Por que isso importa para quem programa

Programar é a atividade que mais sofre com interrupção. Você monta na cabeça um modelo do sistema: quem chama quem, qual estado está onde, por que aquele teste quebra. Esse modelo é frágil. Uma notificação já derruba tudo.

A pesquisadora Gloria Mark, da Universidade da Califórnia em Irvine, ficou conhecida por medir isso. Nos estudos dela, uma pessoa interrompida leva em média uns 23 minutos para voltar de verdade à tarefa original. Vinte e três minutos. Por causa de uma mensagem de grupo.

Agora a parte incômoda. Boa parte das interrupções de um dev não vem de fora. Vem da gente mesmo, e quem provoca é a ferramenta lenta.

O roteiro você conhece:

  1. Você roda npm install.
  2. A barra de progresso começa a andar devagar.
  3. Você pega o celular "só um minuto".
  4. Volta 12 minutos depois sem lembrar o que ia testar.

O install terminou em 40 segundos. Você é que não voltou.

A espera curta é a mais perigosa: ela é longa o bastante para você sair e curta demais para você perceber que saiu.

Onde o Bun entra nessa história

As escolas tiraram o celular da sala. A gente não vai trancar o celular numa gaveta (às vezes devia). Mas dá para eliminar as brechas que levam até ele. E a maior brecha no fluxo de um dev JavaScript é esperar ferramenta.

O Bun foi feito para ser rápido. Ele junta runtime, gerenciador de pacotes, test runner e bundler num binário só. Na prática, isso significa menos esperas em quatro lugares:

  • Instalar dependências. O bun install usa cache global e links do sistema de arquivos. Num projeto com cache quente, ele costuma terminar antes de você pensar em pegar o celular.
  • Rodar TypeScript. O Bun executa .ts direto, sem passo de compilação e sem ts-node.
  • Rodar testes. O bun test sobe muito rápido e aceita boa parte da API do Jest.
  • Subir o servidor em dev. O --watch reinicia o processo quase sem você notar.

Nenhum desses ganhos impressiona sozinho. Dois segundos aqui, cinco ali. O efeito vem da soma, igual ao do estudo. Cada espera que some é uma oportunidade a menos de sair da tarefa.

Como trocar as esperas do seu fluxo pelo Bun

Você não precisa migrar o projeto inteiro de uma vez. Dá para começar pelo que mais dói. Aqui vai o caminho que eu sigo.

Primeiro, o gerenciador de pacotes. Ele funciona com o package.json que você já tem:

# instala tudo a partir do package.json existente
bun install

# adiciona uma dependência
bun add zod

# dev dependency
bun add -d @types/node

Depois, os scripts. O bun run executa os mesmos scripts do package.json, e o boot é bem mais leve que o do npm run:

{
  "scripts": {
    "dev": "bun --watch src/index.ts",
    "test": "bun test",
    "test:watch": "bun test --watch"
  }
}

Repare no dev. Não tem tsc, nodemon nem ts-node. O Bun lê o TypeScript, observa os arquivos e reinicia sozinho.

Nos testes, a sintaxe é a que você já conhece:

import { describe, expect, test } from "bun:test";
import { calcularDesconto } from "./preco";

describe("calcularDesconto", () => {
  test("aplica 10% acima de 100 reais", () => {
    expect(calcularDesconto(200)).toBe(180);
  });

  test("não dá desconto abaixo do mínimo", () => {
    expect(calcularDesconto(50)).toBe(50);
  });
});

Com bun test --watch aberto num terminal ao lado, o ciclo fica assim: você salva, olha para a direita e já tem a resposta. Não sobra tempo para abrir o Instagram. É esse o objetivo.

Uma dica: comece pelos testes. Eles costumam ser a espera mais frequente do dia e a migração mais tranquila. Se algum teste depende de API específica do Jest que o Bun ainda não cobre, você descobre logo e decide se vale ajustar.

O que o Bun não resolve

Agora a parte honesta, porque não quero que isso vire propaganda.

Ferramenta rápida não conserta processo lento. Se seu CI leva 25 minutos porque roda uma suíte E2E gigante a cada push, trocar de runtime não muda quase nada. O gargalo está em outro lugar.

Compatibilidade ainda tem arestas. O Bun cobre a maior parte das APIs do Node, mas sempre aparece um pacote com binding nativo ou uma dependência que mexe em algum detalhe interno e se comporta diferente. Em projeto grande e antigo, teste antes de prometer migração para o time.

Você continua sendo você. Se o install terminar em um segundo e você pegar o celular mesmo assim, o problema não era o install. As escolas não deixaram os alunos mais disciplinados. Elas tiraram o objeto da frente. A ferramenta rápida faz o mesmo: tira a desculpa. A decisão ainda é sua.

Tem também um ponto que pouca gente comenta: velocidade demais pode virar ansiedade. Teste rodando a cada tecla, servidor reiniciando o tempo todo, terminal piscando. Feedback rápido ajuda quando você controla o ritmo. Se ficou barulhento, rode o watch só no arquivo que você está mexendo:

bun test preco.test.ts --watch

O que eu tiro dessa notícia

O estudo das escolas mostra algo que todo dev sente na pele: o que mais pesa é quanto tempo você fica concentrado de verdade, e o talento sozinho conta menos do que parece. E esse tempo é destruído por pequenas fugas que parecem inofensivas.

Minha opinião, sem rodeio: o tempo de espera das suas ferramentas é um custo de produtividade, e a maioria dos times ignora isso. Ninguém coloca na retrospectiva que "perdemos foco porque o install demora 50 segundos". Mas perde. Todo dia, várias vezes.

O Bun não é a única resposta. pnpm, Vite, esbuild e o próprio Node mais recente também cortaram muita espera nos últimos anos. Mas se você trabalha com TypeScript e ainda tem ts-node e nodemon no package.json, vale uma tarde de teste. Na pior das hipóteses, você descobre onde estão suas esperas. Na melhor, ganha de volta uns minutos de foco por dia, e com o tempo eles fazem diferença, que nem nas escolas.

E se o seu celular estiver do lado do teclado agora, talvez a primeira otimização nem seja no código.

Se quiser ver onde eu uso Bun no dia a dia, tem alguns exemplos nos meus projetos.

Resumo para o LinkedIn

Escolas que baniram o celular estão vendo as notas subirem. E eu li a notícia pensando no meu terminal.

A melhora não vem de uma hora para outra. Ela cresce aos poucos, ano a ano, porque o aluno simplesmente para de ser interrompido.

Com dev é igual. Você roda o install, a barra anda devagar, você pega o celular "só um minuto" e volta 12 minutos depois sem lembrar o que ia testar.

O install terminou em 40 segundos. Quem demorou para voltar foi você.

Por isso eu trato o tempo de espera das ferramentas como custo de produtividade. Foi um dos motivos para eu adotar o Bun: install rápido, TypeScript sem compilar, testes em watch. Cada espera que some é uma desculpa a menos para sair da tarefa.

Ferramenta rápida não faz milagre e nem substitui disciplina. Mas tira o celular da frente.

Escrevi sobre isso no blog, com o passo a passo da migração. Quais são as esperas que mais te tiram do foco?

#Bun #JavaScript #TypeScript #Produtividade #DesenvolvimentoDeSoftware