Myself, whenever I’ve had delimiter issues I’ve simply asked the agent to refactor the function into smaller composable functions and that’s solved the problem. I personally favor really short functions especially for LLMs. Strong opinion lightly held…

What is SEC EDGAR?

EDGAR is the U.S. Securities and Exchange Commission’s public filing system. Every public company in the U.S. files here — both structured data (XBRL financials, XML ownership reports) and unstructured text (annual reports, risk disclosures, MD&A narratives). It represents decades of data on thousands of firms, accessible via public HTTP/JSON APIs with no API keys or paid services required.

What does edgarjure do?

It provides comprehensive access to all of it from Clojure:

• Financial statements — income, balance sheet, cash flow with automatic XBRL line-item resolution across accounting tag changes, restatement deduplication, and long or wide output
• XBRL facts — datasets with human-readable labels, concept discovery, and cross-sectional screening across all filers in a single API call
• Filing content — full-text section extraction from 10-K/10-Q (MD&A, Risk Factors, any item), HTML table extraction
• Form parsers — Form 4 (insider trades) and 13F-HR (institutional holdings) into structured maps and datasets
• Panel datasets — multi-ticker, multi-concept, with point-in-time support for look-ahead-bias-free backtesting
• Bulk downloads — bounded parallelism, skip-existing, structured result envelopes
• Unified API — ticker or CIK interchangeably, keyword args throughout, Malli validation at entry

Dataset results are returned as tech.ml.dataset for easy downstream manipulation.

What’s the goal?

A composable, research-grade Clojure data system for SEC filings — where immutable data, lazy sequences, and a unified API make financial research pipelines clean and reproducible.

This is an early release (0.1.1). The core is solid and tested, but there’s plenty more to build. Feedback and contributions are very welcome.

• GitHub: GitHub - clojure-finance/edgarjure: Clojure library for accessing SEC EDGAR filings — company lookup, filing content, XBRL financials, and NLP item extraction via SEC's public APIs · GitHub
• Clojars: {:deps {com.github.clojure-finance/edgarjure {:mvn/version "0.1.1"}}}
• cljdoc: Readme — com.github.clojure-finance/edgarjure 0.1.1

Further development of the ClojureMiniIDE project based on the Protege 3.5 ontology editor. Home: https://github.com/rururu/ClojureProtegeIDE

Specila Features:

1. Representing knowledge as ontologies. Using an ontology editor Protege 3.5 to represent a subject area (frame data model) in object-orientet form.

2. Program. In Clojure, there’s no concept of a “program”; there’s only the concept of a “namespace”. These aren’t quite the same thing. A given task typically requires multiple namespaces. ClojureMiniIDE defines a program as an ordered sequence of namespaces. The order is determined by the order in which namespaces must be loaded, as this is essential for program operation. A special button is available for automatically loading a program.

3. Separate windows for functions and other program elements. This allows you to simultaneously edit multiple functions on the screen, from different namespaces, and only those needed at the moment. The automatic loading button simultaneously composes (“builds”) various namespaces from all open and possibly modified elements, saves them, and loads them in the desired order.

Enjoy!

Sincerely,

Ru

Link into your REPL with clojure.net, from Hyperfiddle (by Dustin Getz)

Is now available on YouTube at:

Link into your REPL with clojure.net, from Hyperfiddle (by Dustin Getz)

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Design in Practice, Documenting Noj, and additional updates.

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.

Design goals:

• Only dependency: data.csv. All HTTP, ZIP, XML, and date handling uses the JDK directly.

• The converter is a plain immutable map — no mutable state, no opaque objects. Inspect it in the REPL, pass it through pipelines, compose it freely.

• Throws on missing dates (weekends/holidays) unless you explicitly opt in to a fallback strategy (:nearest, :before, :after). No silent interpolation or forward-fill — if gap-filling happens, it happens visibly in code you wrote.

• SDMX client gives access to the full ECB statistical catalogue (~100 dataflows), with predefined constants for common series and convenience builders for custom queries.

FX conversion:

