O hot reload do Flutter está muito em alta agora.
Testando como o hot reload do Flutter escala.
Quando o assunto é hot reload, não tem como evitar um meme do Zoolander, então, por favor, perdoe o título.
Uma das funcionalidades mais populares do framework Flutter é seu hot reload. Ele permite recarregar o código no app em execução sem perder o estado, reduzindo muito o tempo de desenvolvimento. O mais importante é que o hot reload do Flutter não é um recurso adicionado ao framework, como o Instant Run no Android Studio. O Flutter foi projetado assim desde o primeiro dia, e ele apenas aproveita o poder de sua arquitetura. O Flutter ainda é relativamente novo, mas empresas de mobile já tentam lidar com desenvolvimento em grande escala. Percebi isso ao observar a mudança nas perguntas feitas em https://gitter.im/flutter/flutter e em meetups. A primeira onda de perguntas:
Como ele desenha? Por que usa Dart? Como ele se diferencia de outros frameworks?
começam a desaparecer e dão lugar a perguntas mais voltadas ao desenvolvimento em larga escala.
Como ele escala? Como é o suporte a CI? Como fica a automação de testes?
Durante o último meetup de Flutter na @Skillsmatter, um dos desenvolvedores fez uma pergunta bem séria:
O hot reload vai ficar mais lento conforme o projeto cresce? Quanto?
Meus próprios projetos em Flutter nunca passaram de algumas dezenas de classes e um punhado de telas. Meu hot reload sempre fica estável em 650 ms, daí minha curiosidade.
Então, onde está o ponto de ruptura?
Por isso decidi criar um projeto fictício para testar o hot reload e levá-lo ao limite. Construí um gerador de código simples, escrito, sem surpresa nenhuma, em Dart. O Dart tem vários truques na manga que são muito úteis na geração de código. O Dart é totalmente indiferente às vírgulas finais (trailing commas). Isso simplifica muito o algoritmo de geração de código. Você não precisa mais ramificar a lógica ao processar o último elemento da lista.
O exemplo
Minha primeira tentativa foi bem simplista.
- O gerador vai criar um número específico de widgets stateless.
- O gerador vai criar um layout que aninha esses widgets.
- Vou modificar manualmente o arquivo .dart gerado e observar o tempo do hot reload.
Abaixo está um exemplo de uma das classes de widget stateless geradas.
class GeneratedWidget0 extends StatelessWidget {
final Widget child;
GeneratedWidget0({this.child});
Widget build(BuildContext context) {
return new Center(
child: new DecoratedBox(
decoration: new BoxDecoration(border: new Border(
top: const BorderSide(color: Colors.blue,width: 0.5,style: BorderStyle.solid),
bottom: const BorderSide(color: Colors.blue,width: 0.5,style: BorderStyle.solid),
left: const BorderSide(color: Colors.blue,width: 0.5,style: BorderStyle.solid),
right: const BorderSide(color: Colors.blue,width: 0.5,style: BorderStyle.solid),
)),
child: new Padding(
padding: new EdgeInsets.all(1.1),
child: child,
)
)
);
}
}
O layout gerado fica assim:
import 'package:flutter/material.dart';
class MainLayout extends StatelessWidget {
@override
Widget build(BuildContext context) {
return new Material(child: new GeneratedWidget4 (
child: new GeneratedWidget3 (
child: new GeneratedWidget2 (
child: new GeneratedWidget1 (
child: new GeneratedWidget0 (
child: new GeneratedWidget0 (
child: new Text('test with 5 items',style: Theme.of(context).textTheme.body1,),
),
),
),
),
),
));
}
}
O teste
Comecei com calma, com 20 widgets. Como eu esperava, nenhum reload deveria passar de 600 ms. Então apertei um pouco mais com 80 widgets. Continuou sem mudança. Decidi ir com tudo e testar com 1000 widgets aninhados.
O resultado foi interessante. O compilador me deu um erro:
error: line 265 pos 8: stack overflow while parsing
Por tentativa e erro, concluí que são necessários cerca de 250 widgets aninhados únicos para gerar esse erro. Esse não era o resultado que eu queria. Eu queria ver como o hot reload desacelera, não onde o compilador me diz que eu sou louco.
Eu precisava encontrar uma forma de passar desse limite de widgets aninhados sem quebrar o parser.
Modifiquei o gerador para criar vários pacotes, cada um com um arquivo gerado como o acima, mas todos com nomes distintos. Depois adicionei um gerador para um router que registrava cada pacote como destino do navigator. Assim, eu tinha certeza de que tinha usado todas as minhas classes.
Abaixo você pode ver o router para 5 pacotes.
import 'package:flutter/material.dart';
import 'package_0/generated_widget.dart';
import 'package_1/generated_widget.dart';
import 'package_2/generated_widget.dart';
import 'package_3/generated_widget.dart';
import 'package_4/generated_widget.dart';
class Router extends StatelessWidget {
@override
Widget build(BuildContext context) {
return new MaterialApp(
title: 'Flutter Demo',
theme: new ThemeData(
primarySwatch: Colors.blue,
),
routes : {
'/' : (context) => new Package0MainLayout(onTapHandler:()=>Navigator.of(context).pushNamed('/route_1')),
'/route_1' : (context) => new Package1MainLayout(onTapHandler:()=>Navigator.of(context).pushNamed('/route_2')),
'/route_2' : (context) => new Package2MainLayout(onTapHandler:()=>Navigator.of(context).pushNamed('/route_3')),
'/route_3' : (context) => new Package3MainLayout(onTapHandler:()=>Navigator.of(context).pushNamed('/route_4')),
'/route_4' : (context) => new Package4MainLayout(onTapHandler:()=>Navigator.of(context).pushNamed('/')),
},
);
}
}
Agora eu conseguia encaixar mais classes em mais layouts sem bater no “muro mágico dos 250 widgets aninhados”. Saí da zona de perigo do problema do parser e pude continuar meus testes.
80 widgets x 1 pacote — uma classe modificada — 650 ms. 80 widgets x 5 pacotes — 5 classes modificadas — 650 ms.
Porém, este aqui retornou com um aviso
Some program elements were changed during reload but did not run when the view was reassembled;
you may need to restart the app (by pressing "R") for the changes to have an effect.
• Package4MainLayout.build (lib/package_4/generated_widget.dart:10)
• Package3MainLayout.build (lib/package_3/generated_widget.dart:10)
• Package2MainLayout.build (lib/package_2/generated_widget.dart:10)
depois adicionei mais 75 pacotes e o resultado foi um erro de timeout da Dart VM:
TimeoutException: Request to Dart VM Service timed out
…
Application finished.
Reiniciei o Flutter e continuei a partir de 80 x 80. Então apertei reload e percebi
Reloaded 82 of 644 libraries in 1,209ms.
OK. Então depende de quantas classes modificamos, e não do tamanho do projeto em si. O Flutter recarregou 80 widgets em 80 pacotes em um pouco mais de 1,2 segundo. Percebi que o motivo de eu receber sempre o mesmo resultado de 650 ms era uma das maiores forças do Dart e do Flutter: a imutabilidade. Dart e Flutter reaproveitam a maior parte do objeto antigo ao criar um novo estado. Somente as partes que inevitavelmente são modificadas são substituídas.
Interessante: isso significa que, se nos mantivermos em um único ponto do código durante o desenvolvimento, teremos 650 ms todas as vezes. Meu pensamento foi direto para as lições do Uncle Bob. Essa ferramenta é perfeita para TDD.
Hora de pisar fundo. 80 widgets x 250 pacotes — se você está desenvolvendo um app com 250 layouts ou telas únicos, por favor, pare agora. Tenha consideração pelo tempo do usuário e pelo seu próprio!
O resultado dessa loucura foi:
Reloaded 252 of 984 libraries in 3,219ms.
Preciso dizer que o hot reload do Flutter é realmente impressionante. Para o uso do dia a dia, ele não vai passar do tempo habitual enquanto fizermos mudanças incrementais pequenas e bem feitas. O tamanho do projeto não importa tanto assim.
Antes de ir, quero compartilhar meu gerador com você. Divirta-se com ele. Sei que não é bonito, mas cumpre o papel. Se tiver ideias de como testar outras partes do framework Flutter, abra um pull request ou faça um fork!