The Higher-Order Conference
Due to COVID pandemic, for 2020 and 2021 we decided to give a sneak peek preview of Functional Fest thanks to the support of these awesome friends!
The only Functional Programming-related event in the country, carefully crafted for you by the Italian FP community. Awesome speakers and lots of functional programming!
Registration will be open soon. Stay tuned!
Stop being scared by the FP jargon and start applying functional design patterns in your day to day job! In this talk we'll see how to start thinking in functional terms using TypeScript and the fp-ts library. We'll cover real code examples and learn how to exploit type-safety and apply FP concepts from the design phase.
Giovanni Gonzaga , Buildo
Giovanni works at Buildo as technical lead on areas related to frontend development and TypeScript. He gained experience working as a freelancer in Italy and the US for several years. Passionate about next-generation web technologies, programming languages, functional programming and aviation. Before co-founding buildo, he founded a consultancy agency in Italy and has been research assistant at UIC, where he focused on security related to compilers and operating systems. He graduated from UIC with a Master’s in Computer Science and from Politecnico di Milano with a Master’s in Computer Engineering.
Coding is not so different from living: at some point, things will go wrong.
As a good software developer, you should expect such failures and be prepared to fail less miserably.
In this brief talk, I will propose a simple approach to functional error handling in Scala with code examples.
Antonio Murgia , Agile Lab
I design and develop Big Data applications at AgileLab, where I also contribute, with other colleagues, to build an environment where good software is taken for granted. Occasional OSS contributor (when the wind blows in my favor), I started developing Scala applications in 2014 and never stopped since then. I graduated in Computer Science Engineering at Bologna University after a three months stage in the U.S.A. When I'm not in front of a PC, I'm probably eating, hiking, running, or miserably performing some Crossfit workout.
Parser combinators are a technique for building a parser by building it from smaller parsers.
They don’t require a separate grammar definition, it’s just a DSL in your code. They allow you parse the input and map it to a useful form (such as an abstract syntax tree) in a single step.
There are many parser combinators libraries that provide all the building blocks and tooling. You could build a complete JSON parser in a handful of lines!
Still, recreating a simple parser from scratch is a fun way to learn how they work, so let’s do that.
(No prior knowledge required)
Mathias Verraes , Value Object Coom.V.
Mathias Verraes runs a boutique consultancy that advises organisations on designing and modelling software for complex environments, including architecture, analysis, testing, and refactoring “unmaintainable” systems. He has worked with clients in Finance, Government, Supply Chain, Mobility, Energy, E-Commerce, and more. He teaches Domain-Driven Design courses and curates the DDD Europe conference. When he’s at home in Kortrijk, Belgium, he helps his two sons build crazy Lego contraptions.
You are about to fall in love with Functional Programming, if not already. You are going to learn the good parts that are going to make your day-to-day life easier. But since nobody is perfect - not even FP -, you are also going to see its bad and ugly parts, and you'll discover how to deal with them: from learning challenges to performance issues on the JVM.
Haskell, Elixir, two languages with a similar soul, but also with quite some differences. In this talk, I’ll explore those differences — in the language and in the ecosystem — from the perspective of an old Haskeller learning (and being excited!) with Elixir.
Alejandro is currently a trainer and sofware engineer at 47 Degrees, a company specialized in functional programming. Before that, he was a PhD and lecturer at Utrecht University, working on compilers for functional languages. He has written two books, "Practical Haskell" and "The Book of Monads", and he’s active in promoting functional programming in general, and Haskell in particular. He’s active in the community, as member of the GHC Steering Committee and maintainer of projects such as Mu-Haskell.
In this talk, I want to discuss one of the Functional Programming (FP) concepts – totality. Totality is an interesting and essential notion that we all use a lot in FP. That is why it is important to understand its meaning, be able to recognise partial (non-total) functions in your code and be aware of the common cases that could lead to the absence of totality. I will use Haskell language to demonstrate totality on examples, but it is a general FP concept that could be applied elsewhere. This talk will be helpful to you if you are interested in understanding the fundamentals of FP.
I am a Software Engineer with years of experience applying Functional Programming in production. Also, I am an active OSS member, maintainer, mentor, content-maker and co-creator of an open-source organisation – Kowainik. Being a Functional Programming enthusiast, I enjoy using new concepts to solve challenges in production. I am fluent in Haskell, Elm, Purescript. I am also a tech follower with love for learning and experimenting. My experience in different domain fields (such as Healthcare, Insurance, Mortgage, etc.) gives me the advantage of making decisions on architecture and design. I believe that the right tools in the right places could ease and even save lives, so I am definitely trying to make the world a better place through my goals.
Testing is a wide field, with lots of weird concepts not much discussed in the industry.
This talk means to introduce:
- example based testing and how it falls short
- property based testing (PBT) and strategies to identify useful properties
- metamorphic testing for when PBT is too expensive
Nicolas is the CTO of Besedo, where we use Scala to moderate large volumes of user generated content and do weird things to machine learning models. After too many years as a Java programmer and a thankfully brief stint in marketing, Nicolas discovered Functional Programming through Scala and fell in love. Since then, he is made it his mission to learn and explain the scary bits, by focusing on practical applications. Nicolas is also the author and sole maintainer of a few useful OSS libraries, such as kantan.csv.
Often when we talk about libraries, frameworks and modules, we talk about their technical aspects. like the language they are created in. However, programming languages and code bases can also be viewed through a cognitive lens. In this talk, Felienne Hermans, author of the Programmer's Brain, will discuss Cognitive Dimensions of Notations (CDN). CDN is a technique to examine languages and code bases from a cognitive perspective. CDN helps you to answer questions about existing large code bases like “will this code be easy for people to change?” or “will this code be easy for people to find information in?”. Examining code bases from a cognitive perspective, rather than a technical perspective, can help you gain a better perspective on how people interact with your code.
In this talk, we're going to take a look at a practical example of why dependent types are cool. We are going to use Idris and look at Fin, a special type of natural number which is limited to a certain threshold. First we're going to see why it is useful and then we will unpack what sort of trickery is required to create it.
Complexity in building Single Page Applications has skyrocketed in recent years. Phoenix LiveView and Rails Hotwire are pushing for a new way of building webapps, by sending snippets of HTML over the wire instead of JSON. This approach affords a much simpler application architecture and keeps all rendering server-side. But does it work well with Functional Programming? In this talk we'll experiment with Typescript and see how far this approach can be pushed (hint: quite far!).
If you like Elm, Typescript and FP this may be the talk for you.
It's not surprising that writing standalone Haskell applications looks intimidating and incredibly challenging for beginners. You may even spend years learning Category Theory to master Haskell, only to realise later that this doesn't help you write applications using your favourite Functional Programming language. The ecosystem still lacks best practices, and, unfortunately, for something more serious, you eventually need to learn some advanced and non-straightforward topics (e.g. Monad Transformers). In my talk, I'm going to make the process of writing apps in Haskell look less intimidating. I'll describe common problems that people face when starting using Haskell seriously. And I'll introduce cake-slayer — Haskell framework for writing backend of web applications — our approach to writing easy-to-maintain-and-extend backends in Haskell.
Functional Programming is one of my passions, and it has been a part of my professional life for quite a while already. I co-created Kowainik — an open-source organisation where I maintain OSS libraries, write tutorials and mentor people. I'm an author and maintainer of dozens OSS libraries and applications.
I also had been teaching Haskell at ITMO University for several years to undergrad students. I love making complicated topics accessible and sharing my knowledge with others!