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.
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")
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.
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 technologies that give static guarantees for web applications, such as type-safe markup DSLs, applicative form parsing and construction, and lifting the entire web application structure to the type-level to ensure correctness and derive program behavior.