ClojuTRE & SmallFP Goes Helsinki

Clojure & Functional Programming event for programmers – September 13-14th 2018

:about

ClojuTRE is a Clojure conference organized by Metosin. Single track, late start, short talks (20 minutes and 5 minutes Q&A) and a funky after party for networking, discussions and craft beer. We welcome both newbies and seasoned Clojurists. This year the event will be held in Helsinki Friday 14th September.

Small FP Conf is about functional programming languages in general and is held on Thursday 13th September. Talks will start at 3-4PM and and the event lasts about 3 hours.

Read also our blog post for more information.

Past events: 2017, 2016, 2015, 2014, 2013 and 2012.

:location

In Helsinki, Finland.

Korjaamo, Tram hall
Töölonkatu 51 a-b
00250 Helsinki
Finland

:coming-from-abroad

You can fly to Helsinki-Vantaa (HEL). There is a train connection to Helsinki Central Railway Station.

:hotels

You can book a room from Scandic Park Helsinki (Booking code BCLO130918) for a special price of 129€/one person room or 149€/two person room per night until 15th August.

:registration

Small FP registration is open

ClojuTRE registration is open

:call-for-speakers

Small FP call for speakers is closed

ClojuTRE call for speakers is closed

:program

Thursday - Small FP conf

Thursday is dedicated for presentations about other languages than Clojure. For those of you interested in Elixir, Haskell, PureScript and the rest.

Thursday - Talks - 15:00-19:45

Friday - Main Event

Friday - Talks - 10:00-18:40

Friday - Afterparty

There will be an afterparty. Details later.

:talks

#TBA

To be announced.

Nada Amin@nadamin,

Nada Amin is a lecturer in Programming Languages at the Computer Laboratory, at the University of Cambridge. Previously, she was a member of the Scala team at EPFL. She has contributed to Clojure’s core.logic and Google’s Closure compiler. She’s loved helping others learn to program ever since tutoring SICP as an undergraduate lab assistant at MIT.

#Native Clojure with GraalVM

GraalVM challenges the status quo on the JVM. This newly-released just-in-time compiler brings substantial speed improvements and support for polyglot applications. It also allows us to translate our JVM bytecode into small self-contained native binaries. In this session we’ll explore Graal’s impact on Clojure.

We’ll use GraalVM to build native binaries with simple command-line tools. We’ll discuss the method’s limitations and their impact. Finally, we’ll build complete Clojure web applications weighing a fraction of their traditional JVM incarnations.

Jan Stępień

Jan is a senior consultant at INNOQ, where he works a whole lot with people and a little bit with computers. He's based in Berlin but you can run into him in other parts of Europe too. He enjoys community events, where he often discusses functional programming, architecture, and testing. Jan used to organise the Munich Clojure Meetup; swing by if you're in town, we're a really friendly bunch.

#Optimizing My Mental Focus with Machine Learning and Clojure

Coding is a skill which requires significant mental focus. As software engineers, we are probably more aware of fluctuations in our daily mental focus than others - we all have our good days and our bad days. While some bad days can be explained by e.g. sleeping too little (or drinking too much), others seem to occur randomly.

In search for a better explanation and equipped with the two most sophisticated tools mankind and Rich Hickey recently came up with (Machine Learning and Clojure), I embarked on a journey in which I noted down everything I ate, drank, 'produced' and did while using Clojure to process the data. I'll share my technical, medical and personal insights from my entertaining search of the ultimate factors which boost and impair my mental focus.

Oliver Eidel@olieidel, ,

Oliver is a doctor and software engineer. After 'developing' hacky php websites as a kid, he got sidetracked and went to medical school. While working in radiology research, he re-discovered his love for coding and noticed that he can help a larger number of patients by improving healthcare IT.

After joining Merantix as first non-machine learning engineer, he introduced Clojure/Script there and is now head of product development.

#Carp—A Language for the 21st Century

We love Clojure because it is expressive, modern, and built on the shoulders of giants. We love it because it enables us to create abstractions that we couldn’t otherwise get when constrained to the JVM and JavaScript world.

