Lambda World
Lambda World 2024 - The Power of Function Composition - Conor Hoekstra
updated
The largest functional programming conference from South Europe is coming stronger than ever with topics such as AI & ML with FP, Software Architecture & System Design, FP in Web Development, Data with FP, Computation in functional technologies, Emerging FP Tools & Trends, etc.
3 days full of workshops, talks and social events.
Bring up your Monads buddies!
More info at: www.lambda.world
A Few Things You Always Wanted to Know About Tagless-Final* (*But Were Afraid to Ask)
- Is tagless-final the same as the MTL style?
- Which is the type of tagless-final programs for a given algebra?
- Pattern-matching on tagless-final terms ... is that possible?
- Bottom-up or top-down? How do I optimize tagless-final programs?
These are some questions about the tagless-final style which we will attempt to answer in this talk (using Scala). In doing so, common themes in functional programming practice will pop-up everywhere: phantom types, type systems, Church encodings, Reader/Writer monads, etc. Familiarity with the style is not mandatory, but it will help. We'll do our best to make a programmer-friendly talk!
Lambda World on Twitter - twitter.com/lambda_world
---
This Meetup is proudly sponsored by:
Xebia Functional - xebia.com
Habla Computing - hablaapps.com
Speaker 1 (begins at 0:00:14 - youtu.be/KGBLX0y-55U?t=14):
Alejandro Serrano
twitter.com/trupill
Talk: Agda´s Greatest Hit
Speaker 2 (begins at 0:10:48 - youtu.be/KGBLX0y-55U?t=648):
Tomás Ruiz
twitter.com/tomasruizlopez
Talk: Functional Programming in Swift with Bow
Speaker 3 (begins at 0:21:42 - youtu.be/KGBLX0y-55U?t=1302):
Tapio Rautonen
twitter.com/trautonen
Talk: Generic Functional Programming with Type Classes
Speaker 4 (begins at 0:38:22 - youtu.be/KGBLX0y-55U?t=2302):
Alfredo de Hoces
Talk: Our smooth transition to functional programming
Speaker 5 (begins at 0:54:58 - youtu.be/KGBLX0y-55U?t=3298):
Flavio Corpa
twitter.com/FlavioCorpa
Talk: ReasonML in 15min
Presentation Description:
JavaScript is a critical part of today's programming landscape, and not just for web applications. However, its lack of static typing has given lots of developers grief over the years as they struggled with cryptic runtime error messages such as 'cannot find property X of undefined' (I've been there, too). With the introduction of ReasonML, we're now able to write statically typed, simpler and faster JavaScript. In this talk, we'll cover what ReasonML is, what it isn't, why it's worth paying attention to, how it works, and how it can be used in your applications.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/tianyupu
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Presentation Description:
In the world of distributed, highly concurrent and scalable systems, few technologies can live up to Erlang/OTP's potential. But, as we often hear, with great power comes great responsibility . . . What if we have designed the architecture of our background to be scalable and used Erlang/OTP to implement it? What now? Should we go straight ahead and jump into the production pool?
Sit and wait for thousands, millions of requests to come? In this talk, we'll see how we can test the robustness of our system in a controlled setting, and in an automated, effective way. Using ProER, a property-based testing tool that follows into the footsteps of the famous QuickCheck, we will see how our software's validation can be both a challenge and a cool task, when we put the right tools in practice.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/lauramcastro
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
For people coming from functional languages, you may wonder when you would want to use Rust. Rust has functional patterns and takes ideas from substructural type systems. A combination of functional patterns, the borrow checker, and drop checker enable us to have nice program control flow you'd expect with a functional language and granular control of our system resources. In this talk, we'll explore how Rust empowers programmers to write logically correct and memory safe programs.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/DebugSteven
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Presentation Description:
What if compile time and type level programming in functional programming languages were easy, something you reach for without even thinking about it? What if you could debug type errors with a simple compile time print statement? Write highly flexible systems by being able to introspect into types at compile time? Pre-calculate large portions of your programs for great efficiency?
Typed functional programming is a great and fun way to write resilient software, and as type systems have become more and more expressive in recent years, we are able to program sophisticated and useful properties at the type level for even better compile time safety. Just one problem: It is very difficult, requires advanced knowledge of the type system, the syntax is convoluted, the error messages are impenetrable, and it is nearly impossible to debug.
This talk will dive into why we should steal static introspection from languages like Nim, and D, state-of-the-art imperative programming languages which can solve all these issues, make type systems much more approachable without losing any expressive power, and offer new design possibilities for functional programs.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/deech
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
Category theory provides us the setting and a common language to talk about computation and composition. Its usage pervades and inspires languages such as Haskell and Scala, lending concepts like functors and monads. Still, functional programming is just one of the possible applications of category theory, which may actually vary from physics and chemistry to machine learning and blockchain. So what about a change of perspective? Let's make category theory the subject of our code and actually implement it!
In this talk, we will take a look at how we can define concepts of category theory, using a programming language as Idris, which allows us to properly define all the required laws and properties of the objects in question, and we will see how we can take advantage of them in concrete contexts.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/marcoshuttle
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Keynote description:
I’ll talk about the history of Scala’s implicits: how they evolved, some mistakes we could have avoided in hindsight, as well as aspects I believe we got right. I then present the revised implicit design of Scala 3 and explain how it addresses the problems mentioned earlier.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/odersky
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
Functional programming and blockchains are a match made in heaven! The immutable and reproducible nature of distributed ledgers is mirrored in the semantic foundation of functional programming. Moreover, the concurrent and distributed operation calls for a programming model that carefully controls shared mutable state and side effects. Finally, the high financial stakes often associated with blockchains suggest the need for high assurance software and formal methods.
Nevertheless, most existing blockchains favour an object-oriented, imperative approach in both their implementation as well as in the contract programming layer that provides user-defined custom functionality on top of the basic ledger. On the one hand, this might appear surprising, given that it is widely understood that this style of programming is particularly risky in concurrent and distributed systems. On the other hand, blockchains are still in their infancy and little research has been conducted into associated programming language technology.
In this talk, I will explain the connection between blockchains and functional programming and argue that blockchains are a well-suited application area for functional programming techniques. I will illustrate this with evidence from the research-driven development of the Cardano blockchain and its contract programming platform, Plutus. Cardano and Plutus are implemented in Haskell and Rust, and the development process includes semi-formal specifications together with mechanised theorem proving to formalise key components.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/TacticalGrace
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
This talk will centre on developing systems where distributed components interact via asynchronous message passing, and need to follow specific interaction patterns, e.g., ad-hoc application-level protocols, such as POP2.
I will discuss ongoing work towards establishing relationships between protocols and their implementations, focussing on time-sensitive protocols, where interactions are associated to time-constraints. We will look at two (partly-related) formal ways of describing protocols: Timed Session Types and Automata.
Session Types are a powerful and effective technique for program verification; they allow to type-check programs against their communication behaviour, other than on the type of the messages. For Timed Automata, the relationship between protocols and (abstractions of) programs can be expressed as a refinement relation between more and less abstract models, giving concrete guidelines on how to implement timed protocols while preserving the intended behaviour and progress.
I will discuss recent theories, learnings, open challenges, and future directions.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
Recursion is the fundamental looping mechanism in functional programming. This talk shows patterns of recursion using Haskell. It shows those patterns for list structure only. This makes it easier for beginners to understand recursion schemes by focusing on their operation with lists. We start by writing explicit recursive versions of sum, product, and length of lists, then factor them into fold functions. We proceed in a similar manner with other folds, unfolds, and refolds with many examples of the patterns in operation. We end by mentioning factoring recursion out of data.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/haroldcarr
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Presentation description:
We, as two entry level engineers, took on the challenge of introducing Kotlin and Functional Programming to our company, Intuit. Even though you all know Kotlin is a great language, we overcame the obstacles associated with a large company structure of having a common tech stack. In addition, Kotlin provided a natural transition for OOP Java developers to use Functional Programming Paradigms.
Hear about how, in less than two years, we went from getting our diplomas to gaining influence and driving change at a major technology company, and how you can do it too.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/klevy110
-twitter.com/srcohen
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Slides are available here: http://www.math.jhu.edu/~eriehl/lambda.pdf
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/emilyriehl
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
The field of data science, which has an increasingly profound impact on our lives, is meanwhile in the middle of an identity crisis. The fundamental questions of what data science is, who is a data scientist, and how do we best do data science to serve society, remain largely undecided. Regardless of where the answers will fall, there are a number of tools, techniques, and ways of thinking that every data scientist should have in their toolbelt. Although the software languages, frameworks, and algorithms will come in and out of fashion, the fundamentals behind the trade have existed for centuries and will continue to be used for ages to come.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/emgrasmeder
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Presentation Description:
Arrow Meta is a library that empowers library and application authors with the ability to write plugins for the Kotlin compiler. Compiler plugins have access to all compiler phases and can intercept and modify the AST, descriptors, and IR intermediate lang for bytecode generation. In this talk, Simon Vergauwen and Raul Raja, Arrow maintainers from 47 Degrees, will go over the main features of Arrow Meta and how the Arrow library aims for:
- Bringing first-class FP capabilities to the Kotlin compiler.
- Provide a framework for developers to write compiler plugins easily.
You will learn how the Kotlin compiler works internally and how you can write compiler plugins with the Arrow Meta library.
We will discuss some of the current Arrow plugins in development and the future and state of FP in Kotlin:
- Keep 87. Type class and extension families
- Monad Comprehensions
- Higher Kinded Types
- Automatic Optics derivation
- Refined types
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/vergauwen_simon
-twitter.com/raulraja
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
Developers interested in seeing Haskell being used as a general programming language. Engineers hoping to see Haskell as an environment in which one can quickly and effectively iterate between requirements, design and running, executable code - providing value to the business with an immediate feedback loop. Developers eager to see how they can rapidly create software that is flexible to changes, extensible and testable.
Pre-requirements:
basic understanding of Haskell syntax (functions, composition, do-notation, type classes)
basic FP building blocks: functor, monad
(optionally) some previous exposure to free monads
(optionally) scars and war stories of using tagless final in Haskell
Tech stack we will explore:
polysemy
servant
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/rabbitonweb
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
In general, we don’t know much about our functions other than their potential associativity. But what if we knew more about them? In this talk, you will learn how to use algebraic properties of functions, data types and effects to improve the performance of your programs.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description
The very essence of functional programming relies on a fairly simple premise: write side-effectless programs, so that you can reason about them equationally. Side-effects however are predominant in every program that . . . well, does something useful. In light of this, the modelling of effects in functional programs has become a fairly active domain of study. From stacked effects, to horizontal ones; from transformers to free monads and so on. Every effect model, though joyfully they may seem, have some rather unfortunate consequences. In this talk, I'd like to share with you some of these effect models and exemplify both their joyful and unfortunate nature.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/amrobert11
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Full Presentation Description:
Racket, a functional language in the Lisp family, promotes a language-oriented style of programming. Developers create many domain-specific languages, write programs in those, and compose these programs via Racket code. This style of programming can work only if creating and composing little languages is simple and effective. This talk will demonstrate how Racket achieves this goal, starting from bare-bones functional code and moving through a range of examples from classical research (Algol '60) to modern end-point programming for the Web.
------
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
Visit:
-47deg.com/events for more details
-http://www.lambda.world
See what you missed over two days of workshops, talks, and networking events. Then, stay tuned to youtube.com/channel/UCEBcDOjv-bhAmLavY71RMHA for all the official videos from the talks.
Thanks to our awesome sponsors:
Platinum:
- Thoughtworks
- The Workshop
- Packlink
Gold:
- Signify Technology
- LetGo
- LunaTech
- RavenPack
- Tecsisa
- ZonaFranca Cádiz
Silver:
- Cabify
- Fundación de Unicaja
twitter.com/Lambda_World
twitter.com/47deg
Our Call For Papers is officially open, apply to share your Functional Programming knowledge with the community!
http://www.lambda.world/call-for-papers/
The event features the following short presentations:
00:00:13 - Shape-dependent computations in Scala - Juan Manuel Serrano (twitter.com/juanshac)
00:18:57 - Reactive architectures: The functional way! - José Escanciano
(twitter.com/slaverg)
00:40:20 - A Tree that counts its leaves, in Haskell! - Alejandro Serrano
(twitter.com/trupill)
00:59:43 - Pragmatic development in Eta - Nikita Tchayka
01:15:37 - Printing Combinators, applying contravariant functions - Pepegar
(twitter.com/pepegar_)
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
Visit:
-47deg.com/events for more details
-http://www.lambda.world
This talk focuses on how Impostor Syndrome and the Dunning-Kruger effect work to undermine our estimation of our individual skills. Who do these cognitive biases affect? And how do they collectively shape the face of the software development industry? The impact of these biases on personal and professional relationships among individuals and groups will be examined, along with what can be done to diagnose and cope with them.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/jesslynnrose
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Boring use cases for exciting types
Functional programming, in Scala and in general, is very jargon-y. Words and co-Words such as coyoneda, adjunction, comonad transformers and divisible functors are impressive, but without making effort to place them in our day-to-day context, they remain an academic interest. That's a shame, though - these data types and type classes can really make our life easier!
In this talk, I will take 3-4 plain and business-y use cases and show how they can benefit from some lesser known constructs from functional programming. Boilerplate will be slain, elegance will ensue and hopefully - you will find them useful enough to incorporate in your day-to-day work!
Slides are available here: speakerdeck.com/iravid/boring-usecases-for-exciting-types
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/itrvd
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Rust and Haskell, sitting in a tree
Rust is a systems programming language with a nice type system and quite a few (maybe surprisingly) functional features. Where do they come from? Let's see if Haskell knows.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
Visit:
-47deg.com/events for more details
-http://www.lambda.world
The Complexity Trap: Think Before You Leap
Recently, many people in the functional programming community, and specifically in the Scala community, seem to follow the trend of solving their programming problems with more and more fancy abstractions and techniques. If in doubt, we throw a monad at the problem, and if that's not good enough, we'll make it free. Naturally, to top it off, we have to sprinkle the whole thing with some type-level programming, because this is common courtesy these days. In this talk I want to challenge some of the fundamental assumptions of how we think and work. With all our sophisticated engineering, are we actually solving the right problems? Are we rushing towards technologically exciting solutions too quickly? How much of the complexity in our software is inherent in the problem domain, and how much of it is of our own making? We may have honorable intentions, but do our solutions come at an acceptable price? Maybe it's time to slow down, think about what the problems we have to solve actually are, and how to do so in the simplest way possible.
If you'd like to get more in-depth, you can read Daniel's article on his talk: danielwestheide.com/blog/2018/12/07/the-complexity-trap.html
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/kaffeecoder
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Functional Programming in Anger
While functional programming may be a simpler and more expressive way to build applications, even functional software endeavors over time are dominated by problems surprisingly similar to those found in traditional approaches. Besides leading ClojureScript compiler development, I’ve had the fortunate opportunity to work closely with a diverse set of clients on ambitious projects and experience their ClojureScript pain points first hand. In this talk, we’ll cover the benefits provided by functional programming without ignoring the many past glaring holes in our technology that have been slowly filled over time by observing users trying to ship real products.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/swannodette
Visit:
-47deg.com/events for more details
-http://www.lambda.world
How to make ad hoc proof automation less ad hoc
To overcome the burden involved in interactively mechanizing mathematical proofs on a computer, most theorem-proving systems such as Coq and Isabelle, support user-customizable proof automation by means of tactics.
Tactics, introduced by Milner in Edinburgh LCF, are programs that can inspect and algorithmically manipulate assertions in the prover's base logic, with the goal of simplifying or discharging them.
While tactics are clearly useful in practice, they are beset by a number of fundamental limitations. They are written in a domain-specific scripting language, which by necessity resides outside of the prover's base logic, and lacks the base logic's precise typing. This in turn makes tactics famously difficult to maintain, and impossible to precisely specify and verify.
In this talk I will present an alternative architecture for user-customizable proof automation, specifically in Coq, which overcomes the above limitation.
The starting point is the observation, well known as Curry-Howard isomorphism, that proofs and programs in Coq are equivalent entities. Thus, concepts and ideas developed in the world of programming, can be applied to mathematics as well.
In particular, I will show how the idea of overloading a method name in programming (a.k.a. ad hoc polymorphism, static dispatch), can be applied to mathematical theorems.
Such an 'overloaded theorem' realizes a method for an automated discharge of a class of proof obligations, which, unlike a tactic, can itself be verified in the base logic of Coq, and flexibly composed with other Coq programs, theorems and proofs.
This is joint work with Georges Gonthier, Beta Ziliani and Derek Dreyer.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
Visit:
-47deg.com/events for more details
-http://www.lambda.world
MirageOS, towards a smaller and safer OS
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/Dinoosaure
Visit:
-47deg.com/events for more details
-http://www.lambda.world
A roadtrip with monads: from MTL, through tagless to BIO
This talk is about a journey: from imperative code to purely functional one. It starts with a program written in imperative style. Its weak spots can be quickly recognized: lack of robustness, testability and maintainability. We seek our salvation in the functional paradigm, but the road to enlightenment, has many dangerous and deceivable dead-ends. The quest has a happy ending, as we reach code that is performant, testable, readable and maintainable. Keep in mind however that knowledge comes from experience. As once someone wise said 'Its the not the Destination, it's the Journey.'
Though it is not a live coding session, it will sure feel like it. Code is written in Scala, parental guidance is advised.
Slides are available here: slideshare.net/paulszulc/trip-with-monads-120830020
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/rabbitonweb
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Testing in the world of Functional Programming
Testing is one of the most fundamental aspects of being a software developer. There are several movements and communities based on different methodologies with regards to testing such as TDD, BDD or design by contract. However, in the FP community testing is often not a large topic and is often glossed over. While it’s true that testing in functional programming tends to be less important, there should still be more resources on how to create tests that add actual value.
This talks aims to provide exactly that, with good examples on how to leverage property based testing, refinement types and the most difficult part: figuring out how to test code that interacts with the outside world.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/LukaJacobowitz
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Functional Lenses in JavaScript
Kmett-style lenses (and others) are pretty useful and common in languages like Haskell and Scala. Lenses are defined as functional getters/setters but... how are they useful? How can they help us... in JavaScript!? In this talk we will implement our own lenses library, without dependencies and we'll see how they enforce functional principles as immutability and other patterns like the Open/Close principle. You can't miss it!
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/FlavioCorpa
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Writing a Screencast Video Editor in Haskell
In dire need of better tools when producing screencasts for Haskell at Work, I started building Komposition, the video editor for screencasters. This desktop application automatically detects scenes in screen capture video, detects sentences in audio parts, and features and a high-productivity editing workflow keyboard-driven navigation.
I’ll talk about why I started this project, and share my experiences building Komposition using Haskell. I’ll describe its architecture, what packages and techniques I’ve used, and outline the plans for its future.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/owickstrom
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Elixir - functional, concurrent, distributed programming for the rest of us
Some functional languages require a lot of ceremony to do imperative things. Some have complex abstractions around concurrency or distribution. Some make handling failures painful.
Elixir is a flexible language that has many of the nice things functional programming provides, but also strives for being practical.
In this talk, we'll see how Elixir and the Erlang virtual machine provide a set of tools that make it easier to work with concurrent, distributed applications.
We'll see how failure handling and most of all recovery are built in the foundations of the language. We'll see how this plays well with modern system architectures.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/whatyouhide
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Headfirst into Haskell
An experience report on a year of learning and working professionally with Haskell. Functional programming newcomers can expect an empathetic tale of learning Haskell the hard way, pitfalls to avoid and tips to get started with Haskell effectively. Seasoned practitioners will gain an overview of the current state of Haskell learning for beginners and where we could learn from other programming language communities.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/sassela
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Keynote: How does code sound?
We study all sorts of aspects of programming languages, their ease of use, type system, their level of abstractness, but we feel one aspect is overlooked, how a programming language sounds like when read aloud. Is reading aloud hard? Well, yes.
We found that developers cannot pronounce code in a consistent fashion. We had 25 experienced developers read code aloud, and it was a mess, even for simple statements. For example, how to pronounce an assignment statement like x = 5? Is it “x is 5”? Or “set x to 5”? Or “x gets 5”? And what about an equality check? Is it “if x is is 5”? Or “if x is 5”? Or “is x is equal to 5”? What can we learn from reading code aloud? We think programming language designers could learn a lot from hearing their language spoken. For example, if programmers consistently read if x == 5 as “if x is 5”, = or even is might be better keyword. What is the ultimate end game of this idea? We envision programming language designers of the future to prescribe a way that their language sounds, much like languages have style guides. When the sound or ‘phonology’ is defined, it can be practiced, taught and analyzed.
This will be useful while learning to program, but could be a valuable tool people that interact with code in an oral way, such as visually and physically disabled programmers, and developers that are doing (remote) pair programming. What will the talk cover?
In the talk, we will describe our experiment and what we learned from it, so other interested in exploring how languages sound can start well-prepared and informed.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/Felienne
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Encoding our way to pure FP in Java
In this talk we will have fun with object algebras and type parameters! Those simple but powerful beasts can quite easily get us:
- Algebraic data-types and lenses;
- DSL (inital or tagless encodings);
- Higher-kinded types!
Let's prove that, with the appropriate tooling, pure FP in Java is quite achievable and desirable!
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/jb9i
Visit:
-47deg.com/events for more details
-http://www.lambda.world
How to get away with functional programming in frontend applications
Functional programming is becoming pervasive in every branch of development, and if you're starting a new frontend project you can choose from many languages that allow you to embrace FP from the start.
However, we can rarely afford to rewrite apps from scratch. So, what to do when you want to start solving problems with functional programming in your existing JavaScript application?
In this presentation, we'll see how we can progressively migrate a codebase to TypeScript and start reaping the benefits of functional programming. You'll learn how to sneak FP into your code base, and get away with it!
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/gabro27
Visit:
-47deg.com/events for more details
-http://www.lambda.world
What Haskell taught us when we were not looking
Haskell, the pure and lazy functional programming language, has now been around for more than 25 years. It had a profound influence on many other programming languages on the JVM: Java, Clojure and Scala and elsewhere: Purescript, Swift, Go (just kidding, not Go :-)). In this talk you will discover which Haskell constructs have made it to mainstream programming languages and change the way you program today. You will also get a glimpse of the features which are yet to be transferred for our greatest benefit. Warning: after this talk you might be tempted to try the real thing!
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/etorreborre
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Diagrammatic Execution Models for Functional Languages
"What is my program actually doing?" Sometimes you feel a need to execute a functional program yourself. Ok, here's a function call. I'll first look at arguments. Now I've got values of arguments, so I'll go onto the function. Remember, this parameter is now this value, that parameter is now that value... You jump around the program, back and forth between variables and pieces of code, and keep collecting results of these visited pieces.
This talk introduces diagrammatic models of functional-program execution. The underlying idea is to express the above process using diagrams; the "token", your agent, moves around a diagrammatic representation of a whole program, and visited pieces of the diagram dynamically change to represent their results (so we do not need to remember!).
We will explore these diagrammatic models, which help us not only with visualising program execution but also with designing a language. These models can cover from conventional programming, with various evaluation strategies including call-by-value (used in OCaml) and call-by-need (lazy, used in Haskell), to unconventional (but increasingly significant) programming with "computational graphs".
Last but not least, the models are for mathematical reasoning; from cost analysis of execution to equational reasoning justifying compiler optimisation.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/koko_muro_m
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Rethinking compilers with live coding
Live coding environments run your program on-the-fly as you write it. This makes development easier, but it is a challenge for compiler writers - textbook compiler architecture does not work for live coding systems.
I'll show interesting aspects of a live coding environment for The Gamma, its functional F# implementation and explain how the compiler differs from textbook examples. Along the way, you'll see practical code samples interesting for both web developers and programming language enthusiasts.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/tomaspetricek
Visit:
-47deg.com/events for more details
-http://www.lambda.world
About Packlink:
Packlink launched in 2012 as a platform for comparing and contracting parcel shipments for individuals and companies. Hand-in-hand with the impressive eCommerce boom, Packlink has experienced rapid growth, already operating in several European markets and offering more than 300 transport services and SaaS technology for SMEs, ensuring that both individuals and companies save time and money in freight transport. The mission of Packlink is to make shipments simple and transparent for consumers, companies, and eCommerce around the world.
For more information about Packlink visit:
www.packlink.com
- twitter.com/PacklinkEng
- https://t.co/lpUj0ArlvE
- packlink.com
Musical Patterns as Functions - Live Coding music with TidalCycles
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/tiemposdelruido
Visit:
-47deg.com/events for more details
-http://www.lambda.world
The Radix Tree: How IntMap Works
The Radix Tree (aka PATRICIA Trie) is an efficient data structure for key-value maps with integral keys. Radix tries come up in a wide range of applications like in-memory databases and the Linux kernel, and can be turned into a persistent data structure useful for functional code (Haskell's IntMap).
With pictures and code, I'll walk you through how the data structure works, what Haskell's implementation looks like under the hood and several ways it's useful in functional code. I'll finish with a look towards the future: a quick overview of the Adaptive Radix Tree, a recently published variation on normal Radix Trees with real potential.
While this talk will be Haskell flavored, the data structure itself and the general concepts are all language-agnostic.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/tikhonjelvis
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Introduction to the Unison Programming Language
Unison is a new purely functional programming language, currently under development. Unison treats any pool of networked machines as if they formed a single supercomputer, and lets you program this supercomputer simply and directly. This talk will introduce the Unison language, its type system, runtime, and developer experience, as well as the core ideas that make Unison unique.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/runarorama
Visit:
-47deg.com/events for more details
-http://www.lambda.world
How to look like a statistician: a developer's guide to probabilistic programming
Probabilistic programming integrates standard programming with probabilistic machine learning - and allows people to write probabilistic models without having to care about how they are evaluated and all the mathematical details underneath.
In the talk, I'll show you what is probabilistic programming about, how it works and how you might include probability distributions into F# - and mainly why you don't need a PhD in statistics to write a Bayesian machine learning model.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/evelgab
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Abstract your representations (and fix your functors)
Factoring in software development is the process of decomposing a complex problem or system into constituent parts which are easier to organize, understand, build, and maintain. So why do we refactor so often in our industry?
This talk will introduce the audience to approaches exploited in functional languages supporting parametric polymorphism and higher-kinded types. Leveraging these constructs allows us to re-compose parts of our system in a way that reduces (compared to conventional industrial techniques) the need to refactor large parts. Instead, we define much smaller pieces, passing them as arguments to reusable (already written) generalized patterns of computation.
Not only do we free ourselves from the underlying representation of our structures, this simplifies and reduces ongoing maintenance efforts, but we also get the benefit of termination guarantees and less cumbersome composition of data constructors.
Join us on an exploration of the promise of recursion schemes starting out by merely abstracting representation from our program's structure.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/SusanPotter
Visit:
-47deg.com/events for more details
-http://www.lambda.world
Consensus Algorithms in Distributed Systems
Functional programming enables easy parallel and distributed computing. Many messaging systems that are widely used in the industry, e.g., Kafka, use centralized distributed systems services to achieve reliability and consensus between servers. Companies in the industry use the services; however, only a few of them understand the details of the protocols. This talk introduces the common distributed systems protocols implemented in functional programming underneath the popular services. It provides details of how the protocols, specifically Paxos and Raft, work, including how they elect leaders among servers, how they achieve consensus between machines, and how they reliably process and execute client commands. Therefore, it shows how the systems and services, which use the protocols, are enabled to have fault-tolerance, and to achieve confidentiality, integrity, authenticity, availability, etc. From the reliability and security point of view, the talk discusses how the protocols deal with machine failures, including leader failures and replicas failures. It shows the vulnerabilities and potential security issues exist in the protocols. Last but not least, we'll take a look at what we can do to avoid the vulnerabilities when applying the academic theories in the industry.
Follow:
-twitter.com/lambda_world
-twitter.com/47deg
-twitter.com/yifan_xing_e
Visit:
-47deg.com/events for more details
-http://www.lambda.world


