|🔵||Little assumed knowledge|
|🔵🔵||Moderate assumed knowledge|
|🔵🔵🔵||Significant assumed knowledge|
|9:00am||Lyndon Maydwell||Introduction by the Committee|| |
|9:30am||Andrew Sorensen||Keynote - Sound Synthesis in the Computational Crucible|| |
|10:30||Andrew McCluskey||Your first Haskell app|| |
|11:30am||George Wilson||Type Class: The Ultimate Ad Hoc|| |
|1pm||Justin Bedő||BioShake: a Haskell EDSL for bioinformatics pipelines|| |
|1:30pm||Tony Morris||FP in Aviation|| |
|2pm||Ronen Narkis||Re-ops, a Functional Live-Infrastructure as Code|| |
|3pm||Luke Stephenson||Reactive Streams for REA feeders|| |
|3:30pm||Huw Campbell||Grenade - Dependently Typed Neural Networks in Haskell|| |
|4:15pm||Jurriaan Hage||Domain-Specific Type Error Diagnosis in GHC|| |
|5:45pm||Closing comment|| |
A crucible allows base metals to be mixed together at high temperatures to form alloys. Medieval alchemists used crucibles to mix an astonishing variety of substances together in the search for new materials. While Alchemy is often derided for its informal approach, early Alchemists paved the wave for modern chemistry, and included Newton and Boyle among their number.
Just as the crucible encouraged an experimental and experiential approach to understanding the world, so too the computer can provide a computational crucible. Code can be mixed and brought to great temperature in the search for greater understanding and new discovery.
Using his own Extempore programming language Andrew will provide a 'live' introduction to sound synthesis, building up the core components of a real-time digital synthesizer on-the-fly 'in the computational crucible'.
Andrew Sorensen is an artist, a programmer, and a computer scientist. His interests are diverse, but unify under a common theme - the programming language as an interface for real-time dialogue between human, machine, and environment. In exploring these ideas Andrew is as likely to be found hacking code in nightclubs as steering scientific codes on distributed high performance computing clusters. Andrew is well known for creating the programming languages that he uses in live performance to generate audiovisual theatre. He is the author of the Extempore programming language - a systems programming language designed for high-performance 'live' programming.
When learning a new programming language there is almost always a leap from learning to applying your knowledge. This leap can be quite large when learning Haskell for a number of reasons. One reason is the dramatic difference between Haskell's style of programming compared to more common imperative languages that many learners are more familiar with. As a consequence, a difficulty for those new to Haskell is identifying when and how to apply the concepts they've learned when writing an application. Another is navigating the Haskell ecosystem; including finding packages and understanding how they work. Finally, some newcomers may delay writing their first application, believing they need to be comfortable with more advanced concepts before they can successfully write useful software. This is not the case. While these abstractions are useful, many of Haskell's benefits can be enjoyed while sticking to its more basic abstractions.
By referring to a simple example application, we'll demonstrate how and when to apply some core techniques and abstractions, and alleviate the burden of starting an app from scratch. We'll cover a number of data types, type classes, and techniques, including:
If you've ever been intimidated by the thought of starting a project in Haskell, then this talk will give you a solid place to start. Along the way we'll see that, not only is Haskell a general purpose language that can be used to write everyday applications, but that it brings with it a range of benefits.
The idea behind this talk is to encourage developers to build real-world applications using PureScript. I hope to take you through a journey of applying functional patterns to everyday problems so that you can appreciate the simplicity and ideas behind these patterns:
Rahul works as a Technical Lead at REA Group building micro services to power their backend systems. He uses Ruby by day and Haskell/PureScript by night. He enjoys learning more about functional patterns and becoming a better dev through applying them in his everyday code.
Since their inception in Haskell, type classes have become a popular feature of modern functional programming. Indeed, key topics in FP often take the form of type classes, such as Monoid and Functor. Many languages developed since Haskell have included type classes in their design, such as Idris and Purescript; or offered facilities capable of simulating type classes, such as Scala's implicits or OCaml's modules.
In this talk we go beyond the basics with type classes. First we'll differentiate between parametric and ad hoc polymorphism, and we'll see why type classes are a compelling solution to the latter. By comparing them to other solutions - Java interfaces and Scala implicits - we'll see the advantages of type classes. In particular, we will focus on why type classes are principled. This section will include examples in Java, Scala, and Haskell.
In order to be principled, there are conditions on the creation of instances: there can be a maximum of one instance for a given type for a given type class, and it must be in one of two allowed places. We will justify this rigidity by discussing instance coherence and its benefits, with examples of incoherence silently causing bugs. We will learn what orphan instances are and why they can be problematic for coherence.
Finally, practical guidelines will be given for programmers aiming to simulate type classes in other languages, as is popular in the Scala community. These guidelines, when followed with discipline, will allow one to recover many of the benefits of type classes. Examples in this section will be in Scala.
Attendees will leave knowing the difference between parametric and ad hoc polymorphism, and they will understand why type classes are a principled approach to the latter. Attendees wishing to simulate type classes in a capable language, such as Scala, will leave the talk with practical guidelines helping them to do so.
George Wilson is an enthusiastic functional programmer at the Queensland Functional Programming Lab, under Data61/CSIRO, located in Brisbane, Australia.
George co-organises the Brisbane Functional Programming Group and enjoys teaching and learning functional programming and related areas of mathematics.
Recently there have been great advances in the field of biology arising from rapid technological progress, notably in certain areas such as genomics. These technologies have drastically increased the use of computing as part of data processing and analysis. It is now common to use many hours of compute to process biological data in what is known as a *bioinformatics pipeline*.
These bioinformatics pipelines are typically composed of numerous programs and stages coupled together loosely using intermediate files. These pipelines tend to be quite complex and require substantial computational time, hence a good pipeline must be able to manage intermediate files, guarantee rentrability — the ability to re-enter and continue a partially run pipeline — and also provide clear syntax to easily describe and understand pipelines.
This is a problem that resembles the problem of building software artefacts that is common in computer science. Some notable tools are the ubiquitous tool *make*, and more recently *Shake*, a robust build tool implemented as an embedded domain specific language (EDSL) in Haskell. However, bioinformatic pipelines have some unique properties that do not fit well into current build tools...
In this talk & demo, we have a look at some of the low-hanging problems in general aviation and how functional programming can be applied to provide significant improvements in efficiency and air safety. The current solutions to problems such as navigation, traffic/terrain collision avoidance and weight/balance calculations will be demonstrated to the audience, mostly for amusement. More seriously, we will have a look at the legacy that has led to the way things are, and how to improve by applying our programming skills.
We will look at:
We will see:
Tony Morris is a software engineer for the Queensland Functional Programming Lab, under Data61/CSIRO, located in Brisbane, Australia. Tony has been deploying functional programming solutions for over 10 years, using the Haskell and Scala programming languages primarily. Tony teaches functional programming at the tertiary level and for professional programmers with a view toward producing a viable commercial result.
Tony takes a fastidious, principled approach to functional programming both when deployed in practice and when in a learning environment to ensure maximum yield from the effort. Tony believes that exploring principles and the following consequences provides a rewarding experience for all involved.
The history of live coding environments isn't new, still most of the current tools we use are static in nature and require long cycles of build/compilation/restart both in development and production, the REPL is one of the most productive environments to get instant feedback and have become the standard for contemporary functional languages.
In this talk we will go through Re-ops, a Clojure based live environment that aims to speed up remote server management, from ad hoc remote operations to metrics collection/reporting up to managing clusters of virtual machines.
Current configuration management tools (Puppet/Chef/Ansible) are custom environments running on top of Ruby/Python that don't interact (for the most part) with the hosting platform, Re-ops on the other hand is native Clojure and can use any library and language facility.
Using function composition, protocols and data structures with a dash of macros we create our own core abstractions, matching the lisp philosophy of extending the language to match our needs while keeping it simple to extend and use.
Re-ops is composed from a number of components:
In summary Re-ops offers an alternative for creating infrastructure as code, one in which we can react quickly to a fast changing environment.
Ronen Narkis has been a pro coder for more than 12 years across a variety of projects ranging from Devops to Bigdata, using Clojure since 2008 to solve real world problems.
He enjoys expanding his knowledge about security, operating systems, programming languages and any other cool tech he can lay his hands on.
This talk introduces Reactive Streams, specifically the Monix implementation and how at REA Group we have used it to solve real problems.
At REA we have many 'feeders' which extract from one data source, perform some processing and transformations before loading into a target system.
Historically these feeders have been built using Java / Scala concurrency primitives (e.g. Future / ExecutionContext). The typical feeder has a very sequential execution model like:
The very sequential nature means the feeds are not as performant as they could be. The source and target systems were never accessed in parallel. Writing to the target required waiting for the source to read another batch. And the feeder would not read another batch from the source until the target completed.
Also being based on lower level concurrency primitives, the data pipeline is not as easy to visualise from reading the codebase.
Reactive streams allow us to model asynchronous processing pipelines as a data type which can then be executed. The APIs are declarative, as opposed to the legacy solution working with Scala Future and ExecutionContext which resulted in immediate evaluation.
The talk will cover:
Attendees should leave with a basic understanding of Reactive Streams, and specifically how to get started with the Monix implementation of reactive streams. I'll share a working basic project (not REA production code) which provides a basic 'feeder' structure for attendees to reference and extend upon if they wish.
Deep learning and deep neural networks are currently fields of great interest and excitement, due to their impressive results in supervised and unsupervised machine learning tasks across a broad range of fields including computer vision, speech recognition, and games such as Go.
In this talk, I'll talk about my recent explorations in using type level and purely functional programming techniques applied to deep learning and neural networks. We'll run over deep neural networks theory, their common architectures, and their various use cases to obtain an appreciation for the depth of the field. I'll then show how the use of modern Haskell programming allows for these networks to be expressed at the type level, providing not only extreme concision, but also compile time safety, functional reasoning and composition, as well as pretty good runtime performance with a high degree of confidence in their correctness.
Huw Campbell is a physicist, data scientist, and functional programmer, currently working at Ambiata in Sydney. Coming from an academic background with a PhD in experimental physics, Huw started working as an applied researcher in machine learning in 2014. With Ambiata's broad Haskell experience and mentorship, and a strong interest in functional programming and type systems, Huw decided to apply these principles to machine learning - bringing together these diverse fields.
With its advanced type system, the purely functional language Haskell is extremely well-suited for developing applications based on embedded domain specific languages (EDSL) for domains where the quality of software is critical to success (e.g., the financial sector). To the compiler an EDSL is no different from any other library written in Haskell; to the user of the EDSL, it is a library that allows her to express her solution to a problem in her domain in a syntax (fluency) reminiscent of that of the domain. But one problem continues to plague the end users of EDSLs: whenever a type error occurs, the encoding of the domain inside the host language Haskell leaks out in those error message. And this encoding is exactly what the EDSL developers were trying to hide! In this talk we demonstrate how type error diagnosis can be made domain-specific by type level programming. We have implemented this in the Glasgow Haskell Compiler, the industrial-strength compiler for Haskell. With relatively small modifications to the compiler, we can show huge gains in terms of domain-aware type error messages, and suggestions on how to fix a given type error. Our solution has more advantages: existing EDSLs can be easily wrapped with specialized error diagnosis, the wrapping is invisible to the end user, and the soundness of the type system is guaranteed by the compiler. The abstractions provided by type-level programming allow us to describe and reuse common patterns in type error diagnosis, lowering the entry barrier for DSL authors.
The talk will consist of an explanation and demonstration of what our technology, as implemented in our branch of GHC, allows EDSL developers to do.
Jurriaan Hage is assistant professor at Utrecht University. His work in programming technology is largely focused on two aspects: the optimisation of functional languages by means of type and effect systems, and type error diagnosis for strongly typed functional languages. He is currently the lead maintainer of the Helium compiler for learning Haskell. You can also talk to him about soft typing dynamic languages, program plagiarism detection and switching classes.