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.
Michael Snoyman is the founder and lead developer of multiple Haskell open source projects, including Yesod, Conduit, Stack, and Stackage. His main interests are creating developer-friendly, high performance libraries that minimize bugs. Michael is VP of Engineering at FP Complete, where he focuses on using Haskell and modern devops to help projects make it to market faster and with fewer bugs.
Zachary has been doing web development for more than 20 years across 3 countries and a wide range of platforms. In that time he has realized that development should be easier than it normally is and has gone to look for the technology that would make that happen.
Bartosz has a Ph D in theoretical physics but his interests led him to study programming, computer science, and mathematics. His blog posts cover wide areas of C++, Haskell, and category theory. His lectures on concurrent programming, Haskell, and category theory are available on YouTube. He has recently finished the online book, Category Theory for Programmers.
I am CTO & co-founder at GetShop.TV, a platform for interactive ads on TV. I also teach a practical course «Programming in Haskell» at MSU for 3rd year undergraduates. I love typed functional programming and use it actively at work, the university and for personal projects.
I am CTO and co-founder of Actyx, author of Reactive Design Patterns, a co-author of the Reactive Manifesto, co-teacher of the Coursera course “Principles of Reactive Programming”, and a passionate open-source hakker. Previously I led the Akka project at Lightbend. I also hold a Dr. rer. nat. in particle physics from TU München and have worked in the space industry for several years.
Loves Clojure, PostgreSQL, open code and open standards, flexible and caring approach to development. Is an active member of FProg and Piter-United communities and Clojurians internet community. Most of Nikolay's code and almost all his presenations can be found on GitHub — niquola.
Almost every step in my professional life has been related to functional programming in one way or another. Currently, I work at Utrecht University, both doing research about functional languages and teaching our students about basic and advanced Haskell. Before that, I was involved in Nublic, a small start-up where we tried to develop the concept of a 'personal cloud'. The project didn't really take off, but we all learnt a lot of Scala. I really enjoy speaking to other about the niceties of functional programming. Some years ago I wrote the book 'Beginning Haskell', and since then I have been active in technical conferences LambdaWorld or LambdaConf, meet-ups in Spain and the Netherlands, apart from more academic conferences about this topic.
Jon has been involved in the Scala community for over a decade, having launched the first commercial and open-source Scala software back in 2005. Since then, he has successfully deployed Scala projects into small, medium and large businesses, and UK government, but is best known these days for his work on Rapture, the Scala World conference, and as chair of the Scala Center Advisory Board.
After some years of musical education, Oskar Wickström began his journey into the world of software. He's currently doing remote work in Haskell. Among the technical topics that interest Oskar are functional programming, systems design, web technology, and programming languages. His more aesthetic side, which mostly involves music, draws him towards graphics and UI design every now and then.
Software developer since 2006, Haskell fan since 2014. Co-founder of the Russian-speaking community of Haskell developers ruHaskell. Author of the book "О Haskell по-человечески" ("About Haskell in Human Words")
I'm a serial entrepreneur and a long time contributor in the Scala.js ecosystem, including popular libraries like Diode and Boopickle.
Twitter: ochrons, Github: https://github.com/ochrons, https://github.com/scalafiddle and https://github.com/suzaku-io
IntelliJ Scala Plugin Developer
Senior software engineer. Currently enjoying writing distributed systems in Thailand.
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.
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.
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.
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.
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".
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.
A talk on how to develop using the whole stack from infrastructure to mobile and css coding in one language - Clojure.
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.