Kotlin do zero a produção: a experiência do C6 Bank

1. Kotlin do zero a produção: a experiência do C6 Bank

2. Eduardinho • Sou desenvolvedor no C6 Bank na área de Cadastro/Onboarding e um grande entusiasta de Kotlin. Antes de trabalhar com Kotlin, tive experiência com aplicações em Java voltada para sistema de publicidade na UOL e com Scala na plataforma corporativa dentro da 99.

3. ROd • Desenvolvedor especialista em soluções de alta performance, atualmente trabalhando no C6 Bank, e com passagens por AWS, Amazon, Walmart.com Brasil e UOL. Mestre em Ciência da Computação pelo IME-USP na área de machine learning. • Pai de primeira viagem =P

4. C6 BANK Surpreender as pessoas com relações verdadeiras, transformando a experiência bancária

5. POR QUE KOTLIN?

6. CANDIDATAS

7. BACKGROUND DO TIME 00% 15% 15% 10% 10% 90%

8. CURVA DE APRENDIZADO LONGA MÉDIA CURTA

9. INTEGRAÇÃO COM REPOSITÓRIOS

10. SUPORTE ANÁLISE ESTÁTICA DE SEGURANÇA

11. RESUMO 00% 15% 15% 10% 10% 90% LONGA MÉDIA CURTA

12. GO • Alguns problemas básicos parecem não ter uma solução ótima ainda, por exemplo, sistema de dependências • Ponteiros • Ecossistema maduro • Goroutines e boas APIs para tratamento de concorrência

13. JAVA • Apesar de novas versões tem uma evolução muita lenta • Linguagem muito verbosa • Facilidade de contratação • Ecossistema extremamente maduro

14. NODE.JS • Não é tipada • Facilidade em criar um callback hell • Linguagem extremamente dinâmica com suporte a diversos "polyfills" • Ecossistema maduro, porém em constante mudança

15. KOTLIN • Sobrecarga de operadores, extension functions (polêmico!!) • Dificuldade em contratar pessoas com experiência prévia • Null safety by design • Ótimo suporte a concorrência • Ecossistema em amadurecimento para back-end • Interoperabilidade com Java é simples

16. KOTLIN • Sobrecarga de operadores, extension functions (polêmico!!) • Dificuldade em contratar pessoas com experiência prévia • Null safety by design • Ótimo suporte a concorrência • Ecossistema em amadurecimento para back-end • Interoperabilidade com Java é simples

17. MAIS SOBRE KOTLIN!

18. TIMELINE • 2011: inicio do desenvolvimento pela JetBrains • 2012: open sourced under Apache 2 license • Feb/2016: Kotlin 1.0 (first LTS version and stable) • Mar/2017: Kotlin 1.1 • May/2017: Google anunciou suporte oficial para Kotlin para Android • Nov/2017: Kotlin 1.2 • Oct/2018: Kotlin 1.3

19. COMO APRENDER • Kotlin Koans - https://play.kotlinlang.org/koans/overview • Free • Kotlin for Java Developers - https://pt.coursera.org/learn/kotlin-for-java-developers • Free • Kotlin in Action - https://www.manning.com/books/kotlin-in-action • < R$ 100

20. Java • package com.application.model; • public class Customer { • private String name; • private String cpf; • public Customer(String name, String cpf) { ... } • public String getName() {...} • public void setName(String name) {...} • public String getCPF() {...} • public void setCPF(String cpf) {...} • }

21. Java - continuação package com.application.service; public class CustomerService { private final CustomerRepository customerRepository; public CustomerService (CustomerRepository repo){...}   public void add(Customer customer) {...}     public void block(String cpf) {...} public Customer find(String cpf) {...} }

22. Kotlin package com.application.model data class Customer(val name: String, val cpf: String) package com.application.service class CustomerService(val repo: CustomerRepository) { fun add(customer: Customer) {...} fun block(cpf: String) {...} fun find(cpf: String): Customer {...} }

23. Kotlin – data class val customer = Customer("Carlos", "00000000000") println(customer) //output Customer(name="Carlos", cpf="00000000000") println(customer.copy(name = "Jose Carlos")) //output Customer(name="Jose Carlos", cpf="00000000000") println(customer.copy(cpf = "01010101010")) //output Customer(name="Carlos", cpf="01010101010")

24. Kotlin – null safety fun doSomething(arg: String){ println("arg value: $arg") } doSomething(null) //Não compila =O fun doSomethingNull(arg: String?){ println("arg value: $arg") } doSomethingNull(null) //Exibe a mensagem 'arg value: null' =D

25. Kotlin – null operators fun doSomething(arg: String?){ val value = arg?.replace("T", "O") ?: ”String vazia” println("arg value: $value") } doSomething(null) //output: “arg value: String vazia” doSomething("Tla") //output: “arg value: Ola”

