Monadic Party is a four-days long Haskell summer school. Our vision is to teach in depth with each talk spanning multiple sessions. Because of the additional time at our disposal we can get deeper into each topic to show a larger part of the story behind the subject.
We will have three tracks, one for programmers that aren't experienced in Haskell and would like to learn it from the basic concepts. The other tracks are for people already familiar with the language and will present a selection of talks and workshops on a variety of topics. We will announce the list of topics after our call for speakers closes at the end of February.
For the attendees that arrive on the 17th, and we have a preparty lined up. Check a signup email for more details.
We chose Poznan to host the summer school because of its architecture, culture and nightlife. The venue is a recently restored lovely old building at Mlynska 12 where we have the whole highest floor at our disposal. So 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.
Check out the last year's website.
We will hold the summer school at Mlynska 12, Poznan, Poland. The venue is in the Old Town, a walking distance from a town square. We would love to help you with choosing a place to stay. If you have any questions, please email us at firstname.lastname@example.org.
In terms of travel, WizzAir, Ryanair, Lufthansa and LOT all have a dense network of daily connections to and from the city. If you want to save some carbon dioxide, there are frequent train connections from Germany and inside Poland. Buses are also a good budget option with PolskiBus which operates a lot of routes in the region.
Inside the city of Poznan there is a good public transporation system with a dense network throughout the city.
We're the organizers of Monadic Warsaw, Ewa Kruzynska and Michal Kawalec. With almost six hundred members it grew up to be one of the biggest Haskell meetups in Europe. We've had speakers and visitors from all over the world and we also host a YouTube channel. It is our way of popularizing functional programming and building a community of interested people. We are sure the summer school will give us as much fun as Monadic Warsaw.
We are deligted to offer a means based scholarship programme. If you are financially unable to attend the summer school, 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 first edition was really successful, so we're really happy that we can continue offering it this year as well.
In Haskell we are used to design systems using types as both a guiding tool and verfication of desired properties. Session types allow to do that when developing protocols. In this course we will dive into this framework and develop an example protocol and prove it correctness (or rather let GHC prove it for us).
If you are not used to the pure functional paradigm, then dealing with arrays in Haskell can be very unintuitive, the code you write can become inefficient, especially if you choose the wrong library or an incorrect data structure for the job.
Throughout the series of talks and workshops I will cover some concepts about native arrays that every Haskell programmer should understand as well as provide concrete examples on how to deal with multidimensional arrays using the `massiv` library. First lectures will start with basic topics, such as memory representations and how to properly handle mutation. Then we will transition into more advanced notions of fusion, stencils and other ways of avoiding unnecessary computation, while taking advantage of automatic parallelization. Besides looking at many simple examples we will have hands on experience developing a more complex application that will reinforce the understanding of concepts introduced earlier.
Haskell is fantastic for industry use. The language can give you some nice correctness guarantees. This peace of mind can make software feel boring (in a good way). I want to convince you of this claim.
In this talk/workshop series, I'll show you how to write small but useful applications in Haskell. We'll talk about common patterns you need in a production setting (e.g. JSON, HTTP, and databases).
This interactive talk series explores the Comonad typeclass while solving real problems. Students are presented with practical examples to ground their understanding and cement their learnings by implementing the things they learn along the way. Git checkpoints are provided so nobody is left behind. The workshop-style series covers everything from "what's a comonad?" to using comonads for solving real problems, including simulating cellular automata and image processing!
Language is everything; it governs our lives: from our thought processes, our communication abilities and our understanding of the world, all the way up to law, politics, logic and programming. All of these domains of human experience are governed by different languages that talk to each other, and so should be your code. Haskell provides all the means necessary—and many more—to easily and safely use embedded small languages that are tailored to specific needs and business domains.
In this series of lectures and workshops, we will explore the whats, whys and hows of embedded domain-specific languages in Haskell, and how language oriented programing can bring type-safety, composability and simplicity to the development of complex applications.
Arthur is a software engineer writing mainly PureScript and Haskell at Lumi. A researcher by heart, passionate learner and languages aficionado—in all their forms—he is currently on a journey into the deep corners of programming languages and type theory.
Build a merkle tree type meant to represent directory trees (as used by git, mercurial, etc) using recursion schemes, then use this to implement lazy diffing of arbitrary large merkle trees (real world problem for bigco monorepos), see an example implementation. We will dive into how functor composition can be used to build different merkle tree structures starting from various primitives (Maybe, , Either a, (,) a, etc) - eg, did you know that
type List a = Fix (Compose Maybe ((,) a)) and
type NonEmptyList a = Fix (Compose ((,) a) Maybe)?
In this talk will start with the untyped lambda calculus and gradually build up towards simply typed, system F, system Fω and a dependently typed language. Particular attention will be paid to the parsing and type-checking issues that arise as the language increases in complexity.