You'll learn how to use Kotlin Coroutines and friends from the Kotlin Coroutines library to take advantage of really efficient and easy to read code. How to handle its lifecycle without being compromised to a specific external Android framework, which would enable your code to be prepared for more purposes than Android only apps.

This talk is about showing you some interesting alternatives and hopefully helps you with finding a good fit for your next project

Let's have a look at a real life borrowed REST endpoint, written in Kotlin (dahhh) using Spring, Ktor, Micronaut and Jooby. We'll compare the efforts, timings and developer experience and collect pros and cons for that next project planning.

From Wikipedia, Reactive Programming is 'a declarative programming paradigm concerned with data streams and the propagation of change.

The programming model is complex to master. It requires a lot of experience to feel comfortable with it. However, there’s no denying that it fits the cloud ecosystem perfectly. Since on-premises infrastructure is oversized, running a program that executes a couple of additional CPU cycles won’t change anything. On the other hand, you will pay for them if you host the same program on third-party infrastructure. Depending on the number of those cycles, and the number of nodes the program runs on, it can make a huge difference in your monthly bill.

In this talk, I’ll demo how you can migrate a traditional sample Spring Boot application written in Kotlin to coroutines one step at a time via a hands-on demo.

In this talk, I will share the discussion that led us to Kotlin Multiplatform, and the following processes we put in place to start using it in production for an Android, iOS, and backend project. I will show you what parts of the code you can (gradually) start to share and how to integrate with existing standalone projects.

How do you integrate with Android? What happens when you rotate your device? What about navigation or one-off events? How do you make the system type-safe? What about developer experience? If you’ve ever had similar questions come to our talk!

In this session you will get to understand what is Compose for Desktop, how does it work and how can you jump right into building for multiple platforms opening up the vast domains other than the mobile.

Let see how we can easily setup a Postgres database connection with Exposed, an ORM library for Kotlin and see how clean architecture can be a good choice for developping your brand new API.

We can even go further and see that we can actully share code from your backend application and your Android application (say hi to Swagger!).

Target audience: Software developers with couple years of experience using a programming language like Java, Kotlin or Scala.

Dmitry has been programming since DOS times. He spent the last 15 years or so in Java lands most recently working with server-side Kotlin.

Some tasks, like upgrading dependencies to the right versions, are still tedious and time consuming. There's also compatibility gotchas because of the lack of metadata.

This talk will start with a mention of the different problems that come with dependency management in real-world projects. Then it'll show how the developer tool refreshVersions (MIT licensed) tackles some of these issues in Gradle projects, saving a lot of time when upgrading dependencies.

Finally, I'll talk about what the future can be for dependency management, be it from new features in future Gradle versions, or tools or conventions that the community can create to improve the status quo.

The JVM platform is evolving, and Kotlin is keeping up with the new features as they become available. This includes the features introduced by the upcoming Project Valhalla and JVM support for sealed classes and records. In this talk, we’ll discuss how these changes affect Kotlin as a language, and how the Kotlin team finds a balance between drawing on the power of the new JVM versions, supporting the same functionality in older versions, and providing a smooth transition. We'll also talk about how you, the community, can influence the design and evolution of the language!

After that, to give you a wider perspective, we will talk about the different obstacles that you might meet on your KMM journey and what you can do to overcome them right now. Finally I'll give you an overview of the experiences of a variety of teams who already use KMM in their production apps. You can start applying their KMM best practices into your applications right away.

Again, no prior programming experience is necessary.

For this talk, a basic knowledge of Kotlin is preferred. After the session, Maryna will share a link to the repository with all the relevant code, so you can fork it and play with it on your own.

As an Android developer, I've always wanted to be able to do a full stack project, connecting my mobile apps with a server, and this is where Ktor came to the rescue. Documentation is there and also many disconnected examples, but when we want to get into business, we need a maintainable and clean architecture if we want to succeed.