(require '[clojure-finance.ecbjure.fx :as fx])
(import '[java.time LocalDate])

(def c (fx/make-converter))
(fx/convert c 100 "USD" "JPY")                          ;; => 15791.89
(fx/convert c 100 "USD" "EUR" (LocalDate/of 2013 3 21)) ;; => 77.46
(fx/get-rate c "USD" (LocalDate/of 2014 3 28))          ;; => 1.3759
(fx/cross-rate c "USD" "GBP" (LocalDate/of 2014 3 28))  ;; => 0.5999

SDMX — interest rates, inflation, and more:

(require '[clojure-finance.ecbjure.sdmx :as sdmx])

(sdmx/get-series sdmx/euribor-3m {:last-n 3})
(sdmx/get-series sdmx/hicp-euro-area {:start-period "2020-01"})
(sdmx/get-series (sdmx/exr-series-key {:currency #{"USD" "JPY"}}) {:last-n 5})

Optional tech.ml.dataset integration for wide/long format output (gated behind an alias — never pulled into your project unless you need it).

com.github.clojure-finance/ecbjure {:mvn/version "0.1.4"}

GitHub: https://github.com/clojure-finance/ecbjure

cljdoc: https://cljdoc.org/d/com.github.clojure-finance/ecbjure/0.1.4

Feedback, issues, and PRs welcome.

Here, we are announcing that the event will be delayed.

Sadly, the current war in the Middle East is affecting more than one of the people involved in organising. We are following the news with concern for our friends, and for anyone in places and countries on the different sides of this conflict.

Let us hope that soon, things will calm down, and the organising team will be able to work towards a new date later this year.

Design goals:

• Zero external dependencies beyond charred (JSON parsing). Uses java.net.http.HttpClient from JDK 11+.

• No Python bridge, no API keys.

• Two-tier API: simple functions for quick REPL use, verbose variants returning structured result envelopes for production code.

• First-class Scicloj ecosystem integration.

Stable features: current prices (single + parallel batch), historical OHLCV, dividends/splits, ticker metadata. Experimental: fundamentals, financial statements, analyst data, earnings calendar, options chains (uses Yahoo’s authenticated endpoint with automatic cookie/crumb session management).

The parallel fetcher uses a bounded thread pool with configurable concurrency, per-ticker error isolation, and structured error types (:rate-limited, :http-error, :connection-error, etc.) so you can build intelligent retry logic.

Integrations (all opt-in via aliases): tech.ml.dataset, Kindly/Clay, Parquet, DuckDB, Noj. The repo includes a Clay demo notebook showing fetch → tablecloth → tableplot → interactive HTML charts.

com.github.clojure-finance/clj-yfinance {:mvn/version "0.1.5"}

GitHub: https://github.com/clojure-finance/clj-yfinance
Clojars: https://clojars.org/com.github.clojure-finance/clj-yfinance

Feedback, issues, and PRs welcome.

For humans there are great tools - paredit (structure editing), rainbow brackets, block highlighting in IDE - that mostly solve this. But for LLMs none of that applies.

I know there’s an existing practice of leaving comments after closing parens:

(defn process-user [user]
  (when (:active? user)
    (update user :name str/upper-case))) ;; when ;; defn

This does help LLMs track context, but it breaks paredit (it doesn’t move comments with parens), and the marker ends up after the closing paren - when the model has already closed the form and moved on.

I’ve been thinking about using #_ instead:

(defn process-users [users]
  (filter
    (fn [user]
      (and (:active? user)
           (> (:age user) 18) #_and) #_fn)
    users #_filter) #_defn)

#_ discards the next form at the reader level, this is valid Clojure - no preprocessor, no changes to the compiler. The marker sits inside the form before the closing paren, so the structure of the code is preserved.

The pattern is specific enough that tooling could do interesting things with it:

• paredit could treat #_token) as a unit and move them together

• rainbow-delimiters could color #_token the same as its opening paren - no name matching needed, just depth counter at that position

• IDEs could hide or de-emphasize these markers if you want cleaner visuals

Obviously this adds verbosity, but it’s purely opt-in - useful in deeply nested code, skip it elsewhere.

Has anyone tried something like this?

THIS IS AN ONLINE EVENT
[Connection details will be shared 1h before the start time]

The London Clojurians are happy to present:

Title: Link into your REPL with clojure.net, from Hyperfiddle
Speaker: Dustin Getz
Time: 2026-03-10 @ 18:30 (London time)
Local time: click here for local time
RSVP: Link into your REPL with clojure.net, from Hyperfiddle (by Dustin Getz), Tue, Mar 10, 2026, 6:30 PM | Meetup

Dustin Getz (http://twitter.com/dustingetz) will be presenting:
“Link into your REPL with clojure.net, from Hyperfiddle”

Join us to experience www.clojure.net, a new experiment from Hyperfiddle.

• link to database queries, clojure documents, http endpoints, and more
  web based, designed for production. create secure service management console UIs (like AWS Console) out of nothing but simple Clojure functions and a couple protocols
• no client-side framework, no frontend build, no REST APIs, no Dockerfile: add one simple Clojure dependency to your REPL and call ‘connect’
• for examples and more, visit: www.clojure.net

Dustin Getz is the creator of Electric Clojure and founder of Hyperfiddle. His mission is to collapse to zero the cost of enterprise frontend development, for a huge range of apps from business process applications to throwaway tools. http://twitter.com/dustingetz

If you missed this event, you can watch the recording on our YouTube channel:
https://www.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:

https://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/
• https://gaiwan.co/
• And many individual sponsors

RSVP: Link into your REPL with clojure.net, from Hyperfiddle (by Dustin Getz), Tue, Mar 10, 2026, 6:30 PM | Meetup

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Design in Practice, Documenting Noj, and additional updates.

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.

When I learned Clojure, it was from Amit Rathore (“Clojure in Action” author), and it was a half-day workshop for $199 (USD) – back in 2010. No downloads of material, no access to the material after that half day. And I had to drive to the workshop – it wasn’t even available online.

but i checked the cost of individual courses and it was 238 cad (174 USD) per course
this is very high , excessively high

udemy have some courses priced at 100+, but many of them get sold at 90% and 80% percent discount during black friday and other discount season during the year
and those are usually 7+ hours courses , with very indepth content

i would also like to hear other people opinion on this, is it just me who think those prices are too high

The secret to avoiding burnout is to always be learning. I’ve worked in a dozen different product domains, companies of different sizes, and different roles. In each I’ve had to learn many things. It’s kept me fresh and engaged in the industry. Again, writing too many while loops will burn anyone out. Start learning new things. It doesn’t need to be software either. During my time in industry, I wrote a Master’s Thesis, started a couple bands, learned to produce and record albums, and a few other things. The secret is to always be learning. Keep your neurons plastic (oddly enough, models of neutral plasticity was the topic of my MSCSb Thesis).

Just to add — the 29 CHF/month subscription gives you access to all courses. But if subscription isn’t your thing, every course is also available as a one-time purchase, own it forever. Those prices came down too.

Always open to feedback on pricing. Appreciate the honest conversation.

That’s about 51 CAN or 37.50 USD. Or about 9 or 10 Starbucks coffees (large latte).

I wouldn’t consider that particularly expensive for a good video course about a niche technology (which we have to admit is what we’ve all chosen here).

First congrats, and second this is very expensive, 49 and 490 EUR is 79 and 790 Canadian
(or 58 and 580 USD)
I understand that maybe the pool of customer is small, and the price need to high to make sense

Pluralsight which have thousands of course is less than half the price (when you get it at their annual 40% or 50% discount)
And that being said, at half the price and with thousand of course pluralsight is still a bad deal
considering many course are old, youtube have a ton of free stuff , and we can learn with AI

your site have 6 courses , and even the workshops are not included

personally i cannot say what would be a fair price, I noticed in general that many specialized courses site are equally expensive (or almost, i think you are the most expensive by quiet a bit), and i think this is not a good trend

Again congrats
Let us know how well it does

I’ve moved all my Clojure courses off Podia and onto a platform I built and self-host: clojure.stream

Some of you might know the courses — Reagent, Re-frame, Reitit, Datomic, and Pedestal. They’ve been on Podia for years, but I wanted full control over the platform and to build something tailored for a developer audience. So I did — in Clojure, all the way down.

The project has been growing organically for about 3-4 years now. Started as a shell over Podia, self-hosted on OpenBSD and a lot of libraries i wanted to use in anger, also a lot of back and forth over the years with @thheller and evolved from there — adding, removing, rewriting. The main reason for self-hosting; It felt like Podia is becoming a platform with way too many bells and whistles that i never used and it was hard for me to pay more, and more for those things.

What’s new:

• All content, accounts, and subscriptions migrated from Podia

• Prices lowered across the board — no more platform tax

  • Monthly: 49 EUR → 29 CHF

  • Yearly: 490 EUR → 290 CHF

  • One-time purchases reduced by 30-50%

• If you bought a course on Podia, restore your purchase at /settings/billing

For the ClojureVerse community — use code CLJVERSE for 20% off any course. Valid through March 10.

I’ll be sharing monthly updates on the platform going forward — new content, features, and improvements: https://clojure.stream/changelog

Happy to answer questions about the stack, the migration, or the courses. Feedback and bug reports always welcome.

Cheers, Jacek

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Design in Practice, Documenting Noj, and additional updates.

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.

The 18th International Symposium on Functional and Logic Programming

May 26-28, Tsukuba, Japan

https://functional-logic.org/events/flops/2026/

Welcome to the 18th International Symposium on Functional and Logic
Programming (FLOPS 2026) on May 26-May 28, 2026 in Tsukuba, Japan.

FLOPS 2026 is co-sponsored by Special Interest Group on Programming
and Programming Languages (SIG-PPL), Japan Society for Software
Science and Technology (JSSST).

FLOPS brings together practitioners, researchers and implementers of
declarative programming, to discuss mutually interesting results and
common problems: theoretical advances, their implementations in
language systems and tools, and applications of these systems in
practice. FLOPS specifically aims to promote cross-fertilization
between theory and practice and among different styles of declarative
programming.

Venue

FLOPS 2026 will take place at the University of Tskukuba. Tsukuba is
about 60km from central Tokyo, and easily reachable via public
transport from both Haneda and Narita airports.

Tsukuba is Japan’s science and technology city. Yet, it preserves
its rich traditions and local heritage with attractions such as
Mt. Tsukuba and Tsukubasan Shrine.

Registration

You can register for FLOPS 2026 here:

https://functional-logic.org/events/flops/2026/registration/

Early-bird registration fee (until Apr 25) is 50000¥/20000¥ for
students - roughly 275€, 325$, 240£ as of February 19.

Registration includes an excursion and a banquet on May 27. Extra
banquet tickets are available.

Program

Keynote speakers:

• Kazunori Ueda, Waseda Univerity
• Fritz Henglein, University of Copenhagen
• Gabriele Keller, Utrecht University

Tutorial:

• Jesse Alama, Scheming in Lean

Accepted papers:

• Li, F., Gupta, G.: Computing Supported Models via Transformation to
  Stable Models

• Miyazawa, O., Nishizaki, S.: Matrix Coeffect: A Coeffect Calculus
  for Handling Interdependent Information

• Arntzenius, M., Willsey, M.: Finite Functional Programming or,
  LAMBDA: the Ultimate Predicate

• Lam, C.: Optimizing Mesh Booleans by Being Lazy (System Description)

• Zhou, N., Jiang, C., Bierlee, H., Stuckey, P.: Dynamic Programming
  and Tabled Logic Programming for Encoding Single-Constant
  Multiplication into SAT (Declarative Pearl)

• Bohrer, R.: Demonic Dynamic Logic Programming

• Morihata, A.: Test Your Polymorphic Functions with Boolean Values

• Kiselyov, O.: More Fun with Monoids (Declarative Pearl)

• Boyland, P., Hyatt, S., Dewey, K., Hardekopf, B.: Breccia: A
  Functional DSL Compiled to Egglog for Test Input Generation

• Cabo, Q., Scholz, S.: Finding Programming Faults Even When Large
  Parts of the Code have Disappeared

• Maieli, R., Acclavio, M.: Probabilistic Linear Logic Programming
  with an application to Bayesian Networks computations

• Tudor, A., Arias, J., Gupta, G.: Automatic Knowledge Gap Detection
  and Plan Validation Using Counterfactual Justifications

• Hemann, J., Pfingsten, B.: Visualizing miniKanren Search with a
  Fine-Grained Small-Step Semantics

• Coltharp, N., Libby, S., Israel, L., Li, Y.: Unifying Hindsight and
  Foresight: Lazy Cost Analysis as Functional Logic Programming

Further information about the conference and local arrangements is
available on the conference website.

And when I know, what I need, I could write the requirements. But then I already have the implementation.

The Clojure tool became an important part of our workflow and managers are saying how important that tool is. Clojure is still not accepted.

Nobody ever asked again in which language the tool is developed.

This all resonates with my experience as well. Eerily familiar.

It was no surprise, that Clojure worked so well. We all know, that Clojure is good. And it was a lucky coincidence, that we had a perfect use case for Clojure: We needed a file format for test definitions. I could use EDN. We needed a comfortable way to edit files. Calva is perfect for EDN files. User data must be checked. I could use Spec. We needed an embedded DSL for simple value transformations. I could use SCI. We needed a small internal DSL for test results (which was XML in the past). I could also use EDN. We needed a small data transformation mechanism. Clojure is very good in this. We needed to create HTML. I could use Hiccup. Clojure already has everything.

What happened then? After a few weeks I approached my boss with this new tool. He was very happy that now we have a prototype, so that we understand exactly our needs. He asked me to make a cost estimation so that we can develop the same in Python. My cost estimation was 1720 man hours. My boss agreed to that number. I considered quitting my job. But after the first job interview I quickly realised, that I don’t want to be C++ developer any more. So I stayed were I was. I got the job to write down the requirements for the tool so that we can contract the development to an external company. Interestingly it took me longer to write these requirements than the whole development of that tool took in Clojure.

And this is for me the lessons learnt. For me writing Clojure is faster than writing requirements. Instead of writing requirements and contracting someone to develop something for me, I can directly write it in Clojure. For example it is very hard to specify formally how to convert a specific data structure into nice readably HTML. You need creativity. You need to try out different formattings and compare them until you actually know, what you want. With Hiccup I can directly try out things and immediately see the result so that I can ask people for feedback. And when I know, what I need, I could write the requirements. But then I already have the implementation.

Now it is one year later. The Clojure tool became an important part of our workflow and managers are saying how important that tool is. Clojure is still not accepted. It was my job to find an external company who we could contract for the Python development. But I ignored that task. Officially I said, that I have too much other things to do, which was true. I validated the Clojure tool without reporting that to my boss. Nobody ever asked again in which language the tool is developed.

In this meeting, we hosted Nathan Marz, who focused on the Agent-o-rama LLM agent platform

Recording

Scicloj AI Meetup 13: Agent-o-rama

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Design in Practice, Documenting Noj, and additional updates.

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.

Lexical Complexity in Software Engineering (by Samantha Cohen)

Is now available on YouTube at:

Lexical Complexity in Software Engineering (by Samantha Cohen)

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Clay, Clojure Civitas, and a new plotting library (continuing Tableplot).

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Clay, Clojure Civitas, and a new plotting library (continuing Tableplot).

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.

The idea is simple: what if your PouchDB database just acted like a regular Clojure atom? You swap! it, you deref it, you add-watch it. Hipflask handles all the sync stuff behind the scenes.

(def todos (pouch-atom db "todos"))

(swap! todos assoc "todos:1" {:text "Buy milk" :done false})

That’s it. It syncs to PouchDB, and if you’ve got CouchDB set up, it syncs there too. Multiple users can edit the same data and everyone stays in sync. It works offline and catches up when you reconnect. Great for building local first apps, multiplayer experiences, or anything where you need shared state across clients.

The interesting bit is how it handles conflicts when two people edit the same thing at once. Instead of going the CRDT route (which I wrote about before and have some issues with), Hipflask just retries your swap function with the latest data when there’s a conflict. So if two people increment a counter at the same time, both increments actually happen. Your application logic decides what “merging” means, not some generic algorithm.

I’ve been using this to power the real time collaboration in NyanCAD’s circuit editor, where multiple engineers can work on the same schematic simultaneously, and it’s been solid. It works great with Reagent and Rum if you’re building reactive UIs. There’s also a silly Global Cookie Clicker example in the repo where everyone in the world shares one cookie counter, if you want to see the multiplayer sync in action.

Check it out: GitHub - NyanCAD/hipflask: A Pouch for Rum

Have a look at using a non‑standard stack at scale: It allows a small team to achieve really great goals, with Marcin Maicki, Dentons - Freshcode

Invoker: functions are all you need (by Filipe Silva)

Is now available on YouTube at:

Invoker: functions are all you need (by Filipe Silva)

One recommended resource is Think DSP 2, discussed here at one of our study meeting announcements.

I’d also be glad to meet, look into it together and catch up, which is what we usually do at our Digital Signal Processing study group.

My company ingests thousands of documents a day, from some chaotic sources. Some of this involves web scraping. We also have a team in the Philippines who do manual web scraping, mostly by copying-and-pasting news articles.

We get a lot of duplicates, often because the team in the Philippines cannot easily coordinate with our automated scripts.

I need to build a system that can catch duplicate documents.

The approach I am familiar with is pushing documents into a vector database and doing cosine similarity searches.

However, I’ve been told that using partial hashes can be more efficient.

I am curious if anyone can point me to articles or videos that are especially good on this topic?

maxweber:

just make the EC2 instance bigger, especially if it does not need to run 24/7. Cheaper than spending too much time with the optimization.

Interesting, unusual advice. I appreciate it.

A lot of that is work-in-progress and will be made more visible soon: updates to the Fastmath 3 library, initial work on a library for domain-specific applied signal processing, meetings at the Scicloj study groups, and some notebook drafts.

We are planning a public meetup on these topics to offer a clear picture of current activity and possibly initiate new collaborations.

The precise agenda and date (tentative: March 2026) will be determined based on your feedback.

Please leave a message in the comments if you are interested or would like to propose topics to discuss.

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Clay, Clojure Civitas, and a new plotting library (continuing Tableplot).

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.

THIS IS AN ONLINE EVENT
[Connection details will be shared 1h before the start time]

The London Clojurians are happy to present:

Title: Invoker: functions are all you need
Speaker: Filipe Silva
Time: 2026-01-27 @ 18:30 (London time)
Local time: click here for local time
RSVP: Invoker: functions are all you need (by Filipe Silva), Tue, Jan 27, 2026, 6:30 PM | Meetup

Filipe Silva (https://github.com/filipesilva) will be presenting:
“Invoker: functions are all you need”

Invoker is a zero config CLI, HTTP, and REPL interface for Clojure.

Commands will automatically connect to an existing nREPL server if available using .nrepl-port. The nvk http and nvk repl commands start a nREPL server that can be connected to.

Invoker aims to make the following usecases easy:

• making a simple webapp from scratch, possibly with Datomic
• running functions and inspecting atoms inside an existing process
• running targetted tests with reloaded code
• allowing agents to interact with your clojure process
• adding dependencies and reloading code without restarting the process

Metabase, previously at Athens Research, Roam Research, Angular. Lover of homemade pizza, craft beers, and games.

If you missed this event, you can watch the recording on our YouTube channel:
https://www.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:

https://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/
• https://gaiwan.co/
• And many individual sponsors

RSVP: Invoker: functions are all you need (by Filipe Silva), Tue, Jan 27, 2026, 6:30 PM | Meetup

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Clay, Clojure Civitas, and a new plotting library (continuing Tableplot).

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.

In the coming period, we will focus on community projects and library development, but people are invited to propose additional topics to discuss and share.

The main topics for the coming meetings will be Clay, Clojure Civitas, and a new plotting library (continuing Tableplot).

Updates about the agenda will be shared in the group chat: the real-world-data channel at the Zulip chat (requires login).

If you wish to join the group, please reach out beforehand, and we’ll add you to the calendar event.