Arquiteto Android — Lição 1: Introdução à Linguagem Kotlin

Kotlin para Android: Quem quer desenvolver aplicativos Android com qualidade precisa dominar mais do que telas e botões. Antes de discutir Clean Architecture, MVVM, modularização, testes e desempenho, precisamos conhecer profundamente a linguagem com a qual escreveremos boa parte desses aplicativos: Kotlin.
Nesta primeira lição da formação Arquiteto Android, vamos entender a origem do Kotlin, como ele funciona, por que foi adotado no ecossistema Android e quais características o tornam interessante para projetos pequenos e grandes.
Também faremos nosso primeiro experimento com a linguagem. A ideia é conectar a teoria à prática, sem confundir conceitos de Kotlin/JVM com a execução de um aplicativo em um dispositivo Android.
Sobre o material de origem: o conteúdo central desta lição foi elaborado a partir da transcrição fornecida da aula “Kotlin Essencial para Android” (aproximadamente 4 minutos e 26 segundos). A aula apresenta a história e as características da linguagem; não demonstra ainda a instalação nem a execução do Olá Mundo. Os exemplos, exercícios e observações sobre o Android moderno abaixo são ampliações didáticas, com correções históricas e técnicas apoiadas nas referências oficiais ao final.
Ao terminar a lição, você deverá ser capaz de:
- explicar o que é Kotlin e quem o criou;
- identificar a ligação entre JetBrains, IntelliJ IDEA e Android Studio;
- distinguir o anúncio da linguagem, em 2011, do lançamento estável, em 2016;
- explicar o que é bytecode e como Kotlin/JVM se relaciona com Java;
- entender por que, no Android, também precisamos conhecer DEX e ART;
- reconhecer a concisão, a segurança de nulos e a interoperabilidade como características essenciais do Kotlin;
- comparar um pequeno programa Java com um programa Kotlin;
- usar
fun main(),println(),valevarem exemplos iniciais; - executar um Olá Mundo no navegador ou em um projeto Kotlin/JVM;
- perceber como decisões simples de linguagem influenciam a qualidade arquitetural de um aplicativo.
Kotlin é uma linguagem de programação moderna, de tipagem estática, que suporta programação orientada a objetos e programação funcional.
Ela procura combinar código legível, expressivo e seguro com a possibilidade de aproveitar sistemas, bibliotecas e ferramentas já existentes.
Em um projeto Android, por exemplo, podemos usar Kotlin para escrever:
- regras de negócio;
- classes e objetos;
- componentes de interface;
- integração com APIs;
- persistência de dados;
- testes automatizados;
- código organizado em diferentes módulos.
Contudo, Kotlin não é exclusiva do Android. Há projetos Kotlin para servidores, aplicações web e diferentes plataformas.
Isso é importante para quem pretende chegar ao nível de arquiteto: devemos enxergar Kotlin como uma linguagem, e Android como uma plataforma que pode utilizá-la.
A linguagem foi criada pela JetBrains, empresa responsável pelo IntelliJ IDEA, um ambiente de desenvolvimento integrado amplamente utilizado no ecossistema Java.
O Android Studio foi construído a partir da plataforma IntelliJ, motivo pelo qual a relação entre essas ferramentas aparece logo na aula original.
Veja a relação:
JetBrains
|
+--> IntelliJ IDEA
| |
| +--> Base tecnológica do Android Studio
|
+--> Linguagem Kotlin
|
+--> Desenvolvimento Android
+--> Backend
+--> Outros alvos e plataformas
A ligação entre essas tecnologias facilita o trabalho do desenvolvedor, mas não significa que o Android Studio seja simplesmente o IntelliJ IDEA com outro nome: ele incorpora ferramentas específicas do Android.
A transcrição da aula menciona 2011 como o lançamento do Kotlin. Para compreender corretamente a história, precisamos diferenciar apresentação pública de primeira versão estável.
| Ano | Marco |
|---|---|
| 2010 | Início do desenvolvimento da linguagem na JetBrains. |
| 2011 | Apresentação pública do Project Kotlin. |
| 2012 | Abertura do código-fonte do projeto. |
| 2016 | Lançamento do Kotlin 1.0, primeira versão oficialmente estável. |
| 2017 | Google anuncia suporte oficial ao Kotlin para desenvolvimento Android. |
| 2019 | Google passa a recomendar uma abordagem Kotlin-first para o desenvolvimento Android. |
Portanto, a afirmação mais precisa é:
Kotlin foi apresentado publicamente em 2011 e chegou à primeira versão estável em 2016.
A aula também descreve Kotlin como uma linguagem de pouco mais de seis anos. Essa observação refletia a época da gravação, não a situação atual. Uma tecnologia precisa ser estudada considerando a data da fonte.
Lição de arquitetura: decisões sobre plataformas e linguagens não devem se basear apenas em afirmações históricas retiradas do contexto. Devemos verificar as versões, o suporte e o estado atual das ferramentas.
A aula destaca quatro referências:
Java;
Scala;
Groovy (o nome aparece como “Groove” na transcrição);
C#.
A proposta foi aprender com soluções desenvolvidas anteriormente e construir uma linguagem que reduzisse problemas comuns de produtividade e segurança.
Isso não significa que Kotlin seja uma cópia dessas linguagens. Ela combina ideias conhecidas e escolhas próprias, como um sistema de tipos que distingue referências anuláveis das não anuláveis.
Quem já programa em Java reconhecerá vários conceitos. No entanto, aprender Kotlin corretamente exige mais do que substituir palavras-chave: devemos aprender a escrever Kotlin idiomático.
No caso do Kotlin/JVM, o código-fonte é compilado para bytecode compatível com a Java Virtual Machine (JVM).
Um fluxo simplificado para uma aplicação de console é:
Arquivo Main.kt
|
v
Compilador Kotlin/JVM
|
v
Bytecode .class
|
v
JVM + bibliotecas necessárias
|
v
Programa em execução
Bytecode é uma representação intermediária gerada pelo compilador. Ele não é o texto Kotlin original, nem é necessariamente código de máquina executado diretamente pelo processador.
A interoperabilidade com Java se beneficia dessa infraestrutura comum. Porém, precisamos entender uma diferença importante no caso do Android.
Na transcrição, a execução do Kotlin é explicada pelo bytecode na JVM. Essa explicação é útil para Kotlin/JVM, mas não descreve toda a cadeia de execução de um aplicativo Android.
Em termos simplificados:
Código Kotlin (.kt) + código Java (.java)
|
v
Compilação para bytecode
|
v
Ferramentas de build Android
(como D8 e, conforme o build, R8)
|
v
Código DEX
|
v
Aplicativo instalado no Android
|
v
Android Runtime (ART)
O DEX é o formato de bytecode utilizado no Android. O ART é o ambiente de execução do Android.
Assim, não devemos imaginar que o celular simplesmente executa o arquivo Kotlin dentro da mesma JVM de um programa de desktop.
Outro cuidado: um computador utilizado para criar projetos Android precisa de um ambiente de desenvolvimento apropriado, incluindo IDE, JDK e ferramentas Android. Ter apenas Java instalado não equivale a ter todo o ambiente Android preparado.
Resumo: Kotlin/JVM e Kotlin no Android compartilham conceitos e ferramentas, mas a cadeia de build e o ambiente de execução Android têm particularidades.
Não. Kotlin suporta tanto orientação a objetos quanto estilo funcional.
Na orientação a objetos, trabalhamos com classes que representam entidades e comportamentos:
class Usuario(val nome: String) {
fun apresentar(): String {
return "Olá, $nome!"
}
}Em outro caso, podemos escrever funções independentes de classes:
fun dobro(numero: Int): Int {
return numero * 2
}As duas abordagens podem coexistir.
Isso será valioso em nossa formação: algumas funcionalidades pedem objetos com responsabilidades bem definidas, enquanto outras ficam mais simples como funções puras, fáceis de testar.
A aula aponta a concisão como um dos principais diferenciais do Kotlin.
Em programação, concisão significa expressar uma ideia com menos código desnecessário, sem perder clareza.
Compare um Olá Mundo em Java:
public class Main {
public static void main(String[] args) {
System.out.println("Olá, mundo!");
}
}Agora veja uma versão em Kotlin:
fun main() {
println("Olá, mundo!")
}Em Kotlin, não precisamos declarar uma classe apenas para criar esse ponto de entrada de uma aplicação de console.
Entendendo o código:
fundeclara uma função;mainé a função de entrada deste programa de console;println()escreve uma linha na saída;- as chaves delimitam o corpo da função.
A diferença é visível. Entretanto, menos linhas não garantem automaticamente um código melhor. O objetivo é manter o programa compreensível, testável e fácil de modificar.
Atenção: a função
main()demonstra a linguagem em uma aplicação de console. Em um aplicativo Android, a entrada e o ciclo de vida são coordenados pelo sistema Android, com componentes como atividades e outros elementos do aplicativo.
Outra característica mencionada na aula é a proteção contra erros associados a referências nulas, como NullPointerException.
Precisamos fazer uma correção importante: Kotlin permite valores nulos, mas obriga o programador a indicar explicitamente quando um tipo aceita null.
Compare:
val nome: String = "Ana"Aqui, nome é declarado como uma referência não anulável.
Já este exemplo permite nulo:
val apelido: String? = nullO símbolo ? indica que a referência pode não conter um valor.
Se tentarmos acessar diretamente uma propriedade anulável:
val apelido: String? = null
// Não compila:
// println(apelido.length)o compilador exige um tratamento seguro.
val apelido: String? = null
println(apelido?.length)Resultado:
null
Quando o valor é nulo, o operador ?. evita o acesso à propriedade.
val apelido: String? = null
val exibicao = apelido ?: "Visitante"
println(exibicao)Resultado:
Visitante
Esse recurso é conhecido como operador Elvis.
Pode acontecer, sim. Kotlin reduz diversas situações perigosas, mas não elimina todos os riscos.
Por exemplo, o operador !! força uma afirmação de não nulidade e pode provocar uma exceção:
val apelido: String? = null
// Não execute sem entender o risco:
// println(apelido!!.length)Também existem situações delicadas na integração com bibliotecas Java e na inicialização de objetos.
Para projetos profissionais, nossa regra inicial será: prefira tratar a ausência de valor explicitamente e evite !! como solução rotineira.
Interoperabilidade significa que código Kotlin pode trabalhar junto de código Java, e vice-versa, no ecossistema JVM e em projetos Android compatíveis.
Isso permite uma migração gradual. Uma empresa não precisa reescrever todo o aplicativo de uma vez.
Imagine que um sistema antigo já possua esta classe Java:
public class SaudacaoJava {
public String mensagem(String nome) {
return "Olá, " + nome + "!";
}
}Um arquivo Kotlin no mesmo projeto, devidamente configurado, pode utilizá-la:
fun main() {
val servico = SaudacaoJava()
println(servico.mensagem("Ana"))
}Resultado:
Olá, Ana!
Também é possível chamar código Kotlin a partir de Java, respeitando detalhes da forma como funções e propriedades são expostas no bytecode.
Por que isso importa para arquitetura? Porque uma equipe pode modernizar módulos isolados, criar testes para as novas partes e manter integrações antigas em funcionamento.
Limitação: a interoperabilidade não torna qualquer biblioteca Java automaticamente adequada a todos os alvos de Kotlin. Uma biblioteca para JVM ou Android não se transforma, por isso, em biblioteca disponível em Kotlin/JS ou Kotlin/Native.
A transcrição observa que Kotlin não se limita a aplicativos móveis. Hoje, podemos organizar os principais contextos assim:
| Contexto | Utilização |
|---|---|
| Android | Aplicativos para celulares, tablets e outros dispositivos Android. |
| Kotlin/JVM | Serviços, aplicações de console, bibliotecas e backend. |
| Kotlin/JS | Projetos que precisam gerar código para JavaScript. |
| Kotlin/Native | Compilação nativa para determinados alvos. |
| Kotlin Multiplatform | Compartilhamento planejado de código entre plataformas. |
A palavra importante é planejado. Um projeto multiplataforma precisa definir quais módulos, dependências e APIs são compatíveis com cada alvo.
Na formação Arquiteto Android, começaremos pelo Kotlin e pelo Android nativo antes de avaliar arquiteturas multiplataforma.
Este laboratório é um complemento à aula transcrita. A transcrição anuncia a intenção de chegar à configuração e ao primeiro programa, mas termina antes de demonstrá-los.
Abra o Kotlin Playground e substitua o conteúdo do editor por:
fun main() {
println("Olá, mundo!")
println("Estou começando minha formação Arquiteto Android.")
}Execute o código e confira a saída:
Olá, mundo!
Estou começando minha formação Arquiteto Android.
Essa opção é suficiente para praticar sintaxe Kotlin, mas não cria um APK ou um aplicativo Android.
- Instale e abra o IntelliJ IDEA.
- Acesse New Project e escolha um projeto Kotlin.
- Utilize um JDK adequado à configuração sugerida pela IDE.
- Selecione um sistema de build, como Gradle, quando a configuração solicitar.
- Crie ou abra um arquivo
Main.kt. - Insira o mesmo código com
fun main(). - Execute pelo botão de execução da IDE.
Menus e modelos de projeto podem variar entre versões. Consulte o tutorial oficial de Kotlin/JVM, disponível nas referências.
Não comece criando uma Activity Android apenas para testar println(). Neste primeiro contato, queremos isolar a linguagem. Na etapa seguinte, entraremos no ambiente de aplicativos Android.
Para praticar Kotlin com mais autonomia, vamos introduzir dois elementos que não foram detalhados na legenda.
val declara uma referência que não pode ser reatribuída:
val linguagem = "Kotlin"
println(linguagem)var declara uma variável que pode receber outro valor:
var quantidadeDeAulas = 1
quantidadeDeAulas = 2
println(quantidadeDeAulas)Uma variável também pode ter seu tipo escrito explicitamente:
val nome: String = "Ana"
var idade: Int = 25
val ativo: Boolean = trueQuando o tipo pode ser inferido com segurança, a declaração pode ser mais curta.
Prefira val quando não precisar reatribuir a referência. Use var quando houver uma necessidade real de alteração.
Entretanto, atenção: val não transforma um objeto mutável em imutável.
val tecnologias = mutableListOf("Kotlin")
tecnologias.add("Java")
println(tecnologias)Embora não seja possível reatribuir tecnologias a outra lista, seu conteúdo pode mudar.
A diferença entre referência não reatribuível e estado imutável será fundamental quando estudarmos gerenciamento de estado no Android.
Agora reuniremos concisão, funções, tipos, valores anuláveis e interpolação de strings.
fun apresentarDesenvolvedor(
nome: String,
tecnologiaFavorita: String?
): String {
val tecnologia = tecnologiaFavorita ?: "Kotlin"
return "Olá, $nome! Vamos estudar $tecnologia."
}
fun main() {
println(apresentarDesenvolvedor("Ana", "Kotlin"))
println(apresentarDesenvolvedor("Carlos", null))
}Saída esperada:
Olá, Ana! Vamos estudar Kotlin.
Olá, Carlos! Vamos estudar Kotlin.
Observe com atenção:
- A função
apresentarDesenvolvedorrecebe dois parâmetros. nome: Stringnão aceitanullem chamadas Kotlin comuns.tecnologiaFavorita: String?pode recebernull.?:define um valor alternativo.Stringapós os parênteses indica o tipo de retorno da função.$nomee$tecnologiainserem valores dentro do texto.
Esse código não cria uma interface Android. Ele demonstra lógica que, no futuro, poderemos testar e reutilizar em componentes de um aplicativo.
É possível aprender a sintaxe de Kotlin e ainda escrever aplicativos difíceis de manter.
Por isso, começaremos a formar hábitos de arquitetura desde a primeira lição.
| Decisão | Benefício esperado |
|---|---|
| Preferir nomes claros | Facilita manutenção e revisões. |
Usar val quando possível | Reduz reatribuições acidentais. |
| Tratar valores anuláveis | Torna a ausência de dados explícita. |
| Isolar regras em funções pequenas | Facilita testes e reutilização. |
| Respeitar limites entre Java e Kotlin | Viabiliza modernização gradual. |
| Distinguir Kotlin/JVM e Android | Evita erros sobre build e execução. |
Uma boa arquitetura não surge apenas ao escolher um padrão sofisticado. Ela começa com decisões cotidianas sobre tipos, dependências, responsabilidades e testes.
A linguagem foi apresentada em 2011; 2016 é o marco da primeira versão estável.
Kotlin distingue tipos anuláveis e não anuláveis. É possível declarar, por exemplo, String?.
Esse operador apenas afirma que o valor não é nulo. Se estiver errado, a execução poderá falhar.
A função main() é apropriada para nosso experimento inicial. Um aplicativo Android tem uma estrutura própria e um ciclo de vida controlado pela plataforma.
A interoperabilidade permite migrar por partes. Em sistemas existentes, uma estratégia gradual costuma reduzir riscos operacionais.
A concisão é útil quando preserva a intenção. Código excessivamente comprimido também pode prejudicar o entendimento.
Tente resolver antes de consultar respostas prontas.
Crie um programa Kotlin que exiba:
Olá, Android!
Minha jornada como Arquiteto Android começou.
Crie uma variável nomeCurso com o valor "Arquiteto Android" e um contador aulasConcluidas que comece em 0. Depois, atualize o contador para 1 e imprima os dois valores.
Escolha val ou var de acordo com o comportamento desejado.
Crie uma função que receba String?. Quando o nome for null, ela deve devolver "Visitante". Caso contrário, deve devolver o próprio nome.
Escreva um programa que mostra uma mensagem em Java e depois reproduza o comportamento em Kotlin.
Responda: qual versão necessita de mais estrutura para esse exemplo específico? Isso prova que toda solução Kotlin será melhor?
Sem olhar o conteúdo acima, desenhe:
Kotlin / Java --> bytecode --> DEX --> ART
Depois, explique em uma frase a função de DEX e de ART.
Crie uma função Kotlin chamada mensagemBoasVindas, recebendo um nome anulável e devolvendo uma saudação.
Exemplos esperados:
mensagemBoasVindas("Ana") -> "Bem-vinda, Ana!"
mensagemBoasVindas(null) -> "Bem-vinda, visitante!"
Se desejar, use uma saudação neutra, adequada a qualquer nome. Não precisa criar interface gráfica.
Questão 1. Qual organização criou Kotlin?
A) Oracle
B) JetBrains
C) Microsoft
D) Mozilla
Questão 2. Qual acontecimento está relacionado ao ano de 2011?
A) Primeira versão estável Kotlin 1.0
B) Kotlin substituiu Java no Android
C) Apresentação pública do Project Kotlin
D) Lançamento do Android Studio
Questão 3. Em Kotlin, o tipo String? significa:
A) Uma String obrigatoriamente vazia
B) Uma String que pode ser nula
C) Um tipo que nunca aceita null
D) Uma String automaticamente convertida para número
Questão 4. O operador ?. é usado principalmente para:
A) Realizar uma chamada segura em referência anulável
B) Concatenar arquivos
C) Declarar um pacote
D) Compilar Android para DEX
Questão 5. Qual alternativa descreve melhor a relação Kotlin e Java em projetos JVM e Android?
A) É proibido misturar as linguagens
B) Projetos Kotlin sempre precisam ser reescritos em Java
C) As linguagens podem interagir, permitindo migração gradual
D) Kotlin executa qualquer biblioteca Java em qualquer plataforma nativa
Questão 6. No Android, o bytecode dos projetos é convertido em qual formato de execução da plataforma?
A) HTML
B) SQL
C) DEX
D) CSS
Questão 7. Sobre val, a afirmação correta é:
A) É impossível modificar qualquer objeto referenciado por val
B) A referência não pode ser reatribuída, mas o objeto pode ser mutável
C) Só aceita valores numéricos
D) É idêntico a var
Questão 8. Qual é a interpretação mais adequada da concisão em Kotlin?
A) Apagar testes para escrever menos código
B) Concentrar todas as regras em uma função
C) Escrever menos código desnecessário sem prejudicar a clareza
D) Evitar nomes descritivos para reduzir linhas
| Questão | Resposta | Explicação |
|---|---|---|
| 1 | B | Kotlin foi criado pela JetBrains. |
| 2 | C | O projeto foi apresentado em 2011; Kotlin 1.0 chegou em 2016. |
| 3 | B | O ? marca a referência como anulável. |
| 4 | A | O operador permite um acesso seguro, retornando nulo quando necessário. |
| 5 | C | A interoperabilidade viabiliza a coexistência e a migração gradual. |
| 6 | C | O Android usa bytecode DEX, executado pelo ART. |
| 7 | B |
val impede reatribuir a referência; não garante imutabilidade do objeto. |
| 8 | C | Concilie concisão com legibilidade e manutenção. |
Marque os itens quando conseguir realizá-los sem consultar a explicação:
- [ ] Sei quem criou Kotlin e sua relação com IntelliJ IDEA.
- [ ] Diferencio o anúncio de 2011 da versão estável de 2016.
- [ ] Sei explicar as influências citadas na aula original.
- [ ] Consigo distinguir Kotlin/JVM de Kotlin executado no Android.
- [ ] Entendo a função de bytecode, DEX e ART em alto nível.
- [ ] Consigo explicar por que Kotlin é considerada concisa.
- [ ] Sei usar
valevar. - [ ] Sei declarar um valor
String?. - [ ] Sei utilizar os operadores
?.e?:em exemplos básicos. - [ ] Entendo o que significa interoperabilidade com Java.
- [ ] Executei o primeiro programa
fun main(). - [ ] Resolvi os exercícios e conferi as oito questões.
Esta lição inicia uma sequência progressiva. O planejamento poderá ser refinado de acordo com os projetos práticos e as versões do ecossistema Android.
| Etapa | Tema | Competência central |
|---|---|---|
| 1 | Kotlin essencial | Sintaxe, tipos, funções e null safety. |
| 2 | Kotlin intermediário | Classes, coleções, lambdas e extensões. |
| 3 | Android Studio | Projetos, Gradle, emulador e depuração. |
| 4 | Fundamentos Android | Componentes, ciclo de vida e navegação. |
| 5 | Jetpack Compose | Interfaces declarativas e estado. |
| 6 | Coroutines e Flow | Assincronismo e fluxos de dados. |
| 7 | Room, DataStore e APIs | Persistência e comunicação externa. |
| 8 | MVVM e Clean Architecture | Camadas, responsabilidades e dependências. |
| 9 | Hilt e modularização | Evolução de aplicações maiores. |
| 10 | Testes e observabilidade | Qualidade, diagnósticos e manutenção. |
| 11 | Segurança e desempenho | Aplicações confiáveis e eficientes. |
| 12 | CI/CD e decisões arquiteturais | Entrega, governança e evolução do produto. |
O objetivo final não é apenas saber programar em Kotlin: é justificar escolhas arquiteturais, comparar alternativas e construir aplicativos Android sustentáveis.
Na Lição 2 — Variáveis, Tipos de Dados e Operadores em Kotlin, aprofundaremos:
valevar;- inferência e declaração explícita de tipos;
Int,Long,Double,Boolean,ChareString;- interpolação de strings;
- operadores aritméticos e de comparação;
- conversões de valores;
- exercícios progressivos;
- erros comuns de compilação e lógica.
Meta antes de avançar: execute o Olá Mundo, explique a diferença entre String e String? e seja capaz de contar, com suas palavras, por que Kotlin e Java podem coexistir no mesmo projeto.
Transcrição fornecida pelo estudante: “Kotlin Essencial para Android”, capítulo introdutório, duração aproximada de 4min26s. Aborda origem, inspirações, bytecode/JVM, concisão, null safety e interoperabilidade.
- Kotlin — História dos primeiros anos (JetBrains)
- Kotlin — Comece por aqui
- Kotlin — Primeiro projeto Kotlin/JVM com Gradle
- Kotlin — Segurança de nulos
- Kotlin — Interoperabilidade: chamando Java a partir de Kotlin
- Android Developers — Kotlin e Android
- Android Developers — Conheça a linguagem Kotlin
- Android Developers — Ferramenta D8 e bytecode DEX
- Kotlin Playground — Editor online
Nota editorial: esta publicação preserva os temas efetivamente presentes na transcrição, distingue práticas adicionais de conteúdo originalmente ministrado e atualiza explicações históricas e técnicas conforme a documentação oficial. Interfaces de ferramentas e versões de SDKs podem mudar; consulte as instruções vigentes ao executar os laboratórios.
Metadescrição: Aprenda Kotlin para Android do zero: origem, JVM e ART, Java, null safety, val e var, primeiro Olá Mundo, exemplos e exercícios práticos.
Tags: Android, Kotlin, Arquiteto Android, JetBrains, IntelliJ IDEA, Android Studio, Java, JVM, DEX, ART, null safety, interoperabilidade, programação mobile.
Veja também: mais conteúdos sobre Android.
Kotlin for Android Beginners: Build Modern Apps Without Confusing Theory (English Edition)
Kotlin for Android Beginners: Build Modern Apps Without Confusing Theory (English Edition). Produto recomendado para estudos, programação e produtividade.