Monadic Party 2020
With the COVID pandemic happening around the world, there is a large chance of our summer school not being able to take place in June. Poland currently has an international travel ban and all gatherings of more than fifty people are forbidden.
Taking this into account and thinking about the safety of our speakers and attendees, we will be postponing the summer school. Our current plan is to have it in October, though it is hard to predict things exactly at this stage. Because of that we have issued full refunds to the attendees.
This is a really hard decision to make and we are not taking it lightly, especially given all the preparation and hard work that made the 2020 edition possible. We want to give a big thank you for all your support.
Monadic Party is a four-days long Haskell summer school. Our vision is to teach in depth with each talk taking between four and six sessions. There are three tracks, one for beginners in Haskell and two aimed at intermediate to advanced Haskell programmers.
For attendees that arrive on the 15th, we have a preparty lined up.
The venue is a recently restored lovely old building at Mlynska 12 where we have the whole highest floor at our disposal. The only thing you need is a ticket, laptop and a place to sleep and you're good to go. Catered lunch, tea and coffee is included in the ticket price.
When traveling from ZuriHac, we highly recommend taking a train to help the environment a bit. There is a train on the 15th of June, leaving Zurich at 9am and arriving in Poznań at 8:27pm (changes in Basel and Berlin). When buying well in advance, it costs 99,90 Euros. You can book it here.
We will hold the summer school at Mlynska 12, Poznan, Poland. The venue is in the Old Town, a walking distance from the town square. We would love to help you with choosing a place to stay. If you have any questions, please email us at [email protected].
Inside the city of Poznan there is a good public transporation system with a dense network throughout the city.
We are deligted to offer a means based scholarship programme. If you are unable to attend the summer school because of financial reasons, we have a number of fully funded places available. Everything needed for you to attend is covered - travel to the event, accommodation and the ticket itself.
The scholarship applications are now closed, if you have applied, expect a message from us between 23rd and 27th of March.
This track consists of a crash introduction to Haskell, in two parts of theory and practice. In the theory, we start from scratch and finish with the concepts of functions, type classes and algebraic data types. Armed with this knowledge we switch to the exercise track where we will implement two small games: Snake and Tetris. We will be using an online exercise platform which will guide you through the various stages of implementing the games.
With all the love surrounding the mysterious monad sometimes it’s sibling type class Applicative gets left out in the cold. I’m this workshop we will take a deep dive into what it takes to spot an applicative, build our own instances and *apply* our knowledge through the use of two powerful libraries that leverage applicative to parse and validate text.
This workshop walks you through how to work on a Haskell codebase from start to finish. Everything from starting a project, standard tools and libraries, testing from scratch, benchmarking from scratch and the development lifecycle will be discussed.
In this talk, Justin will start by going through the PureScript language, both in the type level and what the generated JavaScript code looks like. From there, the sessions will go through how to work with the intersection of the Foreign Function Interface of PureScript and types, in order to help users learn how to write full stack applications in PureScript on the browser and Node.js.
During this workshop we will solve a single problem: building a Reliable, Scalable, Maintainable SPA (single page application). Or we will learn how to go from 75K+ React Beast, that is flaky, builds slow, size >1Mb, and scares away newcomers (me), to a "yay I can go to work" Elm app
Four months ago I joined a startup and I very much enjoy the work. During this short period we developed 50k+ line backend service, with 1000+ tests that take <2m to run, that is a pleasure to work with, refactor and extend.
Sadly the frontend 75k+ line app we developed was a problem for business, and developers. The biggest pains it has (imho) are:
If any/many of these sound like pains you have/had, I encourage you to join this workshop and learn a new way how these problem can be solved. During the workshop You will:
We need an understanding how to build real-world applications in Haskell. This is the biggest demand from the Haskell community according to the yearly surveys. We need design approaches, software architectures, best practices and design principles. We need not just a set of distinct ideas but rather a complete methodology of how to build complex applications that will be manageable, testable, simple. Many approaches emerged from the Haskell world recently: Final Tagless, ReaderT pattern, Service Handle pattern, effect systems. But my approach is based on Hierarchical Free Monads, my own methodology that I successfully used in several companies.
In the workshop, you’ll learn how to use Free monads for layering your application, for designing subsystems, for separating interfaces and implementation. You’ll know how to add support of SQL DB, implement logging, add external services interaction. You’ll know how to create a REST servant-based backend that will be using your business logic for doing stuff. You’ll see that the Free monadic approach allows you to do functional and integration testing easily.
For more info, consider my free book Functional Design and Architecture.
We have a growing number of libraries that use HKDTs to morph input types into type of parsers, or type of errors. That allows us to streamline typed data analytics pipeline, database building, and option parsing.
The workshop will be formulated as a series of quests to analyze the input, and get nice graph representations.
To keep advanced listeners on their toes, I will also introduce optional side-quests with Type Families, Generics, and `barbies` library for generic HKDT manipulation.
This talk will help you understand what Lenses, Folds, Traversals, Prisms and Isos are used for and how they fit together. You should feel comfortable getting work done with optics using a library of your choice by the end.
Though it's recommended that you have an intermediate level of Haskell, this talk is suitable to folks completely new to optics or to those who've used them casually.
In the age of dependent types low-level guts of Haskell are often overlooked. Most of us grew fascinated by polymorphism, functors and effect systems and never looked back. This talk is an invitation to go deeper, back to the very roots and discover primitive operations below. Participants will learn how to operate on unboxed data and primitive arrays, and combine them with the high-level code, aiming for better performance and - even more important - relaxing pressure on garbage collector. Topics covered:
Rust is a memory-safe system programming language that uses functional concepts for safety and productivity while maintaining performance similar to C and C++. In this workshop you'll learn how to use Haskell and Rust together to build blazingly fast programs while keeping your sanity.
We'll start by covering the basics of Rust, how to call it from Haskell via FFI, and performance testing methods to make sure you're using the right language in the right place. Then we'll use a small game made in pure Rust to go hands-on with advanced topics including session types and parallel processing. You’ll leave the workshop unafraid to mix in a dash of Rust whenever your project could benefit.
In this workshop we will learn how to use Haskell's ffi, how to share data between C code, and review a heavy architecture and implementation of Win32-network (which heavily uses FFI calls) package which implements asynchronous IO windows interface (also called Overlapped IO in Windows nomenclature) - so we'll get familiar with it too. The workshop is dedicated to intermediate haskellers, or beginners who know basic C programming. C programming is not a prerequisite, but knowledge of pointers will certainly help.
This course is in two parts, each three hours long. Part I is an introduction to formal methods in Agda, covering datatypes, recursion, structural induction, indexed datatypes, dependent functions, and induction over evidence; with focus on formal definitions of naturals, addition, and inequality, and their properties. Part II is an introduction to formal models of simply-typed lambda calculus in Agda, including reduction, type rules, and progress and preservation, and (as a consequence) evaluation of lambda terms. Part II depends on Part I, but Part I can be skipped by those already familiar with Agda.
The textbook is freely available online: Programming Language Foundations in Agda
The book has been used for teaching by me at:
How does the type checker of GHC work under the hood? I will discuss the basic rules, describe the multitude of extensions and experiments added over the years and give some ideas about the future.
Ever wonder how optics actually work behind the scenes? This talk is a friendly introduction to the machinery behind implementing a profunctor optics library. We'll also touch on the Van Laarhoven optics encoding along the way.
It's recommended you be comfortable using optics to perform simple tasks. The "Practical Introduction to Optics" workshop should prepare you for this workshop.
Though it's not strictly necessary, it's recommended that you look over the Contravariant Functor and Profunctor typeclasses before attending.
In this talk I will develop a programming language based on Classical Logic, which allows explicit reasoning about the control flow of the program. The focus will be on the implementation issues that arise when developing a type system in Haskell, as well as the best practices for translating languages presented in type theory papers into Haskell code. Time allowing, I will also show the benefits of using Classical Logic for structuring programs with effectual computation.
In a perfect world, we should never (EVER) have to rely on voting by electronic means, as we sadly, haven't found any solution that is more trustworthy and secure than the traditional framework of pen and paper combined with people, of different backgrounds and political views, to count votes.
Given that more and more countries are pushing for electronic voting, to reduce the cost of this process, but for the most, not always getting it right from either of the four pillars of voting: Functionality, Security, Resilience and Trust seen from the perspectives of Law, Society and Technology.
We would therefore like to provide a "real" open source implementation, copyleft licensed, that doesn't need to be hidden under a "legal wall" as for example a solution provided by the Postal service of a country known for its watches and chocolate. The approach will be based on the Principle of Least Privilege (PoLP), since Haskell is among the very few programming languages that can enforce this at compile-time, which should provide more trustable and auditable software.
