Take part

A venue that's widely renowned as a platform for scientific innovation, and a group of enthusiastic developers, talented speakers, and programming language fans ready to take functional programming to a whole new level.

The most impressive tech event of the Summer is already turning heads this Winter, combining the Reactive Manifesto with the Scala programming language to ignite a brand-new concept.

Tickets

Talks

1 day — Basic ticket

  • 50€ Early-Bird Price
  • 75€ Regular Price
  • 250€ Last-Minute Price

Talks and Workshops

1 & 1/2 days - Advanced ticket

  • 75€ Early-Bird Price
  • 100€ Regular Price
  • 350€ Last-Minute Price
Buy Tickets arrow_forward
Due Date for Early Bird Tickets: May 6th

Speakers

Jon Pretty

Jon Pretty

Jon has been having fun riding the bleeding edge of Scala for over a decade, and he's not finished yet! When he isn't traveling the world attending Scala conferences or organizing Scala World, Jon spends his time working on a variety of open-source Scala tools and libraries like Fury and Magnolia as well as delivering his Scala One training courses.

The Sound and the Fury

Fury is an exciting new build tool and dependency manager for Scala with bold aspirations to revolutionize the way we define and distribute source builds. You will learn Fury’s radical—but simple—model, see its fast and beautiful UX, and start to believe Fury can be the future of building Scala!

Marcin Rzeźnicki

Marcin Rzeźnicki

I'm a Senior Software Engineer at Iterators, disguised under a self-proclaimed title of Scala Tiger (or Scala Kitten), sometimes also known as Scala Animal. I have been in this business for 10 years, mostly filled with immense displeasure of working in C#, Java or Ruby until I witnessed the advent of FP in the industry and regained the knowledge I'd lost leaving academia halls. Embracing Scala helped me to become a born-again programmer, type system theorist, and category theory hobbyist. I gave talks at the Krakow Scala User Group, Chamberconf, Scalapolis, Lambda Days, ScalaUA and ScalaWAW on subjects like Kleisli arrows, category theory, and Free monads. Here's what my coworkers wrote about me: "Don't let Marcin start talking about type systems... He's an expert using Scala to build the most composable and concise business logic for our partners", but I find it to be unfounded hype.

Idris for (im)practical Scala programmers

I will show how value-dependent types known from Idris can be used in Scala development by explaining how to express the idiomatic Idris code in Scala. The audience will be able to learn a bit about the former language and its unique approach to type-safety. Moreover, those who already have some Scala experience will see that VDT can be simulated in the latter to a great extent. Ultimately, I will try to elaborate on the question of whether or not various forms of dependent typing are useful for a contemporary programmer.

Fabio Tiriticco

Fabio Tiriticco

Fabio is a Software Engineer, conference speaker, and community leader based in Amsterdam. While building his own start-up, he fell in love with Akka, Scala, and Reactive systems. So much so that he founded the 2000-member strong Reactive Amsterdam meetup group. When he doesn't happen to be in front of a screen, he enjoys long-distance bike rides and fingerpicking his guitar.

Reactive from Code to Cloud - Akka and Kubernetes

A fully Cloud-Native system needs to rely on both infrastructure and application levels to deliver scalability and resilience. That which runs inside the containers is actually important! This talk shows how Akka is the perfect match to Kubernetes, allowing you to be cloud-native all the way - from your code to the cloud.

Ivan Topolnjak

Ivan Topolnjak

Ivan is a developer who's driven by boundless curiosity. He's interested in writing concise and expressive code with Scala, teaching, sharing knowledge, and having a good time while getting it all done. He's spent the last few years monitoring, troubleshooting, and learning from production systems. Ivan is a member of Kamon’s core development team and a co-founder of Kamon APM.

WORKSHOP - Instrumenting for Production Deployments with Kamon

In this workshop, we'll seek to establish a definitive understanding of the instrumentation APIs exposed by Kamon as well as gain knowledge on how to apply instrumentation to services before deploying to production. The workshop is split into two sections: learning and applying. During the learning section, we will walk through the common instrumentation needs in modern applications, starting with Context Propagation, then Metrics collection and finally, Distributed Tracing. After we get all of that amazing knowledge, we'll apply what we learned while instrumenting a few example applications built with Play Framework, HTTP4S, and Akka HTTP. Feel free to bring your own microservice - we'll help you get it ready for production! By the end of this workshop, you should be prepared to install Kamon's automatic instrumentation on any JVM service and be able to enrich the telemetry data with domain-specific indicators that will make your monitoring and debugging life much easier.

Justin Kaeser

Justin Kaeser

Justin believes in "Tools before Rules": automating the development toolchain to remove the friction of dealing with manual processes. He works on this goal as part of the IntelliJ Scala plugin team.

Integrating Developer Experiences - Build Server Protocol and beyond

