Scala’s type system is a fundamental bedrock upon which the entire language rests. Advanced Type Mechanics is a comprehensive study into all aspects of the Scala Type System, treating it as a collection of tools to be utilized for solving common problems, with a focus on how each feature or quirk of the type system may be employed for practical benefit, particularly for API designers, helping us to create software which is correct and also intuitive. Advanced Type Mechanics combines theory with practical and compelling examples, designed to start small and demonstrate composition into larger examples.Course material will remain available to view for 30 days after the training session.
Moore's Law may be dead, but CPUs acquire more cores every year. If you want to minimize response latency in your application, you need to use every last core - without wasting resources that would destroy performance and throughput. Traditional locks grind threads to a halt and are prone to deadlocks, and although actors provide a saner alternative, they compose poorly and are at best weakly-typed.
In this presentation, created exclusively for Scalar Conf, John reveals a new alternative to the horrors of traditional concurrency, directly comparing it to other leading approaches in Scala. Witness the beauty, simplicity, and power of declarative concurrency, as you discover how functional programming is the most practical solution to solving the tough challenges of concurrency.
The way we talk about FP make it sounds hard and academic. It doesn't have to be this way!
Streams are often underestimated nowadays, but this is silly. In many cases, streams solutions are more readable, simple and faster than imperative counterparts.
So, I have only 10 minutes to present power and orthogonality of the FS2 library. See ya!
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. I have been focusing on one aspect of this - build tools - and will talk about challenges integrating tools with the IDE and how the Build Server Protocol makes it possible for IntelliJ to interface with any build tool.
Have you ever written some boilerplate code for handling your application’s communication with the outside world? You know, that JSON (de)serializer that once was nicely generated at compile-time but broke when you had to evolve your business model.
Of course you have!
But there may be a way to abstract away this repetitive, low-value code that sneaks into every project. Maybe it can also allow for our business classes to evolve without breaking compatibility, while keeping the necessary boilerplate to a minimum. Maybe it would even give us many other cool things for free, far beyond mere serialization concerns.
Let’s find out!
Yet another presentation about Event Sourcing? Yes and no. Event Sourcing is a really great concept. Some could say it’s a Holy Grail of the software architecture. I might agree with that, while remembering that everything comes with a price. This session is a summary of my experience with ES gathered while working on 3 different commercial products. Instead of theoretical aspects, I will focus on possible challenges with ES implementation based on Akka Persistence library. What could explode (very often with delayed ignition)? How and where to store events effectively? What are possible schema evolution solutions? How to achieve the highest level of scalability and live with eventual consistency? And many other interesting topics that you might face when experimenting with ES.
Aecor is a purely functional eventsourcing library, written in Scala. It provides composable building blocks to define eventsourced behaviors, deploy them into a cluster, run projections to get benefits of CQRS and so on. And you get all of that without compromising a single line of you purely functional code.
This talk is going to be a 30min crash course on how to build eventsourced applications with Aecor.
I would like to present a solution to keeping consistent state in microservices, which is more streamlined for event sourced architectures than the gold standard of Saga pattern. The solution brings some simplicity and other benefits.
Using Akka the "right way" is non-trivial. At its 10 years anniversary, I'd like to share my early pitfalls and misusage of this great toolkit and how you can master it to write fault-tolerant and elegant programs. Based on my bias opinion, you'll learn how to structure actors inside an application and when advanced cluster techniques such as Sharding, Persistence and Distributed Data should be used or not.
Typed Actors is a topic that thrills Scala community for a long time. There were several attempts (that I know of) to implement them but the last one seem to be the one that succeeds. Moreover - despite of status "May change" recently a course on Coursera was published. In my presentation I'm going to show how the API looks like and solutions to common problems.
Being arguably the most popular test framework for Scala, ScalaTest offers a lot of nice syntax for expressing assertions in your tests. However, a lot of people who are new to the library end up using just the basic matchers.
In this live coding session we’re going to walk through some of the less known parts of the matchers DSL and see how they can enhance the error messages in your failing tests, and make your assertions sound even more like English than before.
It’s a theoretical topic. I imagine the audience have just attended talks on issues specific to their jobs, and they plan to attend more of them, but now they look for something a bit different.
I will talk a bit about history of Cellular Automata, what can be practically done with them, and how can we code them in Scala. I will introduce the "engine", which runs CA code, and then go through two-three examples, showing how much of the code is always the same and all the difference in the outcome depends only on a few functions. There will be some visually pleasing (I hope) pictures and animations. And maybe I will be able to summon a bit of nostalgia for the times where we all wanted to program video games.
You can take a look at the project here: https://github.com/makingthematrix/ca_art
Have you heard about all of these breathtaking, purely functional, principled and blazingly fast libraries that handle purity and concurrency in Scala? Interested but lacking foundations and Google doesn’t help much? You’re in luck because that’s what this talk aims to address!
Using IO Monads for concurrency gains a lot of recognition in Scala. However, Functional Programming and JVM’s concurrency model can be challenging to learn and the learning resources are lacking. There are many terms like green threads, thread shifting, or fairness thrown around but what are these and why should we keep them in mind?
Let's dispel some of the magic, answer these questions and see how they relate to each other and Functional Programming.
2017 and 2018 were undoubtedly the years of Tagless Final and MTL in Scala. Continuing with the trend I will show you how to go a step further to truly leverage this kind of applications by introducing classy optics as an error handling technique, configuration passing and state management.
I’ll share as well some real-life experiences of using these techniques in production applications as we have been using it since September 2018.
At the end you will have an understanding of classy optics and how it can help you bring business value by solving problems elegantly.
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 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.
A microlibrary should do one thing and do it well. It's a recipe for composability. This talk will be a rapid-fire tour-de-force of eleven Propensive microlibraries, each given exactly two minutes to demonstrate its uniqueness and usefullness for everyday tasks. You will see new ways to: execute shell processes, work with CSV, calculate digests, use annotations, pattern match on strings, abstract over monads, work with lenses, interpolate strings safely, compose static async graphs, generate valid HTML and diff ADTs. Each one comes with a firm focus on typesafety, elegant syntax and a humorously magniloquent name.
cats is a very useful library, not only for those who go whole hog for functional programming. However, not all of its features and idioms are always obvious, especially those useful for day-to-day coding. In this presentation I will give several tips and show how to avoid some gotchas while - and thanks to - using cats.
Some people claim functional programming is useless because in the end there will be side effects - or else your program won't do anything useful. That's not true, and as it turns out purely functional programming is really good at solving some real-world problems, like concurrency.
I'll talk about how shared mutable state, queues, and streams can be used in purely functional programs, and why such a solution might be preferred over over the classical ways of managing concurrent state.
In the "4V" definition of Big Data, the 3rd V, Velocity, often refers to streaming, where even small chunks of data, arriving at a torrential rate, grow to huge amounts to be processed. That combined with machine learning techniques, gives us vast possibilities, such as interactive traffic predictions for large metropolitan areas, near real time market advice for personal banking clients on their phones or low-latency risk assessment for financial institutions. The presentation explain the possibilities of combining streaming with machine learning in the Spark ecosystem and techniques for optimal implementation of such combinations, together with useful engineering and mathematical techniques that will boost the performance of Streaming ML in Spark.
You have recently started working on Spark and your jobs are taking forever to finish ? This talk is for you! We have compiled many spark best practices, optimisation and tweaks that we have applied over the years in production to make our jobs faster and less resource consuming. In this talk we will learn about advanced spark tuning, data serialisation formats, storage formats, hardware tuning and GC tuning etc. We will also discover the appropriate usage of RDD, DataFrame and Dataset in order to take full advantage of spark internal optimisations.
Udash REST allows you to define REST endpoints with plain Scala traits, customized with annotations. On the surface this looks very similar to already well-established solutions from Java world, e.g. JAX-RS. However, we think that when redone in Scala most of its Java downsides can be avoided, primarily thanks to typeclasses and macro-based compile-time reflection instead of runtime reflection. The presentation will describe how Udash REST strives for type safety and seamless developer experience.
Java ++ or rather Scala – … kotlin is a popular language that you might sooner or later encounter.
Sadly it is missing some important features. On the other hand it has its own strong points and with libraries such as arrow-kt it is possible to overcome some of the limitations and write `almost scala` code.
A mathematician by training but a software engineer by vocation, John A. De Goes has been professionally writing software for more than 20 years. John has contributed to dozens of open source projects written in functional programming languages. In addition to speaking at Strata, OSCON, BigData TechCon, NEScala, and many other conferences, John also published a variety of books on programming. Currently, John consults at De Goes Consulting, a consultancy committed to solving hard business problems using the power of pure functional programming.
Maciek is a Scala and Android developer at Wire in Berlin. AI enthusiast, interested in practical applications of artificial neural networks, game theory, Scrum, riding bicycles around the world, and how to stay sane while pursuing a bunch of other interests. He advocates healthy minimalism and keeping one's code clean and simple.
Software Journeyman with over 8 years of experience in commercial software development. Conference speaker and open source contributor. Devotee of DDD, Event Sourcing and Polyglot Persistence. System performance bottlenecks validator. Continuously chasing the dream of a perfect software architecture, fulfilling all of the requirements and trends, even the strangest ones. Currently one of the Millers in SoftwareMill.
A rank and file programmer, who loves math and hates difficult things. After searching for inner peace and tranquility finally settled down with Scala. Codes, blogs and thinks how to make things easier for himself without making things harder for everyone else.
I became a coder when I got my first 8-bit computer - C64. It was a long journey for me, from a machine assembly code to the pure functional constructs. Right now, I'm passionate about designing pure architectures at reasonable costs. I'm a part of the team responsible for building the platform for implementing machine learning algorithms in Adform.
Markus is the Scala Lead at MOIA. The past 7 years ago his focus was to design and build real-world distributed systems based on Akka. He is co-organizing the Scala and Reactive Systems user group in Hamburg and shares his knowledge regularly at conferences. Markus is also the co-founder and former CTO of Y-Combinator funded startup.
Valentin has come a long way from C++ programming on little machines with 4 MB of unmanaged memory to big clusters with terabytes of RAM. Along the way, he progressively abandoned his old imperative habits to embrace the functional way - a journey that seems to never come to an end.
Jon has been having fun riding the bleeding edge of Scala for nearly fifteen years, and he's not finished yet. When he's not travelling the world attending Scala conferences, or organizing Scala World, he devotes his time to a variety of open-source Scala tools and libraries, and providing professional training services to the Scala industry.
Programmer always looking for newer, better, different solutions in different languages and fields - currently doing Scala @ Scalac. A purist when it comes to code readability and work/process automation.
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.
Frequent contributor to Open Source projects in Scala ecosystem who’s doing his best to make pure FP a little bit more approachable. One of the maintainers of Monix and Kraków Scala User Group co-organizers.
Passionate software engineer, open source contributor and co-organizer of the Scala Tokyo meetup. Currently leading a Scala dev team at Paidy Inc, Tokyo, Japan. Gabriel has been given FP talks for the last two years in both Scala and Haskell and has been very active in the open source community, sharing his knowledge as well as learning from the best developers out there.
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.
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.
I'm a Scala enthusiast interested in programming languages, type systems, metaprogramming and functional programming. I've been writing and teaching Scala for about 5 years, primarily at AVSystem in Cracow. During that time I wrote way too many macros.
Nitya Nand Yadav is a data engineer based in Paris and currently at NeoLynk. He has been working in the domain of Big Data since last few years and worked with different French companies as a software developer on Hadoop stack. He worked on several projects in different sectors as a data engineer and helped build software of production level from scratch. He is a Big Data enthusiast, he believes in learning, sharing and encouraging people to learn and adopt modern technologies.
Himanshu Arora is a passionate Senior Data Engineer from Paris working at NeoLynk. He has been using Scala, Reactive systems and Big data stack for a few years now in production to help enterprises accelerate digital transformation. He is a Lightbend certified expert on Scala, Play, Akka and FastData and Databricks certified Spark developer. He loves to be a reactive and FP advocate. He contributes time to time in open source community and participates in scala, FP and reactive conferences.
Head of Big Data Practice @ GFT. Specializes in Big Data projects involving Data Warehousing & Machine Learning. Personal motto: 'Data is always more valuable than you recognize it to be'.
Currently at SoftwareMill, Mikołaj is an alumni of the Vienna University of Technology's Computational Intelligence programme. As such, he feels at home to different language paradigms, and therefore enjoys the current technology boom in the JVM ecosystem. He strongly believes that taking lazy shortcuts backfires on a programmer sooner or later, and is committed to doing things 'the right way'.
I'm a passionate software engineer living in the JVM land - mainly, but not limited to. I also tend to play with electronics and hardware. When sharing my knowlegde, I always keep in mind that a working example is worth a thousand words.