This year we are focusing on a number of FP languages: Haskell, Elm, Clojure, PureScript, ClojureScript. Thanks to your requests we're bringing a dedicated Scala-track back to F(by).
We were super lucky to get approves from several contributors and influencers in FP world.
The event will deliver 2 types of content:
1. hands-on sessions (including workshops) where you can try the technology;
2. presentations on guts of FP languages.
In addition, you will learn more about using FP in web, VR and devops, how it might help you to simplify the code maintenance process. Traditionally we will go ahead with math in programming and learn more about category theory.
Haskell has purity, immutability, referential transparency, and so on. But how does that affect the programs we write? We'll discuss some subtle and not-so-subtle outcomes—both positive and negative—that come from the architectural choices at the root of Haskell.
Programming is math and math is programming. But the kind of math that's useful in programming is not what they teach you in school. In fact it's much more interesting. Category theory seems to be esoteric when presented by mathematicians, because all their examples come from other branches of mathematics. But when you use examples from programming, things suddenly becomes quite obvious. And the reason there is such a close fit between category theory and programming is quite simple: both are built on the principle of composability.
"Writing asynchronous code is often an uneasy fit for a language like Scala. While high-level constructs like Futures facilitate asynchronous programming, syntactic limitations often make blocking or the unchecked access of asynchronously-computed values more natural than the safer alternatives. In this talk, you will discover Impromptu, a lightweight Scala API for safely defining and executing graphs of dependent tasks, avoiding blocking and preventing access of not-yet-completed values, guaranteed the type system. You will use a combination of several advanced type-system features to encode a task's dependencies, then use these types as constraints to restrict access within a task only to the results of dependent tasks which are known to have been completed. You will further take advantage of Scala's type inference to avoid polluting the code with cumbersome type ascriptions. This gives you very lightweight and natural syntax, without blocking or unsafe access. During this talk, you will explore how Impromptu is implemented, and learn how dependent types allow the framework to be written in just 30 lines of code, and show how a similar approach may be used to concisely implement typed actors. Furthermore, you will take advantage of current research into implicit functions in Dotty to remove the small amount of remaining boilerplate from Impromptu task definitions."
Let's have some fun with metaprogramming in Scala. Is there better place for that than Minsk in Belarus? I will do my best to convince you that you should spend few last evenings of 2017 writing some (compile time) magic. If you don't use Scala I hope you will find inspiration to dig deeper into metaprogramming in your language of choice.
The effects performed for example by an Actor can be tracked using indexed monads and compared with a specification that can be derived from a session type. In this fashion we can ensure that the right type of message is communication at the right time, child actors are created when appropriate, and more; it is crucial to note that for this we need not only to register which kinds of effects are performed but also their individual type parameters and sequence. However, the resulting effect types quickly become complex and tedious to read, especially in Scala type errors. This presentation highlights an approach that validates effects while constructing the computation, using implicit evidence to transition between the different states of the specified communication protocol.
IntelliJ IDEA being one of the most popular development tools for Scala, packs plenty of features which help you stop wasting time and energy on routine tasks. Some of them are common knowledge, some are hidden gems that make full use of the underlying intelligent platform. In this talk I will make an attempt both to introduce the newcomers to IntelliJ platform and uncover some of the power features that even experienced users might not have known.
ScalaFiddle is best known as an online playground for writing and sharing short Scala code snippets, fiddles. But it also acts in embeddable form, making it a great tool for enhancing your library documentation. In this talk we go through how to convert your documentation's static code examples into interactive fiddles and what are the different ways of achieving that. We also cover the architectual and design choices in ScalaFiddle that make it "web scale".
Expression problem is about independent adding of the new objects and\or the new operations done on them. It is often used to describe the difference between the OOP and FP approach to writing software. But is it really paradigm-dependent? Can your language solve it? And what are the common approaches to solve it?
Haskell has purity, immutability, referential transparency, and so on. But how does that affect the programs we write? We'll discuss some subtle and not-so-subtle outcomes—both positive and negative—that come from the architectural choices at the root of Haskell.
Programming is math and math is programming. But the kind of math that's useful in programming is not what they teach you in school. In fact it's much more interesting. Category theory seems to be esoteric when presented by mathematicians, because all their examples come from other branches of mathematics. But when you use examples from programming, things suddenly becomes quite obvious. And the reason there is such a close fit between category theory and programming is quite simple: both are built on the principle of composability.
Virtual Reality is more accessible than it might seem. With Google Cardboard and WebVR anyone can create VR experiences. And now with GHCJS we can explore VR with Haskell easily and type-safe! In this talk we'll see how to get started with VR in Haskell and how to interoperate with existing libraries out there. Specifically we're going to explore A-Frame, a JavaScript framework for WebVR, and miso, a Haskell frontend framework, inspired by Elm.
Code maintenance is a painful process, and it will be painful forever. We cannot take this pain away, but we can relieve it. In this talk I'll show you how the Haskell can help us and make our lives more happier.
Web development is one of the main activities in programming. In this talk we look at different components of a web application from the point of view of Haskell. In particular, I shall introduce Servant's approach to type-safe routing, Aeson to work with JSON data types with zero boilerplate, and Persistent for database access. Each of these parts also introduces an advanced Haskell feature: type-level computation, generic deriving and Template Haskell.
When evolving web applications, in most programming languages and
frameworks, we risk introducing programming errors. Undefined values,
parsing failures, broken links, invalid markup, and good old null
pointers, are all things that can break our applications. Manually
writing and maintaining tests to catch programming errors is a time
consuming effort, and we would rather spend that time testing our
application logic. This talk takes you on a whirlwind tour of mature
technologies that offer static guarantees for modern web applications.
I will introduce the Elm language and show how the type system makes doing development in Elm easy and pleasant. No prior experience with Elm is required.
Telegram becomes popular and for a reason. Telegram bots are easy to build thanks to Telegram Bot API and can provide a nice user experience. Essentially bots provide an interface for some web service. And Haskell has some powerful tools for specifying web APIs, such as Servant library. In this workshop, we'll explore the specifics of bot building with features like commands and notifications, custom keyboards, on-the-fly updating and inline mode.
