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

    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
    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 Susan Potter
    keyboard_arrow_down

    Susan Potter - Growing A Functional Discipline

    30 Mins
    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
    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.

  • No more submissions exist.
Looking for your submitted proposals. Click here.