Konferencja Scala Wave 2017

Scala Wave Conference is created to build the network of Scala enthusiasts & experts in the area of the Baltic Sea Region and beyond.

Scala Wave means sharing Scala passion, knowledge & experience. We love to disseminate Scala trends, build the Baltic Scala community and promote the Baltic Region as a technical hub.

We want to concentrate on Scala applied - programming language which solves real technical problems. We are eager to learn from success stories. Learn about solutions making developer’s life more effective and making code better.

We would like to offer you a piece of fun and really great summer atmosphere. We believe in the power of networking and we create this conference for bringing people together.

Scala Wave 2017:

• Scala We want to talk about Scala applied examples, success stories, design patterns and solutions making developer’s life more effective and making our code better.
• Sharing We want to share community experience and bring Scala functional passionates together.
• Awesome location We would like to offer you a piece of fun and really great summer atmosphere close to the seaside.
• Networking We want to build the network of Scala enthusiasts in the area of the Baltic Sea Region and beyond.
• Speakers We do our best to invite Scala experts. You can take a look on their profiles below.
• Hands-on approach We believe that the best way to improve your skills and share experience is “learning by doing” approach. You will have a chance to participate in really practical workshops and contribute to leading Open Source projects during Scala Spree.

Scala Wave 2017 agenda 7.07 Workshop day

• Eugene Yokota Lightbend sbt workshop: from intro to plugin development "This is a relaxed workshop about sbt. First, we will start with a lecture of the sbt basic concepts, and how to write build files. Next we can move on to more advanced topics such as plugin development, how to contribute to sbt, and general Q&A about the build. Please bring your laptop if you want me to look at your build or participate in hacking." About speaker Eugene is tech lead of Tooling team at Lightbend that’s responsible for sbt and Zinc among other things. His passions are diners in NJ, pancakes in Western Massachusetts, Döner kebab in Berlin, history of JSON libraries, and functional programming.
• Andrew Kozlov JetBrains Scala in Intellij IDEA About speaker Andrew has been a JetBrains employee since graduating with a B.Sc. degree in Computer Science. After falling in love with Scala joined the Scala plugin team. Currently is working on Akka and Dotty support in IntelliJ IDEA. Besides programming is interested in public speaking: has participated in several conferences (including ScalaDays), has been teaching programming courses for high school and university students for more than 5 years.
• Tomasz Sosiński Scalac Up and running with Flink streaming - About speaker I am a programming enthusiast partial to functional programming and Scala with expertise in R and Python; fascinated by data (big and fast) and the ability to tell stories with information utilizing JavaScript. I utilize the whole set of technologies to bring the data experience from Hadoop clusters to your desktops. While searching for new challenges, I meander from rendering infographics on front-end to core data transformations. Photography lover, eager biker and a huge fan of Asaf Avidan.
• Jan Pustelnik GFT Akka streams The intention is to go 'from zero to hero'. We will start with basic notions - Source / Flow / Sink / Backpressure and progress from there, through the plethora of built-in stages, to creating custom shapes and processing complex graphs. The main goal of the workshop is to give the participants solid hands-on experience with using and combining the built-in stages in creative ways, showing them the richness of abstractions already 'in the box'. There will be many practical examples and exercises. However, we will also venture in the land of advanced streaming concepts, covering the materialization process (including the brand new Akka 2.5 materializer), reactive streams abstraction, custom stages, Graph DSL, handling loops in graphs, testing your stages with stream-testkit and timer driven/aware stages. It is expected that participants know Scala, no prior knowledge of Akka or Reactive Streams is being assumed. About speaker Technical Architect at GFT Poland by day, Akka project contributor by night. 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. Currently he is busy with a Big Data project for one of major investment banks. In his spare time he loves to take some random issue of computer science journal and put ideas from there into practice.
• Łukasz Gąsior Scalac Scala & Akka basics If you feel confused by all those advanced topics and the only question you have is "Ok, but how do I get started?", this workshop is for you. During the workshop we'll walk through basic Scala and functional programming concepts. Starting with environment/project setup (with sbt), through things like functions, traits, pattern matching, collections, error handling patterns, finishing on the basics of Akka. If you're just starting your journey with Scala, this workshop will give you a solid ground for the conference day. About speaker I'm a big fan of functional programming and Domain Driven Design. For the past 3 years I've been working for Scalac on a variety of projects. Recently highly interested in cryptocurrencies.
• Marcin Matuszak Iterato.rs DIY: Functional optics The aim of this workshop is not to teach you how to use any existing optics library. We will build our own fully functional library from ground up using just basic constracts. Starting from classic implementation we will quickly move to fancy stuff like van laarhoven or profunctor representation of optics. This will be intermediate level workshop requiring some prior knowledge of things like typeclasses, variance, scalacheck testing. About speaker Marcin is an enthusiastic functional programmer living in Wrocław, by far the best city in World. Working for Iterato.rs doing full-time Scala.
• Andreas Köstler Commonwealth Bank Peeling the Onion - Microservices One Layer at a Time Free monads, as used in the “Datatypes à la carte” pattern, are a useful way to structure code, separating of specification from implementation, and building modern, modular, and functional architectures as advocated by John De Goes and others. However, they also come with a runtime performance penalty. The complementary “typed tagless final interpreters” approach (popularised in the Haskell and OCaml worlds by Oleg Kiselyov) offers a performance boost over free monads for much the same applications, yet available sample code centers around simple expression langauges, and “real world” examples are hard to come by. In this workshop, we’ll demonstrate the viability of the TTFI approach for building modern, layered architectures by building a system of micro services — with configuration, state, side effects and error handling.

