Tue, 16 Nov 2010
On Thursday October 21st, we held the 29th meeting of the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had about 22 people show up to hear our two presenters.
First up we had Benjamin Johnston with a presentation titled "How to Dance the Robot". As part of his work an University of Technology here in Sydney, Ben gets to program robots. One of the results, is robots that dance (thanks to Mark Wotton for capturing this video on his iPhone):
Ben's language of choice is Prolog (not functional but definitely declarative) and he used Prolog to tackle the problem of making the programming of a robot dance easier. A complete dance might last 3 minutes or more, the music is likely to have a tempo of around 100 beats per minute and the dance moves are usually timed down to the half beat. That means some 600 odd half beat events for a 3 minute dance. Entering 600 odd events manually would be somewhat tedious.
Ben's solution to this problem was a compiler for a domain specific language (DSL) which allowed easier specification of the dance in terms of musical sections, repeated moves etc. Writing the compiler was made easier by making good use of Prolog's search and backtracking capabilities and the compiler generated Python output code that was uploaded to the robot.
Our second presenter for the evening was Sean Seefried on the subject of the "The Expression Problem", in Haskell. In Sean's paper (with Manuel M. T. Chakravarty), "Solving the expression problem with true separate compilation" he describes the expression problem as:
"the difficulty of extending the variants and methods on a data type without modifying existing code and while respecting separate compilation"
There are a number of other languages which have solutions to the expression problem, but Sean's work was the first real Haskell solution. With the use of multi-parameter type classes, scoped type variables, kind annotations, zero constructor data types and recursive dictionaries, Sean was able to make it work with GHC 6.4 and later. At the end, Sean also presented some ideas to make the solution of this problem easier and more practical.
A big thanks to Ben and Sean for presenting and Google for providing the meeting venue and refreshments.
Tue, 21 Sep 2010
On Thursday September 16th, we held the 28th meeting of the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had a bit less than 20 people show up to hear our two presenters.
First up we had Shane Stephens with a presentation titled "Exploring 3D Graphics with Togra". Togra (code available here) is a library for 3D graphics that Shane has at different times tried implementing in Python (with C for speed), Ocaml and Haskell before settling on the use of Arrows in Haskell.
Shane started off showing how he used to do it in Python and C and explained that the Python/C code was difficult to maintain and contained significant chunks of code that implemented type checking of data objects passed from Python. He also mentioned very briefly a failed attempt to implement the library with Monads. With the library is not finished, or even really ready for playing with Shane does think that Arrows are the right solution.
Our second presenter for the evening was Anthony Sloane of Macquarie University on the subject of the "Launchbury's Natural Semantics for Lazy Evaluation" with Scala code available on the same page. Tony set up a simple language and then walked us through the reduction rules for the language. This was a real nice introduction to a topic that can be daunting for people unfamiliar with the topic.
A big thanks to Shane and Tony for presenting and Google for providing the meeting venue and refreshments.
Sat, 21 Aug 2010
On Thursday August 12th, we held the 27th meeting of the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had about 20 people show up to hear our two presenters.
First up we had Ben Lippmeier presenting the Haskell library REPA for doing high performance operations on regular, shape polymorphic, parallel arrays. Ben showed us some code for written with the REPA library. The interesting thing about the code was that even though REPA allows parallel execution on multiple cores, this parallel code is not vastly different from how someone would write the code to execute on a single code. Ben also provided some benchmarking figures comparing the multicore Haskell/REPA code performing well against single core code written in C.
Our second presenter for the evening was Simon Winwood who presented on the subject of the Template Haskell, which allows type safe, compile time meta programming. The need for templating in a powerful and flexible language like Haskell is obviously much less than in languages like C++, but still useful for some tasks like quasi-quotation. The mechanics of TH as such that it allows conversion between Haskell's concrete syntax and abstract syntax trees which can be manipulated by Haskell code. One downside of TH is that code relying on regularly breaks when new versions of the GHC compiler are released.
A big thanks to Ben and Simon for presenting and Google for providing the meeting venue and refreshments.
Sun, 25 Jul 2010
On Thursday July 15th, we held the 26th meeting of the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had 18 people show up to hear our two presenters.
First up we had your correspondent (thats me) with a presentation titled An LLVM Backend for DDC. This presentation covered the problems with the current C backend, gave a description of LLVM, the options for using LLVM from Haskell, why the LLVM code from GHC was chosen and how if fits into the DDC compile pipeline. Finally I demoed the very wonderful LLVM CGI script which allows you to enter a small C program and view the LLVM output.
Our second presenter for the evening was Eric Willigers who presented on the subject of the ATS programming langauge. ATS is interesting because it offers functional programming with an advanced type system with things like dependent types and linear types but has excellent performance as shown on the Computer Language Benchmarks Game. Eric was able to demonstrate dependent types on a couple of list operations which certainly showed some of the promise of dependent types. ATS certainly does seem interesting but also seems to lack quite a bit of polish.
A big thanks to Eric for presenting and Google for providing the meeting venue and refreshments.
Mon, 28 Jun 2010
On Thursday June 17th, we held the 25th meeting of the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we about 20 people show up to hear our two presenters.
First up we had Eric Torreborre on the subject of Specs a Scala library designed as an alternative to JUnit for testing Scala and Java projects. Specs seems to remove a lot of the boilerplate normall associated with unit testing.
Our second presenter for the evening was Shane Stephens who presented on the subject of Arrows, a generalisation of Monads. Shane's presentation was originally scheduled to be a 5-7 minute lightning talk but due to a lack of other lightning presenters, Shane managed to pad it out to a full talk in the hour before he presented. According to Shane, his presentation was based quite closely on the original paper "Generalising Monads to Arrows" by John Hughes.
A big thanks to Eric and Shane for presenting and Google for providing the meeting venue and refreshments.
Sun, 30 May 2010
On Thursday May 20th, we held the 24th meeting of the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we a bit over 20 people show up to hear our two presenters.
First up we had Raphael Speyer presenting his impressions on leaning the Ocaml programming language and applying to writing a version of the game "Four in a Row" also known as "Connect Four". The game is a two player game and Raphael implemented the game rules and some basic artificial intelligence so that a single player can play against the AI. Rapahel seemed to have a positive experience with Ocaml and the Batteries Included libraries. The performance was quite as good as he would have liked, but discussion seemed to suggest that switching from lists to arrays would probably improve things. Raphael has made his code available as a github project.
Our second presenter for the evening was Eric Willigers who presented on the subject of the Scala language's Actor library, a library implementation of Erlang's message passing primitives. Eric gave us a number of demos that showed how Actors behave.
A big thanks to Raphael and Eric for presenting and Google for providing the meeting venue and the snacks.
Wed, 28 Apr 2010
On Thursday April 15th, we held the 23rd meeting of the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had 28 people show up to hear our two presenters.
First up we had Ben Lippmeier demonstrating Gloss, a library for 2D vector graphics, animations and simulations. Gloss grew out of a library that Ben and others were using the teach Haskell to first year computer science students at ANU. It is now also being used at UNSW. The library was designed to allow students to get animations running without having to really tangle with monads. Programs using the library can achieve very impressive results with very few lines of code.
Our second presenter for the evening was Barry Jay demonstrating his Bondi programming language. Bondi is an Ocaml-like language in that it is strictly statically typed, is mainly functional but allows imperative constructs as well, is impure with respect to I/O and has an object system.
Bondi came about as a proof of concept language aiming to show that the the ideas behind Pattern Calculus actually have practical application. Bondi shows very clearly the value of being able to pattern match on arbitrary compounds objects without writing code to deal with the specifics of the compound. A simple example Barry came up with was defining a completely new data type Complex and having Bondi's pattern matching immediately able to figure out how to print it using the toString function as follows (the "~~" below is the Bondi REPL command prompt):
~~ datatype Complex = Cmplx of Float and Float ;; Cmplx: Float -> Float -> Complex ~~ toString (Cmplx 1.1 2.2) ;; it: String it = "Cmplx 1.1 2.2"
Towards the end, the questions and resulting discussion turned back to the Pattern Calculus its relationship to Lambda Calculus. This discussion continued at the pub where I think we decided that the Pattern Calculus is a super-set of the Lambda Calculus. For more on this topic I would recommend the slides to Barry's presentation at SAPLING '09 and the full paper version titled "A Combinatory Account of Internal Structure".
A big thanks to Ben and Barry for presenting and Google for providing the meeting venue and the snacks.
Sat, 13 Mar 2010
On Thursday February 25th we held the first meeting for 2010 of the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had 17 people show up to hear our two presenters.
First up we had your correspondent (Erik de Castro Lopo), giving a presentation titled "Hacking DDC" on my bug fixing work on Ben Lippmeier's DDC compiler. I explained a little about what DDC and Disciple were; a Haskell like language with some interesting extensions to the type system. I then suggested that anyone curious as to why these extensions were interesting should read the first chapter of Ben's PhD thesis "Type Inference and Optimisation for an Impure World". I then went on how using Darcs for the revision control made it easy to use one branch per bug or feature I'm working on, specifically, it allowed me to work on one until I got stuck and then move on to another without the debugging of the first interfering with the second.
Our second presenter for the evening was Tim Docker who gave us an explanation of a Domain Specific Language (DSL) for handling dates in financial systems. Code written in his DSL looked a lot like Ocaml, but the implementation was in C++.
A big thanks to Tim for presenting and Google for providing the meeting venue and the snacks.
Sat, 05 Dec 2009
Two weeks ago, on November 19th we held the 21st meeting of FP-Syd, the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had 22 people show up to hear our two presenters.
First up we had repeat offender Mark Wotton give us a presentation titled "Hubris : A Trojan Horse for Haskell" on his project called Hubris, a bridge between Ruby (ie Rails) and Haskell. The specific use case Mark has in mind for this bridge is call fast compiled Haskell code from Ruby web code. The code this is is available at:
git clone git://github.com/mwotton/HaskellHubris.git
but requires the 6.12 release candidate of the GHC Haskell compiler.
Our second presenter for the evening was Tony Sloane who gave us an introduction to "Embedding a Rewriting DSL in Scala". Tony's DSL of interest is the Stratego Language which he is embedding in Scala using the Kiama library. Tony's particular interest seems to be in program transformation; desugaring of high level languages, evaluation by reduction rules, optimisation and source to target translation.
A big thanks to both our speakers and to Dan, Mark and Google for providing the meeting venue and the light refreshments.
FP-Syd will be having brief hiatus over the Xmas/New Year period and our next meeting will be in February.
Sun, 25 Oct 2009
On October 22th we held the 20th meeting of FP-Syd, the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had about 28 people show up to hear our two presenters.
First up we had Roman Leshchinskiy and his presentation "Loop Fusion in Haskell", work that is part of GHC's Data Parallel Haskell library. Loop fusion depends on the ability to convert operations on arrays into operations on streams. Then, when applying multiple stream operations, adjacent conversions to and from streams can be dropped, allowing further inlining. The real beauty of this approach is that stream operations and data parallelism can be written as a library outside of the GHC compiler and then depend on the compiler to do most of the heavy lifting. Romain then moved on to explain that this work was just as applicable to general parallel computation on multicore systems as it was to clusters and GPUs.
Our second presenter for the evening was Barry Jay who gave us an introduction to "Pattern Calculus". Barry's work on Pattern Calculus was inspired by the fact that while lambda calculus is able to adequately explain computation, it does not explain operations on data well. In particular, lambda calculus does not distinguish between variables and data constructors while in the pattern calculus constructors are treated as a separate class; matchable symbols. The ideas behind Pattern Calculus are explained more fully in Barry's book:
A big thanks to both our speakers and to Shane Stephens and Google for providing the meeting venue and the light refreshments.
Mon, 19 Oct 2009
On September 17th we held the 19th meeting of FP-Syd, the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had about 18 people show up to hear our two presenters.
For the second presentation we had Shane Stephens one of the Google people working on Google Wave giving us an overview of Google's Operational Transform algorithm which is at the core Google Wave. He then walked us through a reimplementation of the algorithm in Haskell.
A big thanks to Shane Stephens and Google for providing the meeting venue and the light refreshments.
Tue, 13 Oct 2009
Way back on August 23rd we held the 18th meeting of FP-Syd, the Sydney Functional Programming group. As usual, the meeting was held at Google's Sydney offices and we had about 24 people attend to hear our two presenters.
First up we had Mark Wotton and his presentation "Testing By Convention and Flow". TBC ( on Hackage) is a harness for running tests written with HUnit or Quickcheck. The main idea is that if your tests are written to follow a set of conventions, a lot of the boiler can be skipped used TBC.
The second presentation was by Ben Lippmeier on his work on getting Haskell's GHC compiler working on SUN's OpenSparc T2 processor. The OpenSparc T2 is interesting because it has 8 cores per processor and 8 hardware threads per core and hence is an interesting target for GHC's parallel evaluation model.
A big thanks to Shane Stephens and Google for providing the meeting venue and some light refreshments.
Tue, 18 Aug 2009
On Thursday July 23rd we held the 17th meeting of FP-Syd, the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had about 28 people attending to hear our two presentations.
First up we had Jonathan Lange with a presentation titled "Monads and Twisted" where he introduced the asynchronous event handling in Python's Twisted Framework. During a brief introduction to Twisted he showed how callbacks are registered for future events. He then went on to show how the function signatures for these callbacks were very similar to those for Monadic bind and return and that these callbacks obeyed all three of the monad laws.
Next up we had Paul Steckler demonstrating how he has been using Ocaml's camlp4 macro pre-processor in his work on the Goanna static analysis tool. Paul mentioned that documentation for camlp4 is rather poor and that to figure out some things he actually needed to read the camlp4 source code. It does however seem to be a powerful pre-processor system.
A big thanks to James Kozianski and Google for providing the meeting venue and some light refreshments.
The next meeting of FP-Syd happens this week.
Sun, 21 Jun 2009
On Thursday June 18th we held the 16th meeting of FP-Syd, the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had about 25 people attending to hear our two presentations.
This month we tried something a little different, 5 minute lightning talks. We had four lightning presenters :
- Jeremy Apthorp, "Closures in C" - Jeremy explained how the Clang frontend for LLVM had added lexical closures to the C programming language.
- Jeeva Suresh, "Functional Programming Warps your mind - Quantified"- Jeeva quantified exactly how programming in functional languages changes a programmer's approach when programming in other languages.
- Mark Bradley, "Cycling Josephus for Speed" - Mark show how a naive approach to the Josephus Problem in Haskell would, for some example parameters, exhaust all memory. Mark showed a better solution that satisfied the problem but still consumed a large amount of memory. Interestingly, Benjamin Johnston posted a solution to this problem in SWI Prolog that performed very well in comparison to the Haskell version.
- Ben Lippmeier, "The Poisoning Problem" - Ben showed us an example of the poisoning problem which had cropped up in his DDC compiler where a value might need to be mutable or immutable depending on the value of an if statement.
Interestingly, none of the presenters managed to stay within their allotted 5 minutes but the time limits were not enforced.
Our main speaker of the evening was Eric Willigers who gave us an excellent introduction to the Clojure language, a LISP like language for the Java Virtual Machine. Eric started with the main data structures; lists, vectors, maps and sets, moved on to functions and macros before explaining Clojure's concurrency primitives.
All in all this was another most inspiring and enjoyable meeting. Thanks to all our speakers as well as Shane Stephens and Google for providing the venue.
Sun, 24 May 2009
On Thursday May 21st we held the 15th meeting of FP-Syd, the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had about 22 people attending to hear our two presentations, an Erlang double header.
The first presentations was by Ben Johnston, a PhD candidate at University of Technology, Sydney. Ben's talk was titled "How to build a robotic bear in two weeks (or less)." and in it he explained how the need to get some code running on a new robot quickly led him to try Erlang. He explained how he used C for low level control of hardware devices, SWI Prolog for the AI and Erlang for all the glue to hold it all together.
Next up we had Matt Palmer talk about the Erlang database called Mnesia. Matt showed the close correspondence between Erlang queries and their equivalent in SQL. He also talked about the ease of replications, sharding and in-memory databases in Mnesia.
A big thanks goes to Ben and Matt for their presentations Thanks also to Shane Stephens and Google's Sydney office for making their facilities available.
Mon, 18 May 2009
Some time ago, on Thursday April 16th, we held the 14th meeting of FP-Syd, the Sydney Functional Programming group. The meeting was held at Google's Sydney offices and we had about 25 people attending to hear our two presenters.
The first presentations was by Tom Davies titled "CAL/OpenQuark and Java" about CAL and Haskell 98 like language for the Java Virtual machine. CL was released as open source under a BSD-like license as OpenQuark in 2007. Tom gives a quite comprehensive list of the differences between between CAL and Haskell in his slides and a PDF file of the development history of Quark in a supplementary PDF. The main problem with CAL/OpenQuark is that it is effectively abandon-ware and that no-one is actively maintaining it.
The second presentation was by Simon Winwood and was titled "Program extraction from the Coq Theorem Prover". I've been trying unsuccessfully to contact Simon to get hold of his slides. I'll update this when I do finally have a link.
Update 2009/06/05 : Simon's slides are now available here.
A big thanks goes to Shane Stephens and Google's Sydney office for making their facilities available. Thanks also to Tom and Simon for their presentations.
Thu, 02 Apr 2009
Just today, Richard Collins reminded me that I forgot to blog the last FP-Syd meeting. I'm correcting that now.
Last Thursday (March 26th) was the 13th meeting of FP-Syd, the Sydney Functional Programming group. The meeting was held at Google's new offices in Sydney and we had about 35 people attending to hear our two presenters.
The first presentation was by Simon (Horms) Horman, who volunteered to give a presentation the morning of meeting after our scheduled speaker pulled out due to illness. Horms' presentation was titled "Using Haskell to Write a Very Small Portion of Xen". He started out by explaining how he is relatively new to Haskell and that most of his coding is actually in C, for the Xen hypervisor. Xen hypervisor Advanced Configuration and Power Interface (APCI) which is programmed in a very simple C like language called ACPI Source Language (ASL). Programming ASL is a rather repetitive and error prone task, so Horms' solution was to write a simple Haskell program to generate the ASL code. Horms' slides, Haskell code and output ASL code is available in this tarball .
The second presentation was by Mark Wotton on his attempts to improve predictive text entry on mobile phones. Mark explained how he wanted to improve predictive text by using the previous three words instead of just the current word. He chose Haskell for its rapid prototyping capabilities and explained some of the difficulties he had with performance, especially with large corpora and how he got around these problems.
A big thanks goes to Shane Stephens and Google's Sydney office for making their facilities available. Thanks also to Horms and Mark for their presentations.
Sun, 22 Feb 2009
Last Thursday night was the 12th meeting of FP-Syd, the Sydney Functional Programming group and we had just under 20 people show up at the Sydney offices of Thoughtworks to hear our presenter.
Numbers were down a bit this month, probably because we only had one speaker. While we had a decent number of people volunteering to present when FP-Syd started it looks like we have, to a certain extent, pumped the well dry. The presentations committee is going to look into ways of encouraging more people to come forward and tell us what they're working on.
Tim started off with a demo of what the library could do and explained how it was built on top of hscairo the Haskell bindings to the very wonderful Cairo library as well as Gtk2Hs, the Haskell bindings to GTK. He then went on to discuss the difficulties of building a generic graphing library and of creating an API that exposes all the various features in an as-easy-as-possible to use way.
Internally, Tim's library uses Haskell data types and records, often with ten or more separate fields, in addition to having types and records nested within types and records. He went on to explain that accessing these deep and wide structures in Haskell was painful. In particular, the problems are:
- Field names must be unique with a module.
- "Updates" (creating a new record from an old one with one or more fields changed) have a special syntax.
- The special syntax for these updates doesn't allow composition, making updating of one field deep in a nested structure difficult.
Tim's solution to this problem was the use of the data-accessor library and Template Haskell for automatic generation of accessors. While this was an adequate solution, Tim felt that it was working around a limitation inherent to the Haskell language.
Finally, Tim spoke about making his Charts library extensible using Higher Order Functions.
A big thanks goes to Nick Carroll and Thoughtworks for making their facilities available for FP-Syd for the last 4 or 5 meetings. The next FP-Syd meeting will be a Google's new head quarters in Pyrmont. Thanks also to Tim for the presentation.
Sun, 01 Feb 2009
Last Thursday night was the 11th meeting of FP-Syd, the Sydney Functional Programming group and we had just over 20 people show up at the Sydney offices of Thoughtworks to hear two speakers.
First up was your correspondent with a short presentation on the use Functional Programming languages (Ocaml and a bit of Haskell) at bCODE Pty Ltd a small venture capital funded startup in Sydney Australia.
The second presentation was by Paul Steckler who gave a 10000 meter view of PLT Scheme and its associated tools. Included in this presentation was a quick demo of Typed Scheme which adds static type checking (ie at compile time) to an otherwise dynamically typed language.
A big thanks goes to Nick Carroll and Thoughtworks for making their facilities available for FP-Syd. Thanks also to Paul for the scheme presentation.
Sat, 13 Dec 2008
Last Thursday night was the 10th meeting of FP-Syd, the Sydney Functional Programming group and we had just under 30 people show up at the Sydney offices of Thoughtworks to hear two speakers.
First up André Pang gave us a presentation about Apple's Objective-C language, but looking at it from a functional programming perspective. André had previously given this presentation at Galois a company known for its use of Haskell and for employing at least one well known Haskell hacker.
André started off his presentation demonstrating how Objective-C's object system worked living as it does on top of C. Interestingly this language has static type checking at compile time, but also a dynamically checked runtime to allow the usual dynamic typing trickery like monkey patching. He then went on to look at higher order programming using Objective-C methods, the garbage collection recently added to the Obj-C language (opt in and opt out) and the use of the very wonderful Low Level Virtual Machine (LLVM) in the compiler. There is a very nice set of slides for this presentations available here.
Next up we had Manuel M T Chakravarty speaking about Data Parallel Haskell. The really exciting thing about having Manuel speak on this topic is that Manuel is not just a user of this new feature; he was one of the people involved in designing it and adding it to the compiler. While Manuel's talk was mainly about how to use this new feature he could have just as easily dropped into explaining how it works under the hood. There were a couple of times when he really had to fight to urge to do so.
The main idea behind DHP is nested data parallelism an idea that came from a research language called NESL. DHP adds arrays to Haskell and these arrays are evaluated in parallel by the run time. As usual it is Haskell's by-default purity (ie no side effects) that makes it possible to retrofit nested data parallelism to the language without breaking anything else.
Manuel then went on to show the parallel versions of array/vector multiplication, quick sort and the Barnes-Hut algorithm for the n-body problem. The main differences between the parallel and the canonical sequential versions of these algorithms was the use of slightly different notation for the parallel arrays and a slight rearrangement / modification of the algorithms.
This new DPH stuff is in the latest 6.10.1 release of the GHC compiler. Manuel currently considers it a technology preview and not quite ready yet for serious use. The main problem is that the parallelism still doesn't scale the way the developers wish, probably due to bugs remaining in the scheduler and run time.
Personally, I found this an amazingly elegant approach to the problem of exploiting the soon to be widespread availability of machines with tens and even hundreds of CPU cores. Manuel's slides are available here and are a highly recommended read.
A big thanks to André and Manuel for engaging and thought provoking presentations. A big thanks also goes to Nick Carroll and Thoughtworks for making their facilities available for FP-Syd.
Sat, 15 Nov 2008
On the Thursday night just passed was the 9th meeting of FP-Syd, the Sydney Functional Programming group. We had about 30 people show up at the Sydney offices of Thoughtworks.
First up we had Jeeva Suresh talking about the "The Nix Language", the purely functional language behind the Nix package manager. Normal package managers like Debian apt system, operate on the global state of the system, mutating that global state as packages are added and removed. There are a couple of papers on the NixOS web site explaining it further.
The second presentation was by Thomas Sewell and was titled "Functional Programming : What does it mean?". Tom started off reviewing what it was functional programmers like about functional programming and suggested that a lot of it was to do with its connection to mathematics. He then went on to talk about theorem provers, in particular Isabelle and finished off by doing a live proof that the merge sort algorithm terminates and is correct. The audience was suitably impressed.
This was our first meeting at Thoughtworks and I'd like to extend a huge thanks to Nick Carroll, Raphael Speyer and Thoughtworks the organisation.
Fri, 17 Oct 2008
Last night was the 8th meeting of FP-Syd, the Sydney Functional Programming group with huge turnout of 36 people. We had had three presentations with a very heavy Haskell slant.
First up was Conrad "kfish" Parker giving a introduction to type level programming in Haskell. This talk was a simplified version of his paper in issue 8 of the Monad Reader which described solving the Instant Insanity puzzle in Haskell's type system.
Conrad's type level programming solution uses Haskell's type system (specifically a feature called Functional Dependencies) to generate a solution so that the executable program created by the compiler needs to do nothing more than print the result. This is possible because Haskell's type system is a Turing complete logic programming language (much like the way C++'s template system is a Turing complete functional language).
The motivation for Type Families was to allow the programmer to be able to give the compiler better hints on how to optimize things, but the resulting feature goes far beyond that. The example Manuel gave was defining a data type as an array of (Int, Bool) pairs which would normally be un-boxed requiring two pointer de-references to access a part of the pair at a given index. Type Families however allow the programmer to supply hints to the compiler that it should store these as a pair of contiguous arrays, one for the Ints and one for the Bools.
Finally Manuel mentioned that since Type Families can do everything Functional Dependencies can (and more), but in a cleaner way, that Functional Dependencies may eventually be removed from the language.
Last up we had Simon Winwood giving us a demonstration that Monads aren't just for I/O. Simon's presentation was in many ways a follow on from Manuel Chakravarty's "Monads are Not Scary" presentation from the 2nd FP-Syd meeting. He demonstrated an interpreter for a simply language and used the State monad to handle state, Reader monad to read input and the Error monad for error handling.
Once again a big thank you to Google for supplying the venue as well as food and drinks. Next month we will be moving to Thoughtworks for the first of a series of meetings. I look forward to more head exploding concepts.
Fri, 19 Sep 2008
Last night was the 7th meeting of FP-Syd, the Sydney Functional Programming group with 26 people attending. We had had three short presentations.
First up was Jeremy Apthorp explaining the Y Combinator using a Haskell-like syntax instead of the more usual LISP syntax.
The second presentation was Ben Sinclair giving us a introduction to the Scala language. Scala is a functional language targeting the Java Virtual Machine. Its syntax is Java like, but with elements of ML and things that looked a little like Python. Under the hood, Scala is a traditional object-oriented lagngauge where everything except a few primitive types are derived from a base Object class. Scala can also call into any Java library.
Finally we had Eric Willigers talking about parser combinators in Scala. Eric's first example was just a parser that did parenthesis and square bracket matching. He then showed a more complex example, a partial implementation of a parser for the C language. Interesting.
Once again a big thank you to Google for supplying the venue as well as food and drinks.
Sat, 23 Aug 2008
Last night was the 6th meeting of FP-Syd, the Sydney Functional Programming group with 24 people attending.
The first presentation was by James Kozianski titled "Evaluators and Higher Order Abstract Syntax". James showed that when using a language like Scheme (or LISP) where code and data are both stored as S expressions, that abstract syntax tree of an embedded DSL can actually be encoded in the host language's own data structures. This is rather a neat trick and it was great to see a presentation in Scheme. Thanks James.
David Hearnden gave the second presentation titled "Deltaware: Incremental Change Propagation through Model Transformations". He started of explaining Model Driven Engineering, a simple example of which would be generating database schema from the definition of a set of classes/objects. The problem that David's presentation covered was how to deal with changes to the original classes/objects that need to be propagated to the database schema. He then showed how logic programming languages provided a solution to this problem that functional (and imperative) languages did not (ignoring the possibility of Greenspunning logic language features into a functional language). This was a very thought provoking presentation. Thanks David.
I'd also like to thank Google and the Google employees who helped make this meeting happen. We will be having one more meeting at Google before moving on to Thoughtworks' Sydney office for a block of four meetings.
Fri, 18 Jul 2008
Last night was the 5th meeting of FP-Syd, the Sydney Functional Programming group. The turnout was down a bit (19 people) but I suspect that was due to World Imaginary Friend Day (which for some reason seems to run for a week) clogging up Sydney's streets and public transport system.
The first talk was given by the author of this blog and was titled "Ocaml and Unix.select". I'll be blogging this in more detail some time over the weekend.
Next up we had Ben Lippmeier, author of the Disciple compiler on his entry into the ICFP Programming Contest. In the long tradition of eating one's own dog food, Ben used his DDC compiler to write his entry and ran into a nasty intermittent bug in his compiler's run time. Despite the bug he still managed to put together a pretty decent solution to a rather interesting problem.
As usual, we had post-meeting drinks at the Redoak hotel. Thanks to Shane, James, the other Googlers and Google itself for use of Google's excellent facilities.