Paul Brabban from def_shef in Sheffield will talk us through implementing a classic machine learning algorithm. This is a workshop session, so do bring your laptop to play along if you can! Paul writes:
The algorithm behind the k-nearest neighbour classifier dates back to the early days of computer science. Its simplicity, amongst other properties, make it a great introduction to machine learning algorithms.
In the workshop, you’ll implement a kNN classifier in the functional language of your choice, including training and testing against real data sets using k-fold cross validation. I’ll help anyone who’s having problems, and for FP experts who finish the implementation quickly, there’ll be several suggestions for further exploration.
If any of those terms are new to you, don’t worry! We’ll assume no previous Machine Learning knowledge.
(Please register to let us know you’ll be coming!)
Looking forward to seeing old and new faces, we should have some time after the session to chat about what people been playing since we last met in November. Please shout on the night, or contact the mailing list or ping @lambdamcr to let us know if you have a talk you’d like to give. (We’re a very supportive crowd, do let us know if you have any questions!)
We’ll meet on Monday 20th November, 7pm (doors open a little earlier, we aim to start by 7:10pm) at MadLab for the final meeting of the year! We’ll do a Show and Tell of projects that people have been involved and some Discussion on topics of interest.
- Paul Brabban (defshef) discussion on “intro to FP” workshop
- James Fielder “So you’re stuck with Java/C++ and you want to do FP…”
- Giambattista Pieretti Erlang & Internet of Things, with the Wemos D1 mini (Arduino compatible board)
- Hakim Cassimally a Clojure macro to make declaring XML data simpler
Really looking forward to seeing what people have been playing with over the year! Please reply to the mailing list or ping @lambdamcr to propose a topic!
(Alternatively, feel free to bring an idea on the night and we may be able to fit you in.)
We’ll meet on Monday 16th October, 7pm (doors open a little earlier, we aim to start by 7:10pm) at MadLab to learn about macros in Clojure.
(We don’t know yet if we’ll be in the main section or the next door FabLab - will be clearly signed and we’ll try to tweet details beforehand!)
Clojure Macros - with great power comes much confusion
Dan Meyers (BBC Programme Metadata, @Carr0t) will go through the basic building blocks of macros and how they differ from functions. He writes:
“Anyone who’s written any Clojure has probably used macros that are in the language core, even if they didn’t realise it, but a lot of people might not have written their own macros.
We’ll go through two examples covering what I see as the major use-cases of macros – logging and code readability. We’ll do this bit by bit to see how they do what they do, and then look at the results of that.”
The talk starts from fairly basic principles and building on that so you don’t need to know Clojure or anything to understand it. A few brief slides at the beginning give you all the info you need to understand what’s going on even if you’ve not really looked at a Lisp-like language before.
Back to School evening
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
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.
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!
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.
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!
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.
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.
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!)
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.
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.
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.
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.
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.
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?
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*?
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
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.
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.
Show and Tell
The lambda lounge this Monday are doing a show and
tell. We'll meet at @madlabuk at 7pm
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
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.
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.
Application development with Purescript
There are also versions of Purescript in development that compile to Python and C++.
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.
We’re meeting at the usual time of 7pm @madlabuk, so we’ll see you there!
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.
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!
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.