Carp is a statically typed, compiled Lisp that’s deeply rooted in Clojure. It also takes inspirations from Rust, in that it uses a borrow checker to manage memory. This allows us to create a powerful, pretty Lisp that combines great C interoperability, safe memory semantics, and inferred types to make your life easy and enjoyable. In one sentence: it is to C as Clojure is to Java.

I’d like to give you a glimpse of the language and its semantics and show you how it is similar and different from Clojure at the same time. I’m going to share the philosophy and current state of the language, as well as what’s to come and what’s missing.

Veit Heller,

Veit is one of the core maintainers of Carp. As his day job he works as a System Engineer at Port Zero, a small consultancy based in Berlin. He does a lot of open source work and likes to build programs for domains he knows nothing about.

#Documenting the Clojure/Script Ecosystem

Good documentation starts with good documentation tooling. In this talk I will introduce a new documentation platform for the Clojure/Script ecosystem. This platform aims to support library authors in creating excellent documentation as well as users consuming it.

The talk will be a mix of laying out the rationale and goals, looking at prior art & interesting technical challenges along the way.

Let's make Clojure documentation awesome!

Martin Klepsch@martinklepsch

Martin is a Clojure/Script consultant who never expected to work on a documentation platform. After this conference he'll fly to Greece to embark on a two week sailing trip.

#First 6 years of a life of Clojure project; or, the good, the bad and the ugly in the age of dynamic typing

Lupapiste is now 6 years old Clojure project. When it started, Clojure as a language was viewed as highly controversial and risky for 'real projects'. Dynamic typing was not going to scale with more developers and with larger code-base, we were told by many.

Now, after 6 years, 120 000 end-users, 10 000 permits applied monthly, well over 40k commits made by 25 programmers over the time resulting over 125k lines of Clojure code, it's interesting to take a look how this controversial and risky language has served us.

This talk takes a look on what choices have been made, what has worked well, what has caused pains, and finally, where we are planning to evolve the code-base now as Lupapiste is going global.

Jarppe Länsiö@jarppe,

Programmer

#(block)chain reaction: Ethereum & ClojureScript

A blockchain is a globally shared, transactional, and immutable database. We’ll explore the process of programming distributed applications (dApps) with ClojureScript and Solidity, the primary language used to compile to Ethereum Virtual Machine code. This talk is a high-level overview of building an Ethereum dApp with ClojureScript and web3.js, as well as takeaways from our experience of doing that at district0x.

Dom Kiva-Meyer@domkm,

Dom is a partner at (paren), a small software consultancy that specializes in Clojure, ClojureScript, JavaScript, React, ReactNative, and GraphQL. He has worked with startups in Y Combinator, TechStars, and 500 Startups. He discovered functional programming and Clojure in 2012 and never looked back.

Dom is cursed to run into problematic edge cases in everything he touches. If you have an unusual bug that occurs every few weeks, it will happen to Dom three times on his first use. He tries to solve some of them but must make do with complaining loudly about most of them.

#⚡ Named loop + recur-to: extending the loop + recur-to paradigm to nested loops

Currently loop/recur is limited to 'single-layered' loops: loop forms can occur inside other loop forms, but there is no facility for 'recurring to an outer loop'. This is fine in a lot of everyday high-level code, but can be problematic in implementations of algorithms structured as nested loops that may need to be terminated early, particularly if performance is a significant concern.

In this talk I will discuss my proposal (Clojure ticket CLJ-2235) to extend the loop/recur facility to nested loops in a way that preserves the key semantic properties of regular loop/recur (recur only possible in tail position w.r.t. the target loop, arguments to recur must match loop locals introduced in the corresponding loop form etc.) and arguably feels like a natural extension of loop/recur, both syntactically and semantically. I will also briefly discuss the details of my patches to the Clojure and ClojureScript compilers which implement the above.

Michał Marczyk

Longtime contributor to all parts of ClojureScript, including the compiler and the core library; most notably, author of the ClojureScript ports of the persistent map and set types and PDS-related functionality such as transients. Author and maintainer of core.rrb-vector, data.avl, psq.clj and ctries.clj.

#ClojureScript Concurrency Revisited

