Conference Time
Local Time

FP Intro Day

Mon, May 21
Timezone: Australia/Sydney (AEDT)
  • Added to My Schedule
    Manuel Chakravarty

    Manuel Chakravarty - Welcome to FP Introductory Workshop

    schedule  08:00 AM - 04:00 PM AEDT place Room 1 people 1 Interested shopping_cart Reserve Seat star_halfRate

    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.

  • Added to My Schedule
    Yaron Minsky

    Yaron Minsky - Introduction to OCaml

    schedule  08:00 AM - 04:00 PM AEDT place Room 2 people 211 Interested shopping_cart Reserve Seat star_halfRate
    The goal of this workshop is to get you a basic familiarity with OCaml and the tools you'll need to be effective working in the language. It will be aimed at experienced programmers who don't know OCaml, and don't necessarily know any functional programming.
    The workshop is organized around a set of exercises that should take you through the basics of the language, up through building a simple client/server application using Async RPC.
    In addition to that, we hope to teach people how to use the latest tools for OCaml, including installing dependencies with opam , building your code with Dune, using Merlin for IDE-style functionality like type throwback and go-to-definition, and writing expect tests to visualize what your code is doing. We'll also show you how to write a simple web-game using js_of_ocaml.
  • Added to My Schedule
    Tony Morris

    Tony Morris / Edward Kmett - Let's Lens

    schedule  08:00 AM - 04:00 PM AEDT place Room 3 people 1 Interested shopping_cart Reserve Seat star_halfRate

    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.

  • Added to My Schedule
    David Laing

    David Laing / Ryan Trinkle - Front-end Development with Reflex

    schedule  08:00 AM - 04:00 PM AEDT place Room 4 people 1 Interested shopping_cart Reserve Seat star_halfRate

    There has been a lot of excitement about Functional Reactive Programming (FRP).

    Most of it has been about distant relatives of the original idea, which are nowhere near as powerful or as useful.

    The `reflex` library -- and the companion `reflex-dom` library -- were created in order to use FRP to do front-end development using Haskell.

    This workshop will give you hands-on experience with these libraries.

    The workshop will show attendees a new way to manage state and time-dependent logic, with significant benefits over the standard approaches when it comes to abstraction, composition and correctness.

    It will also make the case that when these ideas are applied to front-end development, they lead to something beyond what is delivered by libraries like `react` and `redux`.

YOW! Lambda Jam 2018 Day 1

