Trilha de Kotlin

Do zero ao Kotlin sênior: história da linguagem, POO, coroutines, JVM, APIs com Spring Boot, persistência e arquitetura, em 59 aulas e 9 fases.

1. 1
   LidaHistória do Kotlin: por que a linguagem nasceu e qual problema ela resolve

   Como a JetBrains criou o Kotlin para aliviar dores do Java, quais objetivos guiaram o projeto e onde a linguagem roda hoje, com datas conferidas.

   iniciante
2. 2
   LidaAmbiente e primeiro programa

   Instale o JDK, o IntelliJ e o Gradle, crie um projeto Kotlin como as equipes criam e rode o primeiro programa pela IDE e pelo terminal.

   iniciante
3. 3
   LidaControle de fluxo: if, when e laços

   Como o Kotlin escolhe e repete: if e when como expressões, ranges com .. e until, for, while, break, continue e labels, com saídas reais.

   iniciante
4. 4
   LidaFunções: parâmetros, retorno e argumentos nomeados

   Como declarar funções em Kotlin com fun, parâmetros, tipo de retorno, Unit, valores padrão e argumentos nomeados, com saídas reais de cada trecho.

   iniciante
5. 5
   LidaNull safety e tipos nuláveis

   Aula da fase 1 da trilha de Kotlin: Como `String?` muda o contrato de uma função, por que `!!` esconde uma decisão de modelagem e como tratar valores vindos do Java?

   iniciante
6. 6
   LidaColeções e lambdas

   Listas, conjuntos e mapas no Kotlin, lambdas com it e as operações do dia a dia, como map, filter e groupBy, com saídas reais do Kotlin 2.4.21.

   iniciante
7. 7
   LidaExceções e primeiro teste automatizado

   Veja como uma exceção interrompe o fluxo, como tratá-la com try, catch e finally e como escrever o primeiro teste com kotlin.test.

   iniciante
8. 8
   LidaClasses, objetos e propriedades

   Classes como moldes e objetos como instâncias, com construtor primário, propriedades, init e identidade em Kotlin, com saídas medidas no JDK 25 e no JDK 21.

   iniciante
9. 9
   LidaEncapsulamento, visibilidade, object e companion

   Aprenda a esconder o estado de uma classe atrás de ações que protegem as regras, com visibilidade, object, companion object e object expression.

   iniciante
10. 10
    LidaHerança e polimorfismo

    Aprenda a reaproveitar e especializar classes com open, override, super e abstract, e a tratar objetos de tipos diferentes da mesma forma em Kotlin.

    iniciante
11. 11
    LidaInterfaces, delegação e classes open

    Aula da fase 2 da trilha de Kotlin: Como compor comportamento com `by` em vez de herança, e por que classes são `final` por padrão?

    intermediário
12. 12
    Lidadata class, enum e value class

    Aula da fase 2 da trilha de Kotlin: Quando usar `data class` para valores, o que ela gera por baixo, e como `value class` evita confundir `UserId` com `OrderId` sem custo extra?

    intermediário
13. 13
    Lidasealed e when exaustivo

    Aula da fase 2 da trilha de Kotlin: Como modelar estados de um processo para que o compilador avise quando um caso novo não foi tratado?

    intermediário
14. 14
    LidaGenéricos básicos: classes e funções para vários tipos

    Como escrever classes e funções genéricas em Kotlin com T, deixar o compilador deduzir o tipo, limitar T com Comparable e lidar com null, com saídas reais.

    intermediário
15. 15
    LidaFunções de escopo e funções de extensão

    Aula da fase 3 da trilha de Kotlin: Qual função de escopo usar em cada caso, e por que uma função de extensão não substitui um método virtual?

    intermediário
16. 16
    LidaColeções imutáveis e Sequence

    Aula da fase 3 da trilha de Kotlin: Qual a diferença entre `List` e `Sequence` em uma cadeia de `map` e `filter`, e quando a alocação de coleções intermediárias importa?

    intermediário
17. 17
    LidaTratamento funcional de erros

    Aula da fase 3 da trilha de Kotlin: Quando `Result` e `runCatching` ajudam, quando `Either` do Arrow vale o custo, e quando uma exceção continua sendo a escolha certa?

    intermediário
18. 18
    LidaVariância e genéricos reified

    Aula da fase 3 da trilha de Kotlin: Por que `List<out T>` aceita subtipos, e como `reified` permite acessar o tipo em tempo de execução?

    avançado
19. 19
    LidaFunções inline e custo de lambdas

    Aula da fase 3 da trilha de Kotlin: Quando uma função `inline` elimina a alocação do lambda, e quando essa otimização não faz diferença?

    avançado
