• London Scala Talks: Gabriele Petronella and Jacob Wang

    Online event

    Come along to another round of London Scala Talks! This month, we’re hearing from Gabriele Petronella and Jacob Wang.

    *Gabriele Petronella: MUnit: your new favorite Scala testing library?*

    MUnit is a testing library for Scala built. “Another one?!”, you may say? In this talk we’ll explore
    together the most notable features of MUnit and see what makes this
    little library unique!

    Via a series of live code examples, we’ll answers questions like “Why
    does MUnit not have a DSL?”, “How do we integrate MUnit with other
    libraries?” and “How can MUnit help dealing with flaky tests?”.

    At the end the presentation, MUnit may become your new favorite testing library!

    *Jacob Wang: Time-warping in tests with Cats Effect*

    How do you test time‑sensitive application logic? In this talk, we will explore what lives under `ExecutionContext` and `cats.effect.Timer` and how these abstractions allow us “warp” forward in time. Armed with our new knowledge, we will then look at how time‑sensitive tests are structured to make them fast and reliable.

    This talk uses cats-effect in its examples but a lot of the concepts are shared across all effect libraries in Scala, so if you use ZIO or even just plain Scala Futures, you too can learn the secrets behind time-warping and perform the magic yourself :)

    *Agenda*
    17:45 - Welcome: join us virtually on YouTube
    18:00 - Gabriele Petronella: MUnit: your new favorite Scala testing library?
    18:45 - Jacob Wang: Time-warping in tests with Cats Effect
    19:30 - Catch up and discuss in SpatialChat at https://spatial.chat/s/londonscala

    Read more on https://www.lsug.co.uk/meetups/2021-03-04

    View the intro deck at https://docs.google.com/presentation/d/1ZYEAVN5gOHuZrA6mYSPkz6Q9IwdYeffJIuoreSw62vw/edit?usp=sharing

    Join at https://www.youtube.com/watch?v=54We1w7oftE

    This event is sponsored by Virtus Lab (https://virtuslab.com/contact/).
    Virtus Lab is working closely with EPFL and the Scala Center to ready the Scala 3 compiler, Metals IDE, Scaladoc and other tools for release this year. If you're working with Scala, and you're excited, intrigued, concerned or underprepared for Scala3, then please reach out to us for a chat, and mention LSUG!

  • London Scala Open Source Saturday

    Online event

    Join us for a virtual London Scala Open Source Saturday!

    Come and meet up with fellow contributors and maintainers to hack on their projects.

    You can support the Scala ecosystem by contributing to a variety of open source projects, including:

    - The LSUG website with Zainab Ali
    - http4s with Ross Baker
    - circe with Travis Brown

    First time contributors are especially welcome to help improve to the brand new LSUG website, written in ScalaJS. Whether you're new to GitHub or Scala, we'll help you get your first taste of open source.

    **Agenda**
    14:00 — Doors open
    Gather together for a casual chat on Spatial Chat at https://spatial.chat/s/londonscala . Catch up with your fellow OSS enthusiasts.

    14:15 — Project briefings
    Maintainers will briefly explain projects, motivations and good first issues.
    You can then choose an issue you wish to tackle, and speak to the maintainer for more guidance. If you're experience lines up and you're keen on the project, the hacking begins!

    14:30 — Round 1
    We'll split up into groups around each project and start hacking!
    You'll start coding your solution, teaming up with others if you wish to. Experienced contributors will be on hand to pair with you, and where possible maintainers will review your PRs as they come. Let's try and merge as many PRs as possible!

    15:45 — Break
    Have a break and sync up with other contributors.

    16:15 — Round 2
    When ready, we'll move back for a last round of hacking.

    17:15 — Closing discussion

    Read more at https://www.lsug.co.uk/meetups/2021-02-27 .

    3
  • European Scala Talks: Monocle 3 by Julien Truffaut

    Online event

    Join the European Scala User Groups to hear from Julien Truffaut on Monocle 3: a peek into the future.

    This meetup is a collaboration between the Scala communities in Europe. London, Amsterdam, Lisbon, Porto, Barcelona, Madrid, Berlin, and Hamburg are already joining. If your city is not on the list, spread the word to your community organizer as well.

    You can find the official event here 👉 https://www.meetup.com/es-ES/Scala-Berlin-Brandenburg/events/275841617/.

    = Agenda (GMT time) =
    18:00 - 19:30: Talk: Monocle 3: a peek into the future
    19:30 - 20:00: Q&A & get-to-gether

    = Abstract of the talk =
    Optics is a popular topic among library authors; they exist in at least four flavours in Scala: Monocle, Quicklens, Shapeless and Tofu. However, we rarely see optics in real world code bases.
    Why is that? Why are optics not popular in Scala?

    In this talk, I plan to not only answer this question, but also offer some solutions to the current problems with Monocle API.

    This presentation is a longer, more in-depth version of the one I gave last year at Scale by the Bay.

    = Bio of Julien =
    I am a backend engineer with experience in companies of all sizes, ranging from start-ups to tech giants like Amazon. For the last 5 years, I have been running functional programming training workshops with great success. I focus my training on simple functional programming techniques that deliver value to companies. You can check my online course page for more details https://www.fp-tower.com/courses/foundations

    = Technicalities =
    - Use the Zoom link to join the meetup (you will see the link once you've RVSPed)
    - The event is limited to 300 participants
    - The event will not be recorded

    = Sponsor =
    This Meetup is brought to you by MOIA - a fully electric ridesharing service operating in Hamburg and Hannover. At MOIA, many core services are written with Scala, Akka Streams, and ZIO and we are looking for great developers to join us.

  • London Scala Open Source Saturday

    Online event

    Join us for a virtual London Scala Open Source Saturday!

    Come and meet up with fellow contributors and maintainers to hack on their projects. You can support the Scala ecosystem by contributing to a variety of open source projects:

    - Probably with Jon Pretty
    - The Typelevel ecosystem with Lars Hupel
    - ZIO projects with Adam Fraser
    - The LSUG website with Zainab Ali
    - more projects to be announced!

    First time contributors are especially welcome to help improve to the brand new LSUG website, written in ScalaJS. Whether you're new to GitHub or Scala, we'll help you get your first taste of open source.

    **Agenda**
    14:00 — Doors open
    Gather together for a casual chat on Spatial Chat at https://spatial.chat/s/londonscala . Catch up with your fellow OSS enthusiasts.

    14:15 — Project briefings
    Maintainers will briefly explain projects, motivations and good first issues.
    You can then choose an issue you wish to tackle, and speak to the maintainer for more guidance. If you're experience lines up and you're keen on the project, the hacking begins!

    14:30 — Round 1
    We'll split up into groups around each project and start hacking!
    You'll start coding your solution, teaming up with others if you wish to. Experienced contributors will be on hand to pair with you, and where possible maintainers will review your PRs as they come. Let's try and merge as many PRs as possible!

    15:45 — Break
    Have a break and sync up with other contributors in the Spatial Chat hallway.

    16:15 — Round 2
    When ready, we'll move back to the breakout rooms for a last round of hacking.

    17:15 — Closing discussion
    Move back to the Spatial Chat hallway to discuss what we've achieved

    *Issue, details and setup*
    More details can be found at https://www.lsug.co.uk/meetups/2021-01-30

    1
  • Nicolas Rinaudo - Introduction to recursion schemes

    Online event

    Come along to another round of London Scala Talks! This month, we're hearing from Nicolas Rinaudo on recursion schemes.

    *Nicolas Rinaudo: Introduction to recursion schemes*

    Recursion schemes are a topic that often come up in conversations with experienced, knowledgeable developers. For the longest time, I’d just nod and smile and pretend I knew what was going on. The purpose of this talk is to help people in the same situation. Recursion schemes are far less scary and confusing than the mystique that surrounds them suggests, and this talk attempts to prove it.

    We’ll start from first principles and refactor our way to proper recursion schemes, discovering and explaining all the necessary concepts as we go along.

    By the end of the talk, attendants should have all the tools they need to understand recursion schemes, and be able to explore the more esoteric ones on their own.

    *Agenda*
    17:45 - Welcome: join us virtually on Spatial Chat at https://spatial.chat/s/londonscala
    18:00 - Nicolas Rinaudo: Introduction to recursion schemes
    19:30 - Catch up and discuss

    Read more on https://www.lsug.co.uk/meetups/2021-01-28
    Join the stream at https://www.youtube.com/watch?v=xoT_ttBYlK

    Browse the news bites:
    https://docs.google.com/presentation/d/1M-6QnNYiTip1E25WaAkVv2y5EuTSOb3_CGZhmNWTgDk/edit?usp=sharing

    8
  • London Scala Open Source Saturday

    Online event

    Join us for a virtual London Scala Open Source Saturday!

    Come and meet up with fellow contributors and maintainers to hack on their projects.

    You can support the Scala ecosystem by contributing to a variety of open source projects, including:

    - scala/scala with Chris Birchall
    - cats-retry with Chris Birchall
    - scala-typed-holes with Chris Birchall
    - Scala.js with Sébastien Doeraene
    - A wealth of projects with Jon Pretty
    - Circe with Travis Brown
    - http4s and its Typelevel dependencies with Ross Baker
    - The LSUG website with Zainab Ali

    First time contributors are especially welcome to help improve to the brand new LSUG website, written in ScalaJS. Whether you're new to GitHub or Scala, we'll help you get your first taste of open source.

    **Agenda**
    14:00 — Doors open
    Gather together for a casual chat on Spatial Chat at https://spatial.chat/s/londonscala . Catch up with your fellow OSS enthusiasts.

    14:15 — Project briefings
    Maintainers will briefly explain projects, motivations and good first issues.
    You can then choose an issue you wish to tackle, and speak to the maintainer for more guidance. If you're experience lines up and you're keen on the project, the hacking begins!

    14:30 — Round 1
    We'll split up into groups around each project and start hacking! We'll move to BlackBoard Collaborate (https://eu.bbcollab.com/guest/df9517e9324d44688f99461cb67b1dec), where each group will be assigned a breakout room.
    You'll start coding your solution, teaming up with others if you wish to. Experienced contributors will be on hand to pair with you, and where possible maintainers will review your PRs as they come. Let's try and merge as many PRs as possible!

    15:45 — Break
    Have a break and sync up with other contributors in the Spatial Chat hallway.

    16:15 — Round 2
    When ready, we'll move back to the breakout rooms for a last round of hacking.

    17:15 — Closing discussion
    Move back to the Spatial Chat hallway to discuss what we've achieved

    *Issue, details and setup*
    More details can be found at https://www.lsug.co.uk/meetups/2020-11-28

  • London Scala Talks: Chris Birchall and Aleksandar Skrbic

    Online event

    Join us virtually for another round of London Scala Talks! This month, we'll be hearing from Chris Birchall.

    You can join the Virtual Classroom at https://eu.bbcollab.com/guest/df6879c6313a410f9a21dfd2bdb2a68f

    6:30pm - Room opens. Come along for a chat!

    7:00pm - *Chris Birchall Type class derivation in Scala 3*

    Type class derivation is one of the most exciting new features of Scala 3. In this talk I'll explain how library authors can use it to make life easier for their users.

    I'll start with a quick recap of how type class derivation is typically achieved in Scala 2, and how it looks in other languages such as Haskell and Rust.

    Then I'll live-code a `derived` method for the world's simplest type class, Show. Once we've seen how all the pieces fit together, we can move on to a more interesting example: deriving Functor for paramterized ADTs.

    Finally I'll demonstrate how I'm planning to combine type class derivation with Scala 3's new macro framework to allow automatic gRPC server and client generation in Mu (https://higherkindness.io/mu-scala/), a microservices framework developed by 47 Degrees.

    7:40pm - Intermission

    7:50pm - *Aleksandar Skrbic - Microservices Patterns with Akka and Kafka*

    Talk about some common patterns specific to microservices and streaming architectures.

    I will show how to integrate Kafka in your microservices and why Akka and especially Akka Streams are great tool for that. Also, I will code a few Akka based services and show how interservice communication can be implemented with Akka Http or Alpakka Kafka.

    Finally, I will review our Akka and Kafka based architecture and of course code will be available on GitHub.

  • Virtual Scala Edition June

    Online event

    Hello Scala lovers,

    We are doing a nice online meetup together with several other user groups in Europe! Jon Pretty introduces the two new libraries Quarantine and Probably, and Andreas Drobisch shares insights about Event Sourcing at Scale.

    = Agenda (BST) =
    18:00 - 19:00: Jon Pretty: Probing the Unprovable, Proving the Improbable and Improving Your Programs' Probity
    19:00 - 19:10: Q&A
    19:10 - 19:40 Andreas Drobisch: Event Sourcing at Scale
    19:40 - 19:50: Q&A

    = Registration =
    This meetup is happening online, you can register for the webinar here:
    https://ziverge.zoom.us/webinar/register/WN_VgJtuXIXQHO3daDzWmbDNg
    = Talk & Speakers =
    == First talk ==
    Jon Pretty: Probing the Unprovable, Proving the Improbable and Improving Your Programs' Probity

    Writing robust, reliable software is the goal of most developers. Scala's type system provides a framework in which many desirable invariants can be enforced and proven at compile-time, while the JVM offers the means to probe the runtime to check that all inputs produce the expected results when executed.

    With this goal in mind, we will examine two new libraries, Quarantine and Probably, which offer solutions from these two orthogonal directions, each introducing a novel idea with the potential to change the way you write tests and handle exceptions. We will explore the details of Scala's type system which facilitates Quarantine's approach to exception handling, and focus on the compositionality that Probably provides as a testing library.

    Finally, we will look ahead to Scala 3, and discover what possibilities it brings for developing more reliable software in the future.
    About the speaker:
    Jon has worked full-time as a Scala developer since 2004, and has been heavily involved in the Scala community for as long as it has existed.

    He travels extensively, speaking on a variety of Scala topics at many Scala events worldwide, including talks on his open-source libraries and original research on subjects such as type inference and the differences between type members and type parameters.

    == Second talk ==
    Andreas Drobisch: Event Sourcing at Scale

    What if you could build your entire application state from immutable
    events, instead of waiting to update it whenever change comes? As a
    commerce platform with high traffic and millions of events, Event
    Sourcing has a great impact on how we build our application. Andreas will give you a quick look into how we tackle the topic of Event
    Sourcing at commercetools and the benefits and drawbacks of our
    approach.

    About the speaker:
    Sitting in front of computers since 1992, on the JVM train from 2010 and a Scala enthusiast since 2012, Andreas is currently a Senior Scala Engineer at commercetools who currently enjoy sitting on the balcony more than usual.

    = Sponsors =
    This Meetup is brought to you by our sponsors: commercetools GmbH in a collaboration with Ziverge Inc.

    1
  • London Scala Talks: Roksolana Diachuk and Adam Warski

    Online event

    Join us virtually for another round of London Scala Talks! This month, we'll be hearing from Roksolana Diachuk and Adam Warski. We look forward to seeing you!

    6:30pm - Room opens. Come along for a chat!

    7:00pm - *Roksolana Diachuk: War stories of lighting a Spark in the Kubernetes sea*

    Big data, Spark, Kubernetes - you may have heard these buzzwords far too many times. Have you ever thought of combining all of them? Running spark jobs on Kubernetes - sounds intriguing! But sailing the unknown see always goes with a challenge, and not even one. And who knows what is hiding deep in the water? If you are ready, let’s embark on this dangerous yet exciting journey.In this talk, I am going to talk about new Spark operator for Kubernetes which allows to run Spark jobs on Kubernetes in a more automated way. The audience will find out about all the challenges my team and I encountered while researching this possibility. How we came all the way through using Spark operator alpha version which then got updated to beta (you know, updates). How we dealt with problems and challenges we encountered on our way.

    7:40pm - Intermission

    7:50pm - *Adam Warski : FP + relational databases = ?*

    Functional programming is an increasingly popular approach to writing and thinking about code. Is it also applicable to such daily programming tasks as accessing a relational database? Is it possible to work with transactions in a "functional" way? Yes! But what does it mean in practice? And is this any better than using JPA's or Spring's @Transactional?

    In this live-coding session, we'll try to answer these questions, and demonstrate how the "functional" approach improves over the "traditional" one in three areas: working with multi-thread code, requiring a framework and precisely delimiting transaction boundaries. In the code we'll use the Doobie library, however no prior knowledge of Doobie is necessary. In fact, you should be able to follow the talk even if you don't know Scala!

    We'll be focusing on one specific problem area, however the techniques that we'll use have broader applicability, and are often used to solve other problems as well.

    8:30pm - Grab a drink and discuss the talks!

    You can join the virtual conference at: https://eu.bbcollab.com/guest/1015c16aa8334be08d26650300ff60c4

    3