Scala Wave 2017 agenda 8.07 Conference day

• Miles Sabin: Keynote presentation About speaker Miles has been doing stuff with Scala for more than ten years, currently with Underscore Consulting. He is a cofounder of Typelevel and his best known project, the Scala generic programming library shapeless, is the weapon of choice wherever boilerplate needs to be scrapped or arities abstracted over.
• Roland Kuhn: Akka typed Cloud computing, reactive systems, microservices: distributed programming has become the norm. But while the shift to loosely coupled message-based systems has manifest benefits in terms of resilience and elasticity, our tools for ensuring correct behavior has not grown at the same pace. Statically typed languages like Java and Scala allow us to exclude large classes of programming errors before the first test is run. Unfortunately, these guarantees are limited to the localbehavior within a single process, the compiler cannot tell us that we are sending the wrong JSON structure to a given web service. Therefore distribution comes at the cost of having to write large test suites, with timing-dependent non-determinism. In this presentation we present a way out of this dilemma. The principles are demonstrated on the simplest distributed system: Actors. We show how parameterized ActorRefs à la Akka Typed together with effect tracking similar to HLists can help us define what an Actor can and cannot do during its lifetime—and have the compiler yell at us when we do it wrong.
• Jon Pretty:
• Daniel Spiewak: Free as in Monads What is `Free`? Where did it come from? Why is it here? Why would anyone *really* care? In this talk, we will embark on an epic journey through a live editor buffer as we derive the `Free` monad from scratch for fun and profit in just a few dozen lines of code. And once we have it, we will see how easy to use and powerful it can be when applied to the right problems. When I was exposed to these ideas and abstractions, it forever changed the way I write software. If you aren't careful, it could do the same for you!
• Andy Petrella: What is data science governance - what it means for Spark 'In the world's of today, citizens' data privacy is taken seriously. This is of course due to global awareness of social network impact on society where everyone is publicly exposing personal and professional information. This access to the world and speed to communication comes with a cost - your public data could be used by organisations. That leads to regulations like the European's General Data Protection Regulation (a.k.a. GDPR) that can lead to 4% of the worldwide annualturnover if it is not respected, that is, if enterprises aren't able to explain how privacy data are used and cannot apply the 'Right to be forgotten' to any citizen in Europe! In this talk, we'll cover what is actually Data Science Governance, how important it is for Enterprise having legacy systems, but it is even more true for labs and units working on Data Science project. Hence, the second part of the talk will focus on what Data Science Governance can be delivered in a context of using Apache Spark in Scala. About speaker Andy Petrella is a data science entrepreneur in Belgium but also an international speaker (Spark, Scala, Strata, ...). After having created and pushed on the market the Spark Notebook (see link) open source solution, he created with Xavier Tordoir the startup Kensu (see link) which is creating an automated data science governance tools targeting problems like GDPR for instance. Andy is also an O'Reilly author (see link), trainer (see link) and a member of the proposal committee of Strata.
• Paweł Szulc: Say Monad one more time...
• Przemysław Pokrywka:
• Marina Sigaeva: Herding types with Scala macros In Scala we use the term "type safety", but what it really means? In short, most applications model data types in a form suitable for storage, change, transmission, and use. During the life cycle of the data, we expect to always use the declared type. But reality is a bit more complicated. One of the main practical problems with the use of types occurs when our application interacts with outside world - in requests to external services, different databases or simply with getting data from file. In most cases, an attempt to support type safety leads to writing a lot of code that we always try to avoid. Fortunately we have macros to do all routine job for us! In this talk we will discuss how to use compile-time reflection in library for schemaless key-value database and the benefits of use of macros in production systems. About speaker Marina is a software engineer. She graduated from Lomonosov MSU with a degree in Physics. Fashion-ballet-travel-addict. Loves life. And Scala.
• Justin Keaser: Scary Build Tool? Automate more with sbt. Let's face it: You may be able to avoid using sbt to build your Scala projects, but you probably don't want to. It's the de-facto standard for Scala projects and is programmed and configured in Scala itself. We'll develop a simple sbt plugin together and explore some of the concepts of an sbt build's architecture. The goal is to help you better automate your builds in a single environment rather than stringing together scripts and tools. About speaker Justin always seems to end up tweaking the tooling rather than doing his actual job. Unsurprisingly, he ended up working at JetBrains, improving the sbt support for the IntelliJ Scala plugin.
• Kamil Owczarek: Reliable Data: How to efficiently develop and test data-driven applications

@scalawavepl 2017

#scalawave

Stary Maneż, Słowackiego 23, Gdańsk