20. 20
    LidaPropriedades delegadas, operadores e destructuring

    Delegates com by (lazy, observable, vetoable e um próprio), operadores com operator fun e destructuring com componentN: o que cada um resolve e onde engana.

    intermediário
21. 21
    LidaExpressões e interop com Java

    Aula da fase 3 da trilha de Kotlin: Como `if`, `when` e `try` produzem valores, e como expor uma API Kotlin de forma amigável para quem ainda chama pelo Java?

    intermediário
22. 22
    LidaThreads e concorrência na JVM

    Threads, condição de corrida, synchronized, volatile, pools com Future e deadlock na JVM, com código rodado em Kotlin e as saídas que apareceram de verdade.

    intermediário
23. 23
    Lidasuspend e a máquina de estados

    Aula da fase 4 da trilha de Kotlin: O que o compilador gera a partir de uma função `suspend`, e por que ela não cria thread por si só?

    intermediário
24. 24
    LidaCoroutineScope e concorrência estruturada

    Aula da fase 4 da trilha de Kotlin: Quando `coroutineScope` falha tudo e `supervisorScope` isola falhas, e quem é responsável por cada coroutine criada?

    intermediário
25. 25
    LidaDispatchers e bloqueio

    Aula da fase 4 da trilha de Kotlin: Por que bloquear `Dispatchers.Default` trava o serviço, e como `limitedParallelism` controla a concorrência?

    intermediário
26. 26
    LidaCancelamento cooperativo

    Aula da fase 4 da trilha de Kotlin: Por que um `catch` genérico quebra o cancelamento, e como `ensureActive` e `NonCancellable` tratam a limpeza?

    intermediário
27. 27
    LidaFlow, StateFlow e Channel

    Aula da fase 4 da trilha de Kotlin: Quando um `Flow` frio basta, quando um fluxo quente é necessário, e quando um `Channel` coordena produtor e consumidor?

    intermediário
28. 28
    LidaEstado compartilhado: Mutex e atomics

    Proteja um contador compartilhado entre coroutines com Mutex, atomics, confinamento ou canais, e veja por que suspender não basta para evitar o erro.

    intermediário
29. 29
    LidaVirtual threads e testes com runTest

    Aula da fase 4 da trilha de Kotlin: Quando virtual threads do Java 21 são a escolha certa, e como testar coroutines com tempo virtual sem `Thread.sleep`?

    avançado
30. 30
    LidaBytecode e decompilação

    Aula da fase 5 da trilha de Kotlin: O que vira objeto, método estático ou classe auxiliar ao compilar Kotlin, e como confirmar isso com `javap`?

    avançado
31. 31
    LidaBoxing e alocações escondidas

    Aula da fase 5 da trilha de Kotlin: Por que `Int` vira `Integer` em coleções genéricas e em tipos nuláveis, e onde isso aparece em laços quentes?

    avançado
32. 32
    LidaHeap, GC e pausas

    Aula da fase 5 da trilha de Kotlin: Como G1, ZGC e Shenandoah diferem em pausa e em custo de CPU, e como ler os logs de GC?

    avançado
33. 33
    LidaJIT e análise de escape

    Aula da fase 5 da trilha de Kotlin: Quando o C2 remove uma alocação, e como escrever código que facilita essa otimização?

    avançado
34. 34
    LidaProfiling com JFR e startup

    Aula da fase 5 da trilha de Kotlin: Como o JFR mostra alocação e pausas em produção, e quais as trocas entre CDS, AOT e GraalVM Native Image?

    avançado
35. 35
    LidaHTTP e REST

    Pedido e resposta HTTP, verbos, idempotência, códigos de status e desenho de recursos, com um servidor de pedidos em Kotlin rodado no JDK 21 e no 25.

    intermediário
36. 36
    LidaGradle Kotlin DSL e multi-módulo

    Aula da fase 6 da trilha de Kotlin: Como organizar módulos e um catálogo de versões para que o build continue claro com o crescimento do projeto?

    intermediário
37. 37
    LidaInjeção de dependência e IoC no Spring

    Como o Spring monta os objetos de um serviço por injeção no construtor, com beans, @Primary, @Qualifier e dependência circular, em saídas reais.

    intermediário
38. 38
    LidaStarters e configuração por ambiente

    Aula da fase 6 da trilha de Kotlin: Como os starters do Spring Boot montam um serviço, e como `application.yml`, profiles e `@ConfigurationProperties` separam configuração de código?

    intermediário
39. 39
    LidaSpring Boot com controllers suspend

    Aula da fase 6 da trilha de Kotlin: Como validar entrada com Bean Validation e como controllers `suspend` se comportam no Spring MVC?

    intermediário
