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,
* existential types,
* structural and refined types,
Between both parts there will be a one-be(v)er(age) break to refresh and network.
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:
Talk #1: “Database access with Slick” by Paweł Dolega
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.
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
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.
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: 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:
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
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.
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!
Please note that both talks will be in English.
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.
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ś
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!
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.
VirtusLab is the founding sponsor of Kraków Scala User Group.
We got 1 free ticket for Scala Wave conference (https://scalawave.io/), so don't waste your time and sign up to participate in a draw!
The winner will be picked at random. To enter simply RSVP to this event.
We invite you for an extraordinary meetup! Take a look at plan and save the date:
#Talk 1: "The Real Serverless" by Jan Pustelnik
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.
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
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!
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!
ScalaSphere (http://scala.sphere.it) is a unique event devoted to important topic for every Scala Software Developer - Dev Tools.
Our aim is to show how they can facilitate effective development of Scala-based systems, how they are written, and to discuss what could still be improved.
Call for Papers is still open and Early Birds tickets are available (https://www.eventbrite.co.uk/e/scalasphere-2018-tickets-40189400579) - Find more info here (http://scala.sphere.it/)
1 TICKET = 3 EVENTS
Take a look at Sister events of ScalaSphere:
- ReactSphere is a conference focused on Reactive Programming and Reactive System Design. Now in its 2nd Edition, it’s a perfect opportunity to meet and share knowledge with experts in this field.
- DataSphere is a conference devoted to data-centric systems and the technologies making them tick. Whether it is data engineering or AI application challenges – they all fit well in.
Here you can find a description what we will do: https://github.com/scalacenter/sprees/blob/master/README.md
Conducted by ScalaCenter: https://scala.epfl.ch/
*Free entrance* but registration is obligatory here: https://scalaspree.eventbrite.co.uk/
• What to bring
• Important to know
Right before ScalaSphere conference: https://scala.sphere.it/ we prepared a special workshop.
A gentle introduction to the world of Scala programming language in which everybody can find a place for themselves. We do not require any great knowledge of programming or information theory, only basic knowledge in the world of computers and your own computer. We will try to match the pace of the workshop to each participant as much as possible.
The workshops will last around 8 hours with a break for dinner and we will try to all the basics during that time which will allow everyone to succesfully continue the adventure with programming in Scala. Precise information on the plan and what is necessary for the preparation will be given before the workshop.
More info: http://www.scalabridge.org/
• What to bring