Tradução Capítulo 10 até linha 363

10_modules.md

@@ -1,170 +1,153 @@
 {{meta {load_files: ["code/packages_chapter_10.js", "code/chapter/07_robot.js"]}}}
 
-# Modules
+# Módulos
 
-{{quote {author: "Tef", title: "Programming is Terrible", chapter: true}
+{{quote {autor: "Tef", title: "Programar é Terrível", chapter: true}
 
-Write code that is easy to delete, not easy to extend.
+Escreva código que seja fácil de deletar, difícil de estender.
 
 quote}}
 
-{{index organization, "code structure", "Yuan-Ma", "Book of Programming"}}
+{{índice organização, "estrutura de código", "Yuan-Ma", "Livro de Programação"}}
 
-The ideal program has a crystal clear structure. It's easy to explain
-how it works, and each part plays a well-defined role.
+O programa ideal tem uma estrutura limpa como cristal. É fácil de explicar como funciona
+e cada parte tem um papel bem definido.
 
-{{index "organic growth"}}
+{{índice "crescimento orgânico"}}
 
-A typical real program grows organically. New pieces of functionality
-are added as new needs come up. Structuring—and preserving
-structure—is additional work, work which will only pay off in the
-future, the _next_ time someone works on the program. So it is
-tempting to neglect it, and allow the parts of the program to become
-deeply entangled.
+Um programa real típico cresce organicamente. Novas funcionalidades são adicionadas
+conforme novas necessidades surgem. Estruturação e preservação da estrutura é um
+trabalho adicional, trabalho que será pago somente no futuro, da próxima vez que 
+alguém trabalhar no programa. Então é tentador negligenciar isso e permite as partes
+do programa ficarem profundamente confusas.
 
-{{index readability, reuse, isolation}}
+{{índice legibilidade, re-uso, isolamento}}
 
-This causes two practical issues. Firstly, understanding such a system
-is hard. If everything can touch everything else, it is difficult to
-look at any given piece in isolation. You are forced to build up a
-holistic understanding of the whole thing. Secondly, if you want to
-use any of the functionality from such a program in another situation,
-rewriting it may be easier than trying to disentangle it from its
-context.
+Isso causa dois problemas práticos. Primeiro, entender este sistema é difícil. Se 
+tudo puder tocar todo o resto, é difícil olhar uma determinada parte isolada. Você
+é forçado a construir uma compreensão holística de toda coisa. Segundo, se você quer 
+usar qualquer funcionalidade do programa em outra situação, re-escrever será mais
+fácil do que tentar desenrolar a função de seu contexto.
 
-The term "((big ball of mud))" is often used for such large,
-structureless programs. Everything sticks together, and when you try
-to pick out a piece, the whole thing comes apart and your hands get
-dirty.
+O termo "((grande bola de lama))" é geralmente para programas grandes e sem estrutura.
+Tudo fica junto e quando você tenta pegar uma parte, toda a coisa despenca e você
+fica com as mãos sujas.
 
-## Modules
+## Módulos
 
-{{index dependency}}
+{{índice dependência}}
 
-_Modules_ are an attempt to avoid these problems. A ((module)) is a
-piece of program that specifies which other pieces it relies on (its
-_dependencies_), and which functionality it provides for other modules
-to use (its _((interface))_).
+_Módulos_ são uma tentativa de evitar estes problemas. Um ((módulo)) é uma parte de 
+programa que especifica quais partes ele depende (são as _dependências_) em que as 
+funcionalidades ele fornece para outros módulos (são as _((interfaces))_).
 
-{{index "big ball of mud"}}
+{{índice "grande bola de lama"}}
 
-Module interfaces have a lot in common with object interfaces, as we
-saw them in [Chapter ?](object#interface). They make part of the
-module available to the outside world, and keep the rest private. By
-restricting the ways in which modules interact with each other, the
-system becomes more like ((Lego)), where pieces interact through
-well-defined connectors, and less like mud, where everything mixes
-with everything.
+Interface de módulo têm muito em comum com interface objetvo como vimos no 
+[Capítulo ?](object#interface). Eles fazem parte do módulo disponível no mundo 
+externo e mantém o resto privado. Restringindo o modo como os módulos interagem entre 
+si, o sistema fica mais parecido com ((Lego)), onde as peças interagem através de 
+conectores bem definidos e menos como lama, onde tudo se mistura.
 
-{{index dependency}}
+{{índice dependência}}
 
-The relations between modules are called dependencies. When a module
-needs a piece from another module, it is said to depend on that
-module. When this fact is clearly specified in the module itself, it
-can be used to figure out which other modules need to be present to be
-able to use a given module and to automatically load dependencies.
+A relação entre módulos é chamada dependência. Quando um módulo precisa de outro 
+módulo, é dito que ele depende daquele módulo. Quando este fato é claramente 
+especificado no próprio módulo, pode ser utilizado para descobrir quais módulos 
+devem estar presentes para que o módulo desejado seja utilizado e carregar automaticamente 
+suas dependências.
 
-To separate modules in that way, each needs it own private ((scope)).
+Para separar módulos desta forma, cada uma precisa de sua privacidade ((escopo)).
 
-Just putting your JavaScript code into different ((file))s does not
-satisfy these requirements. The files still share the same global
-namespace. They can, intentionally or accidentally, interfere with
-each other's bindings. And the dependency structure remains unclear.
-We can do better, as we'll see later in the chapter.
+Apenas colocando seus arquivos JavaScript em diferentes ((arquivo))s não satisfaz esses 
+requerimentos. Os arquivos ainda compartilham o mesmo namespace global. Elas podem, 
+intencionalmente ou acidentalmente, interferir umas com as outras e a estrutura de 
+dependência permanece escondida. Podemos fazer melhor, como veremos mais tarde neste 
+capítulo.
 
-{{index design}}
+{{índice design}}
 
-Designing a fitting module structure for a program can be difficult.
-In the phase where you are still exploring the problem, trying out
-different things to see what works, you might want to not worry about
-it too much, since it can be a big distraction. Once you have
-something that feels solid, that's a good time to take a step back and
-organize it.
+Definir uma estrutura de módulo para um programa pode ser difícil. Na fase onde você 
+está ainda explorando o problema, testar soluções diferentes para ver qual irá funcionar, 
+você pode querer não se preocupar tanto com isso, pois pode ser uma grande distração. 
+Quando você tiver algo que parece definitivo, é um bom momento dar um passo atrás e 
+organizar o programa.
 
-## Packages
+## Pacotes
 
-{{index bug, dependency, structure, reuse}}
+{{índice bug, dependência, estrutura, reuso}}
 
-One of the advantages of building a program out of separate pieces,
-and being actually able to run those pieces on their own, is that you
-might be able to apply the same piece in different programs.
+Uma das vantagens de construir um programa separando por partes e sendo possível executar 
+essas partes separadamente é que você é capaz de executar as mesmas partes em diferentes 
+programas.
 
-{{index "parseINI function"}}
+{{índice "função parseINI"}}
 
-But how do you set this up? Say I want to use the `parseINI` function
-from [Chapter ?](regexp#ini) in another program. If it is clear what
-it depends on (in this case, nothing), I can just copy all the
-necessary code into my new project, and use it. But then, if I find a
-mistake in that code, I'll probably fix it in whichever program that
-I'm working with at the time and forget to also fix it in the other
-program.
+Mas como você faz isso? Digamos que eu queira usar a função `parseINI` do 
+[Capítulo ?](regexp#ini) em outro programa. Se está claro no que esta função depende 
+(neste caso, nada), podemos simplesmente copiar todo código necessário no novo projeto. 
+Mas então se eu encontrar um erro no código, provavelmente irei corrigir no programa em
+que estarei trabalhando e esqueço de corrigir no código de onde copiei.
 
-{{index duplication, "copy-paste programming"}}
+{{índice duplicação, "programando copia-cola"}}
 
-Once you start duplicating code, you'll quickly find yourself wasting
-time and energy moving copies around and keeping them up-to-date.
+Quando você começa a duplicar código, se verá rapidamente perdendo tempo e energia movendo 
+cópias e as mantendo atualizadas.
 
-That's where _((package))s_ come in. A package is a chunk of code that
-can be distributed (copied and installed). It may contain one or more
-modules, and has information about which other packages it depends on.
-A package also usually comes with documentation explaining what it
-does, so that people who didn't write it might still be able to use
-it.
+Aí que entram os _((pacotes))_. Um pacote é um pedaço de um código que pode ser 
+distribuído (copiado e instalado). Pode conter um ou mais módulos e possui informação 
+sobre outros pacotes que ele depende. Um pacote também costuma vir com documentação 
+explicando o que ele faz, assim pessoas que não o escreveram também poderão utilizá-lo.
 
-When a problem is found in a package, or a new feature is added, the
-package is updated. Now the programs that depend on it (which may also
-be packages) can upgrade to the new ((version)).
+Quando um problema é encontrado no pacote ou uma nova funcionalidade é adicionada, o 
+pacote é atualizado. Agora o programa que depende dele (que também podem ser pacotes) 
+podem ser atualizados ((versão)).
 
-{{id modules_npm}}
+{{id módulos npm}}
 
-{{index installation, upgrading, "package manager", download, reuse}}
+{{índice instalação, atualização, "gerenciador de pacotes", download, reuso}}
 
-Working in this way requires ((infrastructure)). We need a place to
-store and find packages, and a convenient way to install and upgrade
-them. In the JavaScript world, this infrastructure is provided by
-((NPM)) ([_npmjs.org_](https://npmjs.org)).
+Trabalhar desta requer ((infra-estrutura)). Precisamos de um lugar para armazenar 
+e encontrar os pacotes e uma forma conveniente de instalar e atualizá-los. No mundo 
+JavaScript, essa infra-estrutura é fornecedir pelo ((NPM)) ([_npmjs.org_](https://npmjs.org)).
 
-NPM is two things: an online service where one can download (and
-upload) packages, and a program (bundled with Node.js) that helps you
-install and manage them.
+NPM é duas coisas: um serviço online onde podemos fazer download (e upload) dos pacotes 
+e programas (juntos com Node.js) que ajudam a instalá-los e gerenciá-los.
 
-{{index "ini package"}}
+{{índice "pacote ini"}}
+
+No momento em que este texto foi escrito, há próximo de 1 milhão de diferentes pacotes 
+disponíveis no NPM. Uma grande parte é lixo, devo dizer, mas quase todos os pacotes 
+úteis estão disponíveis lá. Por exemplo, a função INI file parser, similar ao que 
+foi construído no [Capítulo ?](regexp) está disponível como pacote `ini`.
+
+[Capítulo ?](node) irá mostrar como instalar estes pacotes usando linha de comando 
+`npm`.
+
+Ter pacotes de alta qualidade disponíveis é extremamente valioso. Isso quer dizer 
+que normalmente podemos evitar de re-inventar um programa que diversas pessoas já 
+escreveram antes e ter uma sólida e bem testada implementação apenas apertando 
+alguns botões.
+
+{{índice manutenção}}
+
+É barato copiar software, então quando alguém já escreveu, distribuir para outras 
+pessoas é um processo eficiente. Escrê-lo da primeira vez que _é_ o trabalho e 
+responder a pessoas que encontraram problemas no códio ou querem propor novas 
+funcionalidades, é ainda mais trabalho.
+
+Por padrão, você possui o ((copyright)) do seu código e outras pessoas podem apenas 
+usá-lo com sua permissão. Mas como algumas pessoas são legais e porque publicar 
+bons softwares podem te deixar um pouco mais famoso entre programadores, muitos 
+pacotes são publicados sobre a ((licença)) que explicamente permitem outras pessoas 
+a utilizá-los.
 
-At the time of writing, there are over half a million different
-packages available on NPM. A large portion of those are rubbish, I
-should mention, but almost every useful, publicly available package
-can be found on there. For example, an INI file parser, similar to the
-one we built in [Chapter ?](regexp), is available under the package
-name `ini`.
-
-[Chapter ?](node) will show how to install such packages locally using
-the `npm` ((command line)) program.
-
-Having quality packages available for download is extremely valuable.
-It means that we can often avoid reinventing a program that a hundred
-people have written before, and get a solid, well-tested
-implementation at the press of a few keys.
-
-{{index maintenance}}
-
-Software is cheap to copy, so once someone has written it,
-distributing it to other people is an efficient process. But writing
-it in the first place _is_ work, and responding to people who have
-found problems in the code, or who want to propose new features, is
-even more work.
-
-By default, you own the ((copyright)) to the code you write, and other
-people may only use it with your permission. But because some people
-are just nice, and because publishing good software can help make you
-a little bit famous among programmers, many packages are published
-under a ((license)) that explicitly allows other people to use it.
-
-Most code on ((NPM)) is licensed this way. Some licenses require you
-to also publish code that you build on top of the package under the
-same license. Others are less demanding, just requiring that you keep
-the license with the code as you distribute it. The JavaScript
-community mostly uses the latter type of license. When using other
-people's packages, make sure you are aware of their license.
+A maioria dos códigos do ((NPM)) possui este tipo de licença. Algumas licenças 
+requerem que você publique o código que você criou utilizando o pacote baixado 
+sobre a mesma licença. Outros são menos exigentes, apenas requerindo que você 
+mantenha a licença com o código conforme você o distribui. A maioria da comunidade 
+JavaSciprt usa o último tipo de licença. Quando utilizar o pacote de outras pessoas, 
+tenha certeza de conhecer sua licença.
 
 ## Improvised modules