---
title: "O stub, o servidor e a reconciliação"
url: "https://www.mikefluff.com/pt/experiments/js-ch15-latency-comp"
locale: "pt"
author: "Mikhail Savchenko (Mike Fluff)"
updated: "2026-11-18"
description: "UI otimista: compensação de latência com um stub do método"
book: "https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems"
alternates:
  - locale: "en"
    url: "https://www.mikefluff.com/en/experiments/js-ch15-latency-comp"
    markdown: "https://www.mikefluff.com/en/experiments/js-ch15-latency-comp.md"
  - locale: "ru"
    url: "https://www.mikefluff.com/ru/experiments/js-ch15-latency-comp"
    markdown: "https://www.mikefluff.com/ru/experiments/js-ch15-latency-comp.md"
  - locale: "pt"
    url: "https://www.mikefluff.com/pt/experiments/js-ch15-latency-comp"
    markdown: "https://www.mikefluff.com/pt/experiments/js-ch15-latency-comp.md"
  - locale: "es"
    url: "https://www.mikefluff.com/es/experiments/js-ch15-latency-comp"
    markdown: "https://www.mikefluff.com/es/experiments/js-ch15-latency-comp.md"
---

# O stub, o servidor e a reconciliação

*UI otimista: compensação de latência com um stub do método*

## O que é uma UI otimista?

Uma UI otimista aplica a mudança do usuário na tela antes de o servidor confirmar, apostando que ele vai concordar. O Meteor chamava isso de compensação de latência: o método roda duas vezes, como stub no navegador e de verdade no servidor, e quando chega a resposta do servidor o cliente descarta o que o stub gravou e fica com o que o servidor mandou. Se os dois fizeram a mesma coisa, o usuário não percebe nada. Se fizeram coisas diferentes, ele vê a mudança piscar ou sumir. Chamadas reenviadas pedem cuidado à parte, porque o servidor pode executar a mesma chamada duas vezes.

Sem compensação de latência, cada clique espera a ida e volta: o navegador manda a requisição, o servidor confere, grava e responde, e só então o pedido aparece na lista. O Meteor rodava o mesmo método no navegador como stub, mostrava o resultado na hora e se acertava com o servidor depois. O experimento é um modelo de brinquedo inspirado no Meteor, algumas dezenas de linhas, e não o próprio Meteor.

Aperte “Adicionar pedido”. O stub insere o documento no cliente na hora, o servidor executa o método 150 ms depois e o cliente troca o documento do stub pelo do servidor. A câmera lenta estica cada atraso dez vezes para dar para ver os 150 ms. Troque de modo: com ids próprios o documento some e volta com outro id; com semente comum nada muda; com uma regra do servidor que o stub não tem, o pedido fica 150 ms na tela e some; depois de uma queda de conexão a chamada reenviada insere um segundo documento, a menos que o servidor lembre quais chamadas já executou.

No livro o modelo rodou no Node 24.16.0 com o mesmo atraso de 150 ms. Ids aleatórios deram a cintilação descrita na especificação do DDP. Passar a semente do gerador, como o randomSeed do DDP, fez os ids coincidirem, e a reconciliação não mudou nada. A chamada recusada ficou visível por 150 ms. O reenvio inseriu um segundo documento, e o servidor que guarda os ids das chamadas executou uma vez só.

O capítulo põe isso ao lado da especulação dentro do V8: espiar, apostar, conferir, desfazer. A diferença é quem vê o desfazer. Uma desotimização só deixa o programa mais lento por um tempo, mas o desfazer do stub acontece diante do usuário. Por isso o programador decide o que pode ser adivinhado, uma curtida ou uma tarefa na lista, e o que deve aparecer como aguardando confirmação, como um pagamento, e torna os métodos idempotentes, porque o ambiente reenvia chamadas sem saber se o servidor já as executou.

_A página tem um experimento interativo que roda no navegador: https://www.mikefluff.com/pt/experiments/js-ch15-latency-comp_

## Fontes

- [Meteor, DDP specification (DDP.md)](https://github.com/meteor/meteor/blob/devel/packages/ddp/DDP.md)
- [Kleppmann, Wiggins, van Hardenberg, McGranaghan, Local-first software (Ink & Switch, 2019)](https://www.inkandswitch.com/local-first/)

## Do livro

Ao lado dele no livro:

> Há dois remédios. Dá para proibir a repetição: Meteor.apply tem a opção noRetry, e então, depois de uma queda, o cliente recebe um erro em vez do reenvio, e o que fazer em seguida o programador decide. Ou dá para tornar o método idempotente, isto é, tal que uma chamada repetida não mude nada. Para isso cada chamada precisa ter seu próprio identificador, e o servidor precisa lembrar quais chamadas já executou. No quinto modo do experimento o servidor faz isso, e o segundo pedido não aparece. No décimo segundo capítulo, o cliente a quem responderam «não deu certo» apertava o botão de novo. A repetição depois da reconexão é a mesma história, só que quem aperta o botão pelo usuário é o runtime.

- Ler o capítulo: [Capítulo 15. Estado distribuído](https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch15) (início livre, o resto no livro completo; Markdown: https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch15.md)

- Livro: [JavaScript: das closures aos sistemas autônomos](https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems)
