August 16th and 17th

All ticket sales will be donated to the following social organizations and movements:


Rebouças Convention Center - São Paulo City

São Paulo is a huge city. If it's your first time here, check a good guide such as WikiTravel. You'll stay mostly around Downtown.


The goal is to implement a truly "International" programming-focused conference in Brazil. Meant to introduce Brazilian programmers to the world - and hopefully Latin America in general next time.

We already have many great Brazilian conferences, but all of them are meant just for the Brazilian Audience.

The problem: we only speak Brazilian Portuguese in Brazil. So no one else in the world can see what we are doing.

The solution: it is about time we present in the tech industry lingua-franca: English. Let's start showing off what we are capable to a larger audience.

In 2017 and 2018 we took the chance to prove that such an event has a place.

And we succeeded!

Now, we are going to improve the formula in 2019 and bring even more great speakers to the big stage!

Come make history with us!


August 16th - Friday

  • Track 1 Running multiple Nubanks at once

    We are going to talk about how we built, maintain and scale our microservices architecture. We are a fast-growing digital bank with a lot of challenges regarding scalability, operability and reliability and we would like to present a structured talk about the key components of our ecosystem and also how they interact with each other.

    There’s a few characteristics that are not so usual and gives us a lot of leverage when compared to our competitors, things like Sharding and Homogeneous Codebase, using functional programming as our main paradigm. Also, we build and maintain abstractions that help our engineering team to smoothly operate and constantly improve their microservices, and furthermore the products we offer to customers.

    One of things we use to achieve high levels of resilience and reliability is Kubernetes with our own developed tooling and abstractions, which allows us to provide fast interaction cycle and an even more optimized way to deploy services and other infrastructure parts. For instance, we deploy things like Thanos, Prometheus and Grafana using those abstractions to ensure fast-ish manner to release and control software versioning.
    By dealing with a regulated environment with high requirements around, specially, uptime, SLAs and SLOs we’ve learned how to properly interact with large and complex distributed systems, keeping core platform systems like Kafka, used among services for asynchronous communication, on the highest levels of reliability.

    On daily basis we operate a lot of services, we would like to spread our case, what things we did work, what doesn't work, what drove our decisions. It is a opportunity to learn from others and make it feasible since we use a lot of technologies which are open source to everybody.

    Track 2 To be defined

  • Track 1 How GitLab scaled Git access with Go and what we gained from it

    Back in the early days of, we've used to run Rails worker processes, Sidekiq background processes, and Git storage on a single server, a typical monolith. As expected, it's easy to deploy and maintain, though really hard to scale. Having a single server means we're only able to scale vertically, which becomes increasingly expensive and limiting.

    At a given time, we had to run multiple servers, which meant Git repositories had to be available to all server nodes. For that, we first went for the "quick-win", NFS. It rapidly showed its limitations regarding observability, single point of failure and high latency.

    Beside alternative solutions, we decided to slightly redesign the system and create a Go service called Gitaly, which now acts as a "git database" service for

    This talk will go through the history of how we've gradually separated it from the monolith using Feature flags, Protocol Buffers, gRPC and Go.

    Track 2 Bulletproof API's

    Em sistemas de alta disponibilidade é necessário lidar com inevitáveis falhas. Sejam elas temporárias ou não, temos um impacto
    direto na experiência do usuário. Bulletproof API's seria um conjunto de práticas, técnicas e implementações que focam
    em prover maior resiliência, identificando rapidamente o tipo de falha e possibilitando se recuperar rapidamente, diminuindo ou até zerando o impacto na experiência final
    dos usuários.

    Alguns tópicos que serão abordados:

    * Retries
    * Circuit Breakers
    * Timeouts
    * Como lidar com diferentes tipos de tráfego
    * Análise efetiva de métricas
    * Um caso real e como as técnicas foram aplicadas

    Ao final da palestra, será possível entender melhor como abordagens de resiliência podem impactar na melhoria da experiência final dos usuários.
    Uma visão mais objetiva das diferentes ferramentas que temos no mercado. E a importância de identificar falhas temporárias e como lidar com elas.

  • Track 1 Understanding the role of Artificial Intelligence in the present and in the future

    Artificial Intelligence, which was just a distant future, is now part of our daily lives. Alexa, Google Home, Siri, among other assistants, help us with housework and are examples of the participation of robots in our daily life. Drones are confused with birds and cars can drive without our hands touching the steering wheel. If this is our present, what lies ahead?

    Track 2 Async Programming with Swoole PHP

    I will talk about the new Async PHP extension named Swoole, developed for high-performance, concurrent web servers for modern PHP applications by using Coroutines


  • Track 1 The AI 'Black Box'

    As humans we're inherently biased. Sometimes it's explicit and other times it's unconscious, but as we move forward with technology how do we keep our biases out of the algorithms we create? We need to have a conversation about how AI 'Black Box' should be governed and ask who is responsible for overseeing the ethical standards of these algorithms; and the need for gender balance — having access to large and diverse points of view helps to train algorithms to maintain the principle of fairness.

    Track 2 To be defined

  • Track 1 Why your company should have a Developer's Kit and how to build one

    Today modern application can be composed of multiple pieces that is not always easy to fit together. From the majestic monolith to the micro-service based architecture, there is also a good chance you depend on multiple daemons with a pleteora of configuration parameters that needs be defined in harmony so you can run a fully capable development environment.

    While some approaches like docker composer may be useful to some users, you are making a tradeoff of performance and convenience, by removing the ability to run things natively. You are also making harder for any more advanced debugging techniques on a lower leve of your stack.

    In this talk I will show you how you can build a Developer's Toolkit that compromises nothing: performance, convenience still gives you the ability to do system-level debugging, without any docker required.

    Track 2 Micro-frontends: the golden circle

    As a developer, we are always aware of the latest trends and buzzwords in technology. One of the latest that have been surfacing for me in the frontend word is the idea of micro-frontends. In summary, the idea is to apply the same idea of microservices into our frontend code. The first time I heard something about this was on the RubyConf of 2016, the same year that this term appeared on the ThoughtWorks Technology Radar. As our company, teams, and code are growing, we start to face new challenges and that was one of the reasons we started looking into this topic. In this presentation I plan to use the Golden Circle methodology to analyze this topic:
    * Why use micro-frontends?
    * What is the motivation behind doing it, and when should you use it or not.
    * How to implement micro-frontends?
    * Which are the technical constraints and the available strategies/libraries to implement it.
    * Also how we are researching and experimenting with this on Pipefy.
    * What is micro-frontends?
    * Knowing Why and How, we can do a recap of what is micro-frontends, its advantages and disadvantages to using in your application.

  • Track 1 Evolving Web legacy systems with Microfrontends and Web Components

    Itaú Unibanco has one of the largest and oldest internet banking of the world, it has a long old story, a story that we are not always proud to tell about. But we can't just rewrite everything from the ground up, if we want to update it we need to find a way to do it coexisting with the legacy for a long time. This is not a introductory and conceitual talk, that's a story of how are using a microfrontend architecture with the Web Component technology, how we are scaling these tools for thousands of developers working on it at the same time, and finally automatizing everything we could in the way! We hope our story can bring some hope and ideas for other companies out there to deal with their own legacy.

    Track 2 s/15 years old TCP Service/Elixir HTTP Microservice/g - OLX Backend for Ad Insertion

    On this talk, you'll see the challenges we had at OLX to replace a 15 years old C TCP Service, with lots of memory leaks, using a legacy large database and also unsuitable for maintenance. The new Elixir Microservice had to come without service interruption so there were also rollout challenges with all client platforms like mobile, web and also mass insertion.


  • Track 1 Concurrency, Scalability and Transactions -- Myths and Surprises

    Concurrency is here to stay. Nowadays most web-servers make use of concurrency in order to reap multi-core hardware benefits. Because of that, our server-side software is getting more and more concurrent. However, there is one piece of *concurrency* I see too many developers ignoring: "the database".
    Although relational databases give us ACID properties, this at all doesn't imply race conditions in multi-statement operations.
    In this talk we will explore the interaction between massive concurrent servers, databases and transaction isolation. We will explain what isolation is and what are the "real" guarantees we get from them. We will also show some common mistakes and pitfals in ensuring consistency in high concurrent scenarios and, of course, how to avoid them.

    Track 2 When Stand-up Comedy Meets Machine Learning

    Stand-up Comedy is an art that plays an important role in human history and in recent years it became a trend business in our modern society. Like any other business, this one is also governed by the law of supply and demand, but in this case, the demand is for laughs. To meet this demand in a professional way, comedians are often required to take a step back in art and learn several techniques to better format their show and maximize the chances of success. In this talk, you will be presented to an experimental approach that uses Machine Learning to extract the underlying format of any stand-up performance and create profiles for posterior analysis. With this approach, we can identify interesting patterns that allow us to use it for recommendation systems or simply as an insight generation tool.

  • Track 1 To be defined

    Track 2 To be defined