We'll cover concepts like declarative programming + runtime optimization, integration of functional effects with Jetpack Compose, error handling strategies, data validation, concurrency, safe resource handling to avoid memory leaks, Streams, and much more.

At last, we will see how Compose can be adopted to our current projects and how soon we can be ready for production apps with Compose.

All the Java EE 8 specifications were transferred to Eclipse Foundation and Jakarta EE, MVC was once again left behind. We managed to release MVC 1.0 through the JCP and has since moved over to Jakarta EE as well and released Jakarta MVC 1.1 through the Jakarta EE Specification Process. And we don't stop there, these days, Jakarta MVC 2.0 is on its way out. Maybe it is time for a new slogan? "The Specification that Never Dies!"?

In this talk, I will take you through this journey and show all aspects of Jakarta MVC 2.0 in code. You don't want to miss this!

During this session we will use Kotlin to write a microservice with Quarkus to demonstrate its cloud-native power.

Wouldn't it be nice to get notified if you're accidentally breaking your users' code? A tool to inspect the binary API of your Kotlin/Java code can help you exactly with that. In this talk, we will see some of those tools and how that simplifies the life of library & SDK developers.

Wouldn't it be nice to get notified if you're accidentally breaking your users' code? A tool to inspect the binary API of your Kotlin/Java code can help you exactly with that. In this talk, we will see some of those tools and how that simplifies the life of library & SDK developers.

Kotlin Conf es la conferencia anual más importante de Jetbrains para dar a conocer todas las novedades del lenguaje, la última versión se llevó a cabo del 4 al 6 de Diciembre en Copenhagen.

Kotlin Conf Global es una serie de eventos organizados por la comunidad para ver y debatir las conferencias magistrales llevadas a cabo en el Kotlin Conf 2019.

Más información pronto.

We'll look at the differences. We've extended our open source code optimizer ProGuard and our protection software DexGuard to fully support Kotlin. We'll now share our experiences and point out what can be important in your apps and in your libraries. We'll demonstrate a new open source tool to view the Kotlin metadata hiding inside your apps. We'll show how to optimize and obfuscate Kotlin libraries in such a way that they remain compatible in other Kotlin projects.

Armed with this knowledge, you'll better understand your own Kotlin projects and you can tune them to create more compact and more secure software.

In this talk, you will learn about the reasons for the complexity of exception handling with Kotlin Coroutines and about all things you need to consider to appropriately deal with occurring exceptions. You will learn when you should use a conventional try-catch clause, and when you should install a CoroutineExceptionHandler instead. You will also learn about the special properties of top-level Coroutines when it comes to exception handling and how they differ when they are starting with launch and async. Furthermore, you will learn all about the exception handling peculiarities of the scoping functions coroutineScope{} and supervisorScope{} and why you should re-throw CancellationExceptions to avoid subtle errors.

This talk is for developers that are already familiar with the basics of Kotlin Coroutines but still struggle to understand how exception handling works in detail. By the end of this talk, you will have a better understanding of how exceptions are treated by the Coroutines machinery and how you can handle them appropriately.

Our Meetup at .droidconAmericas is a chance for you to ask questions. We're putting KMM in production every day so we have a lot to share. Maybe you're wondering where to start with KMM or what teams are putting KMM in production? Or maybe you want to dish on the upcoming changes to the Kotlin/Native memory model? It's all fair game, so join us!

Programming might not be magic, but it can definitely feel magical. But the more magic you need to scrape away, the harder it gets. Let’s face it, programming is hard. Once we’ve been doing it for a while, perhaps with a dash of Stockholm Syndrome, we forget how much pain growth we have gone through to get where we are.

So what might you know, but have forgotten that you ever learned it? In this talk, I will share my experiences of working on a software project as a freshly-minted software engineer. I will detail what I struggled with, where everyone around me just kind of “knew”. At the end of this talk, you will have a noob perspective on how fundamental some software fundamentals, or “knowns”, really are.