26. Kotlin – namedparameters & default values fun sum(arg1: Int = 0, arg2: Int = 0): Int { val sum = arg1 + arg2 println("$arg1 + $arg2 = $sum") return sum } sum() //output: 0 + 0 = 0 sum(1, 1) //output: 1 + 1 = 2 sum(arg2 = 1) //output: 0 + 1 = 1 sum(arg1 = 1) //output: 1 + 0 = 1 sum(arg2 = 1, arg1 = 2) //output: 2 + 1 = 3

27. Kotlin – companion object • open class Logger { • fun info(msg: String) { println(msg) } • fun info(function: () -> String) { println(function()) } • } • class CustomerService { • companion object: Logger • fun anyFunction() { info("Log mensage info") } • }

28. Kotlin – companion object package com.application.model fun anotherPackageFunction() { println("Hi, I’m a function =)") CustomerService.info("Other log message") }

29. Kotlin fun parsingJSONs() { valc1: Customer = objectMapper.readValue("""{"name": "Carlos", "cpf": "000000000"}""", Customer::class.java) valc2 = objectMapper.readValue("""{"name": "Maria", "cpf": "000000000"} """, Customer::class.java) }

30. Kotlin – extension functions fun <reified T> ObjectMapper.parse(value: String): T { return objectMapper.readValue(value, T::class.java) } fun parsingJSONs() { val c1: Customer = objectMapper.parse("""{"name": "Carlos", "cpf": "000000000"}""") val c2: Customer = objectMapper.parse("""{"name": "Maria", "cpf": "000000000"}""") }

31. USO NO C6 BANK =)

32. STACK • Exposed • Fuel • Gradle • Jackson + Kotlin bindings • Javalin • Joda Money • Kmongo + mongo-java-driver • Koin • log4j2 • Swagger Java libs Kotlin libs

33. O QUE FAÇO COM TUDO QUE SEI DE SPRING? • Não se preocupe!! =) • Desde de Feb/2016, no lançamento do Kotlin 1.0, o Spring framework oferece suporte oficial a linguagem Kotlin

34. PROCESSO DE ESCOLHER ALGO NOVO • Bom ponto de inicio é o projeto awesome-kotlin • Número de stars no github + frequência de atualização + issues abertas • Avaliação de benchmarks • Sempre optamos por lightweight libs para ter maior controle sobre o tempo de execução

35. COMMONS-MONEY • setup do JodaMoney para BRL • camada fina de abstração com sobrecarga de operadores para operações básicas • valorA + valorB // kotlin style • valorC.add(valorD) // Money/BigDecimal style

36. COMMONS-EXPOSED • Necessidade recorrente em arquivar alterações realizadas em bases transacionais para controles de auditoria • Ideia: criar uma forma simples de declarar uma tabela primária + tabela de histórico usando o exposed

37. COMMONS-EXPOSED object Address : IntIdAuditedTable() { val addressId = tableId val zipCode = varchar("zip_code", 100) val street = varchar("street", 100) val number = varchar("number", 100) … }

38. COMMONS-LOGGING • Prover logs estruturados para nossa plataforma • class BalanceService { • companion object : LoggableClass() • fun getBalance(paramA: String, paramB: String) { • … • logger.info("account") { "message... xyz=$paramA" } • … • } • }

39. COMMONS-JAVALIN • Health-check • Auth providers • Safe deployment • Log context setup • Http and JVM metrics • Jackson setup

40. COMMONS-JAVALIN javalinServer { defaultAuthType(AuthTypes.CUSTOMER) routes { get(”my-endpoint") { ctx -> ctx.html("ok") } } errorHandler(MyCustomException::class.java) { e, ctx -> ctx.html("erro: ${e.name}") } }

41. E EM PRODUÇÃO?

42. IMPRESSÕES APÓS 4 MESES • Comprovamos a curta curva de aprendizado do Kotlin com a entrada de novos membros • Isso se aplica a diferentes backgrounds, não só Javeiros =P • O stack escolhido demonstrou uma grande estabilidade! • Depois de gerar um jar, o serviço tem a mesma operação de um app Java qualquer

43. IMPRESSÕES APÓS 4 MESES • Extension functions auxiliam muito no dia a dia!! • Mudamos nossa opinião em relação ao início da análise =D • Alguns code reviews podem ficar mais complicados • O null safety do Kotlin, nos livrou de muitos null pointer exceptions! • Exceto quando explicitamos (!!) em integrações com Java APIs =/ • Reified parameters são uma forma inteligente de trabalhar com generics! • Estamos dando os primeiros passos com coroutines

44. WE’RE HIRING =)https://c6bank.gupy.io

45. https://c6bank.gupy.io