Tue, May 22

    Registration for YOW! Lambda Jam 2018 - 45 mins


    Session Overviews & Introductions - 15 mins


    Morning Break - 30 mins

  • Added to My Schedule
    Jo Cranford

    Jo Cranford - Drinking the Elixir

    schedule  10:30 - 11:00 AM AEDT place Red Room people 75 Interested star_halfRate

    Elixir is a functional language that's growing in popularity as a stepping stone into functional programming, thanks to its strengths in areas like concurrency, fault tolerance and scalability combined with a syntax that is simple to learn, and feels very familiar for those with experience of languages like Ruby or Python. However, it is a very different beast – a functional style, new tools, and Erlang and Elixir libraries to learn, and while many people are experimenting with it, it's not quite mainstream for apps in the wild yet.

    Our Elixir journey began around two years ago, when we started breaking out parts of our monolith and rebuilding it as microservices in Elixir. It was a chance to introduce boundaries, and consider performance from the ground up for an application for which performance was starting to become a concern as the customer base was growing. This talk will tell the story of a journey into a new, functional language and discuss how we approached decisions around where to start breaking the monolith apart.

    The talk will also cover some of the lessons we learned, including:
    - How Elixir’s functional style made us think differently about writing code in other languages
    - Moving from ExUnit to Espec and back again
    - Tools such as umbrella apps that helped us to work with a group of Elixir microservices
    - How we planned for performance from the beginning, and Elixir features that helped us with this such as GenServer
    - Deployment strategies for the Elixir applications
    - How the migration impacted different team members including front end developers

  • Added to My Schedule
    George Wilson

    George Wilson - Contravariant Functors: The Other Side of the Coin

    schedule  10:30 - 11:00 AM AEDT place Green Room people 167 Interested star_halfRate

    Since their introduction, Applicative and its sidekick Alternative have become ubiquitous and beloved type classes in Haskell and similar languages such as Purescript. By contrast, their contravariant counterparts are relatively unknown. These contravariant structures are useful, and their time has come!

    In this talk, we will learn about Contravariant, and its subclasses Divisible and Decidable. How do they work? How do they relate to the classes we know? Are they useful? For what? This talks aims to demystify these classes in an approachable way, by demonstrating their use with practical motivating examples.

  • schedule  11:40 AM - 12:10 PM AEDT place Red Room people 142 Interested star_halfRate

    Automated testing is key to ensuring the ongoing health and well being of any software project, giving developers and users confidence that their software works as intended. Property based testing is a significant step forward compared to traditional unit tests, exercising code with randomly generated inputs to ensure that key properties hold. However, both of these techniques tend to be used at the level of individual functions. Many important properties of an application only appear at a higher level, and depend on the state of the application under test. The Haskell library hedgehog, a relative newcomer to the property based testing world, includes facilities for property-based state machine testing, giving developers a foundation on which to build these more complicated tests.

    In this talk, Andrew will give you an introduction to state machine property testing using hedgehog.He'll start with a quick refresher on property based testing, followed by a brief introduction to state machines and the sorts of applications they can be used to model. From there, he'll take you on a guided tour of hedgehog's state machine testing facilities. Finally, Andrew will present a series of examples to show off what you can do and hopefully give you enough ideas to start applying this tool to your own projects. The application being tested will be a servant web application, and examples will include testing fundamentals such as content creation and deletion, uniqueness constraints, and authentication.

    An intermediate knowledge of Haskell and familiarity with property based testing will be beneficial,but not essential. The slides and demo application will be available after the talk for people to study in detail.

  • schedule  11:40 AM - 12:10 PM AEDT place Green Room people 112 Interested star_halfRate

    Recursion is used extensively in functional programming. It is indeed iteration through nested data structures. Therefore patterns are identified to generalise the nested structure iteration. Using these patterns can factor out the recursion mechanism from application specific logic for code simplicity. That's the purpose of recursion scheme.

    This talk points out different recursion problems are having similar patterns. The recursion scheme is introduced to support these patterns. It will discuss how the common iteration mechanics is separated from the application specific logic by using the patterns, aka morphisms, provided by the recursion scheme. The fundamental pattern, catamorphism, and a few other commonly-used morphisms will be illustrated with some recursion examples.

    The aim of the talk is to give audience an idea of how recursion can be implemented in simple and elegant ways by applying the various morphisms provided by the recursion schemes.

  • Added to My Schedule
    Xavier Ho

    Xavier Ho - Let's Make Functional Generative Art

    schedule  12:15 - 12:45 PM AEDT place Red Room people 152 Interested star_halfRate

    Programming generative art, also known as creative coding, is often a trial-and-error process, combining creativity and logic to present something aesthetic. However, creative coding has a high barrier to entry due to the breadth of knowledge and coding skills required. This talk aims to lower that barrier for you to take home and practice creative coding.

    In this talk, you will learn about algorithms and techniques for generative art using a pure functional paradigm. First, shepherding random numbers to simulate the universality of nature patterns that appear in plants, rocks, sand, and smoke. Next, using L-system formal grammar to create a seemingly infinite, but well-structured, series of graphics. Lastly, interfacing with printers to bring your drawing to life.

    For you to get the most out of this talk, you should be comfortable working in a functional language of your choice. Although I will introduce some theory, background in mathematics and formal theory is not required to attend.

  • Added to My Schedule
    Jacob Bass

    Jacob Bass - Higher Kinded Types in a Lower Kinded Language: Functional Programming in Kotlin

    schedule  12:15 - 12:45 PM AEDT place Green Room people 83 Interested star_halfRate

    It's hard coming back down to the earth of a JVM based language after spending time with Haskell and OCaml. The type systems are enviable, and the abstractions available are incredibly powerful.

    Yallop and White's paper on Lightweight Higher-Kinded Polymorphism has been an inspiration for many libraries seeking to add functional abstractions to languages that don't support them. For Kotlin, one library is [Arrow](, which provides incredibly powerful abstractions over native language capabilities like co-routines, reactive-streams and nullable types.

    This talk will discuss functional programming in Kotlin with the Arrow library, how the abstractions it provides can improve your code, and how this magic that provides higher-kinded types works under the hood.


    Lunch Break - 60 mins

  • Added to My Schedule
    Vaibhav Sagar

    Vaibhav Sagar - Your First Functional Deployment!

    schedule  01:45 - 03:15 PM AEDT place Red Room people 116 Interested star_halfRate

    Functional programming is wonderful, but what happens after we're done writing code (functionally) and we need to put it in production? The most popular solution is to write a shell script that manually performs the work of installing dependencies, configuring the target, and running our software. This approach is hopelessly imperative and lacks reproducibility, immutability, and simplicity, things we otherwise take for granted. Can we do better?

    The Nix package manager and ecosystem brings the functional programming approach to bear on the the problems of installing, configuring, maintaining, and upgrading software, and allows your development and operations teams to realise the promise of functional programming to move faster, break nothing, and sleep better at night.

    In this workshop I'll walk you through the process of making your first functional deployment and effectively dealing with change. I hope that after this you will be inspired to take a closer look at Nix and see what it can do for you and your team!

  • Added to My Schedule
    Ben Hutchison

    Ben Hutchison - Getting (More) Work Done with Extensible Effects in Scala

    schedule  01:45 - 03:15 PM AEDT place Green Room people 67 Interested star_halfRate

    This hands-on, code-centric session teaches attendees how effectful functional programming can be used to tackle the often messy, IO-heavy problems found in industry. We will use the Scala Eff monad library to incrementally build and extend a directory scanner.

    Participants without any previous background in Eff or effectful FP have a smooth on-ramp. A series of refactoring exercises incrementally transforms an imperative program into a purely functional, effectful programming, introducing the Eff API along the way:

    • The Async effect to model asynchronous requests
    • Using Either effects for error handling
    • Using Reader effects for dependency injection
    • Writer effects for logging

    For those with previous Eff experience, or have done my Eff workshop at Lambdajam 2017, there are new exercises that dig deeper into Eff:

    • Programming stateful systems with the State effect
    • Combining effects and functional optics
    • Two different approaches to side-effects: catch-all IO vs focussed effect DSLs

    The Eff library is an implementation of Extensible Effects in Scala, developed by Eric Torreborre. It is inspired by Oleg Kiselyov’s Haskell paper ‘Freer Monads, More Extensible Effects’ . Like Monad Transformer stacks and the Free monad, it provides an organising principle for the construction of pure functional programs.

    Materials are available at benhutchison Getting Work Done With Extensible Effect. Solutions are included for all exercises.

  • Added to My Schedule
    Jacob Bass

    Jacob Bass - Higher Kinded Types in a Lower Kinded Language: Functional Programming in Kotlin (Code Jam)

    schedule  01:45 - 03:15 PM AEDT place Blue Room people 31 Interested star_halfRate

    It's hard coming back down to the earth of a JVM based language after spending time with Haskell and OCaml. The type systems are enviable, and the abstractions available are incredibly powerful.

    Yallop and White's paper on Lightweight Higher-Kinded Polymorphism has been an inspiration for many libraries seeking to add functional abstractions to languages that don't support them. For Kotlin, one library is [Arrow](, which provides incredibly powerful abstractions over native language capabilities like co-routines, reactive-streams and nullable types.

    This code jam will demonstrate functional programming in Kotlin with the Arrow library, how the abstractions it provides can improve your code, and how this magic that provides higher-kinded types works under the hood.


    Afternoon Break - 30 mins

  • Added to My Schedule
    Brian McKenna

    Brian McKenna - Teaching functional programming at Atlassian

    schedule  03:45 - 04:15 PM AEDT place Red Room people 163 Interested star_halfRate

    My team works on Atlassian Marketplace, a project which started 10 years ago and uses Scala, Haskell and Nix. The Marketplace code uses concepts such as applicative functors, monad transformers and lenses. People joining the team mostly learned concepts as they needed to, through experimentation and asking questions.

    Last year we started hosting functional programming classes for more fundamental and broad understanding. We've been using the Data61 (formerly NICTA) Functional Programming Course with a lot of success. This talk will describe how we teach FP, what we've learned about teaching FP and the challenges we face.

  • Added to My Schedule
    Fraser Tweedale

    Fraser Tweedale - Taming the C monster: Haskell FFI techniques

    schedule  03:45 - 04:15 PM AEDT place Green Room people 68 Interested star_halfRate

    Haskell has a powerful foreign function interface (FFI) for interfacing with C libraries. Haskell is a great language for building libraries and tools, but interoperability requirements or time constraints can make the FFI a compelling option.

    Binding to a non-trivial C library presents several challenges including C idioms, memory management, error handling and more. This presentation will address a selection of these concerns, using hs-notmuch, a binding to the notmuch mail indexer, as a case study. We will discuss:

    • FFI basics and tools to assist binding authors
    • working with "double pointer"-style constructors
    • working with iterators; how to do lazy iteration
    • how to use Haskell's garbage collector to manage lifecycles of external objects, and "gotchas" encountered
    • using types to enforce correct use of unsafe APIs
    • performance considerations (including profiling results)

    The presentation will conclude with a mention of some important FFI concepts that were not covered (e.g. callbacks) and a look at how hs-notmuch is being used in the Real World.

    Developers familiar with C will get the most out of this talk (because there will be limited time to explain C idioms, memory management, etc). To varying degrees, most of the concepts and techniques discussed will apply to other languages' FFIs.

  • Added to My Schedule
    Josh Godsiff

    Josh Godsiff - The Human Side of Haskell

    schedule  04:20 - 04:50 PM AEDT place Red Room people 64 Interested star_halfRate

    I've been writing Haskell at Arbor Networks for about a year now, and while there are certainly a ton of benefits on the technical side, and a lot of interesting concepts, some of the most profound (and least discussed) impacts of Haskell occur on the personal and team levels.

    This is a talk about what I've learned about the human side of Haskell over the passed year. It touches on

    • How it makes it easier to think through problems and express yourself.
    • How it facilitates clear communication within teams.
    • How it allows for more agile decision making.
    • How it makes good practices the easy and natural thing to do
    • Some of the challenges and negative impacts it has.

    It may be of interest to anyone curious about what Haskell is like as a full-time, production language at a commercial company, or to people who are interested in a viewpoint beyond or other than a technical one.

  • Added to My Schedule
    Mark Hopkins

    Mark Hopkins - All of Basic Category Theory

    schedule  04:20 - 04:50 PM AEDT place Green Room people 174 Interested star_halfRate

    Have you ever been puzzled by the suggestion that

    data Lens s a = Lens { get :: s -> a, set :: a -> s -> s }

    might be in some sense the same as

    forall f. Functor f => (a -> f a) -> s -> f s/code>

    or, more to the point, how on earth someone ever went about figuring this out in the first place?
    Don't know your Kan extensions from your co-ends, your pushouts from your presheaves?

    Join me for a scenic adventure tour through the magical land of category theory, stopping off at all the major sights.

    We'll learn the basic notions that form the conceptual backbone of category theory,
    and how they all fit together.

    Category theory has made deep inroads into computer science theory, but in this talk we'll be focused on computer science practice. We'll explore the advantages category theory brings to programming in terms of

    • providing alternate representations for types
    • classifying solutions, or
    • simply providing a clarifying viewpoint and helping to organise our thinking.

    In addition this should provide you with the right framework for further exploring category theory, should you so wish.


    Combinators Revisited - 45 mins


    Conference Drinks & Networking - 80 mins

YOW! Lambda Jam 2018 Day 2

Wed, May 23

    Session Overviews & Introductions - 15 mins

  • Added to My Schedule
    Yaron Minsky

    Yaron Minsky - Reactive Programming with Diff and Patch

    schedule  09:00 - 10:00 AM AEDT place Red Room people 205 Interested star_halfRate
    Writing reactive programs can be challenging. Such programs need to be able to react efficiently to changes as they stream in from the outside world, which often leads people to make their program logic incremental in an ad-hoc way, directly expressing their logic in terms of how to integrate a change, rather than as an all-at-once
    But such ad-hoc incrementalization is complicated, and the resulting programs can be hard to reason about. In this talk, I'll discuss an approach that leverages the fact that functional data structures can often be diffed efficiently. I'll show how the ability to diff and patch can be integrated into a more general reactive programming
    framework to let you write programs which read like simple, all-at-once implementations of your program logic, but which perform like hand-optimized change-oriented programs.

    Morning Break - 30 mins

  • Added to My Schedule
    Sam Ritchie

    Sam Ritchie - Implementing the Elm Architecture for iOS in Swift

    schedule  11:05 - 11:35 AM AEDT place Red Room people 51 Interested star_halfRate

    Elm, for a long time the flag bearer of Functional Reactive Programming on the web, recently switched to a simpler pure functional architecture, citing 'ease of use'. Those of us that have worked on complex reactive mobile apps can sympathise with this - using FRP injudiciously in your app can make the code difficult to understand and near impossible for new developers to pick up.

    So are we able to apply some of the techniques and patterns from Elm into iOS apps? It turns out the Elm architecture is a really great fit for Swift & iOS - it allows us to:

    • reserve our FRP hammer for the use cases that make the most sense
    • separate out a simple, consistent, and highly testable pure functional core, and
    • provide a flexible, yet easily understood & applied set of architectural building blocks.

    This session will cover the basics of implementing and using an Elm-style architecture in a Swift app, will include lessons learnt in a real-world implementation, pitfalls/benefits, and implementation considerations should you adopt the approach in your own app.

  • Added to My Schedule
    Jed Wesley-Smith

    Jed Wesley-Smith - Why "Names Don't Matter" Matters

    schedule  11:05 - 11:35 AM AEDT place Green Room people 188 Interested star_halfRate

    Increasingly, people are popping up stating the controversial opinion that names don't matter. To most programmers this statement is obviously untrue, as naming is seen as difficult, and critical to semantic expression and communication in their code. To make matters worse, these same people demand fidelity to obscure and difficult names from mathematics, leading to charges of hypocrisy – if names don't matter, why do they care we all use any particular ones?

    We'll try and tease out these seeming contradictions. We'll look at why "names don't matter" is an important idea, and why its more obvious superficial interpretation is specious.

  • Added to My Schedule
    Christopher Biggs

    Christopher Biggs - Functional Frontends with Elm

    schedule  11:40 AM - 12:10 PM AEDT place Red Room people 80 Interested star_halfRate

    Functional programmers are lovers of simplicity and order. Developing for the Web has become nothing like either of these. The number of tools and libraries you need to learn seems to multiply without end, and getting them to work together can be a nightmare.

    What if there was a language and environment that had no external dependencies, required no complex packaging tools, runs in the web browser, and oh yes, it's purely Functional.

    The Elm Architecture (consisting of the Elm functional language, and a way of applying it to web development) aims to allow fast iterative development of beautiful web apps in a functional language. Hundreds of easy-to-install libraries give you

    Most elm tutorials stop at the "hello world" level and sweep the complexity of large applications under the carpet. This presentation goes beyond the bare essentials to show you how my team builds real world applications in Elm that incorporate non-elm javascript libraries while still retaining as much of possible of the simplicity, type-safety and ease of refactoring that Elm brings.

    Ports are Elm's mechanism for interaction with the non-functional, loosely typed Javascript runtime. I'll show you practical ways to interact with tools such as Amazon Cognito and the Leaflet mapping engine from within your Elm application, keeping the non-functional glue code to the barest minimum.

  • Added to My Schedule
    Cameron Joannidis

    Cameron Joannidis - An Intuitive Guide to Combining Free Monad and Free Applicative

    schedule  11:40 AM - 12:10 PM AEDT place Green Room people 154 Interested star_halfRate

    The usage of Free Monads is becoming more well understood, however the lesser known Free Applicative is still somewhat of a mystery to the average functional programmer. In this talk I will explain how you can combine the power of both these constructs in an intuitive and visual manner. You will learn the motivations for using Free Structures in the first place, how we can build up a complex domain, how we can introduce parallelism into our domain and a bunch of other practical tips for designing programs with these structures. This will also give you a deeper understanding of what libraries like Freestyle are doing under the hood and why it is so powerful.


    Lunch Break - 60 mins


    Afternoon Break - 30 mins

  • Added to My Schedule
    Mark Hibberd

    Mark Hibberd - Hanging on in Quiet Desperation: Time & Programming

    schedule  03:45 - 04:15 PM AEDT place Red Room people 188 Interested star_halfRate

    Time has a profound impact on the complexity of the systems we build.

    A significant amount of this software complexity comes from either an
    inability to recall previous states or the inability to understand
    how a state was arrived at.

    From the foundations of AI, LISP and functional programming [1], to
    causality in distributed systems [2], to the more grungy practices of
    immutable infrastructure, or the unreasonable effectiveness of
    fact-based approaches to large scale data systems; the ability to
    adequately cope with time, and the change and conflict it inevitable
    creates, is a common thread to being able to build and reason about
    these systems.

    This talk looks at the impact of time on system design. We will walk
    through examples of large-scale systems and their battles with
    complexity. At the end of the talk, the audience should start to see
    the common spectre of time and have an appreciation of how
    understanding time is fundamental to maintaining clarity, correctness
    and reliability in systems.

    [1] Situations, Actions, and Causal Laws
    John McCarthy
    [2] Times, Clocks and the Ordering of Events in a Distributed System
    Leslie Lamport

  • Added to My Schedule
    Tom Sydney Kerckhove

    Tom Sydney Kerckhove - Signature inference for functional property discovery

    schedule  03:45 - 04:15 PM AEDT place Green Room people 33 Interested star_halfRate

    Property discovery is the process of discovering properties of code via
    automated testing. It has the potential to be a great tool for a practical
    approach to software correctness. Unfortunately current methods remain
    infeasible because of the immense search space. We contribute a new
    approach to taming the complexity of a state-of-the-art generate and test
    algorithm. Our approach runs this algorithm several times with carefully
    chosen inputs of smaller size: signature inference. We implement this
    approach in a new tool called EasySpec. The results suggest that this
    approach is several orders of magnitude faster, fast enough to be practical,
    and produces similar results.

  • Added to My Schedule
    Colin Fleming

    Colin Fleming - Developing an IDE for Clojure code

    schedule  04:20 - 04:50 PM AEDT place Red Room people 55 Interested star_halfRate

    Cursive is an IDE for Clojure, based on the IntelliJ framework. In contrast to the majority of Clojure development environments, Cursive uses static analysis of the source code to work its magic rather than using runtime inspection of a live system via the REPL. IntelliJ provides a sophisticated indexing infrastructure, and this in combination with static analysis allows many interesting features which are difficult or impossible to achieve with a traditional REPL-based environment. Essential code navigation tools such as Find Usages and refactorings such as Rename become possible, and using IntelliJ's code inspections can provide error marking and static analysis of code, right in the editor. This ability to see problems immediately provides an even shorter feedback loop than working in the REPL.

    I'll discuss some of the challenges of developing a traditional IDE for a language as flexible as Clojure, including the implementation details of how to deal with syntax extensions from macros. I'll also talk about the various ups and downs of developing much of it in Clojure, and why some of it is also developed in Kotlin. I'll also talk about why I believe our editors should be syntax aware, not just text based.

  • Added to My Schedule
    Vaibhav Sagar

    Vaibhav Sagar - I Haskell a Git

    schedule  04:20 - 04:50 PM AEDT place Green Room people 122 Interested star_halfRate

    Git is the most widely used version control tool today, but what is actually happening when we perform a `git add` or a `git commit`? To answer this question I'm going to walk through a small implementation of Git in Haskell. Along the way we'll touch on functional data structures, content-addressable stores, and parser combinators. At the end we'll analyse an entire Git repository and talk about the practical applications and limitations of what we've built. My hope is that this knowledge will help you be less frustrated the next time you see a cryptic Git error message!


    Full-Stack Haskell, from Prototype to Production - 45 mins