Thanks to Twitter, I came across an announcement for a Functional Conference in Bangalore. I usually do not attend conferences, but then a conference focused on functional programming and ideas was a novelty in India. Quickly took a look at the people behind this conference, liked what I saw, and booked a place for myself. This was back in June 2014.
Coming to the conference itself, the registration process was a breeze, and the conference venue was a rather good hotel, with decent conference room facilities. Most of the talks listed at the conference were rather interesting. I attended the following sessions:
- Functional Reactive UIs with Elm – was curious about Elm, and the presentation content was interesting enough, though the presentation of the content was not engaging.
- Applying functional programming principles to large scale data processing – application of “lambda architecture” for data processing. Would have liked to see more depth/details in this session. In any case, it introduced me to the phrase “lambda architecture” – I was using the “functional-style-of-architecture” in my design discussions earlier.
- Compile your own cloud with Mirage OS v2.0 – creating a “unikernel”; where the OS is treated as a library, and is statically linked to the user application; and all of this runs as a single binary. Wow! I wanted to attend this session because OCaml was mentioned in its abstract, and this turned out to be a session that got me thinking about possibilities, and something I continue to think about. This was a session that gave me a lot of vocabulary and ideas for what I was once proposing within IBM – the concept of “Lean middleware” – the idea being to reduce indirections, and to use the OS as a library.
- Property based testing for functional domain models – I have been following Debasish on twitter, and reading the lucidly written entries on his blog. This session was presented rather well, and I got to learn about “property based testing”, and “dependently typed languages – Idris“. Something I want to use, the next opportunity that I get.
- Code Jugalbandi – this was an interesting experiment; a quick introduction to the idioms in different programming languages – Scala, Clojure, Groovy.
- Learning (from) Haskell – An experience report – liked the way this was presented, and learnings that were applied to improve code quality; reinforcing best-practices / idioms in a language of choice – Python / Ruby, etc
- Pragmatic Functional Programming using Dyalog – It just so happened that I had installed Dyalog, and played with APL a couple of months before this session. So, the APL terseness and unique syntax was something that I was aware of. This session was one that made me re-think how important concise, yet readable, code can be. The demo where Morten – the presenter – scraped Wikipedia content to create a FOAF network was really interesting.
- Monads you already use (without knowing it) – an introduction to Monads.
- Purely functional data structures demystified – a very good introduction to a rather dense topic, and inspired me enough to look up the work that Okasaki has done in this area.
- An introduction to Continuation Passing Style (CPS) – the topic started off on a rather simple note, and quickly developed into something that made me sit at the edge of my seat – intellectually stimulating topic.
- Keynotes – I liked the engaging keynote by Daniel, where my key take away was “approach new topics with an open-mind, and treat people with kindness”.
Overall, the Mirage OS session, Property -based-testing sessions were the ones that engaged me the most, and ones which got me thinking about possibilities.
The conference was a well organized one, and one that I would attend the next time around too.