Sat, 13 Mar 2010
FP-Syd #22.
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.
Posted at: 11:57 | Category: FP-Syd | Permalink
Sat, 05 Dec 2009
FP-Syd #21.
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.
Posted at: 16:19 | Category: FP-Syd | Permalink
Sun, 25 Oct 2009
FP-Syd #20.
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.
Posted at: 17:49 | Category: FP-Syd | Permalink
Mon, 19 Oct 2009
FP-Syd #19.
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.
First up we had Raphael Speyer and his presentation "Rhino, ES5 & GSoC". Raphael explained how he was accepted into the Google Summer of Code project to work on bring the Rhino, a Javascript engine that runs on the Java Virtual machine, into line with the upcoming EcmaScript 5 standard.
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.
Posted at: 19:46 | Category: FP-Syd | Permalink
Tue, 13 Oct 2009
FP-Syd #18.
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.
Posted at: 19:55 | Category: FP-Syd | Permalink
Tue, 18 Aug 2009
FP-Syd #17.
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.
Posted at: 18:57 | Category: FP-Syd | Permalink
Sun, 21 Jun 2009
FP-Syd #16.
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.
Posted at: 13:03 | Category: FP-Syd | Permalink
Sun, 24 May 2009
FP-Syd #15.
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.
Posted at: 21:23 | Category: FP-Syd | Permalink
Mon, 18 May 2009
FP-Syd #14.
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.
Posted at: 19:15 | Category: FP-Syd | Permalink
Thu, 02 Apr 2009
FP-Syd #13.
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.
Mark has put up his slides up here and even has a demo available on the web.
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.
Posted at: 21:36 | Category: FP-Syd | Permalink
Sun, 22 Feb 2009
FP-Syd #12.
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.
Anyway, our presenter for the evening was Tim Docker, talking about his Haskell graphing library Graphics.Rendering.Chart which is also on Hackage.
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.
Posted at: 08:54 | Category: FP-Syd | Permalink
Sun, 01 Feb 2009
FP-Syd #11.
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.
Posted at: 11:14 | Category: FP-Syd | Permalink
Sat, 13 Dec 2008
FP-Syd #10.
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.
Posted at: 09:45 | Category: FP-Syd | Permalink
Sat, 15 Nov 2008
FP-Syd #9.
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.
Posted at: 10:14 | Category: FP-Syd | Permalink
Fri, 17 Oct 2008
FP-Syd #8.
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).
After Conrad's warm up we had Manuel M T Chakravarty giving us an introduction to Type Families, a new extension to the GHC Haskell compiler which Manuel and some others have just completed.
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.
Posted at: 19:39 | Category: FP-Syd | Permalink
Fri, 19 Sep 2008
FP-Syd #7.
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.
Posted at: 21:39 | Category: FP-Syd | Permalink
Sat, 23 Aug 2008
FP-Syd #6.
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.
Posted at: 08:34 | Category: FP-Syd | Permalink
Fri, 18 Jul 2008
FP-Syd #5.
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.
Posted at: 18:08 | Category: FP-Syd | Permalink
Fri, 06 Jun 2008
FP-Syd #4.
Last night was the 4th meeting of FP-Syd, the Sydney Functional Programming group. First up I'd like to thank Shane, James and the other Googlers who organised the use of one of Google's Sydney meeting rooms and laid on drinks and a bunch of tasty snacks. Another big thanks goes to our speakers for the evening and the 32 (!!!) people who showed up.
Unfortunately one of our planned speakers for the night had to drop out at the last minute. This meant that as people arrived I was asking them if anyone had a short talk they could give at very short notice. The thing that impressed me the most was that we got two offers.
First up we had Sean Seefried talk about using Ocaml at Nicta to write Nicta's Goanna static type checking tool for C and C++ code. It was interesting that they were using an existing commercial C and C++ parser and the converting the C abstract syntax tree (AST) produced to an Ocaml AST where they work on it further. Also interesting was that the chose Ocaml because it was a good language for writing compilers as well as having reasonably good and highly predictable performance. This was an excellent talk considering that Sean had about 10 minutes to prepare. Thanks Sean.
The next speaker was Scott Kilpatrick who also had about 10 minutes to prepare as well as being our first international speaker. Scott has just recently completed two B.S. degrees (one in Computer Science, the other in Mathematics) from the University of Texas at Austin and will be starting a Masters there in September. He's is currently interning at Google here in Sydney working on the Google Maps project.
Scott gave us a very interesting introduction to SUN's Fortress language. Scott is working on implementing the type checking system for the Fortress compiler rather than being a dedicated user of the language. He was however able to give us a brief overview of the language, which is designed to replace Fortran in high performance computation tasks. Fortress seems to have a huge array of interesting features and is definitely something to keep an eye on. Thanks Scott.
Finally we had Tim Docker speaking about writing a Tuple Server in Haskell using the State Transactional Memory monads in concurrent Haskell. Tim did a great job explaining what Tuple Servers are and what they are used for where he works at Maquarie Bank. He then talked about the monads in Haskell, in particular the STM monad and its use in his tuple space server. It was a great talk and I mid way through it, I realised that a tuple space server is a nice solution to an architectural problem I have. Thanks Tim.
After the talks we retired to the Redoak hotel for a few beers and a chat. Since a couple of people had missed the previous meeting, Ben Lippmeier, was kind enough to pull out his laptop and give his talk on "The Disciplined Disciple Compiler" again. Interestingly for me, he went into a little more detail on areas that he glossed over in the last meeting. DDC is a really interesting piece of work, being a strictly evaluated dialect of Haskell, with optional lazy evaluation (far more elegant than the way Ocaml does it) and with side effects and destructive updates looked after in the type system. The ideas behind DDC are really compelling. I look forward to seeing it progress. Thanks Ben.
Posted at: 22:18 | Category: FP-Syd | Permalink
Fri, 18 Apr 2008
FP-Syd #3.
Wow! Just Wow! I've just arrived home after another FP-Syd meeting.
First up we had Jeremy Apthorp with a short talk titled "My Favourite Bugs (that don't exist in functional languages)". Jeremy gave us all a good reminder of why we were all there. It was also a good warm up the second talk.
Ben Lippmeier, gave us a talk titled "The Disciplined Disciple Compiler" which is something he's working on as part of his PhD at Australian National University. Ben's DDC is a compiler for a Haskell dialect named Disciple that uses effect typing to deal with issues like side effects and destructive updates. Unlike Haskell, Disciple is strictly evaluated with optional, explicit lazy evaluation. This was a really thought provoking talk. Thanks Ben.
I would also like to send out a big thanks to Tom and Scott of Atlassian's Sydney office for providing the venue.
After the meeting we headed off the to Readoak hotel for beers and more FP discussion. By 10:30pm we were just about to leave the Redoak when I ran into Damana who used to work at bCODE and who had organized Sydney Geek Girl get together that same night.
Posted at: 00:44 | Category: FP-Syd | Permalink
Thu, 27 Mar 2008
FP-Syd #2.
Tonight was the second meeting of fp-syd, the Sydney functional programming group. We had a much more focused group this time with 24 attendees.
First up I gave a short talk on a data structure I had come up with for handling data in a text editor. This data structure was very much inspired by the book, "Purely Functional Data Structures" by Chris Okasaki. All data in the data structure is treated as immutable which means that it is very easy to store past state and to implement undo / redo.
The main talk was split into two parts. First up Manuel Chakravarty gave a talk titled "Monads are Not Scary" and he gave us all an excellent introduction to the topic which I'm pretty sure has convinced all the monad skeptics in the room that monads really aren't anything to be afraid of.
The second part of the main talk, was presented by André Pang who built on Manuel's monad introduction and covered Haskell's Parsec monadic parser combinator library. This too was an excellent talk which explained what seems to be a really elegant tool.
Since the group this week was well over 20 people, we are going to have to look for a bigger venue. Dave Peterson of Orbitec has been a great host for the last two meetings and we would sincerely like to thank him for making his offices available for this bunch of crazy people.
Posted at: 11:54 | Category: FP-Syd | Permalink
Thu, 28 Feb 2008
Inaugural Meeting of FP-Syd.
Tonight was the inaugural meeting of fp-syd, the Sydney functional programming group. Here's a somewhat blurry (sorry, my bad) picture of the attendees.
Across the back from left to right we have; Eric, Ben, Ondrej, Dave, Manuel, Rahul, Shane, André and Ben. At the front, left to right we have Sean, Scott, James and Erik.
I think the night was an absolutely rip roaring success. We met at about 6:30, we each gave an approximately 10 minute each intro of ourselves and our interests in functional program. The meeting then evolved into a general discussion and then at about 8:30 we moved on to Bazaar Beer Cafe for a beer.
Thanks to everyone who attended. It was a huge buzz and I look forward to meeting on a regular basis.
![[operator<< is not my friend]](http://yosefk.com/c++fqa/images/operator.png)
