# Capítulo 4 — O Primeiro Produto
**18 de outubro de 2006 — São Paulo, Brasil**
O relógio sobre a mesa marcava sete e doze da manhã quando Gabriel Almeida abriu os olhos.
Por alguns segundos, permaneceu deitado, olhando para o teto manchado do pequeno quarto nos fundos da casa de Dona Lúcia. A chuva da noite anterior havia deixado o ambiente mais frio, e o som de gotas caindo de uma calha defeituosa preenchia o silêncio.
Ele não se levantou imediatamente.
Estava pensando.
Desde o acidente, sua mente parecia funcionar de uma maneira que ele ainda não conseguia explicar. Não era apenas uma questão de lembrar informações. Era como se, ao observar um problema, conseguisse enxergar as relações entre suas partes com uma clareza que jamais experimentara antes.
Ontem, um erro que o perseguira por dias havia desaparecido em minutos.
Um projeto antigo, que ele abandonara por acreditar que precisaria recomeçá-lo quase do zero, começara a fazer sentido assim que ele examinou sua estrutura.
E havia a memória.
Gabriel conseguia recuperar trechos de livros e tutoriais que lera meses atrás. Não apenas o assunto geral, mas exemplos de código, explicações e detalhes que normalmente precisaria consultar novamente.
Entretanto, ele ainda não sabia se aquela capacidade era permanente, se possuía limites ou se o acidente tinha provocado alguma alteração que só perceberia com o tempo.
Por isso, havia decidido não tirar conclusões precipitadas.
Primeiro, precisava trabalhar.
E, para trabalhar, precisava de um produto.
Gabriel se levantou, dobrou o cobertor e caminhou até a pequena mesa onde seu computador permanecia desligado.
O gabinete velho tinha uma lateral arranhada e uma ventoinha que fazia um ruído desagradável durante a inicialização. O monitor CRT ocupava boa parte da mesa, deixando pouco espaço para os cadernos e as folhas com anotações.
Para muita gente, aquele conjunto não passaria de um equipamento ultrapassado.
Para Gabriel, era o ponto de partida.
Ele pressionou o botão de ligar.
O gabinete respondeu com um estalo discreto. A ventoinha começou a girar, o monitor exibiu sua tela escura e, depois de alguns segundos, o sistema operacional apareceu.
Gabriel observou a área de trabalho.
— Certo. Vamos descobrir se conseguimos construir alguma coisa que preste.
Abriu o ambiente de desenvolvimento e carregou o projeto de busca de arquivos que havia planejado na noite anterior.
Na tela, havia pouco mais do que uma janela básica, alguns campos de pesquisa e uma estrutura inicial para percorrer diretórios.
O programa ainda não tinha um nome.
Era apenas um projeto.
Mas Gabriel pretendia mudar isso.
***
## 1. O problema que ninguém queria resolver
Gabriel conhecia bem as limitações dos computadores modestos.
Muita gente no Brasil ainda utilizava máquinas com pouca memória, discos rígidos lentos e processadores que sofriam para executar diversos programas ao mesmo tempo. Nem todos podiam comprar equipamentos novos apenas para acompanhar o crescimento dos softwares.
O próprio computador de Gabriel era um exemplo disso.
Ele tinha de escolher cuidadosamente quais programas manter abertos. Algumas aplicações demoravam para iniciar, e certas operações simples se tornavam irritantes quando envolviam milhares de arquivos.
A busca de arquivos era uma dessas operações.
O sistema operacional oferecia recursos para localizar documentos, imagens, músicas e outros arquivos. No entanto, dependendo da quantidade de dados e das configurações da máquina, uma pesquisa podia demorar mais do que o usuário gostaria.
Havia programas especializados, mas alguns eram pesados para computadores antigos, outros tinham interfaces confusas e vários ofereciam funcionalidades que o usuário comum nunca utilizaria.
Gabriel não queria criar um programa que fizesse tudo.
Queria criar um que fizesse uma coisa muito bem.
Encontrar arquivos.
Rapidamente.
Sem exigir um computador caro.
Sem obrigar o usuário a entender uma dúzia de configurações.
Ele pegou o caderno e escreveu:
**Objetivo principal: localizar arquivos no computador com rapidez, baixo consumo de memória e uma interface simples.**
Abaixo, acrescentou:
— Pesquisa por nome completo ou parcial.
— Filtros por extensão.
— Seleção das pastas que seriam examinadas.
— Exibição do caminho completo dos resultados.
— Atualização do índice sem reconstruir tudo a cada execução.
— Tratamento de arquivos inacessíveis e unidades desconectadas.
— Possibilidade de interromper uma pesquisa.
— Instalação simples e desinstalação limpa.
Parou por alguns segundos e releu a lista.
— Se eu colocar vinte funções, vou passar meses fazendo um programa que ninguém pediu — murmurou. — Primeiro, o básico precisa funcionar.
A decisão parecia simples, mas era importante.
Gabriel tinha a impressão de que conseguiria desenvolver quase qualquer funcionalidade que imaginasse. O risco era justamente esse: começar projetos grandes demais, acumular recursos e perder de vista o problema original.
Ele precisava aprender a terminar.
Um programa completo, mesmo pequeno, valia mais do que dez projetos extraordinários abandonados pela metade.
Essa ideia permaneceu em sua cabeça enquanto ele abria o código.
***
## 2. A arquitetura
Antes do acidente, Gabriel costumava começar programando a parte que lhe parecia mais interessante. Quando encontrava um obstáculo, fazia alterações sucessivas até o código funcionar.
O método às vezes dava certo.
Em outras ocasiões, criava problemas que só apareciam muito mais tarde.
Agora, olhando para o projeto, ele percebia com facilidade onde aquela abordagem o levaria.
Uma busca de arquivos parecia simples: percorrer uma pasta, verificar os nomes e exibir os resultados.
O problema surgia quando o programa precisava trabalhar com milhares de arquivos, subpastas, permissões diferentes e alterações realizadas depois da criação do índice.
Se toda pesquisa obrigasse o programa a percorrer novamente o disco inteiro, a vantagem seria limitada.
Se o índice fosse mantido apenas na memória, o trabalho poderia precisar ser repetido após o fechamento do aplicativo.
Se o programa registrasse informações sem uma estratégia de atualização, os resultados ficariam desatualizados.
Gabriel abriu uma folha em branco.
Desenhou três blocos.
**Primeiro: o mecanismo de indexação.**
Responsável por percorrer as pastas selecionadas, obter informações dos arquivos e registrar os dados necessários.
**Segundo: o mecanismo de pesquisa.**
Responsável por interpretar os termos digitados, consultar o índice e ordenar os resultados.
**Terceiro: a interface.**
Responsável por receber as solicitações do usuário, mostrar o andamento das operações e apresentar os resultados.
Ele traçou linhas entre os três blocos.
A interface não deveria precisar conhecer os detalhes internos da indexação. O mecanismo de pesquisa não deveria depender de elementos visuais. E o índice deveria ter uma estrutura própria, independente da forma como os resultados seriam exibidos.
Gabriel observou o desenho.
— Se eu separar isso agora, posso melhorar uma parte sem destruir as outras.
Era uma decisão que parecia óbvia para quem já tinha experiência com arquitetura de software. Para Gabriel, porém, a diferença estava na velocidade com que conseguia enxergar as consequências de cada escolha.
Ele não estava apenas escrevendo código.
Estava antecipando problemas futuros.
Abriu os arquivos do projeto e reorganizou as funções em módulos. Em seguida, definiu as informações que cada registro precisaria guardar:
— Nome do arquivo.
— Caminho completo.
— Extensão.
— Tamanho.
— Data de modificação, quando disponível.
— Informações necessárias para identificar alterações posteriores.
Não precisava armazenar o conteúdo inteiro dos arquivos. Fazer isso consumiria espaço desnecessário e aumentaria a complexidade do programa.
O objetivo era localizar arquivos, não indexar tudo o que havia dentro deles.
Também decidiu que o aplicativo ignoraria, por padrão, diretórios do sistema e locais que não fossem apropriados para uma busca comum. O usuário poderia selecionar outras pastas quando tivesse permissão para acessá-las.
Isso reduziria erros e evitaria que o programa tentasse examinar áreas irrelevantes.
Às nove e vinte, a estrutura principal estava pronta.
Gabriel olhou para o relógio e depois para a tela.
O trabalho que, em condições normais, talvez ocupasse boa parte de seu dia havia avançado com uma rapidez impressionante.
Mas ele não comemorou.
Estrutura organizada não significava produto funcionando.
Agora começava a parte que separava uma ideia de um programa utilizável.
***
## 3. O primeiro teste
Gabriel iniciou a compilação.
O computador ficou alguns segundos em silêncio, processando o código. Depois, uma mensagem apareceu no ambiente de desenvolvimento.
A compilação havia sido concluída.
Ele executou o programa.
A janela abriu com uma interface simples. No alto, havia um campo de pesquisa, um botão para iniciar a busca e outro para selecionar os diretórios. Abaixo, uma área vazia aguardava os resultados.
Gabriel digitou:
— relatório
Clicou em pesquisar.
Nada aconteceu.
Ele franziu a testa, embora já esperasse aquele resultado. O mecanismo de pesquisa ainda não estava conectado ao índice.
— Certo. A janela abre. Já temos alguma coisa.
Abriu o depurador, verificou a inicialização e confirmou que os componentes estavam respondendo. Depois, fechou a janela e voltou ao código.
A primeira tarefa seria construir um índice funcional.
Para começar, Gabriel escolheu uma pasta de teste com documentos, imagens e arquivos de texto. Não queria apontar o programa para todo o computador antes de verificar como ele se comportava.
Implementou a leitura dos diretórios, acrescentando verificações para lidar com pastas que não pudessem ser acessadas. Cada erro seria registrado sem encerrar todo o processo.
Também incluiu um contador de arquivos examinados.
A ideia era simples: se o programa encontrasse um arquivo problemático, deveria continuar trabalhando nos demais.
Ele compilou novamente.
Dessa vez, o programa começou a percorrer a pasta.
O contador avançou.
Dez arquivos.
Vinte.
Cinquenta.
Gabriel observou a janela, procurando sinais de travamento.
O contador parou por um instante quando o programa encontrou um diretório ao qual não tinha acesso. Uma mensagem discreta apareceu no registro de execução, e o processo continuou.
— Muito bem.
Ao terminar, o índice continha os registros esperados.
Gabriel fechou o programa e o abriu novamente.
Os dados continuavam lá.
Era importante. O índice estava sendo salvo, de modo que o aplicativo não precisaria reconstruí-lo integralmente sempre que fosse iniciado.
Ele então digitou o nome de um documento conhecido.
O resultado apareceu.
O caminho estava correto.
Gabriel clicou duas vezes no registro, e o sistema abriu o arquivo.
Por alguns segundos, ele ficou olhando para a tela.
Não era uma criação revolucionária.
Não havia inteligência artificial, gráficos impressionantes ou uma tecnologia que mudaria o mundo.
Era apenas um pequeno programa que encontrava arquivos.
Mas funcionava.
E havia uma diferença enorme entre imaginar um produto e vê-lo realizar uma tarefa real.
Gabriel sorriu.
— Primeiro passo concluído.
Em seguida, criou uma lista de testes para não confiar apenas na primeira demonstração.
Precisava verificar nomes incompletos, extensões, arquivos duplicados, caminhos longos, arquivos removidos e mudanças realizadas depois da indexação.
A lista cresceu rapidamente.
Ele começou pelos nomes.
Pesquisou um arquivo usando o nome completo. Funcionou.
Depois, digitou apenas parte do nome. O mecanismo encontrou o documento.
Tentou uma extensão específica. O filtro funcionou.
Por fim, digitou uma palavra que não correspondia a nenhum arquivo.
A janela exibiu uma mensagem informando que nenhum resultado havia sido encontrado.
Gabriel anotou os resultados no caderno.
**Pesquisa básica: aprovada.**
**Filtros: aprovados.**
**Persistência do índice: aprovada.**
**Tratamento de erros: teste inicial aprovado.**
Ele não considerou os testes suficientes para lançar o programa. Eram apenas os primeiros casos, executados em uma pasta controlada.
Mesmo assim, já tinha uma base funcional.
E agora queria descobrir até onde poderia levá-la.
***
## 4. O preço da velocidade
Às dez e quarenta, Gabriel decidiu testar a ferramenta em uma situação mais próxima da realidade.
Escolheu uma pasta com uma quantidade maior de arquivos e iniciou a indexação.
O contador avançou de maneira constante até que, de repente, o programa começou a responder lentamente.
O ponteiro do mouse se movia com dificuldade.
A janela demorava a atualizar.
Gabriel tentou clicar no botão de cancelamento, mas não recebeu resposta imediata.
— Ah, não. Isso não pode acontecer.
Ele esperou o processamento terminar e abriu as informações de execução.
O mecanismo estava examinando os arquivos corretamente. O problema era outro.
A indexação estava sendo realizada de uma maneira que ocupava o fluxo principal da interface. Enquanto o programa examinava os diretórios, a janela não conseguia processar os eventos com a rapidez necessária.
Em um computador mais potente, talvez o incômodo fosse menor.
Na máquina de Gabriel, era evidente.
Ele poderia simplesmente aceitar a lentidão e continuar.
Mas, se fizesse isso, estaria criando exatamente o tipo de programa que queria evitar: uma ferramenta que funcionava, mas incomodava quem a utilizava.
Gabriel voltou ao código.
Precisava separar o trabalho pesado da atualização da interface.
A primeira solução que lhe veio à mente foi executar a indexação em uma tarefa independente, enquanto a interface continuava processando os eventos. Também precisaria estabelecer uma maneira segura de comunicar o progresso e solicitar o cancelamento.
Ele desenhou o fluxo em uma folha.
A tarefa de indexação examinaria os arquivos.
Periodicamente, enviaria uma atualização com o número de itens processados.
A interface receberia essas informações e atualizaria o contador.
Quando o usuário solicitasse o cancelamento, o mecanismo verificaria o pedido em pontos apropriados e encerraria a operação de forma controlada.
Era necessário ter cuidado com o índice. Se o programa fosse interrompido no meio de uma atualização, não deveria deixar um arquivo de dados corrompido ou incompleto.
Gabriel decidiu que a nova versão do índice seria preparada separadamente e validada antes de substituir a anterior. Se a operação falhasse, o índice já existente deveria permanecer disponível sempre que possível.
Não era uma solução sofisticada demais para o tamanho do projeto.
Era uma proteção contra um problema previsível.
Ele implementou as alterações, compilou e repetiu o teste.
A indexação começou.
O contador avançou.
Gabriel movimentou o mouse, abriu outra janela e voltou ao aplicativo.
Dessa vez, a interface continuava respondendo.
Clicou em cancelar.
A tarefa encerrou-se após concluir a etapa em andamento, e o programa informou que a operação havia sido interrompida.
Gabriel abriu novamente o índice.
Os registros anteriores continuavam disponíveis.
Ele repetiu o procedimento.
Depois, repetiu outra vez.
Na terceira tentativa, um detalhe chamou sua atenção: o contador visual parecia avançar em intervalos irregulares, embora o processamento estivesse funcionando.
Não era um defeito grave, mas deixava a impressão de que o programa estava travando.
Gabriel ajustou a frequência das atualizações, evitando enviar informações à interface a cada arquivo examinado. Uma atualização periódica seria suficiente para manter o usuário informado sem desperdiçar processamento.
Executou novamente.
O contador avançou de maneira mais uniforme.
Ele fez uma anotação:
**Responsividade não é apenas velocidade de processamento. É a sensação de que o programa continua sob controle do usuário.**
A frase ficou no caderno.
Gabriel percebeu que, se quisesse criar softwares realmente bons, precisaria pensar não apenas no que acontecia dentro do computador, mas também na experiência de quem estava sentado diante dele.
O usuário não deveria precisar compreender a arquitetura do programa.
Deveria simplesmente utilizá-lo.
***
## 5. A primeira comparação
Depois de concluir os ajustes, Gabriel percebeu que ainda não tinha uma resposta para uma pergunta fundamental.
Seu programa era realmente rápido?
Ele havia melhorado a estrutura, corrigido problemas e eliminado operações desnecessárias. Mas, sem uma comparação, não poderia afirmar que a ferramenta era superior às alternativas existentes.
Gabriel abriu o relógio do sistema e preparou um pequeno roteiro de testes.
Usaria a mesma pasta, a mesma pesquisa e condições semelhantes sempre que possível.
Primeiro, mediria o tempo necessário para construir o índice.
Depois, o tempo de uma pesquisa por um nome conhecido.
Por fim, repetiria a pesquisa para verificar se o resultado se mantinha estável.
Ele tomou o cuidado de distinguir a primeira pesquisa das seguintes. A leitura inicial dos dados do disco poderia afetar o resultado, e o sistema operacional podia manter informações em memória que tornariam as execuções posteriores mais rápidas.
Não queria produzir números bonitos à custa de uma comparação enganosa.
Fez várias execuções e registrou os tempos.
O primeiro resultado foi decepcionante.
Em uma pasta pequena, a diferença era quase imperceptível.
O programa funcionava bem, mas não havia motivo para alguém abandonar uma ferramenta conhecida apenas por causa de uma melhoria tão pequena.
Gabriel apoiou as costas na cadeira.
— Então precisamos encontrar o cenário em que a diferença realmente importa.
A resposta estava na própria arquitetura.
Uma busca tradicional que examinasse o disco a cada solicitação precisava repetir parte do trabalho. O programa de Gabriel, por outro lado, poderia consultar o índice já construído.
Em pesquisas repetidas sobre um conjunto de arquivos estável, essa abordagem tinha potencial para oferecer uma vantagem significativa.
Ele aumentou a quantidade de arquivos do teste.
Criou pesquisas diferentes, incluindo termos que retornavam poucos resultados e outros que correspondiam a muitos nomes.
Executou a primeira pesquisa.
Depois, a segunda.
E a terceira.
Os resultados começaram a mostrar um padrão: depois da indexação inicial, as pesquisas simples eram rápidas, especialmente quando comparadas a uma busca que precisasse percorrer novamente toda a árvore de diretórios.
Mas havia uma condição.
O índice precisava estar atualizado.
Se o usuário criasse um arquivo novo, renomeasse um documento ou removesse uma pasta, o programa teria de detectar ou registrar essas mudanças. Caso contrário, a velocidade seria obtida à custa da confiabilidade.
Gabriel escreveu uma nova tarefa na lista.
**Atualização incremental do índice.**
A ideia era comparar as informações já registradas com as alterações identificadas nas pastas monitoradas ou examinadas novamente. Arquivos inalterados não precisariam ser processados como se fossem novos.
No entanto, ele decidiu não implementar tudo de uma vez.
Primeiro, precisava estabelecer um mecanismo confiável para detectar mudanças. Depois, poderia estudar formas de reduzir o custo da atualização.
A vantagem mais importante não seria produzir uma demonstração impressionante.
Seria manter o programa útil depois de semanas de uso.
Gabriel olhou para os números registrados.
Ainda não tinha dados suficientes para fazer uma afirmação geral sobre desempenho. Os resultados dependiam da quantidade de arquivos, do disco, da memória disponível e da natureza da pesquisa.
Mas tinha aprendido algo valioso.
**Uma boa otimização começa com uma medição, não com um palpite.**
Ele fechou a folha de testes e voltou ao código.
***
## 6. O programa precisa de um nome
Pouco depois do meio-dia, Gabriel interrompeu o trabalho para comer.
Dona Lúcia havia deixado arroz, feijão e ovos preparados. Quando ele apareceu na cozinha, ela olhou para o rosto do rapaz e depois para suas mãos.
— Você dormiu direito?
— Dormi, sim.
— E não ficou com dor de cabeça? Tontura? Nada estranho?
Gabriel puxou a cadeira.
— Não. Estou me sentindo bem.
Ela não pareceu completamente convencida.
— Ontem você foi atingido por um raio, Gabriel. Não é uma coisa que acontece todo dia.
— Eu sei, Dona Lúcia.
— E hoje já está sentado naquele computador desde cedo?
Ele sorriu, sem conseguir esconder a animação.
— Estou trabalhando em um programa.
— Isso eu imaginei. Só queria saber se você não ia esquecer que tem um corpo.
Gabriel abaixou a cabeça, envergonhado.
— Vou fazer pausas.
— Vai mesmo?
— Vou.
Dona Lúcia serviu mais um pouco de feijão no prato dele.
— Então coma. E, se começar a passar mal, você me chama.
— Pode deixar.
Durante alguns minutos, conversaram sobre assuntos comuns. Ela perguntou se ele precisava de alguma coisa para o quarto, e Gabriel respondeu que não.
Na verdade, precisava de várias coisas.
Um disco rígido maior ajudaria. Mais memória seria útil. Um monitor melhor facilitaria o trabalho. Livros técnicos novos também seriam bem-vindos.
Mas nada disso resolveria seu problema principal naquele momento.
Ele precisava terminar alguma coisa que pudesse oferecer a outras pessoas.
Ao voltar para o quarto, encontrou a tela ainda aberta no ambiente de desenvolvimento.
O projeto estava avançando, mas continuava sem identidade.
Gabriel abriu um arquivo de texto e começou a escrever nomes.
Busca Rápida.
Localizador.
FileFinder.
QuickSearch.
Nenhum o agradou.
Ele queria um nome curto, fácil de lembrar e que transmitisse a função principal do programa sem parecer pretensioso.
Escreveu mais algumas opções.
Depois de alguns minutos, digitou:
**Achou!**
Gabriel ficou olhando para a palavra.
Era simples, direta e tinha uma característica que lhe agradava: qualquer pessoa entenderia a ideia imediatamente.
O usuário não precisava saber o que era indexação, banco de dados ou árvore de diretórios.
Ele precisava achar um arquivo.
E o programa ajudaria nisso.
Gabriel abriu o arquivo de configuração do projeto e alterou o nome provisório.
`Achou! — Busca Rápida de Arquivos`
— Pronto — disse, satisfeito. — Pelo menos agora você tem um nome.
Ainda faltava muito para que o programa pudesse ser distribuído. Mas a escolha tornou o projeto mais concreto.
Não era mais apenas uma experiência técnica.
Era um produto que ele pretendia colocar nas mãos de usuários reais.
***
## 7. Uma interface para pessoas comuns
Às treze e vinte, Gabriel voltou sua atenção para a interface.
A versão atual era funcional, mas tinha sido construída para testar o mecanismo de pesquisa, não para ser apresentada a alguém.
Os campos estavam desalinhados, algumas mensagens eram excessivamente técnicas e o botão de cancelamento aparecia mesmo quando não havia uma operação em andamento.
Ele abriu um caderno novo e desenhou a janela que imaginava.
No alto, o nome do programa.
Logo abaixo, um campo de pesquisa.
Ao lado, um botão para iniciar a busca.
Em outra área, filtros simples para selecionar a extensão e a pasta desejada.
Na parte inferior, uma lista de resultados com nome, localização, tamanho e data de modificação.
Por fim, uma pequena área de status para informar se o índice estava atualizado, se havia uma pesquisa em andamento ou se algum problema havia ocorrido.
Gabriel não queria encher a janela de ícones.
Também não queria obrigar o usuário a configurar dezenas de opções antes de realizar a primeira pesquisa.
A primeira experiência precisava ser simples.
Abrir.
Escolher onde procurar.
Digitar o nome.
Encontrar.
Ele começou a reorganizar os componentes.
Em vez de apresentar mensagens como “falha na enumeração do diretório”, o programa usaria uma explicação compreensível: “Não foi possível acessar esta pasta”.
O registro técnico continuaria disponível para investigar problemas, mas o usuário comum não precisava vê-lo o tempo todo.
Também acrescentou uma indicação de progresso.
Se o programa estivesse examinando milhares de arquivos, o usuário saberia que o trabalho continuava em andamento.
Se a operação terminasse, o status seria atualizado.
Se fosse cancelada, a janela retornaria ao estado normal.
Gabriel testou cada mudança.
Uma das alterações provocou um problema na organização da lista de resultados. Quando o usuário iniciava uma nova pesquisa, algumas informações da pesquisa anterior permaneciam na tela.
Ele identificou a origem do defeito, ajustou a rotina de atualização e executou uma sequência de pesquisas diferentes.
O problema desapareceu.
Em seguida, percebeu que a janela não se adaptava bem quando era redimensionada. A lista de resultados ficava estreita, enquanto uma área vazia ocupava espaço desnecessário.
Ajustou o comportamento dos componentes para que a lista utilizasse o espaço disponível.
Não era uma transformação extraordinária.
Mas, aos poucos, a ferramenta começava a parecer um aplicativo de verdade.
Gabriel recostou-se na cadeira e observou a tela.
A interface era discreta, sem efeitos visuais sofisticados ou animações.
E isso era intencional.
Ele queria que o programa abrisse rapidamente, ocupasse pouco espaço e pudesse ser utilizado sem um manual.
Se conseguisse fazer isso bem, já teria um motivo para alguém experimentá-lo.
***
## 8. O primeiro problema de verdade
Às quinze horas, Gabriel decidiu testar o programa em uma situação menos controlada.
Em vez de utilizar apenas uma pasta de teste, selecionou vários diretórios com arquivos de tipos diferentes.
Havia documentos de texto, imagens, arquivos compactados, músicas e instaladores antigos.
A indexação começou normalmente.
Durante alguns minutos, tudo parecia funcionar.
Então, o programa encontrou um caminho com uma combinação de diretórios e nomes que não havia aparecido nos testes anteriores.
O registro de execução mostrou uma falha ao processar o caminho.
A operação não encerrou completamente, mas o arquivo problemático não foi incluído no índice.
Gabriel aproximou-se do monitor.
— Certo. Vamos ver o que aconteceu.
Ele abriu o depurador e reproduziu a situação.
A falha estava relacionada ao tratamento de caminhos. O código fazia suposições que funcionavam na maior parte dos casos, mas não eram válidas para todas as situações que o sistema operacional permitia.
Gabriel poderia simplesmente ignorar o caminho.
Mas isso significaria que o usuário talvez nunca encontrasse um arquivo existente.
A falha precisava ser tratada corretamente.
Ele examinou as operações envolvidas e separou três questões.
A primeira era identificar o caminho sem depender de uma suposição sobre o comprimento ou a forma do texto.
A segunda era verificar se o arquivo continuava disponível no momento em que o programa tentava acessá-lo.
A terceira era garantir que um problema individual não interrompesse a indexação dos demais arquivos.
O terceiro ponto era especialmente importante.
Arquivos podiam ser removidos durante o processo. Discos externos podiam ser desconectados. Permissões podiam mudar. Nem todas as operações sobre o sistema de arquivos terminariam com sucesso.
Um programa robusto precisava esperar essas situações.
Gabriel revisou o código, removeu uma limitação desnecessária e reforçou as verificações antes de registrar cada resultado.
Também passou a registrar os erros de forma que pudesse investigá-los posteriormente sem apresentar uma sequência interminável de mensagens ao usuário.
Compilou novamente.
O programa examinou o mesmo conjunto de diretórios.
Dessa vez, o caminho problemático foi processado corretamente.
Gabriel repetiu o teste com outras variações.
Funcionou.
Depois, simulou um arquivo que deixava de existir durante a indexação.
O programa registrou a ocorrência e continuou.
Ele marcou os itens correspondentes no caderno.
**Caminhos incomuns: corrigidos nos casos testados.**
**Arquivos removidos durante a indexação: tratamento inicial implementado.**
**Interrupção geral causada por falha individual: eliminada nos testes realizados.**
Gabriel sabia que ainda não havia coberto todas as situações possíveis. O sistema de arquivos era cheio de detalhes que poderiam escapar aos testes iniciais.
Mas cada problema encontrado agora tornava o produto mais confiável.
E a confiabilidade era uma parte da velocidade que ele não pretendia sacrificar.
***
## 9. O que significa lançar um programa?
No fim da tarde, Gabriel parou de programar por alguns minutos e abriu o navegador.
A próxima pergunta não era técnica.
Como faria para que alguém encontrasse o Achou!?
Em 2006, a distribuição de programas não acontecia da mesma forma que aconteceria anos depois. Não havia uma loja universal de aplicativos para computadores que garantisse visibilidade a qualquer desenvolvedor.
As pessoas encontravam ferramentas em sites de download, portais de tecnologia, fóruns, comunidades especializadas e recomendações de amigos.
Um programa também precisava ser compatível com as máquinas dos usuários.
Gabriel abriu páginas de distribuição de software e observou como outros desenvolvedores apresentavam seus produtos.
Alguns ofereciam versões gratuitas. Outros tinham períodos de avaliação, edições limitadas ou licenças pagas.
Ele anotou as possibilidades.
**Distribuição gratuita.**
**Versão de avaliação.**
**Licença paga.**
**Doações voluntárias.**
Cada modelo tinha vantagens e desvantagens.
Uma versão paga poderia gerar receita por usuário, mas seria difícil convencer alguém a pagar por um programa desconhecido, criado por um desenvolvedor sem reputação.
Uma versão de avaliação permitiria demonstrar o valor do produto, mas acrescentaria complexidade à implementação e ao suporte.
A distribuição gratuita facilitaria a experimentação, embora não garantisse retorno financeiro.
Gabriel não tinha dinheiro para investir em publicidade.
Também não possuía uma empresa, um nome conhecido ou contatos na indústria de software.
O que tinha era um computador, conhecimento e tempo.
Por isso, decidiu que a primeira versão deveria ser gratuita.
Não significava que nunca cobraria por nada. Ele poderia criar recursos adicionais ou desenvolver outros produtos no futuro.
Mas, naquele momento, o objetivo principal era conseguir usuários reais.
Se o Achou! resolvesse um problema e as pessoas gostassem dele, isso lhe daria algo mais importante do que uma primeira venda: evidências de que estava criando algo útil.
Gabriel abriu um documento e começou a redigir uma apresentação.
**Achou! — Busca Rápida de Arquivos**
*Encontre documentos, imagens, músicas e outros arquivos sem perder tempo procurando pasta por pasta.*
*O Achou! cria um índice local das pastas selecionadas e permite realizar pesquisas rápidas por nome e extensão. Desenvolvido para ser simples, leve e prático, mesmo em computadores modestos.*
Ele releu o texto.
Era direto.
Não prometia localizar arquivos instantaneamente em qualquer situação. Não afirmava ser o programa mais rápido do mundo. Não prometia compatibilidade universal.
Apresentava o que a ferramenta realmente fazia.
Gabriel queria que os primeiros usuários encontrassem um programa útil, não uma coleção de promessas exageradas.
A próxima etapa seria produzir uma versão que pudesse ser instalada em outro computador sem depender do ambiente de desenvolvimento.
E essa tarefa levantou uma série de novas perguntas.
O programa precisaria incluir todas as bibliotecas necessárias? Onde salvaria seu índice? Como evitaria perder os dados caso o usuário encerrasse o aplicativo inesperadamente? Como seria removido sem deixar arquivos desnecessários?
Gabriel escreveu cada questão.
O trabalho estava longe de terminar.
Mas, pela primeira vez, conseguia enxergar um caminho entre o código em sua tela e um programa disponível para outras pessoas.
***
## 10. O primeiro balanço
Às dezoito e dez, Gabriel encerrou a sessão de trabalho.
Não porque tivesse terminado o projeto, mas porque queria organizar o que havia feito antes de continuar.
Abriu o caderno e preparou um pequeno balanço.
**Projeto:** Achou! — Busca Rápida de Arquivos.
**Estado atual:** protótipo funcional.
**Funcionalidades implementadas:**
— Indexação inicial de diretórios selecionados.
— Armazenamento persistente do índice.
- Pesquisa por nome completo ou parcial.
- Filtros por extensão.
— Exibição dos caminhos dos arquivos.
— Indicador de progresso.
— Cancelamento de operações em andamento.
— Tratamento inicial de erros de acesso e arquivos removidos.
— Separação entre interface, pesquisa e indexação.
**Pendências principais:**
— Atualização incremental confiável.
— Testes mais amplos de desempenho.
— Verificação de integridade do índice.
— Tratamento de nomes e caminhos incomuns.
— Empacotamento para distribuição.
— Testes em outro computador.
— Documentação básica.
— Preparação de uma versão inicial para usuários.
Ele acrescentou uma última linha:
**Receita até o momento: R$ 0,00.**
Gabriel olhou para o número.
Não era um problema.
Ainda não havia vendido nada, não tinha lançado o produto e sequer sabia se alguém gostaria de utilizá-lo.
Mas aquele registro lhe pareceu importante.
Ele queria acompanhar a realidade financeira de cada projeto. Não pretendia confundir entusiasmo com lucro, nem considerar que um programa tinha valor comercial apenas porque fora difícil de desenvolver.
Se gastasse dinheiro com um disco rígido, livros, transporte ou divulgação, registraria os gastos.
Se recebesse algum pagamento, registraria a receita.
E, se um produto não encontrasse usuários, precisaria descobrir por quê.
Era uma disciplina que desejava manter mesmo quando os números se tornassem maiores.
Por enquanto, o resultado do dia não era financeiro.
Era técnico.
Naquela manhã, o Achou! era uma ideia organizada em um caderno. Agora, já conseguia indexar arquivos, salvar os dados e responder a pesquisas.
Ainda apresentava limitações. Ainda precisava de testes. Ainda não estava pronto para ser distribuído.
Mas existia.
Gabriel salvou os arquivos, fez uma cópia de segurança do projeto e conferiu se as últimas alterações estavam registradas.
Depois, desligou o computador.
O monitor CRT perdeu o brilho e a pequena luz do gabinete se apagou.
O quarto ficou silencioso.
Gabriel se espreguiçou, sentindo o cansaço acumulado nos ombros.
Ele ainda não sabia que tipo de empresa poderia construir, quantos produtos desenvolveria ou até onde suas capacidades o levariam.
Na verdade, naquele momento, sequer tinha certeza de que conseguiria ganhar dinheiro com o primeiro programa.
Mas já havia estabelecido uma regra para si mesmo.
Não bastava ser capaz de escrever código.
Precisava construir coisas que funcionassem, que resistissem aos problemas do mundo real e que outras pessoas considerassem úteis.
O resto viria depois.
Se viesse.
***
## 11. Uma pergunta inesperada
Gabriel estava guardando o caderno quando ouviu duas batidas na porta.
— Gabriel? — chamou Dona Lúcia. — Posso entrar?
— Pode, sim.
Ela abriu a porta e olhou para o computador desligado.
— Você terminou por hoje?
— Por hoje, sim.
— Que bom. Eu estava começando a achar que precisaria esconder o cabo de força para você descansar.
Gabriel riu.
— Não precisa chegar a esse ponto.
— Ainda bem. Não gostaria de descobrir quanto tempo você levaria para consertar a instalação elétrica e ligar tudo de novo.
Ele sorriu, mas a brincadeira o fez pensar.
A facilidade com que conseguia entender problemas técnicos era justamente o que poderia ajudá-lo a avançar. No entanto, não queria transformar sua vida inteira em uma sequência interminável de horas diante de uma tela.
Dona Lúcia se aproximou da mesa.
— E esse programa? Está ficando pronto?
Gabriel hesitou antes de responder.
— Está começando a funcionar. Ainda preciso corrigir algumas coisas e testar em outros computadores.
— E você vai vender?
— Ainda não sei. Primeiro, quero disponibilizar de graça e ver se as pessoas gostam.
Ela assentiu, como se aquela resposta fizesse sentido.
— E se gostarem?
— Talvez eu consiga ganhar dinheiro com outros programas. Ou criar uma versão melhor.
— Então você está trabalhando para ganhar dinheiro no futuro?
Gabriel pensou um pouco.
— Estou trabalhando para criar alguma coisa que as pessoas queiram usar. Se eu conseguir isso, talvez o dinheiro venha como consequência.
Dona Lúcia ficou em silêncio por alguns segundos.
— Parece um plano melhor do que ficar esperando alguém aparecer com uma oportunidade.
Gabriel não esperava aquela resposta.
— A senhora acha mesmo?
— Acho que você tem que tentar. Só não pode colocar todas as suas esperanças em um único programa. As coisas nem sempre saem como a gente imagina.
Ele assentiu.
— Eu sei.
Ela olhou para o caderno aberto, cheio de anotações, números e desenhos.
— Você sempre foi assim, não foi? Quando colocava alguma coisa na cabeça, ficava tentando até descobrir como funcionava.
Gabriel baixou os olhos.
— Antes eu demorava mais.
— Talvez. Mas você sempre tentava.
A observação permaneceu com ele depois que Dona Lúcia saiu.
Gabriel não podia explicar a ela o que havia mudado desde o acidente. Nem mesmo ele entendia completamente.
Mas uma coisa continuava igual.
Ele gostava de construir coisas.
Gostava de olhar para um problema, imaginar uma solução e ver essa solução ganhar forma na tela.
Agora, porém, sentia que havia um espaço muito maior entre aquilo que conseguia imaginar e aquilo que era capaz de realizar.
Precisava descobrir o tamanho desse espaço.
E, para isso, precisava continuar.
***
## 12. O plano para o dia seguinte
Antes de dormir, Gabriel voltou ao caderno uma última vez.
A lista de tarefas do Achou! ainda era longa, mas agora estava dividida em etapas.
**Etapa 1 — Tornar o protótipo confiável.**
Concluir a atualização do índice, reforçar a integridade dos dados e ampliar os testes com arquivos e diretórios diferentes.
**Etapa 2 — Medir o desempenho.**
Construir um conjunto de testes repetíveis, registrar o comportamento em pesquisas diferentes e verificar o consumo de recursos.
**Etapa 3 — Preparar a distribuição.**
Criar um pacote que funcionasse em outro computador, documentar os requisitos e testar a instalação e a remoção.
**Etapa 4 — Encontrar os primeiros usuários.**
Apresentar o programa em comunidades de tecnologia e fóruns, explicar suas limitações e receber críticas.
Ele sabia que poderia encontrar comentários desagradáveis. Alguém poderia apontar defeitos que ele não havia percebido. Outro usuário poderia preferir uma ferramenta concorrente. Talvez ninguém demonstrasse interesse.
Gabriel decidiu que tentaria aprender com cada resposta.
Se o programa fosse lento em determinadas situações, investigaria.
Se a interface fosse confusa, simplificaria.
Se alguém encontrasse um erro, tentaria reproduzi-lo antes de corrigi-lo.
E, se descobrisse que ninguém precisava daquela ferramenta, teria de aceitar a possibilidade e procurar outro problema para resolver.
A última parte era a mais difícil de escrever.
Ele queria que o primeiro produto desse certo.
Mas não queria que o orgulho o impedisse de enxergar a realidade.
Fechou o caderno.
A luz do quarto foi apagada, e Gabriel se deitou.
Naquela noite, não sonhou com fortunas, empresas gigantescas ou máquinas capazes de conversar como seres humanos.
Pensou em uma janela simples, em uma lista de arquivos e em uma pequena frase que apareceria quando alguém digitasse o nome de um documento e o encontrasse em segundos.
**Arquivo encontrado.**
Era pouco.
Mas era concreto.
E Gabriel estava começando a compreender que grandes transformações não precisavam começar com uma invenção grandiosa.
Às vezes, começavam com alguém percebendo que uma tarefa cotidiana poderia ser feita melhor.
O Achou! ainda não havia conquistado seu primeiro usuário.
Não tinha gerado um centavo.
Não possuía reputação.
Mas, no pequeno quarto dos fundos de uma casa em São Paulo, um jovem de dezessete anos havia dado o primeiro passo para transformar suas capacidades extraordinárias em algo que existiria fora de sua própria cabeça.
E, no dia seguinte, começaria a descobrir se aquele primeiro passo era suficiente para levá-lo adiante.