Kotlin, the productivity-focused language from our friends at JetBrains, takes up the slack to make the experience leaner, cleaner and even more pleasant!

The Spring and Kotlin teams have worked hard to make sure that Kotlin and Spring Boot are a first-class experience for all developers trying to get to production, faster and safer. Come for the Spring and stay for the Bootiful Kotlin.

Расскажу, как использовать мультиплатформу для науки и о науке создания мультиплатформных приложений за пределами сектора мобильной разработки. С примерами!

Kotlin multiplatform gives us a new solution. It focuses on sharing your business logic across all platforms, leaving the UI to be implemented natively. Since it’s Kotlin, you can take full advantage of its language features - concise, safe, etc. Moreover, if you’re coming from android you might already be familiarised with Kotlin and even if you’re an iOS developer you’ll see that it’s quite similar to Swift.

The panel will be moderated by Pablo Gonzales Alonso. The live-stream will be available on the Kotlin London Youtube channel (https://www.youtube.com/c/kotlinlondon/).

Let's explore how the coroutines implementation in the Kotlin language can make asynchronous programming much more programmer friendly. In particular, how it produces more readable and easier to maintain code. We'll compare it with RxJava and see how we can go back and forth between the two.

Kotlin er en russisk øy nær St. Petersburg innerst i Finskebukta, men også et populært programmeringsspråk på JVM-en.

Kotlin ble lansert i 2011 og er ifølge skaperne designet for å være en bedre versjon av Java.

I fjor fortalte Google at Kotlin nå var blitt deres foretrukne programmeringsspråk på Android. Her lokalt på Hamar utvikler større selskaper som Eika og Norsk Tipping integrasjonstjenester i språket.

Ønsker du å få en smakebit og er litt nysgjerrig på om Kotlin er noe for deg? Vi har 2 dyktige utviklere og foredragsholdere som gir en intro til Kotlin samt tips til gode biblioteker du burde ta i bruk.

I’ll talk through what it looks like to create such a library, drawing from my experience building and maintaining one of my own starting in the early days of Kotlin/Native. We'll talk about how to find shared abstractions around different platform APIs, how to handle the fast-paced evolution of this environment, and what this all felt like as a first-time library developer. When we're done, you’ll be ready to leverage the growing ecosystem as well as make your own contributions.

In this session, Rosário will talk about some of the features that are present in the KTX libraries and the features that you can implement yourself to get cleaner and more idiomatic Kotlin code.

You’ll learn how Sequences, Sealed Classes, Coroutines and Asynchronous Flow can provide you with a kotlin-first experience when working with Firebase’s Android Java SDK.

Here are some things we will cover:

- Intro to Kotlin - Create a new project - Funciones - Variables - Classes - Properties - Data Classes - Extension Functions

Key learning concepts: - How to create a new Android Studio project using Kotlin - The basics of the Kotlin language - How they compare with Java and how Kotlin will boost your productivity

Recommendations for attendees: - Basic knowledge of Android development using Java - 2 screens, to be able to see their own Android Studio and the streaming at the same time

Most Android developers are familiar with Kotlin and use it every day with great success (and joy!). But the bloodline of the language extends well beyond Android! From cross-platform development, to the desktop, to the web, to backends, Kotlin’s pedigree as a versatile language puts all us developers in a great position to leverage existing knowledge for a variety of tasks outside a mobile engineer’s comfort zone.

In this session we’ll use Kotlin, Ktor and coroutines to write a backend for our splendid fictional mobile app product: PushBeat. After learning the basics of a RESTful API, we’ll see what Ktor takes care of for us, what features may be helpful for our mobile projects, and how little we actually need to learn to be a productive backend engineer in no time!

This talk will touch lightly on the h264 and FLV formats, and cover the Android Camera2 APIs. We'll see how the Kotlin coroutines approach to structured concurrency makes it easy to create AV pipelines on Android with minimal object allocations.

You'll leave this session with an understanding on how to create your own fast, efficient, and robust video streaming experience.

In this talk, we’ll learn about how to write and test compiler plugins with Arrow Meta. This library provides an API for source transformations, automatic code refactoring, and much more. We’ll look at main use cases from type classes, comprehensions, and lenses that are made possible with Arrow Meta. We’ll also look at how to test each use case

Under the hood, Arrow Meta supplements the compiler by hooking into the various compilation phases. We’ll look at the architecture of Arrow Meta and how this works. We’ll also explore the potential Kotlin multiplatform support. By the end of this talk, you will have a tool that you could use to create plugins.

We'll look at the differences. We've extended our open source code optimizer ProGuard and our protection software DexGuard to fully support Kotlin. We'll now share our experiences and point out what can be important in your apps and in your libraries. We'll demonstrate our new open source tool to view the Kotlin metadata hiding inside your apps. We'll show how to optimize and obfuscate Kotlin libraries in such a way that they remain compatible in other Kotlin projects.

Armed with this knowledge, you'll better understand your own Kotlin projects and you can tune them to create more compact and more secure software.

In this session, we'll discuss the design of this mechanism from the inside out. And we'll explain why it's so important to keep the metadata secure.

In this talk, you will learn about the reasons for the complexity of exception handling with Kotlin Coroutines and about all things you need to consider to appropriately deal with occurring exceptions.

You will learn when you should use a conventional try-catch clause, and when you should install a CoroutineExceptionHandler instead.

You will also learn about the special properties of top-level Coroutines when it comes to exception handling and how they differ when they are starting with launch and async.Furthermore, you will learn all about the exception handling peculiarities of the scoping functions coroutineScope{} and supervisorScope{} and why you should re-throw CancellationExceptions to avoid subtle errors.

This talk is for developers that are already familiar with the basics of Kotlin Coroutines but still struggle to understand how exception handling works in detail. By the end of this talk, you will have a better understanding of how exceptions are treated by the Coroutines machinery and how you can handle them appropriately.

Let's see how we can use them to make our code looks way more elegant, by avoiding interface implementations in many places, reducing the amount of code and also take advantage of the Kotlin's smart-cast feature to have type safety and avoiding castings while doing that.

Being massive TypeScript fans, it would always be their language of choice when working on JavaScript platforms. They didn't feel the drive to switch to other languages that transpile to JS such as Fable (F#), Scala.js, or even KotlinJS, as they always saw Kotlin on the JVM as the solution to a problem, the problem being Java.

In this talk the dynamic duo will go out of their comfort zone and recreate a Breakout clone for the browser using KotlinJS.

They will make use of React, Redux and use React Three Fiber for WebGL graphics. Moreover, they will explore what this transition to KotlinJS is like for a TypeScript fanboy and try to answer some questions along the way.

You'll learn how coroutines simplify asynchronous workflows and concurrency. You'll also learn how interoperability with TypeScript allows you to leverage existing JS libraries in a strongly typed way.

By the end of the workshop you will have been exposed to some of the advanced features of Kotlin and be comfortable using Kotlin for JS platforms.

But the true story behind the success of Kotlin is developer convenience. Kotlin is designed to be as much like Java as possible where it makes sense, and as different from Java as possible where the design choices of Java get in the way.

Although that legacy seems officially denied, others may describe Kotlin as the best mix between Java and Ruby.

Erleben Sie hautnah den Spaß und die Faszination beim Erschaffen von etwas wirklich Außergewöhnlichem! Die kleinen Ideen, die einen nachts wachhalten, bis der erste, kleinste Proof of Concept zusammengehackt ist. Gemeinsam mit Sebastian Aigner erforschen Sie, wie Sie die mächtigen Features von Kotlin bei diesen Projekten nutzen. Dabei kommt eine bunte Mischung zum Einsatz aus Sprachfeatures, Libraries und Praxisbeispielen, die Ihnen vielleicht nicht jeden Tag begegnen.

Selbst wenn Sie gerade nicht an eigenen irrwitzigen Projekten arbeiten, werden Sie in dem Vortrag einige neue Herangehensweisen kennenlernen, um Ihre Aufgaben mit Kotlin zu lösen. Und zwar so, dass man sie nur noch schwer vergisst.

Am Ende des Vortrags kennen Sie die Vorzüge (und auch die Nachteile) von Koroutinen im Vergleich zu herkömmlichen Konzepten und können Koroutinen direkt in Ihren Kotlin-Projekten einsetzen.

Dieser Vortrag behandelt das nötige Wissen um Test Lifecycles, die Handhabung von Test Fixtures, die Herausforderungen beim Mocken, gute Assertion Libraries und die Mächtigkeit von Hilfsfunktionen und Data Classes. Anhand von Anekdoten aus der Praxis präsentiert Philipp Best Practices, mit denen wir Testcode schreiben, der idiomatisch, lesbar und kompakt ist und dabei sinnvolle Fehlermeldungen ausgibt.

Dieser Vortrag gibt einen Überblick über Gradle-Build-Skripte mit Groovy und der Kotlin DSL. Darüber hinaus zeigt er Schritt für Schritt die Migration eines bestehenden Android-Projekts von Groovy nach Kotlin. In dieser Migration werden wir uns die Vor- und Nachteile der Kotlin DSL genauer ansehen und die Eignung für reale Projekte diskutieren.

Serverless application design is becoming more and more prevalent. Now is the time to understand this powerful shift in backend development, simply.

Estas son algunas de las ventajas que tenemos al usar Kotlin para desarrollar aplicaciones móviles:

-Reduce las líneas de código necesarias para crear una app.

-Los valores por defecto no aceptan valores nulos.

-Todas las librerías y frameworks de Java son compatibles.

In this session, we'll take a look at the capabilities of Canvas API for Jetpack Compose and how can we implement Chrome's T-Rex Dino game. We'll discuss some challenges such as game loop, game state management, infinite parallax scrolling etc. By the end of this talk, you'll be more familiar with the concepts of Canvas in Jetpack Compose and how you can use it for games.

Pronto actualizaremos la información de las platicas.

Acompañanos en nuestro quinto meetup de forma virtual, en breve compartiremos los links del streaming.

All of the work involved with just keeping up-to-date was really limiting our progress into more exciting features.

Over a period of two years we’ve introduced multi-branch pipelines, built a GitOps flow, migrated to a monorepo, built an auto-scaling test environment and started using Kubernetes namespaces for our testing.

In this talk we will look at both the technical solutions and the lessons learned. What worked? What didn’t work? What was worth it? What would we have done differently if we knew better?

The talk is targeted towards software developers looking for ways to improve their workflow at the team level but the lessons learned should be relevant in a much broader sense.

Get ready for a dive into compiler structure focusing on practical extension without breaking the language rules. We will go through plugins released by the community and the current state of development for those who dare to create compiler plugins themselves. At last, you will see how the compiler plugins compare to annotation processing and understand pros and cons of each.​

Introducing Ktor and explaining it's architecture Showing how to create a simple API using Ktor Pointing out how it leverages Kotlin's strengths Can it contend with favourites like Java EE or Spring (Boot), and in which scenarios? Is it mature enough to be used in production? After this talk, you'll be equipped to answer those questions for yourself!

A focus on primarily aim Android developers who are interested in making sure their apps/games work well on the latest release of Android and want to avoid any breaking changes.

This presentation will give a quick overview of the features in the latest release: Android 11. It will also cover information about other important releases and products for Android developers, and how to find out more.

This talk also demonstrates how to write test cases for the rules. By the end of the talk, you will be able to understand how lint works and how you can add custom lint rules to your projects.

Given the breadth of the topic and a time limit, this session will only cover the most notable or impactful changes.

For instance, Java 9 introduced 150 new features: Java 9 changes focus on programmatic/syntactic changes for most part but will cover the new Java Module system JPMS, since it makes a huge impact for library developers.

Similar constraints apply for Java 10, 11, 12, 13 and 14. However, post-Java 9, the release cadence of 6 months has greatly reduced the number of features delivered making the content more viable to present a larger percentage of changes.

• We're enforcing a strict attendance limit in coordination with our venue's regulations. • The seats and tables are from the prescribed distance from one another. • Surgeon masks will be made available for every attendee on demand. • We'll be equipped with hand sanitisers. • Our venue is an inner garden with good ventilation. • We kindly ask our attendees to attend only if they weren't abroad or near exposed people in the past two weeks, and aren't experiencing symptoms themselves.

The technical contents of Jakarta EE 8 is mostly the same as Java EE 8 - it solidly enables HTTP/2, Server-Sent Events (SSE), JSON and aligns the platform with Java SE 8. It includes a much awaited security API overhaul as well as a slew of critical updates to APIs like JSF, JPA, JAX-RS and CDI. The true difference is how Jakarta EE is evolved in the open.

Retransmitiremos el webinar via youtube en directo y Tamara Gadea Morera se encargará de recopilar todas las dudas por el chat del vídeo. Al finalizar el evento contestaremos todas dudas que hayan ido surgiendo a lo largo del webinar.

Código compartido con Kotlin multiplataforma: Usemos kotlin para compartir código nativo entre Android y iOS. Un breve ejemplo de cómo configurar tu library nativa en función de no reescribir código de lógica que puede ser compartida y una demo donde podremos ver algunos pros y contras de esta tecnología. Discusión abierta para generar ideas.

In this talk, I will share with you how to build a gRPC server using the gRPC-Kotlin library. We’ll explore how to use protocol buffers to define different types of rpc calls that are unary and bidirectional. On the client side, we’ll also use this library to consume our gRPC service. gRPC-Kotlin provides an API that uses Flows to make rpc calls. We’ll explore how it works internally. For each rpc call we implement using coroutines, I’ll show you how to unit test it.

This talk is about how we solved these problems with the DDT approach and how you can apply this technique on your own backend application. A demonstration with live coding will show how to write them and use it to drive the development.

Сперва в докладе будет описано использование инструмента, затем его внутреннее устройство.

]]> ja 2019-08-24 2019-08-24 Tokyo, Japan Matsuda Jumpei K[日本語注釈つき] Deep Dive into Kotlin DSL https://speakerdeck.com/jmatsu/ri-ben-yu-zhu-shi-tuki-deep-dive-into-kotlin-dsl https://kotlin.connpass.com/event/129860/ ja 2019-08-24 2019-08-24 Tokyo, Japan Akira Aratani Kotlin Multiplatform Project入門/Introduction-Kotlin-MPP https://speakerdeck.com/aakira/introduction-kotlin-mpp https://kotlin.connpass.com/event/129860/ ja 2019-08-24 2019-08-24 Tokyo, Japan Toshihiro Yagi Kotlin コルーチンを 理解しよう https://speakerdeck.com/sys1yagi/kotlin-korutinwo-li-jie-siyou-2019-kotlinfest2019 https://kotlin.connpass.com/event/129860/ - コルーチンとはなにか、なにがうれしいのか - Kotlinにおけるコルーチンの仕組み - Kotlinコルーチンのきほん - コルーチンスコープと構造化された並行性 - コルーチンと設計 - コルーチンのテスト

]]> pl 2019-02-28 2019-02-28 Warsaw, Poland Krzysztof Romanowski The price we all pay. Does Kotlin slow down our code? https://www.meetup.com/Kotlin-Warsaw-by-Kt-Academy/events/258459508/ Kotlin, as well as other languages like Scala or Groovy is developed (echm, hacked, eckm) over JVM. We all enjoy features like extension methods or strict null management that does not have corresponding functionalities native to JVM. How does that affect performance?

