London Clojurians
James Gosling Keynote Thoughts on language evolution
updated
Title: Mailman: event driven made easy
Speaker: Wout Neirynck
Wout Neirynck - github.com/wneirynck will be presenting:
"Mailman: event driven made easy"
Mailman is a lib intended to write event-driven Clojure apps that are testable and maintainable. Wout will explain why he built it and how it's set up. There will also be live coding to see it in action.
Wout is serial founder of several software companies. He's been coding full-stack for over 25 years and has been using Clojure professionally ever since he discovered it over 12 years ago. He's fascinated by event driven software and can go on for hours about test-driven development.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- And many individual sponsors
Title: ECA - Editor Code Assistant
Speaker: Eric Dallo
Eric Dallo - github.com/ericdallo will be presenting:
"ECA - Editor Code Assistant"
ECA is a free OSS tool to use alongside your editor, it gives you AI capabilities for pair programming sharing a same experience across editors.
Eric Dallo works for Nubank since 2019 and is the maintainer of clojure-lsp, eca, lsp-mode, deps-bin and other dev tools.
He loves Linux, NixOs, Emacs and work on dev tooling.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- And many individual sponsors
~~~~ reClojure 2025 ~~~
Title: Brain Data in Clojure
Speaker: Lorelai Lyons
Human-computer interaction is a continually evolving domain stemming from our roots in mechanical forms of computing historically. This evolution has manifested in several well-known areas such as AI, social-networking, cloud computing, etc; but no field is quite as mysterious, misunderstood, or inaccessible as Brain-Computer Interfacing. BCI research and development can seem like a daunting or even impossible field to break into or contribute meaningfully to.
This talk chronicles my interdisciplinary journey to processing brain data with Clojure, and exploring the unique position programmers occupy within the broader BCI development ecosystem. It aims to introduce the audience to the foundational areas of BCI research and development, while sharing my steps taken to parse and visualize real world brain data to corroborate authoritative BCI studies. I'll demonstrate practical techniques for parsing and visualizing neural signals using Clojure, making this complex domain accessible to beginners while showing veterans new application domains.
Importantly, this presentation confronts the controversial nature of BCI technology, offering a balanced yet critical examination of both its revolutionary potential and serious ethical concerns. I intend to communicate a nuanced perspective to open peoples minds and provide a foundation for further inquiry into the subject. Through accessible examples, I will highlight the importance of collaboration across multidisciplinary teams—programmers, engineers, neuroscientists, medical professionals, and other stakeholders—demonstrating that no single person can tackle the complexities of BCIs alone. Attendees will not only discover specific pathways to contribute, but will also be encouraged to engage critically with the ethical dimensions of BCI technology. Many people have been unexposed to these technologies, so I aim to equip listeners with the necessary lexicon and framework for engaging in meaningful discussions. The session concludes with my personal goal and roadmap for a Clojure wrapper around the OpenBCI API and a thought-provoking discussion on responsible innovation in neurotechnology.
- Here is a link to the presentation itself:
docs.google.com/presentation/d/1TZ9qYIDgb0OaEHkJq-gY596Qcjg0kY0JkuLsVKEvKz4/edit?slide=id.g349f26406b5_3_89#slide=id.g349f26406b5_3_89
- and here is the "bci reference sheet" I made:
docs.google.com/spreadsheets/d/1aicfwrHtwl9zzPQbJwuwsnFpA1mycZy1aBQ6K_sjUDk/edit?gid=1165653142#gid=1165653142
- This is some brain analysis I did and shared:
github.com/TheFakeLorLyons/brain-data-in-clojure
- here is the talk I did for scicloj recently
youtube.com/watch?v=MfA8Tyt7Rgk
- I just released this a couple weeks ago and it is what BrainFloj is built on:
github.com/TheFakeLorLyons/brainflow-java
It lets you use BrainFlow in Clojure, the coming BrainFloj API will use this as a base dependency for everything it does
- And now I finally released BrainFloj itself!!!
github.com/TheFakeLorLyons/brainfloj
- I also referenced the book Brain Computer Interfacing: an Introduction by Rajesh P.N. Rao a lot: https://bci.cs.washington.edu/
- Another great (and free!) general text is this one (it is also in the BCI reference sheet): https://www.ece.uprm.edu/~manian/BCI%20principles%20and%20practice.pdf
Speaker Bio:
Long since fascinated by BCI technology, Lorelai has tread a winding path towards finding her own niche in the novel application of Clojure in the BCI space, while simultaneously advocating for the widespread adoption and development of BCIs in the broad mainstream social/political dialogue along the way.
With a background in music and philosophy, Lorelai approaches programming through a lens of epistemological inquiry, questioning not just how, but why we build the systems we do. BCI technology is often framed as a distant, science-fiction technology; yet with an ever lower barrier to entry and cost, BCIs have the increasing potential to completely replace the current mobile and desktop computing markets - it is Lorelai’s belief that need for public dialogue and education pertaining to the ethical, epistemological and metaphysical implications these technologies impose on society becomes more pressing with each passing day.
After ~3 years of studying Clojure, Lorelai has gotten involved in the Clojure community: serving on the Clojurists Together board of directors, volunteering with the “Clojure Camp”, and supporting Sci Cloj initiatives via group organization and facilitation as well as conference preparation. As an artist and technologist, Lorelai aims to merge creative expression with brain-computer interfaces.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
~~~~ reClojure 2025 ~~~
Title: Electric Clojure: Differential Dataflow for UI
Speaker: Dustin Getz
Electric is a new architecture for rich, cloud-connected web products with complex frontend/backend network topology. Electric frames UI as a concurrency problem, applying process supervision and other structured concurrency techniques to achieve a UI=f(state) composition model that does not fail at the network boundary. This talk will introduce Electric by live example, climbing through a series of increasingly sophisticated problems that reveal the deep computational structure of user interfaces.
Speaker Bio:
Dustin Getz is the founder of Hyperfiddle, a "UI Spreadsheet" for making internal app frontends. Hyperfiddle's mission is to collapse to zero the cost of internal frontend development for a wide range of business process applications, by applying distributed systems and concurrency techniques to build a new class of UI infrastructure.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
~~~~ reClojure 2025 ~~~
Title: Wolframite: Bringing computational intelligence to Clojure
Speakers: Jakub Holý and Thomas Clark
First and foremost, we motivate the Clojure-Wolfram bridge and provide a comprehensive demonstration of how one might use the new library in practice: whether you're an everyday programmer, who just wants to edit a video, or a seasoned scientist, who wants to test quantum physics.
Wolframite aims not only to empower programmers but also a large section of the numerical scientific community who rely on tools like Wolfram/Mathematica. Inevitably, tools like Wolfram still need to integrate with the wider world. Wolframite's Clojure provides them with a well designed, more comfortable general language and allows the user to leverage powerful Scicloj libraries for data processing, computation and visualization.
In short, we want to summarize modern scientific Clojure and introduce you to Wolframite 1.0, a tool that combines the best of your favourite general purpose programming language with an unparalleled computational kernel. Wolframite and Scicloj are now ready for adoption and discussion: leaving plenty of room for questions since, as we all know, iron sharpens iron.
Jakub Holý Bio:
I was born in 1980. For the second time I was born on November 17, 1989, when the communist regime of Czechoslovakia begun to collapse. For the third time I was born in august 2005, when a thin branch, invisible in the total darkness, saved me from a fast and fatal fall. I studied software engineering at the Czech Technical University and humanities at the Charles University, both in Prague. I also spent two enriching terms at the Linköpings University in Sweden. After the studies I ended up working with IBA CZ, which turned out to be a warm and friendly place, full of great - nice and smart - people, with challenging tasks and a lot of flexibility. In 2011 I’ve moved to Norway to broaden my views by living in another country and culture. I’m married and live currently in Oslo, Norway. (Before that, my Czech home towns have been Ostrava and Prague.)
In my free time I like to hike, practice martial arts, meditate, read fantasy, and play pen&paper Role-Playing Games. I like books by Andrzej Sapkowski and (unrelated:)) admire Mahatma Gandhi. I’m vegetarian because I couldn’t find any moral justification for killing other beings.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
~~~~ reClojure 2025 ~~~
Title: LLMs + Clojure = Who needs frameworks?
Speaker: Kapil Reddy
Large Language Models have transformed coding workflows. They are particularly good at project scaffolding.
While Clojure's philosophy of composable libraries over frameworks grants exceptional power and flexibility. It also has a steeper learning curve for newer developers — many of whom lament the absence of a Rails-like framework to ease their journey.
This talk introduces a novel approach that preserves Clojure's library-centric philosophy while improving developer experience using LLMs.
Key parts:
llms.edn: A structured, Clojure-native approach to describing libraries and their common usage patterns, building on concepts from llms.txt but tailored specifically for Clojure's ecosystem.
LLM-powered composition workflow: A practical demonstration of how LLMs can intelligently combine libraries based on these declarations, generating cohesive starter projects that reflect Clojure's best practices.
Beyond frameworks: An exploration of whether LLMs fundamentally change the library-vs-framework debate by offering "framework-like" convenience without sacrificing composability.
Let's discuss the future of the llms.edn project and help shape a tool that could significantly enhance Clojure's accessibility while honouring its core design philosophy.
Speaker Bio:
Business-first software generalist.
Curious educator.
Serial community builder.
Server whisperer.
Sometimes dwells into film-making as time and energy permits.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
~~~~ reClojure 2025 ~~~
Title: Recognizing regular patterns in mixed-type sequences using Symbolic Finite Automata
Speaker: Jim Newton
Run-time type-based reflection is a powerful tool which is used to solve certain problems which are out of reach to purely statically typed programming languages. The JVM-based implementation Clojure allows a running program to make certain type-based decisions which cannot be made at compile time. Notably, type predicates and dynamic method dispatch allow the running Clojure program to make run-time decisions based on characteristics of input data, the type of which cannot be known at compile time.
In this expose, we present yet another kind of run-time based type decision which allows us to arbitrate among various regular patterns in otherwise untyped data. We call these patterns RTEs (regular type expressions).
Clojure programs often manipulate sequences of mixed typed elements. We would additionally like to specify sequences of heterogeneous but regular types.
We assume the audience to already be familiar with string-based regular expressions (REs). REs are used to distinguish strings which follow a regular pattern such as `$a(a|b)^*b$`, the set of strings beginning with the character a, ending with b, and with zero or more a or b (or both) characters falling in between. We generalize this familiar concept to define expressions which specify a sequence beginning with an integer, ending with a string, and with zero or more integers or strings (or both) falling in between.
The implementation of Regular Type Expressions (RTEs) in Clojure involved several challenges.
Embed a Simple type system (SETS) into Clojure’s run-time — adding intersection, union, and complement types, as well an singleton and predicate types.
Define an s-expression syntax for defining regular-type-expression in terms of types, including intersections, unions, and complements.
Construct deterministic finite automata, DFAs, from the regular type expressions. This library manipulates DFAs with operations such as minimize, intersection, union, xor, and extract-rte.
There are many theoretical questions which investigate the limitations of the generalization from classical character based regular expressions to regular type expressions. Some of these concerns include habitation and vacuity checks (given an RTE, can we determine whether all or no sequence will match). Given two types designators determine whether one is a subtype of the other, and whether either is empty. Subtype determination is important for guaranteeing that finite automata be deterministic. Unfortunately, the subtype relation cannot always be determined (for several interesting theoretical reasons). We present a clever procedure for DFA construction which is guaranteed to be deterministic, even when the subtype relation cannot be determined.
This project is part of a larger scoped multi-language project including implementsion in Clojure, Scala, Python, and Common Lisp. The fundamental theoretical introduction was given in the PhD thesis: Representing and computing with types in dynamically typed languages.
The library is publically available at: github.com/jimka2001/clojure-rte.
Speaker Bio:
Jim Newton is an assistant research professor at EPITA, Kremlin Becetre, FRANCE, where he occasionally teaches courses in functional programming using Clojure and Scala. Jim has been a Lisp programmer since 1988, and has used various lisp dialects such as Common Lisp, SKILL++ (a Scheme dialect), elisp, and most recently, Clojure.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
~~~~ reClojure 2025 ~~~
Title: Datomic at Nubank, simplicity scaled
Speaker: Jordan Miller
Nubank runs on Clojure and Datomic, but what does that really look like at scale? In this talk, I’ll share my personal journey—from early interactions with the Cognitect team to joining Nubank and working directly with Datomic. I’ll give an inside look at how we use Datomic in production, what we’ve accomplished over the last year, and what it’s like being part of the Datomic team today.
Speaker Bio:
Jordan Miller (she/her/altgirl) is a Staff Software Engineer at Nubank where she focuses on Datomic developer success. Known in the streets for her passion for spreadsheets she enjoys connecting with engineers who appreciate the finest of functions. International globetrotter and stimulation seeker she has no idea how she manages to juggle so many projects; she is co-author of Clojure Brain Teasers, co-founder of Clojure Camp and producer/host of the Lost In Lambduhhs podcast.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
~~~~ reClojure 2025 ~~~
Title: Writing Model Context Protocol (MCP) servers in Clojure
Speaker: Vedang Manerikar
This talk showcases mcp-cljc-sdk, a Clojure SDK I've written for building MCP servers. Model Context Protocol (MCP) is an emerging standard that allows AI agents to interact with external systems through specialized servers. I'll demonstrate how MCP creates powerful, composable workflows that gradually automate complex tasks using real-world examples of MCP servers I have written.
We'll explore why Clojure is particularly well-suited for implementing MCP servers, comparing it with other approaches and highlighting Clojure's strengths through side-by-side code comparisons.
By the end of this talk, you'll understand how to create your own MCP servers, contribute to the growing ecosystem, and leverage these tools to build powerful AI-enhanced applications that integrate with your existing workflows.
Speaker Bio:
I'm Vedang Manerikar 👋, founder of Unravel.tech and former Head of Backend Engineering at Helpshift. I've been a Clojure developer for the last 15 years, and I absolutely love the language.
At Unravel.tech, we focus on building Agentic Systems and unlocking GenAI and LLM magic for our clients. Here's what we've worked on recently:
💻 Automated migrations of large (MASSIVE) code-bases. The kind that make devs lose sleep.
🔍 RAG systems to turn messy legacy data into searchable gold mines.
🤖 Agent-backed "Smart" Chatbots that identify intent and guide users through workflows without the usual headaches.
I personally think Clojure devs are extremely well-prepared for the LLM world, because we are used to working in an un-typed REPL all through the day. Whether you love or hate LLMs and GenAI, if you want to talk about it, come find me!
I am a software developer at the Norwegian Food Safety Authority where I build systems with Clojure and Datomic. I have 20 years of experience, and have been working full-time with Clojure for the last 10 of those. My career has focused on web tech, and love doing what it takes to ship working software to users: from setting up infrastructure to data modeling and frontend work.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
~~~~ reClojure 2025 ~~~
Title: UI, Pure and Simple
Speaker: Christian Johansen
React introduced the idea that the UI is a function of application
state, and it changed the way we think about building
UIs. Unfortunately, it also allowed mutable state everywhere.
What if UI rendering was truly functional — stateless, deterministic,
and built entirely on data? Enter Replicant: a Clojure rendering
library with no dependencies and no state management, just immutable
data and pure functions.
In this talk, we’ll use Replicant to explore how Clojure’s strengths
can refine UI development once again. Let's build modular UIs that
decouple rendering from state management, are fully testable, and
dramatically simpler than the current state of the art.
Speaker Bio:
I am a software developer at the Norwegian Food Safety Authority where
I build systems with Clojure and Datomic. I have 20 years of
experience, and have been working full-time with Clojure for the last
10 of those. My career has focused on web tech, and love doing what it
takes to ship working software to users: from setting up
infrastructure to data modeling and frontend work.
I love sharing, and keep a blog (in Norwegian) with my co-workers,
give frequent talks at conferences, used to teach courses, and
maintain a hodge-podge of open source software libraries in the
Clojure ecosystem.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
Title: Functional Creative Coding with Patterning
Speaker: Phil Jones
Phil Jones - github.com/interstar will be presenting:
"Functional Creative Coding with Patterning"
Patterning is a Clojure(Script) library for creating visual patterns in a functional style. It can make designs suitable for textile prints, laser engraving or (combined with, say, JS, P5 or Quil), for use in generative and interactive art and NFTs. The presentation will introduce and teach the basic principles of Patterning through a number of patterns. And talk about the current latest developments in the library.
Phil has been writing software since the 1980s, but started his serious FP and Clojure journey in 2014 with the creation of the Patterning library. Having done an MA in Computational Art at Goldsmiths in 2010-11, and used Processing extensively, he began thinking about more functional ways to do generative visuals. These days he's fascinated by code for representing and generating everything from music to physical objects, though sadly not always in his favourite Lispish programming language.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
~~~~ reClojure 2025 ~~~
Title: Simple ideas with huge impact from Clojure and Rama
Speaker: Nathan Marz
Clojure is full of great ideas. Some are inherited from the Lisps that came before, like homoiconicity. Others are new to Clojure, like its emphasis (but not mandate) on immutability.
The ideas with the biggest impact eliminate complexity, create leverage, or both. Both homoiconicity and immutability achieve these by creating uniformity. Uniformity enables composition, and composition creates leverage.
Rama builds upon the ideas in Clojure to bring uniformity and composability to backend development. Ideas like data structures instead of data models for indexed datastores and colocating computation and storage have a huge effect on simplifying backend development and enabling much more to be done with much less.
Speaker Bio:
Nathan is the founder of Red Planet Labs. Previously he created a number of popular open-source projects, the most well-known being Apache Storm. Storm was the first open-source project to enable reliable processing of data at large scale in real time.
Nathan has programmed primarily in Clojure since 2010. His biggest open-source contribution in Clojure is Specter, which enables data structures both simple and complex to be queried and transformed extremely concisely and with performance rivaling hand-optimized code.
Nathan wrote the book "Big Data: principles and best practices of scalable realtime data systems".
Before Red Planet Labs, Nathan was an engineer at Twitter where he founded one of their core infrastructure teams.
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- freshcodeit.com
- https://nubank.com.br/
Title: Autology: Writing a self-rewriting Lisp
Speaker: Dave Kimber
Dave Kimber - github.com/Kimbsy will be presenting:
"Autology: Writing a self-rewriting Lisp"
In a Lisp program the code is data. In a metacircular interpreted Lisp, the language itself is defined as a Lisp program, so it too, is just data.
By granting a Lisp the ability to modify the data of its own interpreter we can create a language that has the ability to dynamically rewrite its own implementation at will, adding or removing language features or even transforming it entirely.
From modifying argument evaluation, to writing a custom debugger, to executing raw inlined C code, the possibilities are deep and far-reaching.
Dave has been working almost exclusively in Clojure since he left the world of Java over 9 years ago. Since then he's been solving enterprise problems with functional programming in the dynamic and interactive environment afforded by Lisps. He couldn't be happier.
In his spare time he like writing tiny Lisps, competing in game jams, and playing DnD with his partner and their friends.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Building a 3D Multiplayer Shooter in Clojure: The Making of Wizard Masters
Speaker: Ertugrul Cetin
Ertugrul Cetin - github.com/ertugrulcetin will be presenting:
"Building a 3D Multiplayer Shooter in Clojure: The Making of Wizard Masters"
In this talk, the speaker will walk through how Wizard Masters, a 3D multiplayer browser game, was built using Clojure and Babylon.js. Attendees will get a peek into the architecture, tooling, and lessons learned from blending fullstack Clojure with real-time 3D game development.
The speaker has been working with Clojure for nearly a decade, mostly in fullstack SaaS development. For the past 4 years, he’s been exploring game development as a hobby, building Wizard Masters, a browser-based 3D multiplayer shooter.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Toddler - UI or not to UI
Speaker: Robert Geršak
Robert Geršak - github.com/gersak will be presenting:
"Toddler - UI or not to UI"
Toddler is a curated collection of React hooks, components, and ClojureScript functions, distilled from years of hands-on UI development. It’s not revolutionary—just a practical, common-sense approach to taming frontend complexity.
In this talk, we’ll explore how to save time when building UI. We’ll discuss what it takes to create a solid React UI without external JavaScript dependencies and whether ClojureScript can run on mobile and desktop using Tauri.
Gersak is co-founder of Neyho and has been lead engineer on products in domain of Data Modeling, IAM, RPA and BPM. He was lucky to hear about Clojure in 2009 and has been hooked ever since. Passionate about frontend driven development, minimal(zero) dependency libraries and refactoring.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Lazytest: Standalone BDD testing
Speaker: Noah Bogart
Noah Bogart - github.com/NoahTheDuke will be presenting:
"Lazytest: Standalone BDD testing"
Lazytest is an alternative to clojure.test, aiming to be feature-rich and easily extensible. It has first-class test groups, exception-based assertions, and composable output.
Noah has been a hobby programmer since 2002, a professional programmer since 2016, and a Clojure fanatic since 2018. He loves to take data in, change it, and push it out.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Intro to Collet. A low-code ETL management tool
Speaker: Sergei Tkachenko
Sergei Tkachenko - github.com/margintop15px will be presenting:
"Intro to Collet. A low-code ETL management tool"
In this talk, we'll explore the Collet project, its features, and core concepts. We'll begin with basic building blocks like tasks and actions, and discuss best practices for combining them effectively. You'll learn about built-in and custom actions, error handling, and job monitoring. Finally, we'll cover data exploration during development and deployment options using Docker containers.
Sergei has been actively developing with Clojure since 2018, building a diverse portfolio of projects across different scales and domains. His experience spans from working with early-stage startups building solutions to architecting and maintaining high-load, data-intensive applications that process substantial volumes of information.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Intro to Fugato
Speaker: David Nolen
David Nolen - github.com/swannodette will be presenting:
"Intro to Fugato"
A quick tour of Fugato, a tiny stateful property-based testing library for Clojure(Script). Fugato focuses on modeling the problem, but it's also easy to run the results against your programs.
Lead developer of ClojureScript since 2012.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Don't fear the Storm
Speaker: Juan Monetta
Juan Monetta - github.com/jpmonettas will be presenting:
"Don't fear the Storm"
We will dig into FlowStorm internals, from its approach to instrumentation (ClojureStorm and ClojureScriptStorm), how FlowStorm uses it for tracing, indexing to providing tools for exploring and visualizing full systems execution. We will also explore a little bit of the new FlowStorm data visualization capabilities.
Juan has been working as a programmer since late 90s, and working professionally as a Clojure developer since 2011 over many domains. He has a passion for dev tooling and anything that makes writing software more fun.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Clein: Bringing a bit of leiningen to deps.edn
Speaker: Noah Bogart
Noah Bogart - github.com/NoahTheDuke will be presenting:
"Clein: Bringing a bit of leiningen to deps.edn"
Clein attempts to handle the basic use cases of build.clj, covering the boilerplate with minimal configuration and sensible defaults. This talk will go over why and how Clein was built, and future plans.
Noah has been a hobby programmer since 2002, a professional programmer since 2016, and a Clojure fanatic since 2018. He loves to take data in, change it, and push it out.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Encoding internet-scale decentralised data structures on Convex
Speaker: Mike Anderson
Mike Anderson - linkedin.com/in/mike-cvx will be presenting:
"Encoding internet-scale decentralised data structures on Convex"
This discussion will expand on the first Convex event with the London Clojurians (youtube.com/watch?v=bpKAQgcJRao&authuser=4) which provided an in-depth look at the whole platform. Now that Convex is ready to launch, the second conversation with dive into the significance of these efficient data formats and why the CAD003: Encoding Format (github.com/Convex-Dev/design/tree/develop/docs/cad/003_encoding) will be so revolutionary. The call will also cover examples for users. Note: the VM is written in Convex Lisp, inspired largely by Clojure. This past week Convex was awarded a grant from the EU government for a cross-chain token interoperability project.
Mike is a passionate contributor to open source software projects and an OG Clojurian, all the way back to Clojure 1.1 release. A programming enthusiast since the age of eight, Mike has a particular love for efficient data structures and algorithms. He
represented the UK in the 1996 International Informatics Olympiad. Mike has held multiple CTO roles including being a founding member of Ocean Protocol (Blockchain for Data & AI) and Datacraft Sciences (Machine Learning, Data supply chain orchestration) based in Singapore.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Basilisp: Clojure on the Python VM
Speaker: Chris Rink
Chris Rink - github.com/chrisrink10 will be presenting:
"Basilisp: Clojure on the Python VM"
Everyone knows Clojure runs on the JVM and CLR, in Node, and in the browser, but what about Python? Basilisp is a mostly-compatible implementation of Clojure for Python, enabling users who may not be familiar with Java or JavaScript to experience the joy of Clojure.
Chris has worked for various startups in New York over the past 9 years. Only one of those jobs used Clojure, but that experience clearly left his mark because Chris has been hacking on Basilisp ever since.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Maintainable Clojure code: Visualizing structure and quality metrics
Speaker: Jakub Dundalek
Jakub Dundalek - dundalek.com will be presenting:
"Maintainable Clojure code: Visualizing structure and quality metrics"
Building maintainable software is limited by human cognitive ability to understand systems when they get large. Diagrams and visualizations are often used to help understanding.
This talk will explore downsides of manual diagrams, challenges with automated diagrams from source code and introduce Stratify, a tool for visualizing software structure using interactive hierarchical graphs.
Jakub is a software engineer who finds joy in simplicity and the craft of coding. He looks for ways to build well-structured applications and has been working with Clojure for the last 5 years.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Grinding parenthesis to form Rubies
Speaker: Maurício Szabo
Maurício Szabo - https://mauricio.szabo.link/, gitlab.com/mauricioszabo will be presenting:
"Grinding parenthesis to form Rubies"
Chlorine is a REPL-Driven Development plug-in for Clojure. So what happens when a crazy idea emerges - to port Chlorine to work with Ruby? In this talk, we'll learn how it was done, why ClojureScript and some of the tools selected for the job (like Pathom) helped a lot in the process, and how in the end we had 85% of code reuse, and how both plug-ins use the same codebase (
Maurício is the author of Chlorine, Clover, Lazuli, and a bunch of other tools for interactive development. He feels very happy with REPL-Driven Development, but at the same time feels it's possible to push the limits a little further
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Electric Clojure v3: Differential Dataflow for UI
Speaker: Dustin Getz
Dustin Getz - linkedin.com/in/dustingetz will be presenting:
"Electric Clojure v3: Differential Dataflow for UI"
18 months ago, we released Electric v2 and early adopters have been running it in production since last summer, to build rich web experiences that simply have too much interactivity, realtime streaming, and too rich network connections to be able to write all the frontend/backend network plumbing by hand.
With Electric v2, we demonstrated that we weren’t crazy, this thing is commercially viable in real apps. But it also had growing pains: rendering collections was tricky, and v2’s electric lambdas had serious shortcomings.
Electric v3 is a rewrite of the network runtime, fixing and resolving these issues with a new computational structure based on differential dataflow: diffs through the reactivity graph from database to dom, no collections sent over the wire ever, only diffs.
This talk is a preview of Electric v3, in the form of working examples, where we will dive into the nuance of writing network transparent programs in practice, demonstrating how Electric v3's differential semantics reveal and align with the deep computational structure of a user interface.
Dustin Getz is the founder of Hyperfiddle, low-code declarative infrastructure for user interfaces. Hyperfiddle's mission is to collapse to zero the cost of frontend development for a wide range of applications, by applying distributed systems and concurrency techniques to build a new class of UI infrastructure. Dustin's research interest is in the computational structure of user interfaces.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Data Driven Component Libraries from commercial experiences
Speaker: Johnny Stevenson
Johnny Stevenson - github.com/practicalli-johnny will be presenting:
"Data Driven Component Libraries from commercial experiences"
Experiences in using Integrant / Integrant REP and donut-party/system for a data driven REPL workflow managing multiple system component. Includes juxt/aero for profiles and OS environment variables.
Covering lots of code examples and some live coding. Discussing why I prefer certain design approaches, especially trying to keep the code as simple and consistent as possible.
Johnny joined the Griffin team in 2023 and leads the ever growing Clojure platform. Griffin provides banking as a service with a full banking licence.
Previously worked at Citi, StatsBomb and Billie on commercial Clojure projects since 2017. Lots of Java projects before that, from 1997.
Johnny is the founder of https://practical.li/ providing free educational books and videos for the Clojure community. This work has been supported by the Clojure community and it has been a pleasure to be involved with the London Clojurians since 2010. Johnny also designed the London Clojurians logo.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Introducing EntityGraph: Ergonomic Data Store for SPA State
Speaker: Geo Grigoryan
Geo Grigoryan - github.com/geodrome will be presenting:
"Introducing EntityGraph: Ergonomic Data Store for SPA State"
EntityGraph is an in-memory data store with pull query support for Clojure(Script). It leverages Clojure’s hash maps for EAV and AVE indexes. We’ll do an overview of state management approaches for SPAs and walk through the design and associated trade-offs of EntityGraph.
Geo is an independent software engineer. He’s been working with Clojure(Script) since 2013. He has worked on data intensive applications as well as full-stack applications. He’s also worked with C++, Java, PHP, and a number of other languages.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: FDB - a reactive database environment for your files
Speaker: Filipe Silva
Filipe Silva - github.com/filipesilva will be presenting:
"FDB - a reactive database environment for your files"
In this talk you'll learn how to use FDB to create your own custom automations and integrations so you can easily take control of data and use it however you want.
FDB is a live reactive system based on Clojure and XTDB, aiming to give you a lot of power and expressivity with little effort. You can find it at github.com/filipesilva/fdb.
Filipe loves working on developer tooling, personal knowledge systems, and databases. He's now at Metabase, and previously worked at Athens/Roam Research and Angular.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Speaker: Dragan Djuric
Dragan Djuric - https://dragan.rocks/ will be presenting:
"Programming with Linear Algebra: Hello World"
Kick-starting the understanding of an unfamiliar topic might be
the steepest point in any programming journey. Following the recent AI boom, you might be hearing about matrices and tensors left and right, you probably even know some basics from your math education, but you simply can’t see how to use that in daily programming, in tasks that are not straight out of sci-fi. You might even have tried some software
libraries, but haven’t progressed beyond using them as fancy arrays.
Here, we'll help you take that first step right away, and - if you take it - show you a path that can lead you quite further.
Dragan has been using Clojure for 15 years for fun and profit, and has been teaching programming and AI at university for even longer. He loves learning new topics, and finding a way how to make them work in practice. Loves teaching even more. The author of a few nice Clojure libraries (github.com/uncomplicate) and a fer Clojure books (https://aiprobook.com).
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: From data to insights: Clojure for data deep dive
Speaker: Kira McLean
Kira McLean - github.com/kiramclean will be presenting:
"From data to insights: Clojure for data deep dive"
In this session, participants will dive into the lesser-known corners of Clojure's data ecosystem. Learn how to extract meaningful insights from example datasets, uncovering the versatility of libraries like tablecloth, tech.ml.dataset, and fastmath to confidently tackle realistic and complex data challenges. Participants will leave equipped with the tools and techniques to effectively leverage Clojure's robust data science toolkit for insightful real-world data exploration and analysis.
Kira has been writing software since 2015, focusing on Clojure for the last 4 years. With a desire to pave the way for Clojure's broader recognition and adoption in the data science community, she's actively developing tools and guides aimed at showcasing the strengths of Clojure's data science toolkit. Her efforts are driven by a vision to broaden Clojure's adoption in the data world by improving the usability and effectiveness it's core libraries. An advocate for Clojure's potential in the world of data science, she's spending this year working exclusively on open source contributions to support and grow the Clojure data science ecosystem, supported by Clojurists Together and other generous sponsors.
- Workshop repo with the notebooks used in the talk: github.com/kiramclean/workshops/tree/main/london_clojurians_april_2024
- Getting involved with Scicloj: scicloj.github.io/docs/community/getting_involved
- Clojurians zulip chat: clojurians.zulipchat.com
- More about Kira: codewithkira.com
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Bringing Real-Time AI to Phone Calls using core.async
Speaker: Ovi Stoica
Ovi Stoica - ovistoica.com will be presenting:
"Bringing Real-Time AI to Phone Calls using core.async"
How to bring AI to real-time telephony using Twilio, OpenAI & clojure core.async. The talk will include details about assembling the pipeline, handling audio, and using u/log to find bottlenecks in the pipeline.
Ovi works for 3E, a company building renewable software in the renewable energy space. He has been working with Clojure for the last 3 years mostly building APIs and Web interfaces. He is passionate about AI, functional programming and bringing clojure to the startup space
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Brimm: graph backend with a Notion-inspired UI
Speaker: Filip Juruković
Filip Juruković - github.com/zeitstein will be presenting:
"Brimm: graph backend with a Notion-inspired UI"
In this talk, we'll explore Brimm: a new open source full stack project for knowledge management. We'll showcase the default UI and discuss how you can use Brimm as a tool for thought or a graph CMS.
Filip is a web developer who fell in love with Clojure because of the parentheses. He's been writing Clojure for several years and has thought about Brimm for more. He is interested in UX, knowledge management and a more open Web.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: The Design of Biff
Speaker: Jacob O'Bryant
Jacob O'Bryant - tfos.co will be presenting:
"The Design of Biff"
We'll take a behind-the-scenes tour of Biff, everyone's favorite 4-letter Clojure web framework. Learn about the design tradeoffs and implementation details that help Biff to put solo developers first.
Jacob has been a full-time Clojurist since 2019, when he started living the dream as an entrepreneur. In 2023, after getting sick of living the dream, he joined Tyba, a startup in the renewable energy industry (they use Clojure btw). Jacob is also a musician, father of two, and connoisseur of fine dad jokes.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Sitefox framework: ClojureScript on the backend
Speaker: Chris McCormick
Chris McCormick - https://mccormick.cx will be presenting:
"Sitefox framework: ClojureScript on the backend"
You'll learn a fast way to build web backends (and frontends) in 100% ClojureScript. Leveraging the Node.js ecosystem Sitefox aims to solve the same problems for ClojureScript as Django does for Python, and Ruby on Rails does for Ruby. Since 2021 I've been using it to build web apps for thousands of users with indie-scale resources, and I'd like to show you how you can too.
Chris is an independent programmer who has been building software for decades for clients, side projects, and open source. He started using ClojureScript in 2015 and hasn't looked back. These days he is building full-stack web and SaaS apps on 100% cljs.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: Some controversial truths
Speaker: Peter Taoussanis
Peter Taoussanis - taoensso.com will be presenting:
"Some controversial truths"
Challenging some commonly-held ideas about Clojure, software engineering, and startups; and sharing the 1 secret that will solve all your problems
A serial failed founder, Peter has been (mis)using Clojure full-time for 15 years, and releasing open source nonsense for 12. You probably shouldn't trust anything he says.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- And many individual sponsors
Title: 🎶 Dashing through the flow.. 🎶 - Streamlining state management in ClojureDart with re-dash
Speaker: Werner Kok
Werner Kok - github.com/wkok will be presenting:
"🎶 Dashing through the flow.. 🎶 - Streamlining state management in ClojureDart with re-dash"
Dealing with mutable frontend state in a non-trivial app is tricky, but fortunately, as Clojurists, we have battle-tested solutions.
One of the more popular options in ClojureScript is re-frame - a well thought through & documented data loop, helping us manage state in a controlled way - derived data, flowing.
re-dash is to ClojureDart what re-frame is to ClojureScript - a reactive state manager for Flutter's UI that uses events to update and subscriptions to react to changes.
We'll look at the 6 dominoes of this data loop falling, each triggering the next, from when an event gets triggered until the Flutter widget gets rebuilt. We might even throw in some side effects for fun.
Werner has worked for Hospitality Technology International (HTI) since 2001, dedicating the majority of his professional career to developing hotel booking systems with Java. In the last five years, he shifted his focus to Clojure, during which he spent a two-year stint at JUXT between his tenures at HTI
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: Desktop GUI Made Easy
Speaker: Nikita Prokopov
Nikita Prokopov - tonsky.me will be presenting:
"Desktop GUI Made Easy"
Introduction into Humble UI, new JVM Clojure library for desktop GUI application. Why is it needed, how is it implemented, how deep is the rabbit hole, who could it be useful to, what can you build in it?
Nikita has been programming in Clojure, Java, Python, Erlang for 18 years, been interested in UI/UX design for about the same amount of time, and created a few notable projects, including DataScript, Rum, Fira Code and now Humble UI.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: Reifying execution, the interactive programming missing piece
Speaker: Juan Monetta
Juan Monetta - github.com/jpmonettas will be presenting:
"Reifying execution, the interactive programming missing piece"
This is a talk about recording Clojure programs executions, and how this recordings can
be leveraged, specially in the context of interactive programming.
From making sense of complex systems to debugging, from test coverage, to approximate types extraction, we will explore some instrumentation techniques, and demo a bunch of tools built for recording and visualizing programs executions.
Juan has been working as a programmer since late 90s, and working professionally as a Clojure developer since 2011 over many domains.
He has a passion for dev tooling and anything that makes writing software more fun.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Bookmarks:
00:00 Intro
00:17 Agenda
00:59 What do I mean by reifying execution?
02:35 Why do I think it is interesting?
03:36 It is not only about debugging
04:53 But it is also about debugging
05:36 What most people do
09:00 What does it enable?
10:30 FlowStorm UI demo
33:54 FlowStorm repl api demo
40:11 FlowStorm multihread debugging demo
44:08 Clofidence demo
45:22 DynaSpec demo
47:17 Has this been tried already?
49:30 How? immutability
50:13 How? tracing
52:11 ClojureStorm intro
53:28 ClojureStorm disassembly
57:39 Forms registry
58:17 Coordinates
01:00:09 Dealing with macros
01:01:46 Perf notes
01:03:47 Wrapping up
Title: Cooking up a workflow for data
Speaker: Slutsky, Prately & McLean
Slutsky, Prately & McLean - github.com/daslu will be presenting:
"Cooking up a workflow for data"
What does a typical data analysis workflow look like?
.. and what is needed to make such workflows simple & easy for any person with a data question?
In the talk, we will demonstrate some of the relevant workflows, libraries, and tools through a real-world data problem.
Daniel Slutsky is a mathematician and a community organiser at Scicloj. He has been using Clojure in various data-science and backend teams at startups since 2013. These days he is focusing on building the Clay/Claykind tooling for literate programming in collaboration with Timothy and Kira.
Timothy Prately:
Timothy grew up exploring jungles, fighting kangaroos, surfing, and programming computers. After a career of leveraging computational graphs for companies he is now building Hummi.app, a diagramming app that puts the power of graphs in the hands of individuals.
Kira McLean:
Kira is an independent software engineer from the east coast of Canada. She’s spent her career building web-facing services but has recently taken an interest in data science. After falling in love with Clojure she’s keen to explore the best ways to use the language in these different domains. In her spare time you may catch Kira playing violin, teaching yoga, or hiking with her family.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & StreamYard subscription
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: Writing Maintainable Clojure Applications
Speaker: Dmitri Sotnikov
Dmitri Sotnikov - github.com/yogthos will be presenting:
"Writing Maintainable Clojure Applications"
This talk will discuss a strategy for structuring large Clojure applications to facilitate maintainability.
Dmitri has over a decade of experience doing web development using Clojure and has been an active member of the open source community. Dmitri is the author of Luminus and Kit microframeworks as well as a number of popular libraries.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: UIx, a story behind yet another React wrapper
Speaker: Roman Liutikov
Roman Liutikov - twitter.com/roman01la will be presenting:
"UIx, a story behind yet another React wrapper"
In this talk, we'll go over a brief history of React wrappers in ClojureScript. I'll bring you up to date with modern React, and you'll learn about UIx, the motivation behind it, how the library came to be, and how it found its second home at Pitch.
Roman has been using Clojure at work since 2015 and has dedicated most of his career to front-end engineering. Outside of his daily job, he explores graphics programming, Blender, and AI.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: A functional approach to massively concurrent application design
Speaker: Léo Noel
Léo Noel - github.com/leonoel will be presenting:
"A functional approach to massively concurrent application design"
In this talk, Léo will present the latest features of Missionary, a functional effect system for clojure/script. He will focus on the supervision problem, explain what it is about, show how pervasive it is in our craft, and describe a functional solution scalable to arbitrarily complex problems in many domains, from UIs to databases.
You will learn how functional effect systems fit in the reactive programming landscape and how they address common concurrency concerns such as memoization, asynchronous effects, backpressured streaming, glitch-free propagation of changes and fine-grained updates.
Léo is the creator of Missionary and the architect of Electric Clojure. As an independent software researcher, he is interested in concurrency, reactive user interfaces and language design.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- freshcodeit.com
- nette.io
- nilenso.com
- And many individual sponsors
Title: Portal Internals
Speaker: Chris Badahdah
Chris Badahdah - djblue.github.io will be presenting:
"Portal Internals"
Portal is a Clojure data visualization and exploration tool aimed at enhancing interactive development. In this talk we will explore aspects of Portal's internals and how they enable various types of workflows for different users. After this talk, you should be better equipped to leverage Portal in your specific workflow.
Chris started learning Clojure in 2016 after he realized lisp was the ultimate programming language. In early 2020, he started working in Clojure professionally and hasn’t looked back. He’s been working with data driven systems, during which Portal has been of great use!
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: Ten to the Ninth: Performance Techniques in Jepsen
Speaker: Kyle Kingsbury
Kyle Kingsbury - jepsen.io will be presenting:
"Ten to the Ninth: Performance Techniques in Jepsen"
Jepsen is a Clojure library for testing distributed systems correctness. We'll talk about how Jepsen records and analyzes histories of up to a billion operations with the help of a new file format, faster lazy and persistent data structures, memory-adaptive caching, associative folds, and thread-safe transactional executors. Come learn about some of the lesser-known corners of the JVM and how to write faster, more efficient programs.
Kyle Kingsbury, a.k.a "Aphyr", is a computer safety researcher working as an independent consultant. He's the author of the Riemann monitoring system, the Clojure from the Ground Up introduction to programming, and the Jepsen series on distributed systems correctness. He grills databases in the American Midwest.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: TMD 7.0 - Higher Performance Functional Data Science
Speaker: Chris Nuernberger
Slides: docs.google.com/presentation/d/1xqPYHiLnNiXjcE-5iJLygCtNqkBhbOw_ETI1WN6u3o0/edit?usp=sharing
Chris Nuernberger - github.com/cnuernber will be presenting:
"TMD 7.0 - Higher Performance Functional Data Science"
This talk is about the research and work done to move TMD, our data processing system, from version 6.0 to 7.0. It will then cover the upcoming technologies we are most interested and the vision for the future of functional data science in Clojure.
Chris has been programming in Clojure since 2009 and worked in Clojure since 2015. He is the primary author of the Clojure data analysis library tech.ml.dataset and libpython-clj. He is most interested in high performance computing and functional data analytics.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: Matrix Exposed! (or, You Don't Know Reactive)
Speaker: Kenny Tilton
Kenny Tilton - github.com/kennytilton will be presenting:
"Matrix Exposed! (or, You Don't Know Reactive)"
No one takes state management seriously. ReactJS punted. Flutter punted. Kenny Tilton will lead a deep dive into his Matrix state manager; make the case for state being the first problem solved by any UI framework; and explain how to evaluate state engines when our chosen UI punts.
Kenny is currently developing a new Flutter/Matrix reactive front-end library atop ClojureDart. He came to Clojure from Common Lisp ten years ago, and has used it professionally for ETL and e-commerce, as well his own O/S UI frameworks. He has used re-frame professionally, Reagent in anger, and Hoplon/Javelin, one of his favorites, for fun. Before shuffling off this mortal coil, he wants us to know the power we are missing with even today's excellent reactive solutions.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- **ClojureBridge London**: supports under-represented groups discover Clojure
- **re:Clojure**: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- And many individual sponsors
Title: **Building conditional data dependency graphs with Nodely**
Speaker: **Sophia Velten**
Sophia Velten ( twitter.com/sophiavelten ) will be presenting:
"Building conditional data dependency graphs with Nodely"
There are many libraries out there for declaring and running data
dependency pipelines expressed by directed acyclic graphs, but to our
knowledge none of them have built-in support for expressing
conditional dependencies. With Nodely it is possible to express
conditional dependencies declaratively and decouple declaration from
execution. We are able to run the same dependency definition with
multiple engines such as: lazy synchronous, async with core-async,
async with promesa and potentially many others, unlocking the power of
async and avoiding execution of unneeded dependencies.
Sophia Velten is a Computer Engineer currently working at Nubank as a
Senior Staff Software Engineer, where she designed State Flow, an open
source Clojure library which is the standard integration testing
framework at Nubank. Her main interest in tech is the interface
between humans and machines, which usually means language. She enjoys
a bunch of esoteric languages ranging from Ancient Greek to Haskell,
Lisps (Clojure) and Smalltalk and tends to apply category theory in
more places than it is advisable. Beyond tech she is also interested
in philosophy and (karaoke) singing.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- ClojureBridge London: supports under-represented groups discover Clojure
- re:Clojure: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- freshcodeit.com
- nette.io
- nilenso.com
- And many individual sponsors
Speaker: *Baptiste Dupuch & Christophe Grand*
Baptiste Dupuch & Christophe Grand (@ClojureDart) will be presenting:
"Joyful Mobile Development with ClojureDart"
Java promised WORA: Write Once Run Anywhere.
Clojure dialects deliver SORA: Skill Once Reach Anywhere.
ClojureDart is a recent creatively-named dialect targeting Dart and its cross platform gui Flutter to bring native binaries to mobiles and desktops.
We’ll demo how the Clojure and Flutter combo makes app development enjoyable by leveraging strengths of our favorite language and of the Flutter ecosystem (portability, performance, libraries, tooling and community).
Baptiste and Christophe have been contracting in Clojure together for 3 years and independently for 15 years. During the pandemic they started working on ClojureDart to make development of native GUI apps blissful.
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- ClojureBridge London: supports under-represented groups discover Clojure
- re:Clojure: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- freshcodeit.com
- nette.io
- nilenso.com
- And many individual sponsors
Title: **Talking to Martians**
Speaker: **Oliver Hine**
Oliver Hine (github.com/oliyh) will be presenting:
"Talking to Martians"
How describing remote interfaces using schemas allows abstraction from HTTP and leads to greater good.
Oliver enjoys writing software and wants others to enjoy it too. A decade of Clojure dev across the stack.
If you missed this event, you can watch the recording on our YouTube channel:
youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)
Please, consider supporting the London Clojurians with a small donation:
opencollective.com/london-clojurians
Your contributions will enable the sustainability of the London
Clojurians community and support our varied set of online and
in-person events:
- ClojureBridge London: supports under-represented groups discover Clojure
- re:Clojure: our **free** to attend annual community conference
- monthly meetup events with speakers from all over the world
- subscription and admin costs such as domain name & Zoom plan for
larger online meetups
Thank you to our sponsors:
- https://juxt.pro/
- flexiana.com
- gaiwan.co
- freshcodeit.com
- nette.io
- nilenso.com
- And many individual sponsors


