Meetings

Sep
18

Back to School evening

As we reach the end of the Glorious British Summer, it’s time to pick up our new exercise books and pencil cases and learn some new techniques on Javascript (and a bit of Clojure) in the field!

LambdaLounge is pleased to present an evening suitable for all, and especially newcomers to Functional Programming on Monday 18th September at 7pm at MadLab.

A Functional JS Field Guide

Katie Fenn (@katie_fenn) is a software engineer at npm. She works with all aspects of the web, particularly JavaScript, CSS, Node.JS and ops. When not at her desk, she is usually in the pool or on her bike in the Peak District.

JavaScript is a language of two flavours: object-oriented and functional. Some would say functional is JavaScript’s dominant flavour, but only recently have we started exploring its uses fully. I will show how lessons from functional programming takes advantage of JavaScript’s better features, and may even change the future of computing.

In this talk I will introduce the basic ingredients of functional programming and explain why embracing them makes JavaScript easier to work with. It will be aimed at JavaScript developers of all experience levels and backgrounds.

Writing a tile-matching game in Clojure (first steps)

Ever wondered how to write a tile-matching game (like Candy Crush and the earlier Bejeweled)? And how do you even write a game (with graphics, and state, and user interaction!) functionally? Regular speaker and co-organizer Hakim is just starting to explore this process, and will present some of the basics of modelling the game grid, and playing a basic event loop, introducing some important concepts in functional programming.

Jul
17

Hacknight: The Functional Internet of Things

We’re meeting on Monday 17th July at 7pm at MadLab to play with microcontrollers and functional languages! We will have some instructions for very simple projects that you can extend. Alternatively, you are welcome to work on a project of your own, or join other attendees to help them.

After our May talks on IoT we’ll meet to work together on various Internet of Things projects. This will be a Hands On session, so please do bring:

 * laptop
 * any electronics kit you have that you'd like to play with

But don’t worry: we will bring various microcontrollers: ESP8266, Arduino, some BBC micro:bits etc.

We’ll start by getting software installed and things setup, so do feel free to arrive early if you can. Then we’ll do a brief brainstorming exercise, and form into small teams (or work alone if you prepare) on our projects!

May
15

The Functional Internet of Things

We’re meeting on Monday 15th May at 7pm at MadLab to talk about how Functional Programming can be used to interact with the Internet of Things.

Firstly, Qambar Raza (@QambarRaza) (BBC), who is starting an exciting project using the ESP8266 IC, Clojure, and Firmata and is blogging all the way up to his talk and demo at LambdaLounge.

Our second confirmed speaker, Spencer Marsden (@spencermarsden) (a creative technologist at the BBC’s consumer technology showcase, the Blue Room) will give an overview of some of the exciting projects and technology he’s worked on.

We can still make time for one or two more speakers! could you get involved?

Perhaps you’ve written some dataflow based code on the Raspberry PI with NodeRED? Or you’ve been experimenting with Haskell and hArduino? Or have you been sneaking Functional concepts into C++ code on a PIC?

Whether you are enthusiastically tinkering on a hobby project, or have used these technologies in a successful enterprise, we’d love to hear from you!

We’re really keen to get a diverse range of speakers, from a wide range of backgrounds and experience, whether you’re a relative newcomer to functional programming, a veteran developer, or an academic, we always provide a warm welcome! See our call for speakers for more details or ping us at @lambdamcr!

Mar
20

Discovering the beauty of recursion and pattern matching

We’re meeting on Monday 20th Mar at 7pm at MadLab where DJ Adams will speak about one of the essential features of functional programming: recursion.

Moving from an imperative mindset across to a more functional one requires some rewiring of your brain. One of the areas where this is particularly noticeable is understanding how iteration is achieved in languages without explicit loop constructs. In this talk, we’ll look at recursion as a fundamental building block, and discover how pattern matching in Haskell, Clojure, Elm, Elixir and even JavaScript is a beautiful thing.

Feb
20
We're meeting on Monday 20th Feb at 7pm at madlab to learn Elixir!
Elixir is a dynamic, functional language with Ruby-like syntax that runs on the Erlang virtual machine. With first class support for concurrency, scalability, fault tolerance and high availability, all courtesy of its Erlang roots, it can be described as the language for today's real time, hyper-connected world.

In this short introduction to Elixir presented by Chi-chi Ekweozor, learn how to use the ubiquitous pipeline operator |> to consume functions as data, pattern matching, modules, lists and other language constructs. Level up and get writing distributed software applications that go beyond the browser on to mobile and the Internet of Things.

** Please note: Hands-on Session **
This is a hands-on session, to follow along please come with a laptop with Elixir pre-installed. There are instructions for installing Elixir and Erlang on most operating systems on the Elixir-lang website.
Jan
16
This month Hakim Cassimally is presenting on Data Structures for Text Editors.   We're meeting on Monday 16th Jan in madlab at the normal time of 7pm.
To support the features that we need as programmers, text editors arrange textual data in rather different ways than we might expect from other text-processing tasks, where we commonly use strings and streams of characters.
We'll first look at some classic text editor data-structures like Lists of lines (vi, Atom), the Gap Buffer (Emacs), and then at purely functional data structures that fit better with functional languages - structures like Piece Tables (Abiword, Bravo), various sorts of tree (the infamous Xanadu, GtkTextBuffer) and Zippers (yi).
I'll be showing a few examples in Clojure, but the approaches are valuable in any language (I've done previous prototypes in Perl, Java, and Haskell!)
Oct
17

