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)
