Meteoro é uma estrutura JavaScript full-stack para web e Aplicações Móveis . Existe desde 2011 e ganhou uma forte reputação entre Desenvolvedores de meteoros por ser uma solução ideal e fácil de usar para prototipagem rápida. No entanto, recentemente os desenvolvedores perceberam que o Meteor não é mais apenas para prototipagem: ele está pronto para ser usado para desenvolvimento comercial. Com o arsenal de pacotes que fornece, a base sólida mongoDB / node.js na qual depende e a flexibilidade de codificação que oferece; Meteor torna mais fácil construir aplicativos da web robustos e seguros em tempo real , lidando com tudo, desde o aplicativo do navegador até o servidor ou banco de dados.

Este tutorial do Meteor irá guiá-lo através da criação de um aplicativo web básico no Meteor - um catálogo simples que permite aos usuários fazer login e gerenciar uma lista de livros.

Por que usar o Meteor? A resposta curta é, “porque o Meteor é divertido”. Isso torna o desenvolvimento de aplicativos da web simples. É fácil de aprender e permite que você se concentre mais na funcionalidade de seu aplicativo do que no básico de sincronização de dados e exibição de páginas.

Ele também possui muitos comportamentos convenientemente integrados. O Meteor executa atualizações ao vivo automaticamente, para que as alterações de dados apareçam imediatamente na janela do seu navegador, e até mesmo as alterações de código no próprio aplicativo são enviadas para todos os navegadores e dispositivos em “tempo real”. O Meteor tem compensação de latência embutida, é fácil de implantar e tem “pacotes” fáceis de instalar que lidam com todos os tipos de funcionalidade.

Mesmo sendo uma estrutura relativamente nova, muitas startups já estão construindo aplicativos Meteor, incluindo serviços de escala relativamente grande, como Em resposta e Telescópio .

Instalação e andaime do Meteor

A instalação do Meteor em sistemas * nix é de uma linha:

curl https://install.meteor.com/ | sh

Embora ainda não haja suporte oficial, sua visualização para Windows está indo muito bem. Os rumores são de que o suporte do Windows será fornecido com 1.1, com lançamento previsto para abril ou maio de 2015. Como você pode esperar de uma estrutura inteligente como o Meteor, inicializar um aplicativo requer que uma única linha de comando seja chamada:

meteor create book-list

Isso criará um diretório chamado “book-list” e o preencherá com algum código padrão e dependente. Para executar o aplicativo, insira o diretório recém-criado e execute:

meteor

Aberto http://localhost:3000 em seu navegador da web e você verá o seguinte:

Você também pode verificar a “versão 0” do nosso aplicativo no MeteorPad, um site que é como o JSFiddle for Meteor: Lista de livros: aplicativo padrão

O Meteor armazena suas visualizações em arquivos HTML. Se abrirmos “book-list.html”, veremos:

book-list {{> hello}} Click Me

You've pressed the button {{counter}} times.

O Meteor usa “Blaze”, um mecanismo de modelagem, para processar as respostas desses arquivos HTML. As chaves duplas devem ser familiares a qualquer pessoa que tenha usado Handlebars.js (ou outros mecanismos de modelagem semelhantes) e têm uma função semelhante aqui. Blaze examina as expressões dentro de cada par de chaves duplas e substitui cada uma pelo valor que essas expressões produzem.

Este programa de exemplo simples tem apenas duas expressões com colchetes:

• O primeiro, “{{> hello}}”, diz ao Blaze para incluir um modelo chamado “hello”. Esse modelo é definido na parte inferior do arquivo, na seção.

• O segundo, “{{counter}}”, é um pouco mais complicado. Para ver de onde vem esse valor de “contador”, precisamos abrir “book-list.js”:

