Same as last year, there's a small registration fee to cover some of the organizational costs. In return, we'll deliver the best Scalar so far! You can also register on Evenea's site.
Applied Functional Programming in Scala is an intensive, two-day workshop that teaches attendees to effectively use functional programming in Scala to build high-performance, correct-by-construction software that's easier to reason about, easier to test, easier to compose, and easier to change safely. Taught by John A. De Goes, a CTO whose company is built on functional programming in Scala, attendees will gain mastery of practical techniques in functional programming. If you are struggling with effectively using functional programming in Scala to solve real world problems, then this is the workshop for you.
Adoption of the Scala programming language has grown tremendously in recent years, partially because of the number and quality of libraries written in Scala (including Spark, Akka, Play, Shapeless, scodec, and many others). Yet, the language is broad and complex, containing many features not present in many other common programming languages (implicits, higher-kinded types, declaration-site variance, type lambdas). Most problems have many different and completely incompatible solutions, and the best choice is not obvious. Although the majority of Scala developers know the basics of the programming language, they struggle to translate simple examples of functional programming (like pattern matching and collection processing) into the large-scale code bases and real world problems they work on every day. This course is designed to help Scala developers tackle the most complex problems in the largest code bases using the tremendous real world power of functional programming.
After attending this workshop, attendees will understand how to scale functional programming techniques to real-world problems, including complex state management, input/output, concurrency, resource management, and much more. Attendees will develop a newfound appreciation for how to write simpler code that is correct-by-construction, using techniques in functional programming and the strong type system of the Scala programming language. Companies whose Scala teams are struggling to feel comfortable with the complex language, or who have yet to attain the mastery required to reduce defects and increase productivity, are encouraged to send their developers to this workshop. Functional programming in Scala can be a tremendous competitive advantage for developers who have been properly trained.
What is the required Scala level?
You should be familiar with pattern matching and recursion, but no knowledge above them is required.
An intense training introducing patterns for processing recursive data. We meet such data as JSON/XML objects or various kinds of trees. Recursion schemes focus on a functional approach, allowing us to do recursion in a very elegant and compositional way. This workshop will be based on the Scalaz and Matryoshka libraries. We will start with the basics (fixed-point datatypes), then we will cover basic processing with catamorphisms. Our next step will be some exploration of other kinds of useful morphisms, like paramorphisms, zygomorphisms, and a bunch of other transformations. Finally, we'll try to combine various morphisms together to understand the advantage of their composability.
Requirements: intermediate experience with functional programming in Scala (higher-order functions, algebraic data types, higher-kinded types, functors, applicatives). Nice to have: knowledge of free monads.
Cats library has finally reached stable release. It's a good opportunity to learn how to build a purely functional application using Typelevel stack. The goal of this workshop is to build small REST backend application using Typelevel libraries.
This will be a mix of lecture, exercise and workshop.
* to benefit from this workshop it's advised to have about a year's experience in Scala (or equivalent language)
* be familiar with Scala syntax
* laptop with favourite editor and sbt (preferred 1.0.x version)
* Understand benefits of building purely functional application
* Learn the basic type classes (Functor, Monad, Applicative) and its practical application
* Learn how to use libraries: cats, http4s, circe, monocle
* Have fun
This will not be an introduction to Scala. The workshop will take between 6 and 8 hours.
Akka Streams is a well-known Reactive Streams implementation that helps you build asynchronous, data-intensive applications with no predetermined data volumes. But how would you leverage its full power to design complex, Akka-backed reactive pipelines? At HomeAway.com we devised an approach to tackle this problem, combining elements of Domain-Driven Design with the abstraction power of the Akka Streams model. In this talk we'll present our approach by example, discussing useful patterns to (1) reason about your streaming application and identify its building blocks; (2) type-drive the implementation; (3) handle failure and (4) instrument your application for logging and monitoring purposes
Akka Streams is a versatile framework for creating reactive systems. Does it handle supporting an unusual use case of an arcade video game? In this presentation, I will show how such a game may be implemented, and how this kind of stack holds up in terms of scalability and development effort.
Most importantly, I will highlight potentials pitfalls when using Akka Streams in low-latency, erratic-input applications.
Welcome to the world as seen by a cluster node! This is a world full of changes in link quality, network partitions and outages. In this talk you will learn about failure detectors, gossip protocols and split brain resolvers in the context of Akka Cluster.
Get some theoretical and practical overview of the TDD approach & Functional Programming by creating the multiplayer Pac-Man game server:
* Test Driven Development (baby steps, starting with the game logic and moving towards HTTP).
* Purely functional approach (separated data and behaviors, no exceptions, ADTs, Options).
* Modeling using immutable structures.
* Making impossible states impossible.
* Using function composition.
* Using Monix Atomic to handle state.
* Separate concerns by using functions as input parameters.
In this presentation, John A. De Goes looks at several concurrency and scalability problems similar to the ones all programmers have to face, and shows how purely functional solutions written using Scalaz 8 are shorter, faster, easier to test, and easier to understand than competing solutions written using Akka actors. Discover how functional programming can be your secret superpower when it comes to quickly building bullet-proof business applications!
You probably have heard the pun that serverless is just running software on another person's computer. In this talk we would like to show something else - "real serverless" which is running software without any servers in a fully distributed, peer-to-peer manner. The software stack for this example will consist of Scala, Akka's CRDTs and the Inter Planetary File System (ipfs).
During the workshop I will explain the basic philosophy behind Spark ML and how it fits inside the larger Spark ecosysystem. The participants will learn how to perform single machine learning tasks, productionize and train simple ML models, as well as compose, train and cross-validate more complex Spark ML Pipelines. We will also go through the specifics of some of the useful out-of-the-box Spark ML components.
Spire is a great toolkit of mathematical abstractions and algorithms. Despite mathematical "focus", many instruments in Spire are defined in an abstract, composable way. This allows to leverage the power of spire for tasks, that don't look like mathematical at first glance.
In this talk we'll explore how Spire can help with solving various time resource allocation problems.
How many times have you reimplemented exactly the same http endpoints in server, client and documentation? How often have you struggled with implementation details of your http library? It doesn't matter if it's Play, akka-http or http4s, in most cases it's the business logic that creates a real value.
Let me introduce you to the endpoints, library that tries very hard to solve this problem for you and to object algebras, implementation of the interpreter pattern for those of us who always felt that tagless final and free monads are not so great.
Case class is a most widely used way to model your data. But when the data is huge, you can amazingly discover that only a tiny 10% of your precious RAM used for the data itself. But where is other 90%?
During this talk, you will have a deep dive to the JVM internals learning about case class layout, Scala collections true memory overhead and ways to decrease it. We'll introduce a scala-packed, the project helped Findify to solve a real-life case of reducing memory usage by an order of magnitude by extending Scala collections with transparent Shapeless-based case class <-> Array[Byte] packing.
Recently there is a trend in Scala libraries abstracting over the effect container in which they wrap their computations, allowing users to choose the effect that makes sense for their program.
I'll talk you through how I added this feature to the ScalaCache library, and explain how you can do the same for your own code and why it's a good idea.
One of the most important aspects of programming is iterating or traversing all sorts of collections. The Traversable type class is without a doubt one of the most useful gems of functional programming and, because of its vast versatility, also often the answer to "How do I..."-questions, but how many different kinds of traversals are there?
This talks aims to showcase some of the lesser known facts of traversable functors and also a bunch of other related type classes and functions that exploit different properties of our data types. We'll see some more obscure things like requiring the commutative property to traverse unordered containers like Spark RDDs, or more straightforward ones like running a bunch of asynchronous actions in parallel, waiting for the results and accumulating errors along the way in a simple one-liner.
PW-Sat2 is the project held by Warsaw University of Technology in Students' Space Association at Faculty of Power and Aeronautical Engineering. The project had started in Q1 2013, one year after the launch of the first Polish satellite PW-Sat. As a continuation of the space debris mitigation subject, the second satellite main payload is a deorbit sail fully designed and developed by students. Several additional payloads and been proposed and chosen as a secondary mission goals.
The primary PW-Sat2 mission is to test our two innovative engineering solutions: a deorbitation system and a sun sensor device.
SoftwareMill's engineers bring to the table the software project for radioamateur community to support communication for PW-Sat2
Maybe You want to use tools like Gulp, LessCSS, Sass, NPM and framework like Angular and React ,but for sure with something safer than JS?
You no longer have to sacrifice Yourself and fight with stupid errors for days.
You may use a decent language with typesafety and still use all the power of web developent.
Finally I will compare it to other simillar solutions like TypeScript, Elm, PureScript and discuss when and why could You use any of theese.
ScalaFiddle is a popular playground for experimenting with and sharing Scala code online. It has a lot of use cases that go beyond the basic ones, including building interactive fiddles, integrating fiddles into documentation and utilizing HTML for visual output. This talk covers these different uses of ScalaFiddle and how they can enhance your productivity.
Blockchain! Blockchain! Blockchain!
If you are a geek or startup entrepreneur you probably hear word "blockchain" very often. It is a revolutionary technology that allows you to build fully distributed systems without any central authority.
Today I want to help You to participate in this revolution. During this talk I will present basic technology concepts and I will show You "how to create your own blockchain" in Scala.
In this presentation I will show how we combine declarative and functional programming.
Many of our retail-apps run on LogicBlox (application framework) and are written in the pure-declarative language LogiQL (implementation of first-order logic, superset of Prolog/Datalog). Both of these technologies are developed at Infor/Predictix.
What is interesting is that some time ago we started to... generate the declarative code.
The next part of the speech will be about the structure of code generators written in Scala (language, grammar, AST, parsers, etc...)
The aim of this workshop is to get familiar with Akka Management Service Discovery using Kubernetes API, We will create a stateful distributed service with persistent entities via sharding in persistence mode.
Many of us have seen how a List in Scala - a value representing a list of different values - can be lifted to the type-level to become an HList, that is, a type representing a list of different types.
But can we lift other data structures like Set and Map to the type-level, and perform useful operations on them? Can we do so while maintaining their performance characteristics at compile time?
The answer is "yes"!
In this talk Dave will describe the design, motivation, and implementation of Atlas, a scripting language written in Scala. He'll discuss the use of functional techniques to implement some interesting details including parsing, sandboxing, monitoring, and interaction with the host environment. It'll be a chance to look at Scala for an interesting and slightly out-of-the-ordinary application.
All that power will go to their heads, though. The code will need to be sandboxed and monitored so scripts can't consume too many resources. And it'll need to talk to the database so it'll have to be asynchronous and non-blocking. We can't expose any of that complexity to the user, though, so we'll need to take care of unwanted effects in the interpreter. And don't even get me started on endorsing an imperative scripting language in our beautiful Scala codebase.
We will build a rich interactive website with Play and Scala.js.
If you ask a Scala / Big Data developer about the two major frameworks / toolkits written in and for the language, the answer will likely be: Akka and Spark. From the perspective of data-driven applications and systems, both are productive tools, whose possibilities (batch jobs, streaming, data ingestion) can sometimes overlap. So how to incorporate Spark and Akka in one Big Data system and delineate between them to make the most of them both? The author will attempt to answer that question, based on his experience with designing and developing such systems, going through frequent concerns, such as: data ingestion, complex transformations, constructing machine learning pipelines and exposing transformed data.
Stream processing is a hot topic today and it's easy to get lost among all the possibilities. In this live coding session we will explore the Reactive Streams approach used by the Monix project - one of the Scala implementations of the Reactive Streams concepts. On an almost real-life example we're going to walk through both the basics and some more advanced usages of the library.
Trendy and new language features are often tempting and attractive. Sometimes, they are also dangerous, but it may not be obvious from the beginning. For example, what may be possibly wrong with Scala List? When does your really smart Scala code become unreadable to others or just inefficient? What are the language gotchas? What may go wrong as the project grows? The presentation will focus on such questions in order to help developers avoid certain Scala pitfalls.
At Ocado we need to orchestrate tens of micro-services. In my team we have been using Scala stack for the past few years to successfully deliver quality products to our customers. I would like to bring some lessons we have learnt when building one of the biggest e-commerce systems. The lessons include some known patterns and principles applied to service communication such as timeouts, retries, circuit-breakers, speculative tasks. I will present the caveats of services communication along with the methods of detecting the issues and Scala tools we used to address them including AWS Beanstalk, Akka, Monix, Sttp and more.
UX Forms lets customers deploy custom code on the fly. During this talk I will show how we created our microservices platform in Scala (based on Docker & Kubernetes), that is also asynchronous, testable and secure.
When validating data with Spark, or read/writing it to Kafka topics, the go-to solution is to write a Scala case class or a Java Bean. But what if you had only 5 developers, 10000+ data structures and only a few months to ship your project? Let me show you how the power of hylomorphisms combined with expressive schemas allowed us to write the code that validates and transforms data from dozens of tables from a hundred of data sources, and ship our project in time and on budget.
"Those who cannot remember the past are condemned to repeat it." Our industry is only 70 years old and we've already managed to repeat history few times. Curry and Howard think they've found a way to workaround this issue, but Russel and Whitehead said they tried that already and Godel spoiled all the fun. Dr. Kunth however bet $3,372,548 on that idea, so who knows?
John A. De Goes has been functional programming for more than seven years at multiple companies, and has assembled world-renowned Scala and PureScript engineering teams, trained new developers in Scala and PureScript, and developed several successful open source FP projects. Known for his ability to take very complex concepts and explain them simply, John has taught numerous workshops and classes, including several highly-regarded workshops on Scala and PureScript. John moonlights as an instructor for LambdaConf, but his primary job is Chief Technology Officer of SlamData, an open source software company using pure functional programming to redefine analytics for modern data.
Software engineer, OSS contributor and conference speaker. Working on various projects for SoftwareMill using Scala since over 5 years, Krzysiek never stops exploring new avenues of reactive and functional programming. Passionate about principled design. To get some rest from software, Krzysiek enjoys reading philosophy and science fiction, as well as bouldering.
Marcin is an enthusiastic functional programmer from Wrocław. Working as a Data Engineer at Ryanair. His recent interest is a mix of machine learning and functional programming.
Inna is currently a PhD candidate at Warsaw University of Technology (WUT), and has since 2013 been the project manager of the student satellite project PW-Sat2. She graduated with a master's degree from the Faculty of Power and Aeronautical Engineering at WUT where she specialized in space systems engineering. She has been an active member of Students' Space Association for more than 11 years. Since 2016 she has been the Business Development Manager at Future Processing and lately she became a system engineer at FP Space.
Programmer, father and occasional blogger. SoftwareMill's contractor for over 6 years, day to day developing applications for financial institutions and doing some machine learning fun on the side.
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 over a decade, and he's not finished yet. While he's not travelling the world attending Scala conferences, or organizing Scala World, Jon spends his time working on a variety of open-source Scala libraries, and providing professional Scala training services.
Roman Grebennikov is a passionate software developer from Russia with hands-on experience in software development, JVM, high performance computation and algorithmic research. During last years he has focused on delivery of functional programming
Stefano is a Staff Software Engineer working for HomeAway in London, UK. He has been developing large scale backend systems within the cozy boundaries of the JVM for a few years, and he has recently become passionate about the Scala ecosystem - especially all things Akka. He has contributed to Akka, Akka HTTP and Alpakka codebases. In 2017 he delivered talks at Reactive Summit, Scala.IO and Codemotion Madrid.
Maciej Przewoźnik is a Senior Software Engineer at 9LivesData, working with NEC Laboratories America researchers to bring innovative Machine Learning/Big Data algorithms to the global market. Previously, he worked on an enterprise NEC's HYDRAstor. In total, he has a decade of professional experience in development, testing and troubleshooting complex applications.
Software Engineer at Actyx by day, sporadic Akka and Dotty projects contributor by night. Interested in how software works on low level, he does not find big frameworks appealing. This is the main reason why he loves Scala, a very expressive language that allows one to build right abstractions quickly without losing control over details. Jan is an active member of JUG Łódź and occasional conference speaker. In his spare time he loves to dust-off some old issue of computer science journal only to find out that everything has already been invented before he even was born.
Luka Jacobowitz is a functional programmer from Germany in love with finding great abstractions to engineering problems. He's also a maintainer of several typelevel projects, including Cats and OutWatch and seeks to make learning of pure functional programming as easy as possible.
Manuel is a passionate software engineer, author, speaker, consultant and community leader. Since 2008, he has guided and trained enterprise teams on the transformation to distributed computing, focused primarily on production systems built with Scala, Akka, and Play Framework. When he isn't writing books on computing from his home in Vienna, you can find Manuel at various conferences and meet ups around the globe, where he will be happy to discuss his experiences over a good cup of coffee or a glass of Pinot Noir.
I'm a technical team leader at Ocado Technology working with the team of great devlopers. We are working on the next generation e-commerce platform for Ocado Group using Scala. I've been a contributor to Open Source projects such as Reactive Neo, Phantom DSL. I have been working with students research groups at Technical University in Wroclaw presenting various topics. I was a presenter at Scalapolis and Code Forward.
I'm a software developer focused on solving problems, mostly with Scala, Spark and web services. In my free time, a try to pay back to the community by contributing to open source. Fan of OOFP.
In 2007 Katarzyna finished her M.Eng in Informatics. Since that time she has been working as software engineer. Over the years, she has worked with many technologies like Python, Perl, Java but more recently she bet on Scala. She loves the Internet and new technologies, especially these that help to deliver better software. Currently she is software engineer at Equal Experts.
I'm a serial entrepreneur and a long time contributor in the Scala/Scala.js ecosystems, including popular libraries like Diode and Boopickle, and the creator of the scalafiddle.io service.
Big Data Developer / Team Leader @ IQVIA. Specializes in Big Data projects involving Data Warehousing & Machine Learning. Active member of JUG Łódź. 'Data is always more valuable than you recognize it to be'.
I am a software engineer and FP professor living in Medellin, Colombia. I am a Scala and distributed systems enthusiast interested in FP, software architecture and infrastructure. Scuba diving wannabe.
Greg is a software developer at Expedia. Professionally he's been building backend services using Scala for 6 years. In the last few years he's been delighted by Scala.js after using it in a number of side projects.
Polyglot software engineer specialised in developing distributed applications. Tea drinker, cyclist & functional programming enthusiast. Loves the human component in software projects. Has a blog at michalplachta.com.
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.