August 17th - Saturday

  • Track 1 DevOps for Blockchain Apps

    We know that DevOps is a set of best practices to smoothly deliver project delivery by integrating processes, tools and teams.

    This is no different in the blockchain universe.

    Let's understand how we can have quality, integration and delivery fluidly in applications, smartcontracts or blockchain projects.

    We'll look at some practices and platforms like Azure DevOps and Azure Blockchain Development Kit that can help you with pipeline operations and CI / CD strategies as well.

    Track 2 GraphQL + Apollo Server + Azure Functions = Magic

    Serverless applications have been helping many companies to spend less money on infrastructure, application management and performance by passing the responsibility to their 3rd-party provider platforms. The union between GraphQL and Serverless functions is are a great solution to create applications with no worries about scaling, performance, and maintainability. In this talk attendees will see how to start in the Serverless architecture world by use of Azure Functions platform and expose their services using GraphQL and Apollo Server, providing a rich and secure frontend.
    We will take a look at the following topics:
    - Introduction to Azure Functions
    - Benefits and Drawbacks adopting Serverless architectures
    - Adopting GraphQL, Apollo Server and Azure Functions in real scenarios
    - Tips and tricks about production experiences

  • Track 1 Migrating to an Event Sourced system

    This is a case-study about migrating a regular app with relational data to an event-sourced system.

    We are EmCasa, a real estate startup using react, react native and elixir as our main stack. As a company committed to be data-driven, we chose to migrate to an event-sourced system to be able to capture our data in a immutable and permanent fashion and have flexibility to display in various forms.

    This talk will guide the audience through our exploration, decision and migration process with pain points, benefits and actual code examples (bonus: we're open source).

    Will also briefly touch and illustrate on topics like CQRS and DDD which supports our migration very well and helps model our data and domain language more accordingly to the business we're trying to model.

    A draft of the topics follow below:

    - Introduction to our stack
    - Frontend: React, Next.js, React Native, Apollo
    - Backend: Elixir, PostgreSQL, Absinthe, Phoenix
    - Data: Redshift, Metabase
    - Motivation to migrate
    - First clue: GraphQL and Command/Query segregation
    - Pain: Read/Write modelling incompatibilities
    - Fits nicely: Event-driven architecture (internally)
    - Aims to improve: Domain-modelling and communication with business
    - Hands-on
    - Migrating IDs → UUIDs
    - How to provide a "kickoff" migration step
    - Thinking about strong/eventual consistency
    - Modelling aggregates
    - From CRUD → Domain's ubiquitous language
    - Talking to the outside world: APIs and integrations

    Track 2 Have a SQL and Eat it Too!

    Experience report about using CockroachDB, and how it gives a familiar full-compatible SQL interface on top of a globally distributed database - something that til' some time is only found on NoSQL databases

  • Track 1 Building .NET software with focus on performance and scalability - a Warren Brasil study case

    This talk will explain the main technological challenges (along with their solutions) to build Warren's investment core with two main focuses - performance and scalability. The focus on these two concepts is particularly important because, being a financial institution, Warren has a variety of complex processes running recurrently for an exponentially growing base of customers.

    The talk will cover 4 main points:
    - The challenges, approaches and gains (losses, also) of migrating from Microsoft SQL Server to Amazon Aurora MySQL database
    - How to dose the use of Entity Framework, Dapper and DB procedures to create scalable and performant code
    - Why not to use IIS in our Web APIs
    - The main differences between the concept of performance in our processing core and the Web APIs

    The talk will use the .NET stack to bring all-technology concepts to the table, like the use of cloud databases, Object-Relational Mapping importance, RESTful API performance and how to create applications that perform the same for 100 or 1 million users.

    Track 2 Maintaining a big open source project: lessons learned

    About a year ago, I started to maintain Devise - one of the most popular Ruby Gems available. I had no knowledge of the code and a little experience with open source from a side project I developed myself.

    Obviously, this was a very challenging task and I made a lot of mistakes in the process. The good thing is I learned a lot too.

    In this talk, I will share with you some of the lessons I learned that I think can be valuable not only for open source but for our day-to-day work too.


  • Track 1 Kotlin: introduction to a modern language

    Kotlin is a very recent language that compiles to JVM and has gained great popularity, having become the Android official language, being the second most loved language by developers in the current StackOverflow Survey and becoming the main backend language for many companies. The more daring prophesize that she is the "successor" to Java. In this presentation, I will show some of the main features supported by Kotlin and explain why a Fintech, with absolutely nothing of the JVM in its stack, decided to migrate its backend services to this language.

    Track 2 Back to the Future - with TypeScript

    What are the future features provided for Typescript? What can I do today to assist in JavaScript development with Ts? What will be the future of the typescript?
    During this talk, I will tell you a bit about the history of TypeScript and its importance in using it in different frameworks. And what will be the roadmaps provided for our most beloved JavaScript transpiler by all!

  • Track 1 Collaborative koloring with Kotlin

    The best way to test limits is to challenge yourself. For this talk we wanted to test some limits by mixing the subjects we've been more excited about recently - Kotlin, games and architecture - challenging ourselves to create a collaborative game using Kotlin in the whole tech stack and being able to explain each design decision and approach and, of course, have fun. Let's add some color to Kotlin!

    Track 2 Data Science in Ruby? Is it possible? Is it Fast? Should we use it?

    In this talk we'll review the state of the tools for data science in Ruby!

    Python is the "crown jewel" of the data science languages today, but many of us work mostly with Ruby for the business applications, and it is important to use the best tool for each job.

    So we'll analyse gems and groups of gems available in Ruby for Data Science

    * their performance
    * features available
    * is ruby is being used for data science at all?
    * Should we use it? and when?
    * what are the alternatives?

    And after this talk you'll have enough information to choose the toolset to use for your next data science project, or event to "add some data science" to your existing project.

  • Track 1 Unleashing Kotlin on JVM backends with Ktor

    Kotlin is trending as a programming language on JVM (and beyond!) that focus on pragmatic syntax, awesome tooling, and developer happiness.

    In this talk, we'll learn more about Ktor, a web applications framework offered by Jetbrains - the company behind Kotlin language itself! - that is written 100% in Kotlin and supports all the handy features needed to develop great web applications and/or microservices while relying on Kotlin flavor of Coroutines for the ultimate performance.

    Track 2 GraalVM for Polyglots: Harder, Better, Faster, Stronger?

    GraalVM is an embeddable virtual machine that embraces dynamic, static, and native languages. Yes, it's a polyglot environment created for running all languages efficiently, from Java and Kotlin, to JavaScript, C, Ruby and so on.

    It is much faster than usual language setups, has lower runtime overhead. It can be run in databases with no overhead. Let's take a closer look for you to check by yourself if it is or not a good pick!


  • Track 1 Programming for entertainment: Music and its perpetual inertia

    One thing that caught my attention throughout the years were I adopted music and music production as a hobby, is the fact that their technologies are in a constant state of inertia, trying to recreate what was done in the past, and even more than that, pushing itself back into the analog era, all in the name of questionable higher fidelity and easily reproducible warmth and identity.
    This talk will not only analyse the current state of technology and programming in the world of music, compare it to the current states on different media, and also present a doorway into programming for musical production, using the JUCE framework, one of the most used frameworks for cross-platform audio applications, together with C++, as a mean of sparking curiosity and interest, to try and push it out of this meaningless inertia, as well as presenting the challenges and required skills involved in it.

    Track 2 The day I reverse engineered a Gameboy Advance game

    Gameboy Advance was one of the most popular video games platform of its time, and because of it, many people worked together as a community to study and to document its architecture, develop romhacking and others tools for the GBA - This community is still alive and working! This video game is a fantastic way to start studying reverse engineering, because it is an old console very well documented, it has a simpler architecture if compared to the current game console generation, and of course, it is very fun to work in a game-related project!

    So, what do you think of learning reverse engineering through this challenge: developing a level editor for a GBA game called "Klonoa: Empire of Dreams"?
    It is a very interesting challenge, because we need to understand the architecture of ARM hardware, apply reverse engineering in order to discover how the logic of the game works, and then use our knowledge to build a level editor, that will be developed using JS + React.

  • Track 1 Is There A Needle In The Haystack? Using Python To Narrow Down The Search For Life In Our Galaxy

    The Milky Way is a spiral galaxy, but what you might not know is that life in any planet - or moon, or basically anything - that crosses one of the Galaxy's arms is (probably) doomed.

    Looking for life in other planets is a herculean task, there are just too many of them. But what if we can look only into those that, like our solar system, swirls calmly around, never crossing the danger zone? That can make the task doable.

    Why are the arms dangerous? Why does our sun look safe? What does it have to do with code (hint: it has something to do with Python and galpy)? Well, come aboard and see it yourself.

    Track 2 Career Abroad - How the best Technologists are conquering the World

    Whether you have just started or you are already working in Tech for a couple of years, I’m pretty sure that you have asked yourself the following questions at some point:

    * How does a successful career in Tech look like? What are my career options?
    * How can I advance my career and take it to the next level?
    * How do I become valuable to my company? What separates the best performers from the average performers?
    * How can I prepare myself to the upcoming changes in our industry?
    * How can I market myself?
    * How do I pass on the interview process to the best companies?
    * How do I negotiate my salary?
    * How can I have more autonomy in my job? How can I work 100% remotely?
    * How can I get a job abroad?

    Back in 2009, I had the same questions, but I could not find the answer to most of them. There was not much out there in Portuguese back then. (Yes, I only got to learn English much later on.)

    Today, living and working in New York City for the past 5 years, I would like to share the tips that I wished I had received 10+ years ago when I was starting my career in Tubarão, Santa Catarina, Brazil.

    I'm currently writing a book that I plan to launch this year about Career Abroad in IT. For that, I'm interviewing a total of 50 Successful Technologists working on most important Tech Hubs around the world.

    This talk will be a summary of my experience and the main lessons that I learned from those 50 professionals.

    Topics: Career, Goals, Job Resumes & Interviewing, Soft Skills, Psychology, Personal Knowledge and Productivity, Mastering English as a Second Language.