filter_list help_outline
  • Liked Philip Wadler
    keyboard_arrow_down

    Philip Wadler - (Programming Languages) in Agda = Programming (Languages in Agda)

    60 Mins
    Keynote
    Beginner

    The most profound connection between logic and computation is a pun. The doctrine of Propositions as Types asserts that propositions correspond to types, proofs to programs, and simplification of proofs to evaluation of programs. The proof of a conjunction is a pair, the proof of a disjunction is a case expression, and the proof of an implication is a lambda expression. Proof by induction is just programming by recursion.

    Dependently-typed programming languages, such as Agda, exploit this pun. To prove properties of programming languages in Agda, all we need do is program a description of those languages Agda. Finding an abstruse mathematical proof becomes as simple and as fun as hacking a program. This talk introduces *Programming Language Foundations in Agda*, a new textbook that is also an executable Agda script---and also explains the role Agda is playing in IOHK's new cryptocurrency.

  • Liked Bartosz Milewski
    keyboard_arrow_down

    Bartosz Milewski - A Taste of Type Theory

    Bartosz Milewski
    Bartosz Milewski
    Math Evangelist
    Programming Cafe
    schedule 3 months ago
    Sold Out!
    60 Mins
    Keynote
    Beginner

    We use types in programming, often without realizing how deeply rooted they are in the foundations of mathematics. There is a constant flow of ideas from type theory to programming (and back). We are familiar with algebraic data types; inductive types, like lists or trees; we've heard of dependent types and, in the future, we might encounter identity types and possibly get familiar with elements of homotopy type theory. I can't possibly talk about all of this, but I'll try to give you a little taste.

  • Liked Edward Kmett
    keyboard_arrow_down

    Edward Kmett / Tony Morris - Let's Lens

    480 Mins
    Introductory Workshop
    Beginner

    Let's Lens presents a series of exercises, in a similar format to the Data61 functional programming course material. The subject of the exercises is around the concept of lenses, initially proposed by Foster et al., to solve the view-update problem of relational databases.

    The theories around lenses have been advanced significantly in recent years, resulting in a library, implemented in Haskell, called lens.

    This workshop will take you through the basic definition of the lens data structure and its related structures such as traversals and prisms. Following this we implement some of the low-level lens library, then go on to discuss and solve a practical problem that uses all of these structures.

  • Liked Edward Kmett
    keyboard_arrow_down

    Edward Kmett - Logic Programming à la Carte

    30 Mins
    Invited Talk
    Beginner
    I've been working on a logic programming framework in Haskell, called guanxi (關係) with an eye towards scalability. To build it I leaned heavily on my previous work on propagators and a bunch of other little bits and pieces of algebra and category theory in the design process. A number of patterns have arisen repeatedly throughout the process of building this library. I'll give a tour through the current state of guanxi and try to extract some of the more reusable bits of its design for your inspection.
  • Liked Les Kitchen
    keyboard_arrow_down

    Les Kitchen - Compose:: Hang out and Hack (Free!)

    480 Mins
    Introductory Workshop
    Beginner

    In conjunction with YOW! Lambda Jam, Compose::Melbourne will be running an all-day Hang Out And Hack session, on Monday May 13 - the same day as Lambda Jam Introductory Workshops. Bring your laptop if you have one, learn and work on Functional Programming. We'll run "office hours" (people can request help on particular topics, or offer to help others); lightning talks; and generally we'll hang out and hack together.

    This is a free event, open to the whole Functional Programming community, beginners or experts, whether or not you are attending the main Lambda Jam conference on 14th & 15th.

    Unlike the paid Workshops, the free Hang Out And Hack will not be catered so attendees will need to make their own arrangements for food; there are a number of places within the venue and surrounds, or feel free to BYO.

    Please register for your free Hang out and Hack ticket, so we can get an idea of numbers and plan activities appropriately.

  • Liked Susan Potter
    keyboard_arrow_down

    Susan Potter - Growing A Functional Discipline

    30 Mins
    Invited Talk
    Beginner
    Adopting functional programming in an existing software development organization is plagued with difficulties. Challenges include how to manage, maintain, and evolve existing systems with your new vision in a sustainable way while building expertise in a systematic functional mindset.

    This talk reviews some of the lessons learned over several years of growing a functional discipline at primarily mainstream approach organizations to building backend services and infrastructure in Scala and Haskell to satisfy business needs where mainstream software development approaches were failing to produce.

    Technical leaders, engineering managers, and individual software developers should expect to learn some approaches to:
    - reducing risks associated with introducing new methods to an organization
    - growing a learning culture from the ground up with support from the top
    - transitioning from ad-hoc workaround-based implementations with example-based usages to more defined understanding of the problem domain by considering domain and system properties and translating that from business to code at multiple levels.
  • Liked Josh Price
    keyboard_arrow_down

    Josh Price / James Sadler - Intro to Elixir

    480 Mins
    Introductory Workshop
    Beginner

    Elixir is an extremely accessible functional programming language that is rapidly gaining popularity for good reason. With it's well curated, batteries-included tool chain, excellent documentation and it's sheer simplicity, not to mention its incredible 30+ year Erlang heritage.

    The goal of this workshop is to get you a basic familiarity with Elixir and the tools you'll need to be effective working in the language. It will be aimed at programmers who don't know Elixir, and don't necessarily know any functional programming.

    The workshop is organised around a set of exercises that should take you through the basics of the language. Once you've got to grips with the language and tools you'll be ready to build a real time game server. In this workshop you'll learn everything you need to start building amazing, production ready Elixir applications

  • Liked Manuel Chakravarty
    keyboard_arrow_down

    Manuel Chakravarty - Welcome to FP Introductory Workshop

    480 Mins
    Introductory Workshop
    Beginner

    Functional programming has become inevitable. New programming languages draw inspiration from the functional paradigm; old programming languages retrofit support for functional programming; and development teams change their coding style to adopt the best functional programming idioms. We are clearly experiencing a paradigm shift in our industry.

    Due to its academic roots, functional programming sometimes seems unapproachable, with unfamiliar jargon, obscure concepts, and bewildering theories. It doesn’t have to be like that.

    In this one-day series of lectures and hands-on workshops, we will translate the jargon, demystify the concepts, and put the theories into practice. There is nothing inherently difficult about functional programming. In fact, its main aim is to simplify programming and to make it more widely accessible. Functional programming is about being able to understand one function without the million lines of code it is a part of. It is about code reuse. It is about modularity and keeping code easy to change and refactor. These are all goals of good program design that every developer appreciates. Based on this common ground, we will explore functional programming together and see how it can help us to achieve these design goals. In fact, by learning the fundamentals of functional programming in Haskell, we can improve program design in mainstream languages, such as Javascript and C++, and even more so, in hybrid languages, such as Scala and Swift.

    Throughout the day, we will explain the most commonly used functional programming terminology. You will learn the fundamentals of Haskell, one of the most popular functional programming languages. In the process, we will look at a lot of concrete code to understand what functional programming is all about and how to use it in your own programs. In the workshops, you will have plenty of opportunity to write code yourself, experiment, and ask questions. It’ll be fun!

    Bring your laptop and your curiosity and by the end of the day, functional programming will be another tool in your toolbox, and you will be ready to enjoy the main YOW! Lambda Jam conference.

  • Liked Manuel Chakravarty
    keyboard_arrow_down

    Manuel Chakravarty - Plutus — Haskell for Blockchain Contract Development

    30 Mins
    Invited Talk
    Beginner

    With the proliferation of blockchain designs, we see a proliferation of proposals for languages and systems to script the rules governing transactions on these blockchains, generally known as smart contract languages. Despite the name, these languages are usually fairly conventional programming languages used to impose constraints on the transactions permitted to transfer assets and manipulate data stored on the blockchain.

    Given the high financial stakes and widely publicised exploits on first generation (Bitcoin) and second generation (Ethereum) blockchains, the third-generation Cardano blockchain places a strong emphasis on functional programming and formal methods. This includes a new approach to contract languages based on state-of-the art research in programming languages and the increased safety provided by functional programming. The benefits of functional programming go even further: instead of having to invent yet another custom language, we simply use Haskell for the job, we design a functional blockchain architecture, and we seamlessly combine on-chain and off-chain computations.

    In this talk, I will outline how IOHK’s Plutus team combines programming language theory, functional programming in Haskell, and theorem-proving in Agda to develop a radically new approach to blockchain contract development. This work has resulted in the Plutus Platform, which uses meta-programming in Haskell for distributed contract applications operating on the Cardano blockchain.

  • Liked Dmitrii Kovanikov
    keyboard_arrow_down

    Dmitrii Kovanikov - co-log: Composable Contravariant Comonadic Logging Component

    Dmitrii Kovanikov
    Dmitrii Kovanikov
    Haskell Adept
    Holmusk
    schedule 2 months ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    In this talk I'm going to share key design decisions behind Haskell logging library called co-log.

    This library combines multiple algebraic concepts in order to provide convenient and composable solution for the logging problem:

    • Semigroup and Monoid
    • Contravariant/Divisible/Decidable
    • Comonads

    I'm also going to show how we use this library in commercial Haskell projects.

  • Liked Andy Kitchen
    keyboard_arrow_down

    Andy Kitchen - Meta-quines

    30 Mins
    Talk
    Beginner

    A quine is a program that outputs its own source code, but can you create a 2 quine, a pair of programs that output each other with an A->B->A->B cycle? What about between different languages? Can you gzip your own source code? Is there a structured way to do this with theory? All these questions will be somewhat answered, in ways that will make your head hurt... math-a-magical demos and over 9000 layers of meta-ness await!

  • Liked Brad Urani
    keyboard_arrow_down

    Brad Urani - Elixir's Ecto: Functional-Relational Data Access Done Right

    Brad Urani
    Brad Urani
    Staff Engineer
    Procore
    schedule 4 months ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    Relational databases provide a challenge for functional programmers: they're inherently mutable, but they're still the best choice for many applications due to their guarantees and performance. Fortunately, functional languages like Elixir - and the frameworks built around them - are re-inventing the way we do SQL, and the results are all positive. Join us and learn about Ecto, Elixir's answer to functional-relational data access. If you're sick of leaky abstractions, you'll love how it exposes the database for what it is. If you're building for the web, you'll love how its incorporation into the Phoenix web framework is modernizing web development. If you've had a bad experience with database abstractions in the past, you won't want to use anything else. Just don't call it an ORM.

  • Liked Ben Lippmeier
    keyboard_arrow_down

    Ben Lippmeier - Types (are / want to be) Calling Conventions

    30 Mins
    Talk
    Intermediate

    Functions in the lambda calculus rightly take single values as their arguments, and return single values as their results. Functions in machine code rightly take multiple values as their arguments (preferably in registers), and return multiple values (preferably in registers) as their results. For a compiler writer, dealing with this mismatch is a right headache. Arity information, which describes how many arguments each source level function "actually" takes wafts through ones codebase like an unpleasant odour, and after particular compiler stages subverts ones once loved source-level type signatures into unfortunate lies.

    Salt is a new compiler intermediate language that embraces uncurriedness as a first class condition, and whose type signatures speak the truth about arity. Functions are functions still, but their types are honest about the fact that no one really evaluates lambda expressions using capture avoiding substitution. The GHC core language tried to tell a similar story using unboxed tuples, but it didn't quite work. The C language stayed out in the sun for too long wondering what a void returning lambda abstraction really returned, and when we all came back to find it, the only thing left was Salt.

  • Liked Jonathan Merritt
    keyboard_arrow_down

    Jonathan Merritt / Luke Clifton - Haskell Spaceflight Workshop

    90 Mins
    Workshop
    Intermediate

    In celebration of the 50th Anniversary year of the Apollo 11 moon landing, we present a spaceflight-themed exploration of numerical methods in Haskell!

    This workshop focuses on both the joys and pain-points of intentionally using Haskell's abstraction capabilities for numerical work. We consider what approaches are available to make the time-domain simulation of dynamical systems safer. To do this, we solve practical problems by combining vector-spaces, units, linear, and several other libraries. The results are not always ergonomic (warning: may contain some horrible type errors), but we feel they help to demonstrate what is currently possible and motivate further development. Unlike many more theoretical presentations of this topic, our focus in this workshop is very much on solving real problems, selected from the published spaceflight literature.

    Participants will use abstractions from the vector-spaces library, applied to numerical integration of ordinary differential equations (ODEs) and simple optimization algorithms. They will see how algorithms written using these abstractions are more generic, even allowing types with statically-checked units to be used with them.

    On the spaceflight side, participants will implement some basic spacecraft manoeuvres, and we include some pre-baked simulations that interact with participants' code. Among the scenarios examined is a simulation of the lunar ascent phase of the Apollo missions, including a faithful transcription into Haskell of the actual guidance algorithm used during the lunar ascent (our Haskell version has statically-checked units!).

    We encourage all forms of participation; from people who want to follow the prescribed set of problems, to those who may want to re-implement our examples in other languages, or just deep-dive into the spaceflight theory. All the problems have fallback solutions that can be examined or called directly.

  • Liked Ken Scambler
    keyboard_arrow_down

    Ken Scambler - Applied Category Theory - The Emerging Science of Compositionality

    Ken Scambler
    Ken Scambler
    Software Architect
    MYOB
    schedule 4 months ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    What do programming, quantum physics, chemistry, neuroscience, systems biology, natural language parsing, causality, network theory, game theory, dynamical systems and database theory have in common?

    As functional programmers, we know how useful category theory can be for our work - or perhaps how abstruse and distant it can seem. What is less well known is that applying category theory to the real world is an exciting field of study that has really taken off in just the last few years. It turns out that we share something big with other fields and industries - we want to make big things out of little things without everything going to hell! The key is compositionality, the central idea of category theory.

    This talk will introduce the emerging field of applied category theory, with the aims of:

    • Giving attendees a broad overview of cutting-edge applications of category theory
    • Building an understanding of a small number of the most important core concepts
    • Getting attendees excited, inspired to learn more, and equipped to apply some basic concepts to their work

  • Liked Ben Kolera
    keyboard_arrow_down

    Ben Kolera - The Reflex Architecture (Combo Workshop)

    90 Mins
    Workshop
    Intermediate

    Reflex-dom is a remarkably awesome way to write frontend web applications in Haskell. Reflex DOM is built from Functional Reactive Programming (FRP) primitives defined in a library called Reflex.

    Writing apps in reflex-dom is a little weird at first because it's a whole brand new paradigm to structuring your programs. Just like the jump from imperative programming to FP, jumping into FRP is a tricky process of rewiring your brain to fit the new model of thinking. It can be very difficult to appreciate the power and architectures that you can from this transition while you are still learning the basics, which naturally makes it difficult to be motivated to put in the work.

    In this workshop we will implement parts of the "real world demo", a demo blogging application designed as a way to test frontend frameworks with things like backend calls and frontend routing. There will be a lot of skeleton and example code already written and be very directed, so it's -- as with the talk -- it is going to be more getting a high level feel than learning all of the fundamentals. It is the hope that the fast paced guided intro will allow you to do the rest of the learning at your own pace later.

  • Liked Attila Egri-Nagy
    keyboard_arrow_down

    Attila Egri-Nagy - Approaching the Yoneda Lemma

    30 Mins
    Talk
    Intermediate

    The Yoneda lemma is not the first thing to learn in category theory, but sooner or later it appears in studying the field. Unfortunately, there is quite a gap between the intuitive idea, "tell me your friends, and I will know who you are" , and its precise formulation. This talk aims to bridge this gap by introducing algebraic results in the middle, namely Cayley's theorem for groups and its generalization to semigroups. These are elementary enough, but at the same time they exhibit the conceptual step of representability, and the idea of studying all different things in a familiar form.

  • Liked Xuanyi Chew
    keyboard_arrow_down

    Xuanyi Chew - An Alien Lambda Calculus

    Xuanyi Chew
    Xuanyi Chew
    Chief Data Scientist
    Ordermentum
    schedule 2 months ago
    Sold Out!
    30 Mins
    Talk
    Beginner

    The conventional wisdom in functional programming communities is that lambda calculus was "discovered". Extending the logic of the statement to its extreme, we might propose that an alien would recognize lambda calculus as a computational model. But would we be able to recognize an alien lambda calculus?

    This talk is part gedankenexperiment, part speculative fiction, part practical advice on compiler design. We begin by imagining ourselves to be creatures in a universe which is very different from the one we're in, except the notion of consciousness and intelligence are preserved from our current universe. From there, we shall explore the physics and alternate philosophies that would yield an alien lambda calculus.

    Of course, being from an alien conception, there are some questions that must be answered - in the name of practicality, is there perhaps even a weak notion of a functor from the alien lambda calculus to that of the one we know today? Is there anything from the alien lambda calculus that we may yield and put into practice? And what is this pesky business with state? Isn't the point of functional programming to hide states from the programmer by abstracting over them? Or was it to make clear the states? And what of names? Isn't lambda purely anonymous?

  • Liked Jacob Bass
    keyboard_arrow_down

    Jacob Bass - Functional Programming in Spring with Arrow, Lenses and Effects

    Jacob Bass
    Jacob Bass
    Engineering Manager
    Ordermentum
    schedule 2 months ago
    Sold Out!
    30 Mins
    Talk
    Intermediate

    With the introduction of Kotlin as a supported language, as well as the Arrow functional programming framework, building a functional web application with Spring has never been easier. More importantly, the conversion path from an Object Oriented Spring app to a Functional Programming Spring app can be accomplished with little risk and much reward.

    Spring is the most widely used JVM web framework. For many years, the paradigm it has adopted has been object-oriented, stateful and imperative. This talk will show how to take such a codebase and refactor it into a functional programming style. It will show the benefits of this approach with regards to clarity, stability, safety and testability.

  • Liked Andy Kitchen
    keyboard_arrow_down

    Andy Kitchen / Les Kitchen / Lyndon Maydwell / Noon van der Silk - Compose Melbourne :: What we Learned from Starting a Functional Programming Conference

    30 Mins
    Talk
    Beginner

    Everything you ever wanted to know about starting a functional programming conference from scratch and some things you didn't. We'll cover the great times, the stressful times and all of the behind-the-scenes. Learn how we brought people together, how we chose talks and how we managed to create a community atmosphere enjoyed by both beginners and sages alike.

Looking for your submitted proposals. Click here.