�ݺ�ߣ

© freiheit.com technologies gmbh
Clojure:
Programming self-optimizing webapps in Lisp
- Release 0.1 -
Developer Conference 2013
Hamburg, November 7th/8th 2013

Welcome, Earthlings!
● My name ist Stefan Richter
● I am a programmer, engineer and computer scientist
● I started programming in 1983 on an Apple ][ (UCSD Pascal)
● Worked in polar research, software development & consulting
● In 1999, I founded freiheit.com technologies gmbh
● We are building large-scale internet systems
● 70 people. 90% programmers with a strong academic background
● We mostly use Java and JavaScript
● Today I want to show you how to have fun with Lisp (Clojure)

This is no Clojure
101 class.

There are some
really good books
about Clojure if you
want to learn the
language.

Today, I want to
show you how it
“feels” to work
with Lisp/Clojure.

I love...

Simple,
powerful
syntax

No state
(Almost)

Interactive
programming

Objectives of this talk
● We will learn what multi-armed bandit algorithms are
● We will write a Clojure library for the epsilon-greedy algorithm
○Two approaches: Naive and idiomatic
● I will show you some nice features of the Clojure language
● We will make our library thread-safe by using agents
● And we will expose our Clojure library as a JAR-File to use it from
an “ordinary” Java program
So in the end you’ll get an idea of how you can write Lisp/Clojure
code and use it as a library from within your Java apps. ;)

Multi-armed bandit
algorithms
● Which arms on which
machines would you draw
based on the past outcome
(reward)?
● Exploration vs. exploitation
● What do you need?
○ select-arm()
○ update()
○ algorithms: epsilon-
greedy, Softmax, UCB etc.

Epsilon: The explore frequency

First try: The naive solution

Demo-Time!
Interactive programming,
functions, sequences
(vectors), immutability or the
absence of state

Okay, what’s wrong with this code?

What’s wrong with the naive implementation?
● Code must “know” what to expect at which vector index.
● Vector index access is diffcult to read/grasp.
● The functions have no cohesion. They are just named functions
that accidentally work together on the same datastructure, a
vector.
● How can we implement different algorithm versions that provide
the same interface functions (select-arm, update)?
● The code isn’t self-explanatory. How do you should use the
functions?

Let’s fix it in a
more idiomatic
way.

A protocol and a datastructure

Naive and idiomatic: Almost the same SLOCs
● Much better now. More readable and understandable.
● We are now accessing the different fields the algorithm needs by
name instead of by index.
● We defined a datastructure and implemented functions that are
working on this datastructure based on a protocol (“interface”).
● We can create many different implementations of the
BanditAlgorithm protocol.
● And along the way, a new Java class and interface are generated!

Demo-Time!
Interactive programming
(again), protocols and records,
sequences revisited (maps),
immutability or the absence
of state (again)

Now we need some
state and a way to
change it from
different threads.

We need…
Agents!

Agents: async. shared access to mutable state

Next we wrap and
package our
Clojure code into a
Java class and JAR.

Let’s use it from a Java program...thread-safe.

Thank you!
Web:
http://www.freiheit.com
Twitter:
http://twitter.com/smartrevolution
GitHub:
https://github.com/smartrevolution
Google+:
https://plus.google.com/u/0/+StefanRichterSmartrevolution

Programming multi-armed bandit algorithms
in Go
- Release 0.1 -
Developer Conference 2013
Hamburg, November 7th/8th 2013

Welcome, Earthlings!
● My name ist Stefan Richter
● I am a programmer, engineer and computer scientist
● I started programming in 1983 on an Apple ][ (UCSD Pascal)
● Worked in polar research, software development & consulting
● In 1999, I founded freiheit.com technologies gmbh
● We are building large-scale internet systems
● 70 people. 90% programmers with a strong academic background
● We mostly use Java and JavaScript
● Today I want to show you how to have fun with Go and in about
one hour I will show how to solve the same problem in Clojure.

Why should you
learn Golang?

Easy to learn,
highly
productiveMade by hackers, for hackers

Batteries
includedWorld-class libraries

Fast CompilerSaves time...

Testing is
part of the
platformTesting and Benchmarking

Easy to setupSuper-simple dependency-management

Easy to deployCompiles and links a single binary

Objectives of this talk
● We will learn what multi-armed bandit algorithms are
● We will write a Golang program for the epsilon-greedy algorithm
● I will show you some nice Golang features
● This prepares you for my next talk today at 1600 in Kinosaal 2

Multi-armed bandit
algorithms
● Which arms on which
machines would you draw
based on the past outcome
(reward)?
● Exploration vs. exploitation
● What do you need?
○ selectArm()
○ update()
○ algorithms: epsilon-
greedy, Softmax, UCB etc.

Not really trendy...
● Go is not object-oriented
● Good thing: You can’t mess up your code with “Enterprise
patterns”... ;)
● Go doesn’t support functional programming
● But you can define your own types
● And you have duck typing and interfaces
● It is like C without the bad parts
● (I think almost every language in the past 30 years was made to
fix the “problems” of C - and along the way new problems were
created)
●

An interface and a datastructure

Demo-Time!
Setup your Go-env, languages
basics, functions, structs,
visibility, build, run

Method definitions (“implementing interface”) I

Method definitions (“implementing interface”) II

Demo-Time!
Methods, for-loops,
go-routines

I hope you had
some fun!

Don’t forget to visit
my Clojure talk
today at 1600/Saal5

�ݺ�ߣ

Clojure: Programming self-optimizing webapps in Lisp

More Related Content

Clojure: Programming self-optimizing webapps in Lisp