Your current filters are…
by Bodil Stokke
The programming paradigms that served us so well through the 80s and 90s are failing us. Building systems the way we're used to building them always seems to end in the inevitable death march towards exponential complexity. But once you stop to ask the right question- "what's really causing all this complexity?" - you realise the answers have really been staring you in the face all along. Debugging is only hard when you can't reason about your code. Concurrency is only hard when you can't predict the state of your code. Reusability is only hard when your components aren't naturally composable.
Fortunately, languages addressing these issues specifically are popping up all over the place. In many cases, it turns out we've had the solutions to our problems for a long time, we've just forgotten about them, or never really bothered to look. Let's take a moment to explore some of these languages, not as exercises in syntactic details, but looking at the inherent properties in their design that enable us to defy decades of OO tradition and write honest-to-Dijkstra bug free, fault tolerant software without even trying. After half a century in the wilderness, functional programming seems to finally be gaining some ground on the barbarians. Let's examine why.
In this session, we demonstrate how to develop F# mobile web applications using functional programming techniques and abstractions that dramatically cut development time and code size, and at the same time increase readability and ease of maintenance.
We will use WebSharper, the main web development framework for F#, to implement client and server-side code, and do all of our development work in CloudSharper, an up and coming online IDE that enables full-scale F# development.
Along the way, we learn some CloudSharper basics, get our hands dirty with testing various client-side functionality in its interactive REPL facilities, and build, deploy and test our mobile applications all on the web and in the cloud.
This session is about the journey Erlang/OTP has taken since it was first introduced into the business in 2000. Hear how we started with one engineer who discovered Erlang/OTP, and how it has grown to underpin the entire data and voice revenue stream in EE (Umbrella company which owns and operates the EE, T-Mobile and Orange brand mobile networks in the UK).
This session will be a brief introduction to the OCaml programming language and will go through some of the topics covered in the new O'Reilly book, Real World OCaml (https://realworldocaml.org - the book is freely available online under a Creative Commons Licence so all attendees will be able to read it).
We will also introduce the initial version of a new OCaml Platform which combines the core OCaml compiler with a coherent set of tools, documentation, libraries and testing resources. The Platform will represent the best way for developers, both new and old, to write software in OCaml.
There will be a break for lunch part-way through the session.
You are a Clojure newbie who has a firm grasp of the sequence abstraction and have been mapping and reducing like a pro, enthusiastically solving project euler and 4clojure problems. Life is good and producing a fibonacci sequence has never been so much fun. However, the time has come to produce a web app but you are not sure where to begin! Does functional programming work on the web?
This tutorial will provide an introduction to web development in Clojure for beginners, using a monitoring dashboard as the vehicle.
There will be a break for lunch part-way through the session.
by Irek Jozwiak
Haskell is without a doubt a cool programming language, but how well does it perform in a real-world, enterprise project? What kind of everyday experience awaits the working programmer?
How does one adopt a non-mainstream tool that is alien to most developers? How does this new tool affect the project in terms of architecture, modeling business logic, testing, etc.?
In this talk, Irek share stories about using Haskell to write a system responsible for data collection, analysis and billing. Attendees will find out about how interesting problems got solved, and get to see relevant code that illustrates the point.
No prior Haskell or functional programming knowledge is required.
by Tom Ellis
Refactoring is the practice of improving the design of existing code.
A significant component of refactoring is the separation of concerns, that is making code more modular. Haskell provides an excellent environment to explore this concept since its type system makes it clear what side effects can occur during execution. This tutorial will explore techniques for improving the modularity of Haskell programs using the type system for evidence about which program transformations are worthwhile. Most of the lessons learned will carry over to other functional languages, and many of them to non-functional languages as well.
Goals: By the end of this tutorial you will be able to use a variety of techniques to improve the design of existing Haskell code, make it more modular, and understand the dependencies between its constituent parts.
Most of these lessons will transfer directly to other languages, especially functional languages.
Intended audience: This workshop will be suitable for users of all programming languages, though a passing familiarity with, and enthusiasm for, Haskell will be beneficial.
Infrastructure required: No special requirements. To follow the live coding execises participants should have a laptop with the Haskell Platform installed. An internet connection is not required but there will be a tarball containing course materials available to download before or during the talk for those who are interested.
by Brian Rowe
The computational sciences are still learning the benefits of functional programming. Most users of R are familiar with object-oriented programming but have not been exposed to the joys of functional programming. In this session I discuss why functional programming is important for the computational sciences in terms of modeling, program organization, and reasoning about the correctness of a program.
The session introduces lambda.r, a package I wrote that enables a functional programming style in the R language. Using examples based on my work forecasting consumer financial transactions, I will discuss when and why I use the various features of lambda.r, including multipart function definitions, guard expressions, type constraints and variables, and attributes in my models.
The session also explores practical uses of the lambda calculus to reason about numerical programs and show the equivalence between various forms (using Church numerals and iterative function systems as examples). As R supports vectors natively, there are some surprising results that stem from this.
Language-integrated query is receiving renewed attention, in part because of its support through Microsoft's LINQ framework. We present a theory of language-integrated query based on quotation and normalisation of quoted terms. Our technique supports abstraction over values and predicates, composition of queries, dynamic generation of queries, and queries with nested intermediate data. Higher-order features prove useful even for constructing first-order queries. We prove that normalisation always succeeds in translating any query of flat relation type to SQL. We present experimental results confirming our technique works, even in situations where Microsoft's LINQ framework either fails to produce an SQL query or, in one case, produces an avalanche of SQL queries.
24th–25th October 2013