This Monday at 7pm Chi-chi Ekweozor is giving a talk on the soft real-time aspects of Elixir/Phoenix and its web sockets implementation (aka Phoenix channels) - which was the main draw for building a real-time Q&A service with it over at assenty.com. And, yes, there will be a live demo!

Sep
18
This Monday at 7pm Alex Weaver is giving a talk on deep learning for functional programmers.
Deep learning has improved on the state of the art in several fields of machine learning, and is beginning to be used in commercial settings. This talk aims to provide a grounding in the core concepts of the topic, explore parallels with functional programming and introduce some promising recent research.
Aug
15
This Monday at 7pm we're pleased to announce we have another talk by Lee Kitching, this time on Property Based Testing a Regex Processor in F# with FsCheck.

Traditional unit testing requires the programmer to manually generate test cases, which are highly specific but give poor coverage of the range of possible inputs.

Property-based testing is used to specify the behaviour of programs and assert the adherence of the implementation to the specification by randomly exploring the input space.

This talk introduces property-based testing FsCheck, an F# port of Quickcheck. The API will be introduced before being demonstrated in development of a simple regular expression engine, and used to check invariants for data structures.
Jul
18
This monday at 7pm Rick Moynihan is talking about Clojure, the functional Lisp for the JVM.

The interactive REPL driven demonstration will try and provide a whistlestop tour of Clojure and its workflow, showcasing unique aspects of the language and its workflows.  Depending on what people want to see, we can touch on topics ranging from macros and meta programming to interacting with Lisp at the REPL, using profilers to diagnose performance issues, tools such as Leiningen, nREPL, Paredit, or CIDER, or the concurrency options available to you such as futures, promises, agents, atoms and the Software Transactional Memory.

Or perhaps any other core language features such as protocols, multimethods, persistent data structures, lazy sequences, transducers, that I can talk about.

I won't be able to cover everything, but I'll try my best to give you a flavour of this practical language.

Jun
20
This month we have another talk from Jaakko Pallari, this time on the Apache Spark platform. 

Spark provides a functional programming interface for building parallel, distributed data processing jobs.  Jaakko will talk about what Spark is and how to set it up, whilst demonstrating examples of developing with Sparqk.
We'll be meeting at 7pm at madlab as normal.
May
16
This monday at 7pm we have PLT guru Lee Kitching talking about Pipes.

Pipes is a Haskell library based on a composable push/pull streaming abstraction.

Laziness is crucial for defining reusable algorithms which can be freely composed together, and most modern languages define an abstractions for lazy sequences such as Java 8 Streams and IEnumerable in C#. However laziness is problematic when streams are derived from resources such as file handles which are consumed incrementally and require prompt cleanup since streams hide the nature of the source from the consumer. This presents a risk of resource leaks if clients fail to consume the entire stream, or inefficient use of resources if the problem is avoided by consuming the entire stream eagerly.

This talk describes the abstraction defined by the Pipes library and demonstrates how it can be used to define reusable streaming components.
Apr
18
This month Hakim Cassimally is presenting on why "Haskell is an acceptable Perl".  We're meeting on Monday in madlab at the normal time of 7pm... 

So, Haskell is "an advanced purely-functional programming language" which supports writing "declarative, statically typed code". It may be optimized for academic buzzwords you've never heard of but... is it any good for writing code in the way that you'd write Perl, Python, or Ruby?
What are strong types, and why are we so frightened of them anyway? Can you develop interactively in  Haskell, the way you would in a dynamic language?

Does Haskell have "whipuptitude" (being able to get things done quickly) as well as "manipulexity" (being able to manipulate complex things)? And perhaps most importantly, can writing Haskell be *fun*?
Haskell is founded on decades of the finest mathematical and computer science research.  Perl, quite demonstrably isn't... but why do so many Perl programmers also love Haskell?

Audrey Tang wrote the first prototype for Perl 6, Pugs, in Haskell, and coined the phrase "lambdacamel" for the substantial crossover between the languages.
What does a Perl programmer make of Haskell?  What are the lessons that can be learned (in either direction).  And do the languages have more in common than you might have thought?
Mar
21
This month after a brief hiatus we return at the usual time of 7pm with a talk by DJ Adams entitled:

Learning by Doing: Beginning Clojure by Solving Puzzles.

DJ had this to say about his talk:

"I'm teaching myself Clojure, because awesome. In this talk, I'll relate some of my experiences in trying to discover how natives speak, by tackling puzzles in Project Euler and Advent of Code.  If you're a Clojure beginner too, or even if you're not, this might give you some confidence in taking a similar journey; if you're more experienced, it might be a comedy half hour. Either way it will be fun :-)"

