- London Scala Talks: Vilem Liepelt
We're giving away a free ticket to ScalaDays at this event (https://www.scaladays.org/)! For April's talks we are delighted to be joined by Vilem Liepelt who will be presenting on type systems: * Resource-oriented programming with graded modal types * Linear types, derived from Girard's Linear Logic, provide a means to expose safe interfaces to stateful protocols and language features, e.g. channels and file handles. Data is delineated into two camps: unconstrained values which can be consumed or discarded arbitrarily and 'resources' which must be used exactly once. Bounded Linear Logic (BLL) , allows tracking a more nuanced notion of nonlinearity via the natural numbers semiring which is baked into its proof rules. Our system of Graded Modal Types generalises BLL by parameterising over the resource algebra, thus allowing a wide array of analyses to be captured in the type system. In this talk we will explore how graded modal types and linearity conveniently extend our typical toolkit of parametric polymorphism and indexed types, allowing us to reason about pure and effectful programs in a novel, resource-oriented, manner. Session typed channels and mutable arrays are just two examples of programming idioms that can be provided in such a language without having to give up safety and compositionality. We will see this in action via Granule , our implementation of a functional language with a type system which supports all these features. 1. Girard, Scedrov, Scott (1992) 2. https://github.com/granule-project/granule Pizza and drinks will be sponsored by District4 https://district4.io/
- London Scala Talks: Jon Pretty
For March's talks we are delighted to be joined by Jon Pretty who will be presenting on microlibraries. *Introduction by Matt Roberts, Disney* *Jon Pretty: Eleven Little Life-enhancing Libraries* A microlibrary should do one thing and do it well. It's a recipe for composability. This talk will be a rapid-fire tour-de-force of eleven Propensive microlibraries, each one given exactly three minutes to demonstrate its usefulness for an everyday task, and its unique features. You will see new ways to execute system processes, work with CSV, calculate digests, use annotations, pattern match on strings, abstract over monads, work with lenses, diff ADT instances, generate valid HTML5, statically-check interpolated strings and compose async graphs. Each library comes with a firm focus on typesafety, elegant syntax and a humorously magniloquent name. Food and drinks will be sponsored by Disney. Please read the following document on how to find Disney's reception: https://drive.google.com/file/d/1c5L766WUSux_dAp78kJDoReKrMokDwZs/view?usp=sharing
- London Scala Talks: Chris Birchall and Leszek Silwko
Please register on the SkillsMatter website at https://skillsmatter.com/meetups/12117-london-scala-talks-chris-birchall-and-leszek-silwko For February's talks we are delighted to be joined by Leszek Silwko who will be presenting on release processes and Chris Birchall who will be talking about writing sbt plugins. Here are their abstracts: *Leszek Silwko: Drone Delivery Queue* The presentation is about release/build process we setup in my team. The novelty here was to integrate the images building as a result of a story (i.e. not the code changes). Then the images are moved through environments – such a process guarantees the release on prod is exactly the same system as that which has been seen and approved by business. As an interesting note, we use Open Source tools released by UK Home Office. Presentation is available here: https://prezi.com/foqqashbe8pz/drone-delivery-queue/ *Chris Birchall: Writing an sbt plugin* First I'd like to introduce sbt-explicit-dependencies, an sbt plugin I made recently. I'll explain what it does, why you should consider using it, and how it works under the hood. In the second half of the talk I'll give a beginner's guide to writing an sbt plugin, including how to test plugins, how to distribute them for public consumption and how to cross-build for sbt 0.13.x and 1.x. Pizza and drinks will be sponsored by District4 https://district4.io/
- London Scala Talks: Scala at ClearScore
We're kicking off this year's LSUG with some lightning talks and an informal question & answer session at ClearScore. 7pm – *Klaus Thorup (CTO) - Kick off, Selecting Scala for micro services* 7:20pm - *Michal - TBC* 7:40pm - *Barry and Danny - Scala On Kubernetes: Performance Pitfalls* Story of ClearScore’s migration from a Java monolith to Akka microservices, and from a Hashicorp/Nomad platform to Kubernetes, and unanticipated network performance degradation due to differing network topologies. How we diagnosed the problem. How we solved it. And how we plan to address similar problems in the future. 8pm - *Justin Basinin (CEO)* 8:10pm - open panel Q&A Pizza and drinks will be sponsored by District4
- London Scala Talks: Diego Alonso, Lindsey Dew, and Omnia Ibrahim
Our final LSUG of 2018 will be a festive one, with the tinsel exchanged for shiny, sparkly functional streams in FS2 and Kafka. As usual please sign up on the Skills Matter web site via the following link: https://skillsmatter.com/meetups/11322-london-scala-users-group *Diego Alonso, Functional Reactive Programming with FS2* Functional Reactive Programming is an approach to writing programs. FRP uses signals, which represent a mutable value time-line of a value, and signal transformations as its basic blocks. `fs2` is a functional streaming library for Scala. This talk explores the key concepts of both FRP and `fs2`, how they relate to each other, whether we can write an FRP system on top of `fs2`, and what ideas from FRP can be used to guide future development of `fs2`. *Lindsey Dew and Omnia Ibrahim, Introduction to Kafka Streaming* The last few years we've witnessed the rise of data-driven projects, with Apache Kafka leading the charge for streaming big volumes of data. In this session Omnia and Lindsey will introduce you to Kafka Streams. They will be sharing with you Scala code examples, demonstrations of use-cases they have at Deliveroo, the problems they faced, how they solved them, and the lessons they've learned.
- London Scala Talks: Rory Graves
What colour is your function? Red vs Blue What colour is your function? In software we are often face with dichotomies in our design decisions. Each trade-off has costs and benefits. Do you chose mutable vs Immutable, blocking vs futures, single vs multi-threaded. How do we reason about the trade-offs we make? Starting from a blog post by Bob Nystrom we explore the rabbitholes and their effect on writing performant, reliable, maintainable code. - Will you stay in wonderland and see how deep the rabbithole goes? Please sign up on the Skills Matter event at https://skillsmatter.com/meetups/11308-london-scala-users-group
- London Scala Talks: Francesco Cesarini and Tamer Abdulradi
We're delighed to be joined this month by two fantastic speakers: Francesco Cesarini of Erlang Solutions and Tamer Abdulradi of Disney Streaming Services. Join us for an inspirational evening of distributed systems and recursion schemes! **Please sign up for this event on the Skills Matter web site using the following link:** https://skillsmatter.com/meetups/11288-london-scala-users-group ===== Francesco Cesarini: Immutability for scale and reliability The functional paradigm has been influencing mainstream languages for decades, making developers more efficient whilst helping reduce maintenance costs. As we are faced with a programming model that needs to scale on multi-core architectures and distributed environemnts, concurrency becomes critical. In these concurrency models, immutability, a key feature of functional programming paradigm will become even more evident. To quote Simon Peyton Jones, future concurrent languages will be functional; they might not be called functional, but the features will be. In this talk, we explain why! --- Francesco is the founder of Erlang Solutions Ltd. He has used Erlang on a daily basis since 1995, starting as an intern at Ericsson's computer science laboratory, the birthplace of Erlang. He is also the co-author of 'Erlang Programming' and 'Designing for Scalability with Erlang/OTP' both published by O'Reilly and lectures at Oxford University. ===== Tamer Abdulradi: Recursion Schemes: How to Factor Recursion Out of Your Codebase Recursion is hard! But luckily you can "get it right" once and reuse it in other projects. Recursion schemes is a code pattern that allows you to automate the process of traversing and recursing through nested data structures by separating recursion out of the rest of the logic. They allow you to use off-the-shelf libraries to do the recursion for you, so you can write less code and potentially fewer bugs! In this talk, Tamer will share with you an example, a JSON data-structure, walk-through a step-by-step transformation of the code to use a recursion schemes library. By attending you will understand the gist of Recursion Schemes and how to use it in your codebase. --- Tamer is a Senior Software Engineer at Disney Streaming Services, building and maintaining distributed systems armed with nothing but Scala, types and the power of functional programming. He is the author of Troy, a type- and schema-safe interface to Cassandra (https://github.com/schemasafe/troy), and has a general fascination with all kinds of functional and type level programming.
- London Scala Talks: Oleg Volkov and Francesco Cessarini
We're back at CodeNode for this month's LSUG Talks. Please note the slightly later start time of 7pm! As usual, please sign up on the Skills Matter web site: https://skillsmatter.com/meetups/11275-london-scala-users-group Combining BDD and DDD with functional Scala: How BADD can it get? by Oleg Volkov “Functional and Reactive Domain Modeling” by D. Ghosh combines classic object-oriented DDD with functional programming in Scala. Although powerful, the book’s methodology leaves key questions unanswered, such as “How to choose a particular model among alternatives? How to split a model into parts? How to decide upon the modelling granularity?” This talk attempts to solve these questions by combining the DDD methodology with Behaviour-Driven Development. First, the example domain — the design of pharmaceutical experiments — is introduced. Next, key concepts of BDD are adapted to functional programming, and a visual BDD-style model is developed for the domain. This model is then used to drive functional domain-driven design. Finally, we discuss the costs and benefits of the combined BDD/DDD approach for software development in complex domains. Immutability for scale and reliability by Francesco Cessarini The functional paradigm has been influencing mainstream languages for decades, making developers more efficient whilst helping reduce maintenance costs. As we are faced with a programming model that needs to scale on multi-core architectures and distributed environemnts, concurrency becomes critical. In these concurrency models, immutability, a key feature of functional programming paradigm will become even more evident. To quote Simon Peyton Jones, future concurrent languages will be functional; they might not be called functional, but the features will be. In this talk, we explain why!