Talks
Caught in a Web of Functions
Functional programming is a great tool for enabling programmers to solve complex problems through the use of data and functions. However, not all data and functions are created equal, and some are less composable than others. Web libraries in particular are guilty of being overly opinionated and ending up as closed worlds of functionality. As programmers we are complicit whenever we find ourselves asking: “What web framework should I use”? But why do we need to choose a single framework in the first place? Why can’t we compose functions from different libraries? Do we really need 5 different ways to get/set a cookie?
This talk aims to deconstruct what we typically expect from a web framework, and how we can achieve the same functionality with a series of small, composable functions. This will be demonstrated using Haskell’s WAI library as a common building block, and contrasted to the equivalent implementation in other modern Haskell web frameworks. By the end of this talk web frameworks will be demystified and exposed for what they should be – a collection of composable functions. In addition the audience will have gained confidence in their ability to recognise good and bad functions, and to better evaluate the cost of the libraries they inhabit.
Property Testing: Finding More Bugs With Less Effort
Testing is an essential part of writing and maintaining correct and reliable software. However, for the most part the best technique we have for writing tests is to capture some examples in the hope that they cover all the known edge cases. Unfortunately these examples almost always missing something.
What if we could ask the computer to generate these examples? Not just a handful, but hundreds of them that we never even considered. It turns out we can! By using the technique known as Property Based Testing.
This talk will explore the motivation and concepts behind this powerful testing technique. We also introduce a number of simple but useful patterns that can be applied again and again when writing properties. In addition this talk will highlight a handful of compelling examples of Property Based Testing uncovering nasty bugs in real world software.
Finally, apart from learning about why and how to use Property Based Testing to write better software, the audience will also realise that testing can be made more enjoyable in the process.
Life Without Stacktraces
Standard programming techniques and debuggers have left us dependant on stacktraces to give us an understanding of how our programs work. With async continuations, trampolining, recursion and other programming techniques, the stack no longer provides us with any useful information about calling context. This talk will show how safe error handling can provide us with superior tools for the purpose, and how to use them effectively.
Practical property-based testing with ScalaCheck
At first it can be tricky working out how exactly you test your code with properties. The good news is that there are some very obvious and useful patterns that can make writing generators and properties easy by mere-mortals.
This talk aims to cover some of those patterns, and in doing so help both people working or struggling with property-based testing, and through that to also motivate the use of property-based testing for those still unfamiliar with the concept.
Practical property-based testing with ScalaCheck
Property-based testing can be little daunting when you first start. Fortunately there are few simple tricks/patterns that can open up a world of possibilities for testing your code. These techniques also serve as good motivation for why property-based testing is so damn useful.
Scala: The Good Parts
An inside look into some of the best-practices of the Ambiata team as they battle Scala in the trenches.
Null is not an Option, Either are NPEs
Shapeless
Charles O’Farrell will attempt to explain the inner workings of Miles Sabin’s brain and how he is pushing the frontier of polytypic programming in Scala with the Shapeless library
Type Classes as Object and Implicits
What are type classes, how can they help and why can’t we get them in stupid ol’ Java?
A Taste of Scala
The talk will begin by covering the Scala syntax briefly and then delving into some of the nicer features (type inference, functional programming, etc). It will then concentrate on some specific things like Option and Case Classes to hopefully highlight some immediate and easy wins over Java.