From the browser to Node, every platform that JavaScript reaches inevitably embraces the event loop. But asynchronous logic affects pure functions like the Midas Touch: whatever it touches turns into callback hell. Meanwhile JavaScript hasn't been standing still, so it's time to revisit the question how to tackle concurrency in ClojureScript.

In this talk I will compare the different concurrency options available to ClojureScript programmers today, including straight callbacks, ES6 promises, core.async and the Promesa library. We will investigate if these approaches solve the problems all too familiar from the JavaScript universe, from error handling to the dreaded Pyramid of Doom.

Paulus Esterhazy@pesterhazy,

A longtime Clojurist, Paulus works at Pitch in Berlin. Paulus is organizer of the ClojureBerlin meetup and author of the unravel REPL client

#Domain-Driven Design in an event-driven Clojure application

We at Funding Circle are delivering a new Kafka Streams and Clojure based platform to power our business with the goal to reach $100 billion of loans per year to small and medium enterprises.

Discover how applying Domain-Driven-Design patterns both at the system level and the Clojure code level greatly helped us design this platform.

I will explain strategic vs. tactical patterns, and give examples of how we applied ubiquitous language, bounded contexts, anti-corruption layer, hexagonal architecture, aggregate and event sourcing in our Kafka and Clojure context.

We will have also see how these patterns tremendously boosted the testability at all levels.

Gilles Philippart@gphilippart

I am currently a senior software engineer at Funding Circle. I’ve been designing system for two decades now, mostly in Investment Banking, both in the large and in the small scale. I like it when components are decoupled, testable and tested from unit to acceptance level. I rely extensively on Domain Driven Design, Behaviour-Driven-development and lean techniques to make sure I build the right thing that will deliver maximum value. Since I discovered Clojure in 2013, I spend much more time than before in a Hammock.

#The philosophy of (functional) programming