if (Meteor.isClient) { // counter starts at 0 Session.setDefault('counter', 0); Template.hello.helpers({ counter: function () { return Session.get('counter'); } }); Template.hello.events({ 'click button': function () { // increment the counter when button is clicked Session.set('counter', Session.get('counter') + 1); } }); } if (Meteor.isServer) { Meteor.startup(function () { // code to run on server at startup }); }

Algumas coisas exigem explicação aqui. Primeiro, a divisão em “if (Meteor.isClient)” e “if (Meteor.isServer)”. Lembre-se de que o meteoro é uma estrutura de pilha completa, portanto, o código que você escreve é ​​executado no servidor e no cliente. Essas condicionais nos permitem limitar isso: o primeiro bloco é executado apenas no cliente e o segundo apenas no servidor.

Em segundo lugar, há a chamada 'Session.setDefault' - isso inicializa uma variável de sessão chamada 'contador' no navegador. As variáveis ​​de sessão agem um pouco como globais no Meteor (para o bem e para o mal). No entanto, essa variável de sessão não está aparecendo diretamente em “{{contador}}”. Em vez disso, essa expressão 'contador' é um 'auxiliar', definido na seção 'Template.hello.helpers'. Este auxiliar simplesmente pega o valor da variável de sessão e o retorna.

Observe que o auxiliar é “reativo”. Isso significa que sempre que a variável de sessão muda, o Meteor reexecuta automaticamente esta função auxiliar que a faz referência e o Blaze atualiza automaticamente o navegador com o novo conteúdo.

O código do cliente também monitora eventos, via “Template.hello.events”. Identificamos o evento por tipo de evento e seletor (neste caso, “botão de clique”), e então informamos ao Meteor o que aquele evento deve fazer. Nesse caso, a variável de sessão é incrementada, o que executa novamente a função auxiliar e, por sua vez, processa novamente o conteúdo.

Exibindo dados estáticos

Tudo isso é muito bom, mas não é o aplicativo Meteor que queremos para este tutorial.

Vamos começar a ajustar este aplicativo - exibiremos uma lista de livros estática e codificada. Por enquanto, vamos esconder a lista de livros em um variável de sessão . No código “isClient”, usaremos “Template.hello.rendered” para definir a variável de sessão assim que o modelo bookList for renderizado:

Template.hello.rendered = function() { Session.setDefault('books', [ {title: 'To Kill a Mockingbird', author: 'Harper Lee'}, {title: '1984', author: 'George Orwell'}, {title: 'The Lord of the Rings', author: 'J. R. R. Tolkien'}, {title: 'The Catcher in the Rye', author: 'J. D. Salinger'}, {title: 'The Great Gatsby', author: 'F. Scott Fitzgerald'} ]); };

Em seguida, retornamos essa variável de sessão com um novo auxiliar no modelo “hello”:

Template.hello.helpers({ books: function () { return Session.get('books'); } });

E exiba-o na tela por meio de interpolação de variável no modelo “hello”:

Here are your books:

{{ books }}

Você pode verificar este código em ação no Meteorpad: Lista de livros: Mostrar variável de sessão

A primeira coisa a notar é que o servidor Meteor detectou automaticamente as alterações em nossa base de código, enviou o novo código aos clientes e solicitou que o cliente recarregasse. Mesmo depois de implantarmos um aplicativo, podemos implantar mudanças e atualizar automaticamente nossos clientes por push de hot-code.

Até agora, isso é o que obtivemos:

Ops, estamos exibindo os dados incorretos. Blaze ganha pontos por precisão aqui (por que sim, é uma matriz de objetos), mas teremos que ser um pouco mais inteligentes se quisermos exibir nossa lista de livros de uma forma útil. Felizmente, o Blaze torna muito fácil trabalhar com matrizes de dados usando a diretiva “#each”:

Here are your books:

{{#each books}}
• {{title}} by {{author}}
{{/each}}

No Blaze, “#each” funciona um pouco como a diretiva “ng-repeat” do Angular - itera através da estrutura da matriz, definindo o contexto atual para o objeto atual na matriz e exibindo repetidamente o HTML dentro do “{{#each …}} ”. Esta é a aparência de nossa lista de livros agora:

No MeteorPad: Mostrar variável de sessão corretamente

Alguma Limpeza

Antes de prosseguir, vamos limpar nosso código um pouco.

O Meteor permite uma grande margem de manobra na organização de sua base de código. Como você verá, existem apenas algumas regras rígidas e rápidas: onde quer que você coloque seu HTML e JavaScript, o Meteor o encontrará. Essa flexibilidade é boa, mas significa que é mais incumbente de você organizar seu código de uma maneira que faça sentido, para que você não fique preso mantendo uma bagunça gigante desordenada.

Primeiro, vamos renomear este modelo “hello” para algo significativo, como “bookList”, e substituir o HTML padrão por este:

book-list {{> bookList}}

Here are some books:

{{#each books}}
• {{title}} by {{author}}
{{/each}}

Em segundo lugar, vamos dividir as partes “cliente” e “servidor” em arquivos separados. Em nosso diretório de aplicativo, vamos configurar um subdiretório 'cliente' e um subdiretório 'servidor' - o Meteor saberá automaticamente para executar os arquivos '/ client /' no cliente e executar os arquivos '/ server /' no servidor. É uma boa convenção colocar o código do modelo em um arquivo JavaScript com o nome do modelo, então vamos colocar nosso código do cliente em “client / bookList.js”. Podemos colocar nosso código de inicialização do servidor atualmente vazio em “server / startup.js”. Finalmente, vamos mover o código do modelo “” para “client / bookList.html”.

Observe que mesmo depois de toda essa mudança, o Meteor ainda encontrará automaticamente todos os nossos arquivos HTML e JavaScript. Contanto que um arquivo seja algum lugar em “/ client /”, o Meteor saberá como executá-lo no cliente. Contanto que um arquivo seja algum lugar em “/ server /”, o meteoro saberá executá-lo no servidor. Novamente, é responsabilidade do desenvolvedor manter as coisas organizadas.

Portanto, agora nosso código deve ser semelhante a este:

book-list.html:

book-list {{> bookList}}

client / bookList.html:

Here are some books:

{{#each books}}
• {{title}} by {{author}}
{{/each}}

client / bookList.js:

Template.bookList.rendered = function() { Session.setDefault('books', [ {title: 'To Kill a Mockingbird', author: 'Harper Lee'}, {title: '1984', author: 'George Orwell'}, {title: 'The Lord of the Rings', author: 'J. R. R. Tolkien'}, {title: 'The Catcher in the Rye', author: 'J. D. Salinger'}, {title: 'The Great Gatsby', author: 'F. Scott Fitzgerald'} ]); }; Template.bookList.helpers({ books: function () { return Session.get('books'); } });

server / startup.js:

Meteor.startup(function () { // code to run on server at startup }); ~~~ Check it out on MeteorPad: [Initial Code Cleanup](http://meteorpad.com/pad/MwvMcsBAzfbWwEXp3/Book-List:%20Initial%20Code%20Cleanup) Verify that everything's running correctly by checking the browser window and then we're good to move on to the next step. ## Using the Database in Meteor The Meteor server runs on top of a MongoDB database. In this section of our tutorial, we will move the static list of books out of the session variable and into that database. First, delete the Template.bookList.rendered code, so that we're no longer putting stuff into that session variable. Next, we should add that list of books to the database as fixture data when the server initializes. As you'd expect for MongoDB, Meteor stores data in 'collections'. So, we'll create a new collection for our books. To keep things simple we will name it 'books'. It turns out that both the client and the server will want to know about this collection, so we'll put this code in a new subfolder: '/lib/'. Meteor knows automatically that files in '/lib/' run on the client and the server. We'll create a file called 'lib/collections/books.js', and give it just one line of code: ~~~ js Books = new Meteor.Collection('books');

Dentro da janela do navegador apontada para http: // localhost: 3000 , vá para o console do desenvolvedor e verifique o valor de “Livros”. Agora deve ser uma coleção Mongo! Tente executar “Books.find (). Fetch ()”, e você obterá uma matriz vazia - o que faz sentido, já que não adicionamos nenhum livro a ela ainda. Podemos tentar adicionar itens a ele no console:

Books.insert({title: 'To Kill a Mockingbird', author: 'Harper Lee'})

Adicionar coisas no console é bastante tedioso. Em vez disso, vamos configurar as coisas para que, quando o servidor for inicializado, possamos inserir automaticamente os dados do aparelho no banco de dados Então, vamos voltar para “server / startup.js” e adicionar isto:

Meteor.startup(function () { if (!Books.findOne()) { Books.insert({title: 'To Kill a Mockingbird', author: 'Harper Lee'}); Books.insert({title: '1984', author: 'George Orwell'}); Books.insert({title: 'The Lord of the Rings', author: 'J. R. R. Tolkien'}); Books.insert({title: 'The Catcher in the Rye', author: 'J. D. Salinger'}); Books.insert({title: 'The Great Gatsby', author: 'F. Scott Fitzgerald'}); } });

Agora, quando o servidor é inicializado, se não houver dados presentes, adicionaremos os dados do aparelho. Podemos verificar isso voltando ao nosso terminal, parando o servidor de meteoros e executando este comando:

meteor reset

Nota: você vai raramente precisa deste comando, porque ele redefine - ou seja, limpa - o banco de dados que o Meteor está usando. Se o seu aplicativo Meteor tiver quaisquer dados do usuário no banco de dados, você não deve executar este comando. Mas, neste caso, vamos apenas limpar todos os dados de teste que temos.

Agora vamos iniciar o servidor novamente:

meteor

Na inicialização, o Meteor executará a rotina de inicialização, verá que o banco de dados está vazio e adicionará os dados do aparelho. Neste ponto, se formos ao console e digitarmos “Books.find (). Fetch ()”, obteremos os cinco livros que tínhamos antes.

Tudo o que resta para esta etapa é exibir os livros na tela. Felizmente, isso é tão simples quanto substituir “return Session.get (‘ books ’);” com o seguinte no ajudante de “livros”:

return Books.find();

E estamos de volta aos negócios! O aplicativo agora está exibindo dados de um cursor de banco de dados, em vez de da variável de sessão.

Confira no MeteorPad: Movendo para o banco de dados

Preocupações com segurança

Vou começar dizendo: “não faça isso”.

O que você acha que aconteceria se alguém abrisse este aplicativo em seu navegador, fosse para o console e digitasse “Books.remove ({})”?

A resposta é: eles eliminariam a coleção.

Então, esse é um grande problema de segurança - nossos usuários têm demais acesso ao nosso banco de dados. Qualquer cliente pode acessar todo o banco de dados. Não só isso, qualquer cliente pode fazer qualquer mudança para todo o banco de dados, incluindo aquele apagamento de dados “.remove ({})”.

Isso não é bom, então vamos consertar.

O Meteor usa os chamados “pacotes” para adicionar funcionalidade. O que os módulos são para o Node.js e as gemas para o Ruby, os pacotes são um pacote de vantagens de funcionalidade para o Meteor. Existem pacotes para todos os tipos de coisas. Para navegar pelo que está disponível, verifique a atmosfera.js .

O aplicativo de meteoros padrão que fizemos com “criação de meteoro” inclui dois pacotes chamados “autopublish” e “inseguro”. O primeiro pacote permite que os clientes tenham acesso automático a todo o banco de dados e o segundo permite que os usuários executem qualquer ação nesse banco de dados.

Vamos remover isso. Podemos fazer isso executando o seguinte no diretório do aplicativo:

meteor remove autopublish insecure

Quando isso for feito, você verá os dados da lista de livros desaparecerem da tela (já que você não tem mais acesso a eles) e, se tentar uma chamada “Books.insert”, receberá o erro: “insert failed : Acesso negado'. No MeteorPad: Exagero de segurança

Se você não entender mais nada deste tutorial do Meteor, lembre-se disso: quando você estiver implantando um aplicativo Meteor, certifique-se de remover os pacotes autopublish e inseguros. O Meteor tem muitas boas precauções de segurança, mas todas elas são inúteis se você deixar esses dois pacotes instalados.

Então, por que o Meteor inclui automaticamente esses pacotes, se eles são um risco para a segurança? O motivo é que, especialmente para iniciantes, esses dois pacotes tornam mais fácil começar - você pode facilmente depurar e ajustar o banco de dados a partir do console de um navegador. Mas é uma boa prática abandonar a publicação automática e não segura o mais rápido possível.

Publicar e assinar

Então, consertamos essa lacuna de segurança, mas introduzimos dois problemas. Primeiro, agora não temos acesso ao banco de dados. Em segundo lugar, não temos como interagir com o banco de dados.

Vamos resolver o primeiro problema aqui. O Meteor fornece acesso seguro a um banco de dados fazendo com que o servidor “publique” um subconjunto do banco de dados e o cliente “assine” essa publicação.

Primeiro, vamos criar “/server/publications.js”:

Meteor.publish('books', function() { return Books.find({}); });

E vamos criar “/client/subscriptions.js”:

Meteor.subscribe('books');

Confira no MeteorPad: Publicar e assinar

O servidor “publica” um cursor que tem acesso a todos os dados e o cliente “assina” na outra extremidade. O cliente usa essa assinatura para preencher uma cópia espelhada do banco de dados com todos os dados do cursor. Quando acessamos “Books.find (). Fetch ()”, vemos todos os cinco objetos e os vemos exibidos na tela como antes.

A diferença agora é que é muito fácil limitar o que os clientes podem acessar. Tente mudar a publicação “find ()” para um subconjunto dos dados:

Meteor.publish('books', function() { return Books.find({}, {limit:3}); });

Agora, o cliente só vê três dos cinco livros, e não há como chegar ao resto. Isso não é apenas um grande benefício para a segurança (não consigo ver as contas bancárias de todos), mas você pode usá-lo para dividir os dados e evitar sobrecarregar um cliente.

Adicionar novos livros

Vimos como dar aos clientes acesso de leitura ao banco de dados de maneira limitada e segura. Agora, vamos examinar o segundo problema: como permitimos que os usuários alterem o banco de dados sem permitir que eles façam o que desejam? Livrar-se do pacote inseguro fez com que os clientes não tivessem nenhum acesso - vamos tentar permitir a adição de livros novamente. No meteoro, fazemos isso adicionando um “método” ao servidor. Vamos adicionar um método, um que adiciona um novo livro, a “/lib/collections/books.js”:

Meteor.methods({ addBook: function(bookData) { var bookID = Books.insert(bookData); return bookID; } });

Como você pode ver, isso pega 'bookData' - neste caso, é um objeto com os campos 'título' e 'autor' - e o adiciona ao banco de dados. Depois que seu cliente for recarregado, podemos chamar esse método do cliente. Você pode ir para o console e digitar algo assim:

Meteor.call('addBook', {title: 'A Tale of Two Cities', author: 'Charles Dickens'})

E pronto! Você obtém outro livro na lista de livros. Usar o console é insuportavelmente desajeitado, então vamos em frente e adicionar um formulário simples ao final do modelo “bookList” que nos permitirá adicionar novos livros:

Title:

Author:


E podemos conectar isso ao JavaScript usando um caso de evento, como fizemos no aplicativo de teste original:

Template.bookList.events({ 'submit .add-book': function(event) { event.preventDefault(); // this prevents built-in form submission Meteor.call('addBook', {title: event.target.title.value, author: event.target.author.value}) } });

Você pode ver isso em ação no MeteorPad: Métodos

Quando tínhamos o inseguro e a publicação automática em vigor, os clientes podiam acessar e alterar todo o banco de dados. Agora, sem segurança e publicação automática, mas com publicações, assinaturas e métodos, os clientes podem acessar o banco de dados e interagir com ele de maneira controlada.

Em uma observação lateral: você também pode resolver problemas de segurança no Meteor usando “regras de permissão e negação”. Você pode descobrir mais sobre esses e alguns motivos pelos quais prefiro a abordagem acima em discoverymeteor.com .

Autenticação de usuário

Pode parecer que acabamos de voltar ao ponto de partida, mas há uma diferença importante: agora é muito fácil limitar o acesso ao banco de dados. Para ver como isso funciona, vamos tentar adicionar usuários a este aplicativo. Adicionaremos um sistema de login ao nosso aplicativo e, em vez de fazer com que todos os clientes trabalhem com uma lista de livros para todo o sistema, faremos com que cada usuário só possa adicionar ou ler sua própria lista de livros.

Vá para o diretório do aplicativo e instale dois pacotes:

meteor add accounts-ui accounts-password

Lá. Você acabou de adicionar um sistema de login ao aplicativo. Agora precisamos apenas adicionar a IU de login a book-list.html. Coloque esta linha única no topo do corpo:

{{> loginButtons}}

Você deverá ver um prompt de login na parte superior da tela:

Observe que se você clicar no link de login, ele solicitará um endereço de e-mail e uma senha. Podemos mudar isso para um sistema simples de login com nome de usuário / senha criando “/client/config.js” com o seguinte:

Accounts.ui.config({ passwordSignupFields: 'USERNAME_ONLY' });

Neste ponto, você pode digitar “Meteor.userId ()” no console e ele retornará “null”. Você pode tentar clicar no link para criar uma conta. Chamar “Meteor.userId ()” agora deve retornar uma string de ID. O servidor tem acesso a esta mesma informação (como “this.userId”), então é trivial fazer o método “adicionar livros” forçar o usuário a se conectar e incluir um campo de ID do usuário:

Meteor.methods({ addBook: function(bookData) { if (this.userId) { bookData.userID = this.userId; var bookID = Books.insert(bookData); return bookID; } } });

Resta agora limitar o cliente, mostrando apenas os livros que este usuário adicionou. Usamos a capacidade da publicação para restringir o que o cliente tem acesso:

Meteor.publish('books', function() { return Books.find({userID: this.userId}); });

Agora, a publicação encontra apenas livros desse usuário em particular. Podemos até acessar o userId de expressões Blaze como “{{currentUser}}”; e podemos usar isso, com uma diretiva “{{#if}}” (que faz exatamente o que você pensa que faz), para mostrar os dados apenas quando o usuário está conectado:

{{#if currentUser}}

Here are your books:

{{#each books}}
• {{title}} by {{author}}
{{/each}}

Title:

Author:
{{else}}

Please log in to see your books

{{/if}}

Confira o resultado final no MeteorPad: Usuários

Desdobramento, desenvolvimento

Agora podemos implantar este aplicativo Meteor na Internet. Fazemos isso indo para o diretório do aplicativo em um terminal e executando:

meteor deploy .meteor.com

Certifique-se de substituir “” por um nome abreviado real para a instância do aplicativo. A execução deste comando solicitará que você configure uma conta com o Meteor e, em seguida, colocará seu novo aplicativo nos servidores de teste do Meteor para que você possa experimentá-lo na Internet.

Para uma demonstração rápida, esta solução meteor.com é tudo que você precisa. A equipe Meteor não anunciou nenhum limite explícito de armazenamento ou largura de banda em seus servidores. A única limitação notável é que se seu aplicativo ficar sem uso por muito tempo, o site leva alguns segundos para girar para o próximo usuário .

Dito isso, o meteor.com não se destina ao uso comercial. Mas quando você vai para a produção, existem empresas de plataforma como serviço, como Módulo e Oceano digital que tornam a implantação de aplicativos Meteor fácil. Se você quiser implantar um aplicativo de meteoros em seu próprio servidor, o 'meteoro para cima' também torna esse processo simples.

Próximos passos

Parabéns! Em sua busca para aprender o Meteor, você agora criou e implantou um aplicativo da web Meteor em tempo real muito simples. Obviamente, este é apenas um pequeno primeiro passo em todo um universo de recursos e funcionalidades. Se você gostou do que viu até agora, eu recomendo fortemente Seu primeiro aplicativo Meteor por David Turnbull , que orienta os leitores na criação de um aplicativo mais complicado, com mais informações sobre os recursos de meteoros ao longo do caminho. Ele está disponível como um livro Kindle por um pequeno preço e como um PDF gratuito no site da Turnbull.

Você também vai querer explorar os pacotes que estão disponíveis para o Meteor. Nove em cada dez vezes, a resposta para 'como faço no Meteor?' é “há um pacote para isso”. “Como faço para adicionar roteamento ao meu aplicativo?” Você usa Router de Ferro . “Como faço para fornecer uma API RESTful?” Você usa RESTivus . “Como faço para incluir o teste de unidade?” Você usa Velocidade . “Como adiciono validações de esquema?” Você usa Coleção 2 . Você pode se perder facilmente Atmosphere.js olhando todos os pacotes disponíveis.

Por que não usar o Meteor?

Como você pode ver neste tutorial, o Meteor é simples e divertido de escrever aplicativos, mas seria negligente se não mencionasse as desvantagens.

Meteor ainda é relativamente imaturo. Ele atingiu 1.0 em outubro passado, o que leva a alguns problemas. Se você está procurando fazer algo obscuro, é possível que ninguém tenha escrito um pacote para essa funcionalidade ainda. Os pacotes que existem são mais propensos a ter bugs, simplesmente porque não existem há tempo suficiente para solucionar todos os problemas.

A escala também pode ser um tanto desconhecida com o Meteor. Existem muitos sites Meteor que alcançam uma quantidade razoável de usuários, mas poucos sites muito grandes - nada na ordem do Facebook ou LinkedIn, com dezenas ou centenas de milhões de usuários.

No entanto, para a maioria das aplicações, o Meteor é a escolha perfeita, pois é uma chance de reduzir o tempo de desenvolvimento e participar do início de algo grande.