Let’s run some benchmarks!

We'll also briefly talk about how we at JetBrains employ these Kotlin multiplatform features to prototype new ideas and realize products – from hackathon projects to JetBrains Space, our integrated team environment

This talk aims to explore the possibility of adding pattern matching to Kotlin. It will go through why and how it could be done, from adding it to the actual language to using a compiler plugin (much like kotlinx.serialization works).

In my talk, I would like to tell you how we decided to redesign and reimplement Dokka from scratch. I will introduce you to all the dangers and risks of pluggability and tell you how we mitigated them by design, grounded in strong guarantees. Finally, I want to show how easily and how much you can do with your old, boring documentation using new Dokka.

Raúl Raja is a Co-founder and CTO of 47 Degrees and one of the core maintainers of the Arrow open-source library. Over the last few years, Raul has been working closely with the Kotlin compiler and the Arrow library to help build a new type system and features for improving the ease of practicing Typed Functional Programming in Kotlin.

The Android developer community seems pretty excited by the possibilities. However, coming from the JVM, there are new things you must learn. One of the most important is Kotlin/Native’s state and concurrency model. While the Kotlin/Native state model is conceptually simple, it is also different, and will cause some confusion if you don’t learn the rules.

Then what is it, really? And why would Kotlin be any different than all those other failed multiplatform tools?

