Being in a Scala community, you've probably heard about type classes. Very basic concept that both commonly used among many Scala libraries and at the same time very fundamental to understand any theoretical concepts behind Functional Programming. This short talk is all about explaining what Type classes are, how to use them and how to create them, with strong emphasis on answering the question "why should I even care?". We will focus on both on prons and cons, however speaker will probably be a bit biased towards the former.
We will follow story of couple of developers, struggling with conceptual design problem. As many before them, they will eventually reinvent the wheel. The solution they will end up with, is what we call a Type class.
This is a "from zero to hero" talk. Preferable audience are people who want to:
1. understand any shapeless/scalaz/cats presentation out there (this presentation will give you ability to survive first 10 minutes of mentioned talks)
2. be enlightened that "monads are just type classes with some laws" (this is not a monad tutorial though)
3. get the "aha!" moment, realising that they've been using Type classes from time to time, without knowing it
Pawel Szulc is primarily a programmer. Always was and always will be. Experienced professionally in JVM ecosystem, currently having tons of fun with Scala, Erlang, Clojure and Haskell. By day working on (not that) BigData problems with Akka Stream ∓ Apache Spark, by night hacking whatever he finds interesting at that given moment. Humble apprentice of Functional Programming. Runs a blog rabbitonweb.com.
One of the most exciting developments of the last two years has been the advent of "Reactive Streams", a powerful new abstraction for defining and scaling pipelined processing logic in a fully asynchronous, non-blocking and generally *reactive* fashion.
In this talk I'll introduce you to a new, fully-featured Reactive Streams infrastructure toolkit for Scala, called "Swave", which has been built from scratch with a special focus on maximum performance, a simple and powerful API as well as minimal dependencies.
We'll look into the general design approach, feature set and core implementation choices as well as basic benchmark and performance figures.
We'll also contrast with other Reactive Streams implementations and highlight pros and cons from a user's perspective.
So the next time you are reaching for a Reactive Streams toolkit you'll have one more choice to pick from.
Monad transformers are a neat way to compose effectul computations: pass some configuration, read/write from disk, track errors...
However they can be a bit cumbersome to deal with, especially if you want to use different stacks sharing some common effects: for example a stack to interact with AWS and another one for Hadoop computations.
This talk will shortly introduce monad transformers in Scala and their drawbacks then present the Eff monad.
The Eff monad has some really interesting properties:
I am a software developer living in Berlin, working for Zalando.
I am the creator of the specs2 library for software specifications in Scala.
Scala has been my gateway drug to functional programming and to many "unknown unknowns".
When I manage to go from "unknown unknowns" to "known knowns" I try to spread the word.
In the wild, Scalac is an enormous beast. When run freely compilation takes ages even for simple changes in your project. Luckily, in the end of stone age of scala tooling first incremental compilers emerged and time spent on scala compilation’s become less and less noticeable...
In this talk I want to explain what incremental compiler is and how it works in sbt world. Further down the road I will show how name hashing reduces amount of compiled files. In the end we will ask ourselves if we can do any better (and by what cost).
Modern container-based cluster computing frameworks like Mesos, Kubernetes, or EC2 Container Service usually execute services on nodes not known beforehand. This creates a problem for Akka Cluster deployments, where seed nodes need to be established.
In this talk we present a zero-configuration deployment scenario for Akka Cluster using etc.d as a distributed configuration store.
Maciej Biłas is a software engineer at Adform Research. He spent over 3 years developing production Scala code and many more in the JVM ecosystem. Makes data run in the pipes during the day.
In 30 minutes I want to build a full blown web app based on Lift framework.
Shapeless is known for being difficult to grasp, even for experienced Scala developers. In this talk, I will do my best to show you that this difficulty is somehow overrated.
Of course we'll only scratch the surface there. But hopefully, you'll take home enough hints to begin your own exploration of what this powerful tool enables.
IOT has a massive potential and its impact in our daily life is important. Here is an exemple of using a connected object and analysing its data: we'll see how to collect data using the accelerometer sensor of your smartphone. Then, we'll store it in Cassandra as a Timeseries model. Finally, we'll analyse those data and predict the activity with Spark. We will see a live demo on stage to show this solution working in realtime.
Amira Lakhal is an Agile Java Scala developer at Valtech France. She is passionate about functional languages and Big Data. She is one of the Duchess France leaders where she helps women in IT to became role models.
In this talk we will discuss in detail the current object initialization order scheme in Scala.
Though a fundamental and seemingly basic feature, the order in which class fields are initialized is often a source of bugs and frustration for users. We will demonstrate how apparently-innocent changes can lead to surprising behavior at runtime.
Workarounds already exist in Scala—early initializers and lazy vals—and alternative compiler implementations could enhance the the safety guarantees provided at compile-time. We will look at some of these possibilities and will briefly discuss potential changes to initialization order in Dotty.
Dmytro Petrashko is a programming languages and algorithms researcher and a doctoral assistant at EPFL. He is currently working on a doctorate as a research assistant in the School of Computer and Communication Sciences at the EPFL in Switzerland, on experimental Dotty compiler for Scala. Previously he was working on ScalaBlitz—macro generated collections for Scala.
In this talk we intend to show that the two libraries: Scalaz and Cats widely held to be cryptic, hermetic and full of scary Mooonads in reality contain lots of easy to use components ready to be embeded in your code to make it shorter, clearer and easier to maintain. We will look at certain constructs from pragmatic point of view as just "Design Patterns" that happen to match ideally functional programming style.
Jan is a Scala & Java developer at GFT Poland. He is very interested in how software works on low detail level and does not find big frameworks appealing. This is the main reason why he loves Scala, a very expressive language that allows one to build the right abstraction quickly without loosing the control on details.
This talk's about how actors should communicate with the outside world as expressed in Joe Armstrongs proposed Erlang implementation of "UBF", the "Universal Binary Format" specification, a paper that let to the concept of Session Types. What are Session Types? What kind of a safety do they provide? We'll demo how "Session Types" can be unified with real world RESTFul applications, in an almost typesafe way.
Marco Borst and Slava Schmidt are freelance Scala Developers. For Zalando SE they created Play-Swagger, an open source plugin that lets Play developers treat Swagger API specifications as the single source of thruth. This work did fuel their interest in protocol languages, the state of the art in API specifications and the safety that this specifications can provide in real world scenarios. They have experience presenting at multiple conferences and meetups from 2013 on, most notably the Java User Group Taiwan, Innovation Days, ScalaDay, QALab and JavaDay in the Ukraine, JavaDay in Belarus, the Scala User Group in Berlin and the Scala World Unconference in the UK.
Enabling blazing fast search on a 1 billion member social network demands special weapons and tactics. Let me take you on a journey around the edges of existing technologies. I'll tell you how we took advantage of the Scala ecosystem and modern tools to realize persistence and processing of such a data set.
About this conversation:
Case study focused on the client requirements and tools we have made use of to meet them. Thoughts, injuries and ideas about real life fast & big data challenge brought to you directly from the trenches.