One might think that teaching programming to beginners is only beneficial for the learners. It turns out that explaining programming in basic terms has side-effects on the teacher. The difficulties the novices encounter are often just symptoms of deeper issues. Therefore the instructor is forced to (re-)consider fundamental questions. What is programming? Where does the difficulty come from? What is a `natural' programming concept? It is impossible to teach without having some answers (admittedly or not) to these philosophical questions.

The 'Poetry of Programming' is a course about the functional core of Clojure, designed for Liberal Arts students with no prior coding experience (https://egri-nagy.github.io/popbook/). It is in its third semester, so it has provided ample opportunities for the above philosophical reflections. The talk will go through the insights gained from running the course. These will be presented through code examples from the classroom, keeping the high-flying general ideas close to everyday programming.

The content will be interesting for anyone who is - engaged in teaching/learning functional programming, - puzzled about the nature of programming or the relationship between mathematics and programming, - willing to have a closer look at functional programming concepts and techniques.

Attila Egri-Nagy@EgriNagy, ,

Former software developer who turned into a maths professor. Doing research in biological applications of computational abstract algebra and in the foundations of computation. Trying to make both mathematics and programming more accessible for everyone.

#My long path towards O(n) longest-path in 2-trees

An experience report of using Clojure to implement a novel graph algorithm.

We’ll quickly go over the algorithm, then dive into optimization techniques like choice of data representation, using transient variants of persistent data structures, using macros to inline computations, implementing our own memoization and benchmarking.

We’ll discuss examples of using generative/property-based testing both at the unit and algorithm levels, turning a recursive algorithm into an iterative one and “unrolling” recursion.

Jordan Biserkov@jbiserkov, ,

Jordan is a software developer from Bulgaria with an incredible talent for finding bugs and sometimes even fixing them. His joy of using Clojure is rivaled only by his passion for expanding his brain via discrete and algebraic structures. He loves traveling, hates commuting, and enjoys working as an independent contractor for Cognitect.

#⚡ Build your own tools for agile data science

The current state of data science is sad. Our de facto model of data analysis is a waterfall, where we are unable to go back, after we have learned more about the things that we are trying to measure. An agile model for data science embraces our uncertainty about the real world, and allows us to iterate our analyses, hypotheses, and data collection. Clojure is uniquely suited for agile data science, as it provides a powerful set of core tools for data processing, and its flexibility and ecosystem allow you to build rapid prototypes of your own analysis tools. In this talk, I will demonstrate the strengths of Clojure ecosystem by a case example: a serverless Google Cloud pipeline for automatic processing and analysis of spoken interviews conducted by a chatbot. After preprocessing, the user of the system can explore the data using tailored analysis tools, which we were able to construct and iterate in just a few days.

Toni Vanhala@Motor_Toni

Toni is a web developer by trade and a data scientist by heart. He is helping Vincit to join emotions and design with agile data science. Previously he has worked on IoT systems, wearables, real-time signal processing, and data analysis, in the context of human physiology, emotions, and machinery. His Ph.D. thesis focused on AI for emotion detection and regulation.

#Small FP: TBA

To be announced.

Bodil Stokke@bodil,

Bodil is an experienced conference speaker and active contributor in the Free Software community. In addition she works for a London-based Future Ad Labs as a developer. Bodil’s expertise is in functional programming and JavaScript frontend development. She has done consulting and product development in several tech-companies in Europe. Bodil’s favourite pony is Pinkie Pie.

#Small FP: I used Elm in production and it cost me my job

Functional programming is beloved by developers because it allows us to efficiently produce code that is easy to work with, stable, and reliable. But what if that's also our biggest weakness? What if our own brilliance is killing us on the market? Working in Elm, we produced an app that was fast, quick to develop in, and incredibly stable ... so stable that there was no need to keep paying me to maintain it anymore. What's a consultant to do?

Annaia Berry

Conjured up from the deepest pits of Hell, and empowered by the weapons of Lisp and functional programming, Annaia Berry works her black arts for Futurice, in the darkest heart of Frozen Helsinki. Annaia is the creator of the Heresy programming language, as well as the Clojurice web template, and other projects in Clojure, Rust, and Python.

#Small FP: Purely Functional DevOps with Dhall

Functional programming is now mainstream in Software Development. Does the same trend apply to Operations as well?

Well, kind of: the DevOpsculture is bringing to the table declarative configurations with Infrastructure-as-Code deployments, but this usually happens by employing either full-fledged programming languages or simple data languages (YAML is nicer to type down than XML, but still)...can we do better?

In this talk we'll see how to avoid Turing-completeness and leverage Dhall - a strongly typed, total functional language - to get safety, modularity and reusability while still being able to do dangerous things like templating configurations and spinning up cloud machines.

Fabrizio Ferrai@fabferrai,

Fabrizio is a Software Engineer from Sardinia (Italy), currently writing Haskell and a lot of YAML at KSF Media in Helsinki, Finland. He really likes writing open source code, writing music, and writing pizza. If you'd like to get him excited come talk and mention functional programming, fractals, electronic music, rockets, coffee and food.

#Small FP: OCaml, REborn: fullstack applications with ReasonML

OCaml is a systems language that’s been around for more than 20 years. Reason is a new syntax and toolchain that aims to make OCaml more accessible to everyone.

This talk aims to present Reason / OCaml as a viable alternative to building modern, fullstack, data-driven web applications that share the types of their business objects between the backend and the frontend (much like Clojure programmers are used to with CLJC).

I will also demonstrate how GraphQL, a data-driven query language for APIs, plays nicely with OCaml’s type system to achieve fully type-checked queries across the board, for instance disallowing clients to compile if they’re requesting a piece of data that the backend cannot provide.

António Monteiro@anmonteiro90,

António is a functional programmer. He works as a Software Engineer at Ladder, a company that is reshaping the life insurance industry in California.

A Clojure(Script) programmer by day, he's recently been contributing heavily to the ReasonML ecosystem.

#Small FP: KernelF: a functional core for domain-specific languages in JetBrains MPS

KernelF is a new functional language built by Markus Voelter (@markusvoelter) and itemis.de on top of JetBrains Meta Programming System MPS. This language is extensible (new constructs can be added to KernelF) and embeddable (KernelF can be used as the core of arbitrary other languages). I will give an overview of KernelF's features (e.g. unconventional numeric types, type tags, effect tracking, attempt types and error handling, natural language function calls), explain some intricacies of its type system and discuss how KernelF can be embedded into domain-specific languages (DSLs). I will explain how JetBrains MPS can be used to implement DSLs that are based on KernelF.

Mikhail Barash@mikhail_barash,

Mikhail’s interests include domain-specific languages, model-driven software development, compiler construction, parsing algorithms and metaprogramming. He obtained his Ph.D. degree from University of Turku (Finland) focusing on studying new ways of defining syntax of programming languages. He is currently a lecturer at Åbo Akademi and teaches domain-specific languages with Eclipse Xtext and JetBrains MPS.

#Small FP: Interactive, Functional, GPU Accelerated Programming in Clojure

Who wouldn't like to program with CUDA dynamically, in an interactive, but compiled, environment? I present an interactive approach to accelerating dynamic functional programs with GPU kernels.

I developed ClojureCUDA an ClojureCL, libraries that integrate CUDA and OpenCL into a Clojure environment, which compiles to Java bytecode and integrates into ubiquitous Java enterprise ecosystem. They help programmers discover the solutions by growing GPU programs inside a live session, by constantly learning and experimenting with instant results, rather than having to specify the whole GPU program right away, compile it, and run it to see the result.

CUDA and parallel programming are complex and brittle. Interactive programming is indispensable when the details of the solution are not certain beforehand. For both the novice and the expert, the instant feedback is of great help. We aim at full CUDA power at a low level and offer a nice dynamic environment and the power of LISP to automate grudge work without hiding the important details of CUDA kernels.

ClojureCUDA demonstrates this in Bayadera and Neanderthal projects. The resulting programs are novel, require typically very little code (low thousands instead of hundreds of thousands), have little if any overhead, and, what is unusual, have equivalent functionality an similar performance on both Nvidia (CUDA) and AMD (OpenCL) hardware.

Dragan Djuric@draganrocks,

Dragan Djuric is a professor at the Department of Software Engineering, FON, University of Belgrade, Serbia. He passionately uses Clojure as a primary language since 2009, and teaches Clojure-based courses at the university since 2010. He published his Clojure-based research in leading scientific journals, but does not skip contributing to the community through open-source Clojure projects. His main interests are in the area of software engineering and intelligent systems, but programming in Clojure is the activity he enjoys the most. When he is not working in Emacs, he likes doing his daily dose of long-distance running, gym, and Cuban salsa dancing. He also has a black belt in Taekwondo.

#Small FP: Regular Expressions of Types

A neat feature of clojure.spec is regular expressions for describing shapes of (heterogenous, i.e. non-uniform) sequences. It can be used as an argument against static type systems. Type systems cannot have such things, can they?

In this talk, we'll see that, in fact, regular expressions are a nice theory, which can be fitted into type systems. We'll discuss some of the properties of regular expressions, which make them a suitable and convenient to use addition. To make that concrete, we'll build a prototype Haskell extension, and see it working!

Oleg Grenrus@phadej,

Oleg is a programmer from Finland (i.e. he's a humble person). He became active in Haskell community around 2015, and nowadays co-maintains (among other things) servant web framework, the one where type trickery is involved.

:code-of-conduct

People are different. Let's respect that.

We, the organizers, want everybody to be able to enjoy ClojuTRE. We hope that everybody, regardless of gender, gender identity and expression, age, sexual orientation, disability, physical appearance, body size, race, ethnicity, or religion, can feel welcome and respected at ClojuTRE.

We need your help to to achieve this. We are counting on you!

Use your common sense. Don't be a jerk, ok?

If you notice any wrong doing please contact any organizer. You can also call or send an SMS to number +358 50 326 2280 (Mikko).

:sponsors

Organizer

Metosin

Main sponsor

Siili

Small FP sponsor

Futurice

Platinum

SolitaLeanheatNitor

Gold

GoforeHappy or NotReaktor

Silver

LambdawerkFlowaNubankJUXTDigiaElisaNetum

If you are interested in sponsoring the event, please contact clojutre2018@metosin.fi for information.