- λ: Streaming with FS2 // Sync considered unethical
Welcome in 2019! We hope that you had great holidays and some of your New Year's resolutions include λs, because the first meetup of the year is all about functional programming! We invited two guest speakers, who will present their approach to some of the hottest Scala FP topics. 1. "Stream or not to Stream? FS2 is the answer" (Łukasz Byczyński) Streams are often underestimated and skipped as possible solutions. In many cases, we created much more complex solutions than their streams counterpart. Why? It's hard to answer, but in this presentation, I would like to tell you a story about how we started to use FS2, without sacrificing purity and code readability. (https://github.com/functional-streams-for-scala/fs2) 2. "Sync considered unethical" (Tomek Kogut) Scala over the past few years has become more and more inclined towards the pure FP. Most of the techniques and concepts are coming from the Haskell programming language. Some of those are already considered obsolete, some are being adjusted to what Scala is and some new might be just heading our way to show up during 2019 Scala conferences. Let's try to look where all of this have led us. Compare it to some of the works done in real world Haskell. We'll see if it brought us any closer to the liberation from the von Neumann paradigm. Last but not least we'll try to answer the question: are we any better than our colleagues doing plain old imperative programming? About our speakers: Łukasz Byczyński (https://twitter.com/lukaszbyczynski) I started as coder since from I get my first 8-bit computer - C64. It was a long journey for me, from a machine assembly code to the pure functional constructs. Right now, I'm passionate about designing pure architectures with reasonable costs. I'm a part of the team responsible for build the platform for implementing machine learning algorithms in Adform. Tomek Kogut (https://twitter.com/almendar) Technical Lead in Adform’s research department. He gained his programming experience from creating low-level kernel modules in C / C ++ through telecommunications systems written in enterprise Java to ETL big data pipelines. His favorite programming language since 2011 is Scala. He likes and appreciates the functional approach to programming, but tries to keep an eye on the efficiency of the solutions he creates. In everyday work in Adform he builds with his team the best platform for implementing machine learning algorithms. --- As always there will be some beer, contests and JetBrains' licenses to give away! See you in Metaforma!
- Decentralised applications using ipfs and libp2p
This month we are going back to the Barka Alrina and will have a special guest coming to Kraków. Jan Pustelnik will take us to the truly decentralized world. Abstract Cloud or so-called serverless is just an evolution of the traditional client-server model. But what about applications that do not require any server? Yes, it's not just possible, but even very easy with ipfs and libp2p. In this talk, I want to discuss decentralized applications, basic tools for creating them and typical problems they solve. Bio TBA https://twitter.com/gosubpl As Always there will be some beer, contests and JetBrains' licenses to give away!
- Trip into Reactive System with Lagom & Practical Reactive Streams with Monix
Forklog - Crypto Cowork In Krakow
Hi all! I'm happy to announce you that we have two speakers for our next meetup: Krzysztof Borowski from VirtusLab and Jacek Kunicki from SoftwareMill. Talk #1 Krzysztof Borowski "Short Trip into Reactive System space with Lagom" Abstract I want to invite you on a short trip around a few popular recently spots. We will visit the rapidly developing space of Reactive Systems and mighty Domain Driven Design region assisted by our new friend Lagom. Alongside visiting some interesting places like Reactive Programming marketplace, CQRS and Event Sourcing library, Lightbend factory, our friend Lagom will perform for us showing some nice skills. Sounds interesting? Bio Krzysiek is a Scala programmer @ Virtuslab. Believes that simplicity is the key to modern software development. Passionate about all technologies and ideas that make programmer life brighter and more interesting. Born with a love of mountains, singing, and exciting new experiences. Talk #2 Jacek Kunicki "Practical Reactive Streams with Monix" Abstract Stream processing is a hot topic today and it’s easy to get lost among all the possibilities. In this live coding session, we will explore the Reactive Streams approach used by the Monix project - one of the Scala implementations of the Reactive Streams concepts. Bio I'm a passionate software engineer living in the JVM land - mainly, but not limited to. I also tend to play with electronics and hardware. When sharing my knowledge, I always keep in mind that a working example is worth a thousand words.
- Journey in the World of Types
This month we have a special guest coming to Kraków. Mateusz Kuboszok (https://kubuszok.com/) will take us to the world of TYPES. We will start with the fundamental question of "what is type?" and end up with more involved ones like "how to implement kind projectors using structural and path-dependent types". There will be two related talks: beginner-level and advanced one. 1. Introduction to types This one will cover some foundations: * types and sets, * how type inference works, * what are algebraic data types, * relation between types and classes, * type constructors. As such it is aimed at beginners that are familiar with Scala's syntax, but feel their knowledge about types is a bit unstructured. 2. All you need to know about types in Scala ...assuming, you already know the basics ;) [see above!] Here, we'll discuss some more advanced stuff, some of which is what gives Scala an advantage over many other languages: * kinds and higher-kinded types, * type constraints, * variance, * existential types, * structural and refined types, * path-dependant-types, * kind-projectors. Between both parts there will be a one-be(v)er(age) break to refresh and network. Bio: Mateusz is a software engineer that likes math and correctness. He has been programming in Scala for 3 years, wrote a few small libraries and articles. More about Mateusz: * https://kubuszok.com/ * https://twitter.com/MateuszKubuszok * https://github.com/MateuszKubuszok
- Slick 3 / Compile faster with Bloop
Talk #1: “Database access with Slick” by Paweł Dolega Abstract The goal of the presentation is to have a quick introduction to Slick in version 3.x — Scala most popular alternative for classic ORMs (like Hibernate in Java). In fact it’s not an ORM… but we’ll talk about that later. Presentation is to be pragmatic, so after going through it (together with code samples) you should be able to start using it in your project with no problems at all. We will focus on how basics of Slick work and how you can build relevant queries / operations / patterns, how to wrap them in transactions and generally — how to use Slick wisely. We won’t talk about Slick internals at all. This will also be sort of an excuse to dig into functional programming paradigms. No prior Slick experience is required. Even more, no prior Scala experience is required (!), though it might help a little. Some experience with classical ORMs or DB access libraries might be beneficial. So in short — if you are Java developer and wanted to come to see what Slick is all about — even only for broadening your horizons (without really thinking about using it at work) — you are still invited and hopefully you should be able to gain some useful knowledge here. Bio Jack of all trades (and a master of none). Software engineer by education and at heart. Throughout my career I have been developer, team lead, manager. Worked in international corporations, small local software houses (two of which I co-founded) and medium-size software house. Delivered projects for large corporations, small startups and everything in-between (small, medium companies, corporations, startups, government organizations). These days I am VP of Engineering responsible for Cloud & Reactive stack applications at VirtusLab. --- Talk #2: “Compile faster with Bloop” by Paweł Bartkiewicz Abstract Bloop is a Scala build server, aiming to make your edit-compile-test workflows as fast as possible. It is build-tool-agnostic, so you can use it on its own, but there are also integrations for sbt, Gradle, Maven and Mill. During this talk we will explore how it works, how it can make your work more efficient and see how to set it up. Bio Bloop contributor, Scala developer at Scalac. Enjoys every form of programming, from assembly and microcontrollers to Haskell and big servers. Loves types. Always considers security first.
- Workshop: Asynchronous programming in late 2018
Workshop: Asynchronous programming in late 2018: Akka, scalaz-zio, Cats-effect or maybe Kotlin’s coroutines? We will build system for decrypting hashed passwords. Input data - encrypted text - will be delivered by the external server over REST calls. Client library, which we will be implementing during this workshop, will be responsible for fetching encrypted passwords, decrypting them, and sending them back to the central server. Whole workshop is divided into few sections. We will start with most basic prototype, and will try to gradually make it more efficient and less error prone. You need to pick one of 4 teams: Akka scalaz-zio Cats-effect Kotlin’s coroutines Each team will try to solve the same problem with its technology guided by its own mentor. Do you want to learn one of those four and compete against others? Sign up here: https://goo.gl/forms/OPCeBHRimy3Y4jNs1 today! There are 5 places in each team and if we get more registration by the end of this week then we will pick lucky ones at random. This is a joint workshop with Kraków Kotlin User Group: https://meetup.com/krakow-kotlin
- Special Summer Meetup: The hour of Jon's Fury
Hi! The reason of our Special Summer Meetup is that Jon Pretty's coming to Cracow! Take a look at his talks: Topic 1: Builds are Infuriating Fury is a new build and dependency manager for Scala, taking a revolutionary new approach to how Scala may be developed in the future. At Scala Sphere in April, I gave an introduction to Fury, but three months later, it is about time you saw Fury in action! So I will give an overview of Fury's capabilities, and a live demonstration where we will go through the steps of creating, developing, building and publishing a build for an existing open-source Scala project. You will see how easy it becomes to make, modify, and maintain Fury builds and get an insight into how I envisage Scala's ecosystem changing for the better over the next few years. The talk will be a very interactive session, with interruptions and suggestions welcome, so please bring and ask questions! Topic 2: Lifting Data Structures to the Type-level In this talk, I will give a fast-paced tour of how various features of the Scala type system, many of them under-explored, can be harnessed to construct type-level representations of a number of different datatypes in Scala. The type system offers a limited number of “tools”, such as subtyping, least-upper-bound inference, type unification, singleton types and dependent types and (of course) implicit search, which we can compose in interesting ways to implement type-level operations on these type-level data structures. Value-level operations follow naturally from the types, but they are much less interesting. Jon's Bio: He is a longstanding contributor to the Scala community, having launched the first commercial applications written in Scala over ten years ago. He is best known for his work on Rapture, and his contributions to Typelevel Scala. Hope to see you there! KSUG Team *** Please note that both talks will be in English.
- Intro do Scala / FP + Starting out in open source
Talk #1: “Introduction to Scala via FP (and to FP via Scala)" by Paweł Włodarski Abstract (talk in Polish!) A mixture of introduction to Scala & Functional Programming. We will focus on mechanisms of Scala that allow to easily transition toward functional programming. I will try to show which aspects of Scala / FP are the most useful ones in daily work. Bio Member of Łódź JUG — group of passionate engineers focused on Java and other technologies. He organizes lectures and workshops — so called educational activities within IT community. Every year tries to help a little with (perhaps the largest) mobile technology conference — “Mobilization”. Professionally in develops software in Java for last 10 years. Recently he does more also in Scala. Talk #2: “Starting out in Open Source” by Piotr Gawryś Abstract Contributing to Open Source seems appealing to many but it might feel like the entry point is hidden behind impassable wall. Based on my experience starting out as a passionate but clueless rookie I will talk about contributing to open source projects and share advice how to actually commit to it regardless of your level! Bio My main interests in programming revolve around leveraging purely functional abstractions and type systems to make our developers' lives easier. I started getting involved in open source projects early in my career and now I am one of the maintainers of Monix, high-performance Scala / Scala.js library for dealing with asynchronous programming. Currently Software Developer at VirtusLab. *** Sponsors VirtusLab is the founding sponsor of Kraków Scala User Group.
- The Real Serverless & sttp: the Scala HTTP client that you always wanted!
Hi, We invite you for an extraordinary meetup! Take a look at plan and save the date: #Talk 1: "The Real Serverless" by Jan Pustelnik Abstract: You probably have heard the pun that serverless is just running software on another person's computer. However, I would like to show something else - "real serverless" which is running software without any servers in a fully distributed, peer-to-peer manner. Let's discover how Scala, Akka's CRDTs and the Inter Planetary File System (ipfs) can help you build applications that can scale and work without any central point of failure. Bio: Software Engineer at Actyx by day, sporadic Akka and Dotty projects contributor by night. Interested in how software works on low level, he does not find big frameworks appealing. This is the main reason why 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. In his spare time he loves to dust-off some old issue of computer science journal only to find out that everything has already been invented before he even was born. Talk #2: sttp: the Scala HTTP client that you always wanted! by Adam Warski Abstract: There’s a number of great Scala HTTP libraries, however on the API side, we can do better! That's where sttp comes in: it's goal is to provide a simple, type-safe API for defining & sending HTTP requests, while leveraging battle-proven backends. In the no-slides, purely live-coding talk we’ll go through the main features of sttp: the URI interpolator, API for building requests, decoupling request definition and execution. Plus, integrations with a variety of effect-wrapping stacks, mean you can use the same programmer-friendly API regardless if you use Akka Streams, Monix, Scalaz or Cats! Bio: I am one of the co-founders of SoftwareMill, where I code mainly using Scala and other interesting technologies. I am involved in open-source projects, such as sttp, MacWire, Quicklens and others. I have been a speaker at major conferences, such as ScalaDays, LambdaConf and Devoxx. Apart from writing software, in my free time I try to read the Internet on various (functional) programming-related subjects. Any ideas or insights usually end up with a blog (https://softwaremill.com/blog). *** We do our best to organise KSUG meetups regularly. If you would like to share something among community, do not hesitate to poke us :) Speakers are always welcome. Huge thanks to VirtusLab for sponsoring the event - venue, drinks & video. See you soon! KSUG Team