pt-br docs

.gitignore

@@ -3,3 +3,4 @@
 node_modules/
 tools/runkeeper/
 docker-compose.override.yml
+package-lock.json

README.md

@@ -1,5 +1,6 @@
 # Blockchain Demo
 A web-based demonstration of blockchain concepts.
+_(If you want to read this in Brazilian Portuguese [click this link](docs/pt-br/index.html))_.
 
 [![Blockchain 101 - Demo](https://img.youtube.com/vi/_160oMzblY8/0.jpg)](https://www.youtube.com/watch?v=_160oMzblY8)
 

docs/pt-br/.gitignore

@@ -0,0 +1,3 @@
+/index.html
+/index.xml
+/blockchain-demo.pdf

docs/pt-br/build

@@ -0,0 +1,37 @@
+#!/bin/bash
+set +x
+set -e
+
+BASE_DIR=`cd "$(dirname "$0")"; pwd`
+pdf_generate=${pdf_generate:-true}
+use_fopub=${use_fopub:-false}
+fopub=${fopub:-~/Projects/github.com/asciidoctor/asciidoctor-fopub/bin/fopub}
+
+cd "$BASE_DIR"
+
+which asciidoctor > /dev/null || { echo "Install asciidoctor first!"; exit 1; }
+
+clean() {
+  rm -f index.{html,xml}
+  rm -f blockchain-demo.pdf
+}
+
+main() {
+  asciidoctor index.adoc
+  result=$?
+
+  $pdf_generate || exit $result
+
+  if $use_fopub
+  then
+    asciidoctor -b docbook -d book -a data-uri! index.adoc
+    [ -x "$fopub" ] || { echo "WARN: $fopub not executable. PDF will not be generated!"; exit 0; }
+    $fopub index.xml
+  else
+    asciidoctor-pdf -o blockchain-demo.pdf index.adoc
+  fi
+}
+
+op=$1
+[ "$op" ] || op=main
+type $op &> /dev/null && $op || { echo "\"$op\" isn't an option!"; exit 1; }

docs/pt-br/demonstracao/index.adoc

@@ -0,0 +1,14 @@
+[[demonstracao]]
+= Demonstração
+
+:srcdir: ../../..
+
+:leveloffset: +1
+
+include::o-que-e-um-hash.adoc[]
+
+include::o-que-e-um-bloco.adoc[]
+
+include::o-que-e-uma-blockchain.adoc[]
+
+:leveloffset: -1

docs/pt-br/demonstracao/o-que-e-um-bloco.adoc

@@ -0,0 +1,34 @@
+[[o-que-e-um-bloco]]
+= O que é um Bloco?
+
+Vamos agora para a aba {uri-blockchain-demo-block}[Block].
+Adicionaremos, acima do campo `Data` aprensentado na aba `Hash`, dois outros campos: `Block` e `Nonce`.
+Eles serão explicados agora.
+Também vamos criar um botão `Miner` e explicar qual será sua utilidade.
+Com a adição desses novos elementos, estamos criando o que chamaremos de *Bloco*.
+
+Um bloco, então, tem um número identificador (`Block`), um `Nonce`, e pode ser "minerado" quado clicarmos no botão `Miner`.
+Também notemos que o campo `Hash` agora possui um valor interessante, iniciado por quatro zeros ("0000").
+Esse valor de `Hash` é bastante singular.
+Ele é criado através de uma *regra que é utilizada para verificar se o bloco é válido*.
+Nesse nosso caso, a regra é bem simples: o valor do `Hash`, calculado em função do valor inserido em `Data` (e dos outros campos), precisará começar com esses quatro zeros.
+
+Para encontar um `Hash` que safisfaça essa regra, após inserir os dados que desejamos no campo `Data`, iremos alterar o valor de `Nonce`.
+O número identificador do bloco (`Block`) será gerado automaticamente (apesar de podermos modificá-lo, para testes, nesse exemplo).
+Esse cáculo do `Hash` será repetidamente refeito, até encontarmos um `Hash` que comece com esses quatro zeros.
+
+Você pode notar também que, qualquer mudança nos campos (`Block`, `Nonce` e `Data`) altera o valor de `Hash`.
+
+Manualmente, poderíamos ficar tentando modificar o valor de `Nonce` até encontarmos a solução para esse problema.
+Mas, fazendo isso, poderemos passar vários minutos ou horas (ou mesmo dias) em tentativas.
+Então, o botão `Miner` servirá para realizar essa tarefa pra nós.
+
+A atividade de {uri-mining}["mineração"], então, é nesse nosso caso uma tarefa que será executada pelo computador.
+Ela será realizada em função do valor de todos os campos e buscará um `Hash` que atenda a regra estabelecida: começar com quatro zeros.
+Essa regra também é conhecida por "desafio matemático".
+Você pode notar que esse desafio (no nosso caso e em várias outras formas de propô-lo) não é uma função complexa.
+Por outro lado, ela é onerosa pois pode cosumir muito tempo de processamento.
+O trabalho de "mineração" realizado dessa forma é também conhecido por {uri-proof-of-work}["Proof of Work"].
+
+Após um bloco ser "minerado", a conferência de sua validade é algo extremamente simples e rápido.
+Essa conferência é apenas o cálculo do `Hash` de `Data` + `Nonce` e a obediência a regra estabelecida (em nosso caso, um `Hash` começando com quatro zeros iniciais).

docs/pt-br/demonstracao/o-que-e-um-hash.adoc

@@ -0,0 +1,57 @@
+[[o-que-e-um-hash]]
+= O que é um Hash?
+
+Hashes são parte de várias informações armazenadas na {blockchain} e são essenciais para garantir sua segurança.
+
+Matematicamente falando, uma {uri-funcao-hash}[função hash] é um algoritmo que mapeia dados de comprimento variável para dados de comprimento fixo.
+Os valores retornados por uma função hash são chamados valores hash, códigos hash, somas hash, checksums ou, simplesmente, hashes.
+
+Nessa demonstração, a aba {uri-blockchain-demo-hash}[Hash] possibilita a entrada de uma informação de tamanho qualquer (no campo `Data`) e produz um `Hash` de tamanho fixo.
+A função SHA256 é uma das variantes do {uri-sha-2}[SHA-2] e utilizada para gerar esse código hash.
+Esse código é geralmente representado por uma string de 64 caracteres hexadecimais (de "0" a "9" e de "a" a "f").
+Obviamente, além dessa função, existem várias outras que poderiam ser utilizadas para gerar uma string de tamanho fixo a partir de uma quantidade de dados variáveis.
+Outros exemplos de funções (dentre várias) são o MD5 e o SHA-1.
+
+Ao se gerar um hash, espera-se que a cadeia fixa produzida a partir de um conjunto de informações tenha sempre um valor diferente para outro conjunto de entrada.
+Se o hash gerado num conjunto de dados for igual ao de outro, ocorre o que chamamos de colisão.
+Quanto menos colisões houverem ao se gerar um hash para um conjunto de informações diferentes, melhor o algoritmo de Hash.
+
+Foram necessários 20 anos para que fosse {uri-announcing-first-sha1-collision}[anunciada a primeira colisão de hash para a função SHA-1].
+Isso quer dizer que esse algoritmo foi considerado seguro e utilizado por todo esse espaço de tempo, sem problemas.
+O site {uri-shattered} demonstra que, para se proferir um ataque onde se tentaria obter um hash igual para um `input` diferente utilizando o algoritmo SHA-1, seriam necessárias 9.223.372.036.854.775.808 de execuções do algoritmo.
+Ou seja, um número monstruoso de compressões.
+Para ser realizado esse número de compressões, seriam necessários 6.500 anos de processamento de uma CPU comum (ou 110 anos de uma GPU).
+
+Uma colisão de SHA-1 é demonstrada na saída dos seguintes comandos (executados num macOS):
+
+----
+for i in 1 2; do curl -O https://shattered.it/static/shattered-i.pdf; done
+diff shattered-*.pdf
+shasum shattered-*.pdf
+----
+
+O código JavaScript da {uri-blockchain-demo-hash}[página Hash] é um código escrito em Jade (link:{rootdir}/views/hash.jade[]).
+Ele calcula o hash através de um código (em JavaScript) que executa a função sha256.
+
+[source,javascript]
+.{rootdir}/public/javascripts/lib/sha256.js
+----
+include::{srcdir}/public/javascripts/blockchain.js[lines=1..4]
+----
+
+Obviamente, a função hash implementada em JavaScript também deve produzir o mesmo resultado que uma função que pode ser chamada via linha de comando.
+Sendo assim, também é possível gerar o hash de uma string informada no quadro `Data` através de uma linha de comando (em Bash, por exemplo).
+
+O Hash para a string vazia (valor inicial do quadro), pode ser calculado assim:
+
+----
+echo -n ''|shasum -a 256
+----
+
+Então, o hash de "Paulo Jerônimo" poderia ser calculado assim:
+
+----
+echo -n 'Paulo Jerônimo'|shasum -a 256
+----
+
+Para se aprofundar um pouco mais em funções hash aplicadas a moedas digitais e saber quando um colisões em valores de hash tem importância nesse contexto, recomenda-se a leitura do artigo {uri-history-of-hash-function-attacks}["Lessons From The History Of Attacks On Secure Hash Functions"].

docs/pt-br/demonstracao/o-que-e-uma-blockchain.adoc

@@ -0,0 +1,75 @@
+[[o-que-e-uma-blockchain]]
+= O que é uma Blockchain?
+
+== Uma visualização gráfica
+
+Finalmente, vamos à {uri-blockchain-demo-blockchain}[aba {blockchain}] para entender o que é esse conceito genial, numa visualização gráfica! 😃
+
+Nessa aba, apenas para fins de demonstração, apresentamos cinco (5) blocos encadeados.
+Observe que, agora, foi adicionado o campo `Prev`.
+Esse campo também é um `Hash`.
+No primeiro bloco, seu valor é nulo.
+Para todos os demais blocos, o campo `Prev` armazena o valor do `Hash` do bloco anterior.
+Assim, agora há um encademento que forma o que chamamos de "corrente de blocos".
+Ou, o nome bonito em inglês: {blockchain}.
+
+O objetivo desse encadeamento entre os blocos é muito simples.
+Se você fizer uma alteração em qualquer campo do bloco o seu `Hash` será alterado.
+Consequentemente, todos os blocos posteriores a essa alteração também não serão mais considerados válidos.
+O motivo para isso é que, a partir do momento em que é modificado o `Hash` de um bloco, o valor de `Prev`, registrado no bloco posterior, não coincidirá mais.
+Logo, uma {blockchain} considerará todos os blocos inválidos a partir de algum que tenha sido adulterado em qualquer um de seus campos.
+
+Para fazer uma {blockchain} adulterada ser novamente considerada válida, alguns passos seriam necessários.
+Por exemplo, vamos supor que estamos fazendo uma alteração de dados apenas no último bloco.
+Nesse caso, tornar a {blockchain} válida é algo simples: basta recalcular o `Hash` desse bloco executando a operação `Miner`.
+Ou seja, executar o processo de mineração.
+
+O problema real surge ao ser feita uma tentativa de alterar um bloco que não é o último!
+Vamos ver também que a dificuldade de se alterar um bloco é gradativamente aumentada quando ele vai se aproximando do primeiro bloco (ou se distanciando do último).
+Suponhamos, por exemplo, que alguém tentasse fazer a adulteração de um dado no bloco 3.
+Para que isso fosse possível, a operação de mineração para todos deveria ser novamente realizada a partir desse bloco.
+Assim, o custo de tornar um bloco válido vai aumentando exponencialmente a medida em que ele se aproxima do primeiro bloco.
+
+Podemos observar, então, que uma {blockchain} é uma estrutura (ou um banco) de dados que rejeita modificações que não sejam no último bloco.
+Poderíamos fazer uma comparação com um livro onde só é possível se escrever na última página.
+E, continuando nessa linha, esse livro só poderia ser escrito a caneta.
+Por fim, qualquer tentativa de se modificar um dado registrado nesse livro o deixaria manchado (ou rasurado) para sempre.
+
+Uma {blockchain} é citada por muitos como sendo "o protocolo da confiança".
+Um dos motivos é decorrente do fato de somente ser possível se adicionar informações.
+Não são permitidas alterações de informação, pois, pelo que vimos, a rede rejeita mudanças através de seu protocolo.
+Finalmente, é importante entender que uma {blockchain} é uma estrutura de dados que fica "na mão de muitos".
+Ou seja, é descentralizada.
+Vamos agora entender como uma {blockchain} é considerada ainda mais segura quando ela é distribuída entre vários nós de uma rede.
+
+== A Blockchain é distribuída
+
+Vimos que uma {blockchain} é uma estrutura de dados confiável que só aceita inserções de dados.
+Ou seja, ela é resistente a mudanças.
+Mas, além disso, uma {blockchain} é também uma rede de computadores onde essa estrutura de dados é replicada.
+Dessa forma, sua estrutura de dados existe, distribuída, em cada um dos computadores (nós) dessa rede.
+
+O objetivo principal da distribuição de uma {blockchain} entre vários nós é impedir que mesmo sendo ela válida num único nó, ela só seja totalmente válida quando houver um consenso (na rede) de que suas informações também são válidas em todos os outros nós.
+Numa {blockchain}, os nós pertencentes a sua rede são responsáveis por validar dados e retransmití-los de forma que eles sejam replicados em todos os nós.
+Mais especificamente, quando dados precisam ser inseridos num bloco, todos os nós devem verificar se esses dados são válidos.
+Caso não sejam, esses dados serão descartados e não retransmitidos aos próximos nós.
+
+A validação de dados, obviamente, depende do que são esses dados.
+A primeira {blockchain} foi construída para resolver um problema complexo: a tranferência de valores.
+Dando crédito: *os conceitos de {blockchain} que estamos aprendendo surgiram para fazer a moeda digital {uri-bitcoin}[Bitcoin] entrar em funcionamento*.
+Perceba que só agora estamos falando de uma das várias possibilidades de aplicação da {blockchain}.
+Apresentaremos, ainda, vários outros casos de uso de uma {blockchain}.
+
+O que diferencia a solução da {blockchain}, dada para o Bitcoin, de soluções bancárias tradicionais que resolvem esse problema, entretanto, é a descentralização.
+Detalharemos mais sobre transações, logo a frente.
+Mas, por enquanto, é importante saber que uma {blockchain}, por ser descentralizada, precisa criar algoritmos que promovam a manutenção de um consenso entre os nós.
+
+É através de consenso que uma {blockchain} identifica se uma cópia de seus dados, que está num nó, é realmente válida ou não.
+Acessando a aba {uri-blockchain-demo-distributed}[Distributed] podemos identificar que a alteração de uma das cópias da {blockchain} num dos nós é possível de ser realizada.
+E, essa alteração pode, com certeza, tornar a cópia da {blockchain} válida nesse nó.
+Como vimos, para isso ocorrer, seria necessário refazer os cálculos de `Hash` para cada bloco a partir do que for modificado.
+Mas, caso isso ocorra, outros nós da rede percebem a diferença e, automaticamente, eliminam a participação do nó que possui a {blockchain} adulterada.
+Isso é feito através de consenso.
+A rede que está certa é a rede que detém a maioria do consenso (51%).
+
+== A Blockchain utilizada no controle de transações: o Bitcoin

docs/pt-br/enviando-um-obrigado.adoc

@@ -0,0 +1,14 @@
+[[enviando-um-obrigado]]
+= Enviando um obrigado
+
+Se você gostou deste projeto, incluindo seu texto e vídeos, e deseja enviar um "obrigado", saiba que Bitcoin e Ethereum são, agradecidamente, aceitos por seus desenvolvedores nos seguintes endereços:
+
+* {uri-andersbrownworth}[Anders Brownworth] (criador do projeto):
+** Bitcoin (BTC): `1K3NvcuZzVTueHW1qhkG2Cm3viRkh2EXJp`
+* {uri-paulojeronimo}[Paulo Jerônimo] (criador deste documento e de vídeos em português)
+** Bitcoin (BTC): `1LTrDUdUw2zCS7LE93hDuvYiG326VnxL6k`
+** Ether (ETH): `0xc8780E07eE3C0f058315a20D2fD7dE6d2505f7a3`
+
+Claramente, parte do valor depositado será revertido em melhorias para este projeto.
+
+include::todo.adoc[leveloffset=+1]

docs/pt-br/extras/blockchain-fora-do-contexto-financeiro.adoc

@@ -0,0 +1,3 @@
+= A Blockchain utilizada fora do contexto financeiro
+
+== Em desenvolvimento: run4.money (uma nova forma de ganhar prêmios em corridas)

docs/pt-br/extras/ethereum/index.adoc

@@ -0,0 +1,7 @@
+= Ethereum
+
+:leveloffset: +1
+
+include::o-computador-e-a-rede.adoc[]
+
+:leveloffset: -1

docs/pt-br/extras/ethereum/o-computador-e-a-rede.adoc

@@ -0,0 +1 @@
+= O computador é a rede!

docs/pt-br/extras/hyperledger/index.adoc

@@ -0,0 +1,5 @@
+= Hyperledger
+
+:leveloffset: +1
+
+:leveloffset: -1

docs/pt-br/extras/index.adoc

@@ -0,0 +1,11 @@
+= Extras
+
+:leveloffset: +1
+
+include::blockchain-fora-do-contexto-financeiro.adoc[]
+
+include::ethereum/index.adoc[]
+
+include::hyperledger/index.adoc[]
+
+:leveloffset: -1

docs/pt-br/index.adoc

@@ -0,0 +1,39 @@
+= Blockchain: Uma visualização gráfica
+:author: Paulo Jerônimo
+:toc:
+:toc-title: Conteúdo
+:toclevels: 4
+:numbered:
+:icons: font
+
+:srcdir: ../..
+
+ifdef::backend-html5[]
+:rootdir: ../..
+:blockchain: pass:[<b>Blockchain</b>]
+endif::[]
+
+ifdef::backend-pdf[]
+:rootdir: blockchain-demo
+:blockchain: Blockchain
+endif::[]
+
+include::uris.conf[]
+
+:leveloffset: +1
+
+include::introducao.adoc[]
+
+<<<
+include::instalacao/index.adoc[]
+
+<<<
+include::demonstracao/index.adoc[]
+
+<<<
+include::extras/index.adoc[]
+
+<<<
+include::enviando-um-obrigado.adoc[]
+
+:leveloffset: -1

docs/pt-br/instalacao/index.adoc

@@ -0,0 +1,10 @@
+[[instalacao]]
+= Instalação
+
+:leveloffset: +1
+
+include::instalacao-direta.adoc[]
+
+include::instalacao-via-docker.adoc[]
+
+:leveloffset: -1

docs/pt-br/instalacao/instalacao-direta.adoc

@@ -0,0 +1,29 @@
+[[instalacao-direta]]
+= Direta, utilizando o teu próprio sistema operacional (SO)
+
+Baixe o código:
+
+[source,bash,subs="attributes"]
+----
+git clone {uri-blockchain-demo}
+----
+
+Para rodar essa aplicação, você deverá ter instalado o {uri-nodejs}[Node.js]. Em seguida, instale as dependências dessa aplicação através do {uri-npm}[npm].
+
+[NOTE]
+====
+A instalação do comando npm pode ser executada, no macOS, através de um único comando: `brew install npm`. Isso é tudo que é necessário fazer neste sistema operacional.
+====
+
+----
+cd blockchain-demo
+npm install
+----
+
+Execute o servidor:
+
+----
+./bin/www
+----
+
+Abra o teu browser e acesse a URL da página de demonstração: http://localhost:3000.