IDEs - Integrated Development Environments - traditionally provide out of the box support for many of the tasks that go into making working software out of source code. But increasingly, developers expect to be able to use any one of a variety of special-purpose tools for each task. This shifts the focus of the IDE from "Integrated" to "Integrating" external tools into a coherent experience. Especially in the Scala ecosystem, we have an increasing number of build tools to choose from. I have been focusing on integrating sbt and other new tools with the IntelliJ Scala plugin and will talk about the challenges involved and how the Build Server Protocol makes it possible for IntelliJ to interface with any build tool.

Rui Batista

Rui Batista

Rui is a Scala Developer, functional programming advocate, and accessibility consultant by design.

FP and concurrency walk into a bar…

Functional programming is usually associated with immutable data structures, pure mathematical functions without side effects and no global state, or no state at all. Even though this makes sense to some extent, functional programs in the real world must deal with such mundane concerns as reading and writing to files and networks, processing user input, or managing concurrently shared mutable state among different processes. In this presentation, I want to argue that functional programming idioms and libraries not only make it possible to develop real-world systems that deal with the external world, asynchronous events, state, concurrency, parallelism, but also that Scala FP libraries such as cats-effect or ZIO allow for an easier development of these kinds of programs, usually hard to reason about.
Here's the talk's plan:

  • A quick review of the I/O monad, the functional and non-functional code; programs as immutable data structures
  • Synchronous and asynchronous effects; unification in terms of API usage
  • Concurrent execution: fibbers, fork, join, parallelism
  • Execution Contexts, blocking operations, shifting
  • Mutable refs, get, set, modify, concurrent access and semantics, atomicity
  • Promises, read and write
  • Well-known concurrency structures: queues, semaphores, etc.
  • Easy software transactional memory (STM)
  • Safe resource handling (try/catch/finally), safe interruption/cancelation of running code
  • Aliaksandra Sankova and Felipe Sotille

    Aliaksandra Sankova and Felipe Sotille

    Mycujoo is a platform that allows for the legal streaming of football videos. Since our development teams are located in different countries, we opted for a microservices architecture and Kafka in order to let our teams work independently. Aliaksandra and Felipe are Software Engineers at mycujoo Lisbon. They work on the community's product and on the improvement of the players’ experience.

    Nanoservices is not an antipattern! Vert.x, Java and Scala at mycujoo

    Eclipse Vert.x is a polyglot event-driven application framework that runs on the Java Virtual Machine. It has been called the Node.js for JVM applications. Here, at mycujoo, microservices were built with Java and Vert.x. We decided to move to Scala but - instead of classical Akka - we opted to preserve Vert.x in order to migrate our codebase at the slowest pace possible with the least amount of effort and disruption. While changing small pieces of code once at a time and writing something that we call “nanoservices”, we would like to share our vision with the community.

    Wojtek Pituła

    Wojtek Pituła

    Wojtek Pituła is a Scala developer and an open-source contributor. He's currently hoping to earn the title of the laziest person in the world (for a very peculiar definition of lazy.)

    Pragmatic object-oriented tagless final. Purity, abstraction and referential transparency with class(es).

    Tagless final was born in Haskell but this doesn’t mean it’s the only way. Let’s see how we can encode the general idea in Scala, where we can use inheritance, classes, abstract type members and even reflection to get more out of it, always focused on providing real business value!

    Jakub Kozłowski

    Jakub Kozłowski

    Jakub is a young Scala hAkker who spends his days writing code, running and lifting in the late evenings. In his free time, if he has any, Jakub explores his other interests, which include coffee, playing bass, and watching outstanding TV series.

    Flawless testing for the functional folks

    The year is 2019 and there have never been more people writing functional Scala. We've grown tired of frameworks, magic (reflection) and omnipotent testing libraries with hundreds of testing styles.
    I want to fight back against tests that stop on the first failed assertion. Against `beforeAll` and `afterEach`.
    I want to seek vengeance for unexpected, globally configured test parallelism and flaky tests.
    I want to rethink how we test pure and effective functional code and show another approach to doing it in Scala.
    In this talk, I will share what I've learned trying to make that approach become a reality. We'll talk about the characteristics of test frameworks, functional API design and making trade-offs.

    Mikołaj Koziarkiewicz

    Mikołaj Koziarkiewicz

    Currently at SoftwareMill, Mikołaj is an alumni of the Vienna University of Technology's Computational Intelligence programme. As such, he feels at home with different language paradigms, and therefore enjoys the current technology boom in the JVM ecosystem. He believes that taking lazy shortcuts backfires on a programmer sooner or later, and is committed to doing things 'the right way'.

    Cats for everyone!

    Cats is a very useful library for those who go whole hog for functional programming - but not exclusively. However, not all of its features and idioms are always obvious, especially those which are useful for day-to-day coding. In this presentation, I will give several tips and show you how you can avoid some gotchas while - and thanks to - using cats.

    Vincent de Haan

    Vincent de Haan

    Vincent de Haan was trained as a lawyer and a mathematician before switching to software development. Using the skills he acquired, he can take advantage of a business perspective as well as a deep understanding of the theory of programming. At the moment, he works at Cleverbase, a trust service provider, building high-security software for identity management.

    Befriend the compiler and enhance GDPR compliance

    For most developers, the compiler is just a black box that compiles the code. Getting to look inside this box might be complicated and even scary. In this talk, I will show how we can use a compiler plugin to achieve a specific business goal: enhance GDPR compliance. Even so, this plugin is only an example. Indeed, I will show that anyone with a fair understanding of Scala can make use of compiler internals such as plugins and macros to accomplish business goals or debug more effectively. Furthermore, I will explain how to achieve all of this without needing to have a thorough understanding of the compiler's inner workings.

    Alexey Novakov

    Alexey Novakov

    Alexey Novakov is an experienced Scala and Java Developer. He's been working at product-based and IT-consultancy companies for more than 10 years. He's taught Java through online courses for several years. More recently, he discovered the realm of Functional Programming and fell in love!

    Building Scala Microservices

    Workshop program
    Attendee level: beginner, intermediate
    We're going to have fun while building a Scala microservice. It will be based on a mix of mature libraries from Lightbend, Typelevel and other great Scala community members.
    Our focus is to go through the end-to-end development process of building a Scala application using a set of community libraries for the following tasks:

  • HTTP Server
  • Logging
  • CRUD operations using JDBC
  • JSON encoding/decoding
  • Application configuration
  • Build tool plugins to get runnable artefact and Docker image
  • E2E Tests
  • Functional approach
  • Dependency Injection

  • This workshop will require you to implement the CRUD service in Scala based on the provided SBT project template. During the implementation, you will be guided with code examples and documentation to successfully build the app. The workshop will consist of a short presentation and several exercises which are based on the microservice requirements we'll need to cover.
    At the end of the workshop, we'll understand how the current Scala ecosystem gets to provide an array of mature libraries and tooling to create a highly-maintainable backend application.

    Jarek Ratajski

    Jarek Ratajski

    Jarek Ratajski fell in love with programming while writing his first line of code on the C64 in Basic. In the 1990s, he decided to switch from C++ to Java, and spent 18 years developing Java software while working at different companies. Today, he works for Engenius in Switzerland. He's a Java/Kotlin developer by day and a Scala/Haskell open source hacker by night!

    (Dys)functional DDD

    Domain Driven Design patterns are commonly used in business applications. There is, however, a visible mismatch when we look at them from a functional programming perspective. Some concepts seem to fit perfectly - it's the case of event sourcing. Some others seem to be built around mutability or side effects such as aggregates or commands in CQRS. Some are just hard to grasp like domain events or integration events.
    In this talk, we will try to revisit the core concepts of DDD from a functional perspective and build a simple system using a more functional approach.

    Krzysztof Otrębski

    Krzysztof Otrębski

    Krzysztof is a software developer with 10 years of professional experience. Having spent many years on Java programming and problem-solving, he has developed useful tools that make a programmer’s life easier. He is also a founder of a few open-source projects.

    State vs Stateful Actors

    During this talk, I will show you how we can move the logic from actors into a monad state. We will see the benefits of the logic implemented in a composable, side-effect-free way. The talk is based on a project that keeps all of the business logic inside actors. Our goal is to refactor actors into a monad state. The changes will make the application more testable and comprehensible.

    Hugo Sousa

    Hugo Sousa

    Hugo Sousa is a Software Developer with experience in multiple Scala code-bases and a regular speaker at local meetups. He loves pushing the boundaries of how to write great production code and tests, which is why he loves Functional Programming and Scala!

    Full Referential Transparency

    Everyone complains that maintaining legacy code is hard. The plain rewriting of systems does not help in the long run if there are no lessons learned. If today's code is tomorrow's legacy in the exact same way as it happens today, then maintainability has not progressed. Referential transparency can improve the hurdles of debugging, refactoring and maintaining codebases. In this presentation, we will explore the concept as well as how to lift it into a data structure - the IO monad - so that your code composes in a way that helps you write more expressive programs.

    Sponsors

    Jon Pretty
    Jon Pretty
    Jon Pretty
    Jon Pretty
    Jon Pretty
    Jon Pretty
    Jon Pretty
    Jon Pretty

    Sponsorship Packs

    BRONZE

    1000€

    • Logo and goodies inside the welcome bag
    • Landing page on the website
    • Social media recognition
    • Recognition on the event's video
    • 2 tickets + 2 tickets with group pricing

    SILVER

    1500€

    • Logo and goodies inside the welcome bag
    • Landing page on the website
    • Social media recognition
    • Recognition on the event's video
    • 4 tickets + 4 tickets with group pricing
    • Recognition at the opening
    • Logo inside the venue
    • Roll up next to the talks

    GOLD

    2500€

    • Logo and goodies inside the welcome bag
    • Landing page on the website
    • Social media recognition
    • Recognition on the event's video
    • 6 tickets + 6 tickets with group pricing
    • Recognition at the opening
    • Logo inside the venue
    • Roll up next to the talks
    • Appreciation in the newsletters
    • Booth
    • Greetings post on the website and closing party
    • Media recognition

    Venues

    Talks

    Academia das Ciências

    Workshops

    Connect Enterprises