Criador do JavaScript Critica Inchaco de Software Web: Brendan Eich Ataca Electron e Apps Lentos

Ola HaWkers, Brendan Eich, o criador do JavaScript, gerou polemica ao criticar duramente o "inchaco" de aplicativos baseados em interfaces web no Windows 11. Ele apontou que muitos softwares modernos estao lentos e consomem recursos excessivos por causa da dependencia de tecnologias web.

Voce ja sentiu frustrado ao ver um app "simples" consumindo gigabytes de RAM? Brendan Eich sente o mesmo, e ele criou a linguagem que muitos culpam por isso.

O Que Brendan Eich Disse

Em uma serie de posts nas redes sociais, Eich criticou a tendencia de empacotar navegadores inteiros em aplicativos desktop:

Os Pontos Principais da Critica

Problemas identificados:

• Apps Electron carregam um Chromium completo para cada instancia
• Windows 11 tem varios componentes baseados em web que sao lentos
• Memoria RAM e desperdicada com multiplas instancias de runtimes web
• Performance sacrificada por conveniencia do desenvolvedor
• Usuarios pagam o preco com hardware mais caro necessario

Exemplos citados:

• Teams (Microsoft) - notoriamente lento e pesado
• Slack - consome GBs de RAM
• VS Code - baseado em Electron (embora bem otimizado)
• Discord - outro app Electron popular
• Spotify desktop - interface web empacotada

A Ironia da Situacao

O critico faz uma observacao ironica: ele criou JavaScript em 10 dias em 1995 para rodar em navegadores. Nao imaginava que decadas depois, navegadores inteiros seriam empacotados para rodar aplicativos que poderiam ser nativos.

O Problema do Electron em Numeros

Para entender a critica de Eich, vejamos os numeros:

Comparativo de Recursos

App de chat simples:

Implementacao	RAM em Repouso	Tamanho do App	Tempo de Inicio
Nativo (Swift/C++)	15-30 MB	5-20 MB	< 1s
Tauri (Rust + WebView)	30-60 MB	3-10 MB	1-2s
Electron	150-300 MB	150-400 MB	3-5s

O que cada app Electron inclui:

• Chromium completo (~100 MB)
• Node.js runtime (~30 MB)
• V8 JavaScript engine
• Toda a stack de renderizacao web
• Multiplos processos (main, renderer, GPU)

Por Que Desenvolvedores Escolhem Electron

Apesar dos problemas, Electron domina por razoes praticas:

Vantagens para desenvolvedores:

• Uma unica codebase para Windows, Mac, Linux
• Usar JavaScript/TypeScript, HTML, CSS conhecidos
• Ecossistema npm disponivel
• Prototipagem rapida
• Facil encontrar desenvolvedores web

O custo oculto:

• Usuarios precisam de mais RAM
• Bateria de laptops drena mais rapido
• Apps competem por recursos
• Experiencia do usuario degradada

Alternativas Mais Leves

A critica de Eich nao vem sem solucoes. Existem alternativas modernas:

Tauri

Tauri usa o WebView do sistema operacional ao inves de empacotar Chromium:

// Backend em Rust - performance nativa
#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}! You've been greeted from Rust!", name)
}

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// Frontend em qualquer framework web
import { invoke } from '@tauri-apps/api';

async function greet() {
  const message = await invoke('greet', { name: 'HaWker' });
  console.log(message); // "Hello, HaWker! You've been greeted from Rust!"
}

Beneficios do Tauri:

• Apps 10x menores que Electron
• Usa menos de 1/3 da RAM
• Backend em Rust (seguranca e performance)
• Ainda permite usar React, Vue, Svelte no frontend

Neutralino.js

Outra alternativa leve:

// neutralino.js - Ainda mais leve que Tauri
Neutralino.init();

document.getElementById('btn').addEventListener('click', async () => {
  const response = await Neutralino.os.execCommand('ls -la');
  console.log(response.stdOut);
});

Comparativo final:

Framework	Tamanho Minimo	RAM Tipica	Linguagem Backend
Electron	~150 MB	200-500 MB	JavaScript/Node.js
Tauri	~3 MB	30-80 MB	Rust
Neutralino	~2 MB	20-50 MB	JavaScript
Nativo	~1 MB	15-40 MB	C++/Swift/Rust

A Defesa do Electron

Por outro lado, defensores do Electron argumentam:

Produtividade Importa

Argumentos a favor do Electron:

• Time-to-market mais rapido
• Custo de desenvolvimento menor
• Manutencao mais simples
• Atualizacoes sincronizadas entre plataformas
• Consistencia visual garantida

VS Code: O Contra-Exemplo

O Visual Studio Code e frequentemente citado como prova de que apps Electron podem ser rapidos:

O que a Microsoft fez diferente:

• Otimizacoes agressivas de performance
• Lazy loading de extensoes
• Virtualizacao de listas longas
• Uso inteligente de Web Workers
• Profiling constante e correcao de gargalos

Isso mostra que o problema nao e Electron em si, mas como ele e usado.

O Que Desenvolvedores Podem Fazer

Se voce trabalha com apps desktop, considere estas praticas:

Otimizacoes para Electron

// 1. Lazy loading de modulos
const heavyModule = () => import('./heavy-module');

// 2. Usar requestIdleCallback para tarefas nao-criticas
requestIdleCallback(() => {
  performBackgroundTask();
});

// 3. Virtualizar listas longas
import { FixedSizeList } from 'react-window';

function VirtualizedList({ items }) {
  return (
    <FixedSizeList
      height={400}
      itemCount={items.length}
      itemSize={35}
    >
      {({ index, style }) => (
        <div style={style}>{items[index].name}</div>
      )}
    </FixedSizeList>
  );
}

// 4. Desabilitar recursos desnecessarios
// main.js
const win = new BrowserWindow({
  webPreferences: {
    nodeIntegration: false, // Seguranca + performance
    contextIsolation: true,
    enableRemoteModule: false,
  },
});

Quando Considerar Alternativas

Use Tauri quando:

• Performance e critica
• App sera distribuido amplamente
• Tamanho do download importa
• Seguranca e prioridade

Use Electron quando:

• Precisa de compatibilidade maxima com libs npm
• Time-to-market e critico
• Ja tem equipe especializada em web
• App interno/corporativo

O Futuro dos Apps Desktop

A industria esta respondendo as criticas:

Tendencias Emergentes

WebAssembly + WebView:

• Apps hibridos com WASM para partes criticas
• Performance proxima ao nativo
• Ainda usa tecnologias web

PWAs Avancados:

• Progressive Web Apps como alternativa
• Instalacao leve
• Atualizacao automatica
• Suporte crescente em sistemas operacionais

Frameworks Nativos Modernos:

• SwiftUI (Apple)
• Jetpack Compose (Android/Desktop)
• Flutter (cross-platform)

Conclusao

A critica de Brendan Eich ressoa com muitos desenvolvedores e usuarios frustrados com apps pesados. O criador do JavaScript nao esta criticando a web em si, mas o uso excessivo e desnecessario de recursos quando alternativas mais leves existem.

Para nos desenvolvedores, a licao e clara: considere o impacto das suas escolhas tecnologicas nos usuarios finais. Nem todo app precisa carregar um navegador completo. As vezes, menos e mais.

Se voce se sente inspirado por discussoes sobre performance, recomendo que de uma olhada em outro artigo: HTMX 2.0 Chega Com Revolucao: HTML Interativo Sem JavaScript Pesado onde voce vai descobrir uma abordagem alternativa para interatividade web.

Bora pra cima! 🦅