So come and join us for an interesting tour in applying a modern Lisp to classic computing and problems
Nov
16
This month saw Scala developer, Jaakko Pallari, talk about how Free monads are a general way of deriving monads for functor data types.

Besides reducing the boilerplate for creating new monads, they allow customising how the monads are interpreted.

Jakko demonstrated what free monads can be used for in practice, as well as how the free monad itself is structured.

The code examples in Haskell can be applied to other functional programming languages as well.
Oct
19
This month we have Lee Kitching giving us a talk on  Servant, a Haskell DSL for creating HTTP APIs.

We'll be meeting @madlabuk at the usual time of 7pm.

API endpoints in Servant are represented as types which ensures implementations conform to the definition and enables safe routing and automatic client generation.

The talk will cover how to use Servant to create web APIs, and examine some of the features of the Haskell type system which make it possible.
Sep
20

Show and Tell

The lambda lounge this Monday are doing a show and tell.  We'll meet at @madlabuk at 7pm as usual.

It's going to be a pretty informal round table discussion, so bring something along to chat about that you think will be interesting to the Lambda Lounge!

Things you could bring...

- A cool book you've read on Functional Programming or Computer Science

- An interesting paper, you've read on Computer Science, Types, Functional Programming etc...

- A neat algorithm

- An awesome API you've found

- A blog article you've found interesting.

Ideally you should be able to talk about what you've brought for a minute or two.  Feel free to bring as many things as you want to chat about - just try and keep them relevant to computer science and/or PLT

Don't worry if you don't have anything to bring - just come and join the conversations.

Aug
17
This Monday at 7pm, we'll be looking at Split-Apply-Combine a strategy for analysing data: split up the problem, apply a function, and combine the pieces.

Adopting this pattern will free you to focus on the unique aspects of your problem.

The strategy was first described by Hadley Wickham with a implementation he wrote in GNU-R. With roots in Scheme and S, R is a statistical language and computing environment offering both functional programming features (first class functions, higher-order functions, and closures) and support for objects.

Robin Gower, of Infonomics, is a data scientist with many years experience using R and he will be providing us with an overview of the split-apply-combine strategy and some live coded examples.
Jul
20

Application development with Purescript


Join us on the 20th July at 7pm at Madlab, where Becky Conning tells us about her path from Javascript to Purescript.

Becky's team uses Javascript for everything and over time has found the approaches and technologies that were helping them the most have their roots in functional programming.

Purescript is written in and inspired by Haskell. Luckily for us web developers, Purescript modules compile to CommonJS modules making  it surprisingly easy to interface between Javascript and Purescript in both directions.

There are also versions of Purescript in development that compile to Python and C++.

Becky will be sharing her excitement about the possibilities of functional programming for application development with you and we’ll building a small application to help get you motivated.

So whether you’re a Javascript developer, a seasoned functional programmer or just interested in applications come on down and get excited about Purescript and functional programming for applications!
Jun
15

Introducing Rust

This Monday at the usual time of 7pm, Michael Jones will introduce the Rust programming language from Mozilla with an overview of the goals of the project, what has been achieved so far and a focus on some of the functional influences in the language.

Rust is a systems programming language, that is gaining traction.  Its features include an innovative borrow checker, and many zero-cost abstractions to ensure type and memory safety.

May
18

Calling all Javascripters!

This Monday we have two talks talking about how to write better Javascript by using functional programming techniques.

Firstly Matthew Cannon will tell us about how the functional features of Javascript and the lodash framework helped deoderise his nodejs code.

This will be followed by Rick Moynihan giving a brief talk and discussion on why Javascripters might want to learn other functional languages.

We’re meeting at the usual time of 7pm @madlabuk, so we’ll see you there!

Mar
16
This month on Monday 16th @7pm we have Claudia Doppioslash talking about the adventures she's been having exploring the Elm programming language.

Elm is a Functional Reactive Programming language that targets the web (Javascript, Html, CSS). Reactive Programming, which has gotten in the mainstream with the Microsoft Rx extensions, is basically a better abstraction for anything that requires interactivity, like GUIs and games.

Some useful features of Elm are a Time Travelling debugger (which is remarkably similar to Bret Victors'), hot code swapping, immutability, Union Types, type inference and of course FRP.

We will be meeting at Madlab as usual.
Feb
16
On Monday February 16th at 7pm we're hosting a series of lightning talks @madlabuk.

The first talk by Michael Jones is on Facebook's React, a Javascript framework for functional DOM manipulation. 

This talk will then segway  nicely into a talk by Andrew Kirkham on the advantages of using React for Clojurescript UI's via either Om or Reagent.

In our third talk Daira Hopwood gives an introduction to the cool things you can do with dependent types and how they can help you write safer code.

We still have room for another lightning talk so if you'd like to talk for ~10-20mins, we'd love to listen!

Jan
29
This Monday @RickMoynihan will be introducing Grafter, an opensource Clojure DSL developed by Swirrl to solve the hard graft of linked data ETL

We'll look at how Clojure's affordances make it a natural language for simplifying the process of cleaning tabular data and converting it into linked graph data and how we're  building an interactive environment for lay users to write purely functional programs.

As usual we'll be meeting at 7pm at Madlab.