Kotlin Cloud Scala Microspheres

hosted online
16.06.2020 / 5:30 pm - 8:30 pm (CEST)

Hear from our top-seniority experts in Kotlin Ecosystem, Cloud-Native Applications Development and Scala Dev Tooling in three parallel sessions.

5:30 pm - 6:00 pm
Networking

Kotlin Microsphere

6:00 pm - 6:45 pm
Building Kotlin DSL

In past years we can see an explosion of DSL usage, from different kinds of configurations to view definitions. Especially lately mobile world is shaken by Jetpack Compose and Swift UI, but DSLs are becoming more popular on the backend too. In this presentation we will learn how Kotlin DSLs work and how can we define our own statically typed DSLs in Kotlin. Step by step, through live coding.

6:45 pm - 7:30 pm
Type Proofs and Functional Programming for the Kotlin Type System

Type Proofs is a new compiler plugin built on Arrow Meta enabling new features in the Kotlin type system, such as Type Classes, Union Types, Type Refinements, and many other extensions that make Functional Programming easier in Kotlin.

Type Proofs propositions are expressed as extension functions that unlock new relationships between types ad-hoc whilst remaining fully compatible with subtype polymorphism and the existing inheritance type system.

This talk demonstrates some of the new features the Arrow team is introducing in Arrow at the type level and IDE and how others can benefit from them when building libraries and applications.

Cloud Microsphere

6:00 pm - 6:45 pm
Building a social network in under 4 weeks with Serverless and GraphQL
Serverless technologies drastically simplify the task of building modern, scalable APIs in the cloud, and GraphQL makes it easy for frontend teams to consume these APIs and to iterate quickly on your product idea. Together, they are a perfect combination for a product-focused, full-stack team to deliver customer values quickly.
In this talk, see how we built a new social network mobile app in under 4 weeks using Lambda, AppSync, DynamoDB and Algolia. How we approached CI/CD, testing, authentication and lessons we learnt along the way.
6:45 pm - 7:30 pm
Serverless 2.0 with Cloudstate.io

The Serverless experience is revolutionary and will grow to dominate the future of Cloud. Function-as-a-Service (FaaS) however—with its ephemeral, stateless, and short-lived functions—is only the first step. FaaS is great for processing-intensive, parallelizable workloads, moving data from A to B providing enrichment and transformation along the way. But it is quite limited and constrained in what use-cases it addresses well, which makes it very hard/inefficient to implement general-purpose application development and distributed systems protocols.

What’s needed is a next-generation Serverless platform and programming model for general-purpose application development in the new world of real-time data and event-driven systems. What is missing is ways to manage distributed state in a scalable and available fashion, support for long-lived virtual stateful services, ways to physically co-locate data and processing, and options for choosing the right data consistency model for the job.

This talk will discuss the challenges, requirements, and introduce you to our proposed solution: Cloudstate—an Open Source project building the next generation Stateful Serverless and leveraging state models such as Event Sourcing, CQRS, and CRDTs, running on Akka, gRPC, Knative, Kubernetes, and GraalVM, in a polyglot fashion with support for Go, JavaScript, Java, Swift, Scala, Python, Kotlin, and more.

Scala Microsphere

6:00 pm - 6:45 pm
Tooling for Scala 3 - Dotty support in Metals
6:45 pm - 7:30 pm
Mutatis Mutandis: Typesafe, transactional, indexed database queries in the cloud

Our data is moving into the cloud, and all the major cloud service providers now offer simple abstractions for dynamically-structured object databases.

However, having a network layer between application server and database, and the potential for mismatched code and data schemas poses the risk of runtime failures which may compromise the reliability of the software we write. Queries are typically invoked as strings, whose syntax, and the indexes they require, may not be checked until runtime.

Mutatus provides a mapping between Scala case classes and Google Cloud Datastore rows, which is as simple to use as calling .save() on an object. But then it goes further to ensure that queries may be specified using typesafe collection-like constructs and lambda predicates, and may only be run in an environment known to have the necessary indexes, determined on initialization. What this means for developers is that runtime errors when working with Cloud Datastore may become a thing of the past!
7:30 pm - 8:30 pm
Discussion Panel