One short answer is: **Kotlin _works_ on multiple platforms, but is _not_ multiplatform.**

Sounds like another paradox? Then let us start from the beginning...

In this talk, we demonstrate how the http4k library leverages its “Server as a Function” roots to enable writing apps which can be test-driven at all levels of the Testing Pyramid, using a set of tools derived from decades of experience testing backend applications to make many of the above issues go away.

Message for you, so you can already be aware what you can expect from this session: Using existing Java game engines, you can create a game that runs on the JVM, in a browser or on Android and iOS. But it requires some complex tooling, when tools are available for the platform you're targeting.

This session is about the creation of a game engine that runs the same way in a browser, in a JVM, on iOS or Android.

Throughout this session, attendees will learn: - Basic matrix computation needed for 3D engine; - Basic game development concept: drawing shapes on screen, dealing with skeleton animations; - How to convert a pure Kotlin/JVM library into a Kotlin/Multiplaform library; - Example of use of Kotlinx.serialization to share game content between each platforms; - What didn't work while budding this kind of engine, like building a common API over heterogeneous game engine; or converting a java engine into a Kotlin one; - The challenges to build a game engine on the top of the Open GL API. (Open GL is a 3D API available almost everywhere: WebGL (browser), Open GL ES (Android / iOS - deprecated), Open GL (JVM / Native); - Issues encounter to build such engine on different platform: name forbidden in Kotlin/JS (val input -- package input conflict). Taking very seriously the naming and the abstraction on the common.

In this talk, we'll explore the benefits and challenges when it comes to targeting the JavaScript world with Kotlin. From standard libraries and simple DOM manipulation to building full React applications: guided by code and configuration examples, we will get an impression of the technology and its interoperability with an exciting ecosystem – including the freshest changes and additions for Kotlin 1.4 and going forward.

We'll also see how Kotlin libraries support development of Kotlin/JS applications, even beyond the browser – from concurrent applications with coroutines to painless communication supported by kotlinx.serialization. In the same context, we will also look at interesting and useful constructs we can create for Kotlin/JS in multiplatform projects.

Let us go on an adventure in my favorite ecosystem for Kotlin!

In this talk, we will investigate the tools and processes for building serverless applications using Kotlin. We will then deploy our application and look at some interesting ways we can consume our serverless apps.

Get ready to learn how serverless Kotlin makes it easier to create backends and other utilities for your applications.