40. 40
    LidaSerialização com kotlinx.serialization e Jackson

    Aula da fase 6 da trilha de Kotlin: Quais as diferenças de comportamento com nulos e campos ausentes entre as duas bibliotecas?

    intermediário
41. 41
    LidaTratamento de erros com ProblemDetail

    Aula da fase 6 da trilha de Kotlin: Como mapear exceções de domínio para status HTTP sem vazar detalhes internos?

    intermediário
42. 42
    LidaSegurança com JWT e OpenAPI

    Aula da fase 6 da trilha de Kotlin: Como validar claims em um resource server e documentar a API com springdoc sem expor o que não deveria?

    avançado
43. 43
    LidaDesign avançado de API: paginação, versionamento e idempotência

    Paginação por deslocamento e por cursor, versões de API, Idempotency-Key e ETag em Spring Boot, com requisições reais e as falhas que cada escolha esconde.

    avançado
44. 44
    LidaClientes HTTP com RestClient e WebClient

    Chame outro serviço com RestClient e WebClient, trate erros de status, faça o timeout disparar de verdade e teste o cliente sem rede, com saídas reais.

    intermediário
45. 45
    LidaMensageria com Kafka

    Por que pôr um broker entre dois sistemas, como o Kafka ordena e entrega mensagens, e um produtor e um consumidor em Kotlin com reentrega medida.

    avançado
46. 46
    LidaSQL e modelagem relacional essencial

    Tabelas, chaves, restrições, JOIN, agregação e normalização com clientes e pedidos, rodados no PostgreSQL 18.6 antes de qualquer ORM.

    intermediário
47. 47
    LidaJPA básico: entidades, repositórios e @Transactional

    Como mapear classes Kotlin para tabelas com JPA e Spring Data, e por que o rollback depende da classe da exceção, com saídas medidas em PostgreSQL.

    intermediário
48. 48
    LidaJPA, Hibernate e N+1

    Aula da fase 7 da trilha de Kotlin: Quando o carregamento lazy causa N+1, e como `fetch join` e `@EntityGraph` resolvem o problema?

    intermediário
49. 49
    Lidadata class como entidade

    Aula da fase 7 da trilha de Kotlin: Por que `equals`, `hashCode` e `toString` gerados podem disparar carregamento lazy ou recursão em relacionamentos?

    intermediário
50. 50
    LidaMigrations com Liquibase

    Aula da fase 7 da trilha de Kotlin: Como versionar o schema com changesets, por que um changeset já aplicado nunca deve ser editado e como o `contexts` separa dados de teste?

    intermediário
51. 51
    LidaHikariCP e limites do banco

    Aula da fase 7 da trilha de Kotlin: Como dimensionar o pool em relação ao número de threads e ao limite de conexões do Postgres?

    avançado
52. 52
    LidaSpring Data MongoDB: documentos e modelagem

    Aula da fase 7 da trilha de Kotlin: Quando embutir um documento e quando referenciá-lo, e como `MongoTemplate` atende consultas que o repositório não cobre?

    intermediário
53. 53
    LidaÍndices e transações no MongoDB

    Aula da fase 7 da trilha de Kotlin: Como usar `explain` para evitar varredura completa da coleção, e o que o replica set muda nas transações?

    intermediário
54. 54
    LidaSOLID e padrões de projeto em Kotlin

    Cinco princípios SOLID com código Kotlin que viola e depois corrige, padrões que a linguagem já resolve e o que sobra das regras de Object Calisthenics.

    intermediário
55. 55
    LidaArquitetura hexagonal com ArchUnit

    Aula da fase 8 da trilha de Kotlin: Como manter o domínio sem dependência de framework e como impedir que a regra seja quebrada no futuro?

    avançado
56. 56
    LidaTestes com Kotest, MockK e Testcontainers

    Aula da fase 8 da trilha de Kotlin: Quando usar testes de propriedade, por que MockK lida melhor com Kotlin do que Mockito, e como subir Postgres e MongoDB reais nos testes, além de testar o Azure…

    intermediário
57. 57
    LidaObservabilidade com Micrometer e OpenTelemetry

    Aula da fase 8 da trilha de Kotlin: Como expor métricas, propagar traces e manter logs estruturados em JSON no mesmo serviço?

    avançado
58. 58
    LidaResiliência e empacotamento

    Aula da fase 8 da trilha de Kotlin: Como aplicar circuit breaker e retry com jitter, e como gerar uma imagem Docker enxuta com camadas e `jlink`?

    avançado
59. 59
    LidaProjeto final: uma API completa de ponta a ponta

    Uma API de pedidos com hexagonal, JWT, paginação, ProblemDetail, Liquibase, Micrometer e Docker, testada com Testcontainers e chamada com curl.

    avançado