We have almost 20 years of Scala experience between us and have experience with many other languages. Recently we have jumped onto Kotlin because it looks very promising as Java competitor.
Of course, there is no one size fits all solution. We will show how the two languages compare and explain why and when you should pick one over the other. Or maybe should consider some else altogether.
Passionate software craftsman working for Xebia and organiser at Amsterdam.scala & Kotlin.amsterdam, always looking to learn, share, help, teach and meet new people
Urs is a seasoned software engineer and trainer with over 15 years of experience in building resilient, scalable, mission-critical systems on the JVM mostly using Scala and Java, with Kotlin as a recent addition. Besides his job as a consultant, he is also a passionate trainer who has taught and mentored over more than two hundred developers in getting mature with the Scala ecosystem and reactive programming. As a people person by nature, he loves to share knowledge and inspire pears on meetups and conferences.
The Lagom Team is holding a team meeting in Leuven next week and we thought that it will be a great opportunity to organise a BeScala summer drink at the Oude Markt.
There will be no presentations, just informal drinks. Hopefully on a nice summer terrace.
We don't have yet a fixed place to meet. Probably at the Metropole, but it all depends on the place availability at runtime. Just look around, we will be somewhere at the Oude Markt, scheduled on some beer tap thread and letting the stream flow.
You are all welcome!
When you first learn scala, coming from another language such as Java, you'll probably fall in love with the Option type. This type protects you from bugs because you know that the value wrapped in an Option might be absent and if you have a plain value, you know it will never be null.
What if you could extend this and have types that provide even stronger guarantees, for example: a String that is never empty, an Int that is always known to be positive? Refinement types allow exactly this. You refine a base type, like a String with a predicate, such as minimum length must be 5 and wherever you have a value of this refined type in your code, you can rest assured that it conforms.
In this session, you will explore the refined library and learn how to use it in practice with some popular libraries/frameworks. Together you will discover a Play/Slick example application that's strongly typed, using refinement types.
Peter is a well seasoned freelance developer, who still vividly remembers the birth of the JVM. Currently he's exploring the field of functional programming in scala at the Agency for roads and traffic of the Flemish government
• What we'll do
In this hands-on workshop, we use a simple yet powerful visualization of a 5-node, RaspberryPi-based cluster to reveal the inner workings of Akka Cluster.
We'll observe and explore:
- basic Akka cluster formation
- different failure scenarios such as network partitioning and node failure
- the occurrence of the so-called Split Brain Syndrome
- Akka Split Brain Resolver strategies
- Run a clustered app on the platform
• What to bring
A Laptop that can both connect to the local Wifi network -and- a physical ethernet network TP-Hub.
I'm looking for volunteers that can do some preparation of their laptop ahead of the workshop. Please volunteer either via the meetup message board or send me an email (eric dot loots at gmail dot dom). Indicate the OS your using (MacOS, Linux or Windows).
• What we'll do
During this session I explain implicit functions (a new concept introduced by Martin that is implemented in Dotty). Implicit functions greatly reduce boilerplate code.
As an example, I show how they can greatly reduce the complexity of implementing reader transformers.
• What to bring
I introduce Program Description Based Programming (PDBP).
Notice that the pipe on the picture is a description of a pipe.
This is the first meetup of series of meetups.
I am planning to write a book about this.
The book is similar to (but also different from) the "Functional Programming in Scala" book of Runar. I'll try to keep the meetups as simple as possible in order not to loose too many attendees :-)
10 min walk from Station Gent Dampoort
parking on public road
What to bring:
The code that I show is written in Dotty.
The difference with Scala is minimal (after all Dotty will be the next Scala).
This meetup will be focused on both Scala and Scala.js. The first presentation will explain why and how N-SIDE created a Scala platform for all the solutions it develops. N-SIDE is specialized in Optimization softwares. Those solutions heavily rely on data to take decisions. The presentation will thus focus on the data, both in back-end (with Scala) and front-end (with Scala.js). The second talk will be an interactive presentation on building native applications with electron and Scala.js. An example game, built with electron and Scala.js, will be presented.
If this is not convincing enough: beers and pizza's will be offered!
• 18:30: Welcome
• 19:00 - 20:00: Data modeled from back to front end: Multipurpose, context-dependent & typesafe data model -- By Olivier Guerriat
Learn why and how we addressed our complex requirements by leveraging Scala projected types to write a single data model adapting itself to different use cases from web UI (thanks to Scala.js) to optimization algorithms.
• 20:00 - 20:30: Pizza/beer break !
• 20:30 - 21:30: Building cross platform desktop applications with Electron and Scala.js. -- By Antoine Doeraene
Details: The meetup will be held at N-SIDE offices: 25, Avenue Baudouin 1er, 1348 Louvain-la-Neuve (https://maps.google.com/?q=25,+Avenue+Baudouin+1er,+1348+Louvain-la-Neuve&entry=gmail&source=g). Private parking is available with enough places for everyone. The Louvain-la-Neuve train station is only 10 minutes walking distance from our N-SIDE offices.
Olivier Guerriat is a passionate Scala developer since 2014. After working on the different N-SIDE optimization solutions, he has launched the Edge project, of which he is currently technical lead. This project aims at providing a common framework for the different solutions developed by N-SIDE, from back-end (Scala) to front-end (Scala.js). All new solutions developed by N-SIDE are based exclusively on Edge.
Antoine Doeraene discovered Scala with the Coursera online course "Functional programming principles in Scala". Mainly developing as a hobby, he then started to use functional principles in game development. He is currently finishing his PhD thesis in pure mathematics at UCL, where he also uses Scala and Scala.js for solving combinatorics problems.
In this talk we’ll have a look at Akka Streams and its relation to Reactive Streams, a standard for asynchronous stream processing with non-blocking back pressure. We’ll see how Reactive Streams principles enable the building of highly responsive applications that adapt to load changes and that are resilient to failure. Real-life scenarios will be shown where applying so-called back-pressure keeps systems fast and healthy at the same time.
About Eric Loots
Eric Loots is a Scala & Akka champion, teaching courses on these topics across the world for Lightbend, his employer. Having started programming in various machine languages some odd 35 years ago, subsequently passing via C and Java to Scala and Akka, Eric’s glad with the coming of age of Reactive Systems.