Browse Clojure Foundations for Java Developers

Functional Programming Conferences

Fuad Efendi

Which broader functional-programming conferences can still sharpen a Clojure engineer's judgment, and how to use them without drifting into random language tourism.

On this page

Clojure conferences help you learn the Clojure ecosystem. Broader functional-programming conferences help you sharpen the ideas behind it.

That difference matters. If you are a Java developer moving into Clojure, you do not only need more Clojure syntax. You need stronger instincts about immutability, composition, effect management, concurrency, data modeling, and the trade-offs between static and dynamic approaches.

Use broader FP conferences to improve judgment, not to collect languages

A common beginner mistake is to treat functional-programming conferences as a tour of unfamiliar syntax. That is not the best use of them.

A better use is to compare how different communities think about the same engineering problems:

  • state and concurrency
  • data modeling
  • type systems and correctness
  • functional architecture
  • streaming and distributed systems
  • UI and effect management

When you do that, a non-Clojure talk can still make you better at Clojure.

Recent examples worth knowing

As of April 1, 2026, a few recent examples stand out:

  • Lambda Days 2025 took place on June 12–13, 2025 in Kraków and is one of the best-known multi-language FP conferences. It also announced a break in 2026, which is a good reminder that conference calendars change.
  • Functional Conf 2025 ran on January 24–25, 2025 as an online event and remains useful for developers who want access to speakers across several FP ecosystems without travel.
  • BOB 2025 took place on March 14, 2025 in Berlin. It is not a Clojure conference and not purely an FP conference, but it is valuable for the same kind of engineers who care about thoughtful language and architecture choices.

A historical archive such as Strange Loop can also still be worth watching, even though it is more useful today as a talk library than as a current event to plan around.

What these conferences are good for

Lambda Days

Use a conference like Lambda Days when you want to see serious functional-programming ideas discussed across languages and levels of abstraction. It is particularly useful when you want to compare how different ecosystems talk about correctness, concurrency, and language design.

Functional Conf

Use an event like Functional Conf when you want broad exposure without the cost of travel. It is a practical choice if you are still deciding which FP ideas matter most to your day-to-day engineering work.

BOB and adjacent conferences

Use a conference like BOB when your real interest is not “functional programming” as a brand, but better software design. These conferences are often strong on architecture, programming-language trade-offs, and techniques that transfer well back into Clojure.

How to convert non-Clojure talks into Clojure progress

After a talk, ask four questions:

  1. What engineering problem is this speaker actually solving?
  2. How would I express the same idea in Clojure?
  3. Where would Clojure make this easier, and where would it make it different?
  4. What is the closest problem in my Java or JVM work today?

That is the right way to learn from a Haskell, Scala, OCaml, Elm, or architecture talk without getting lost in language tourism.

Good talk themes for Java developers learning Clojure

If your goal is practical growth, look for talks on:

  • effect boundaries and side-effect control
  • concurrency and message-passing models
  • streaming data and backpressure
  • local-first or distributed-system design
  • type-driven design, even if Clojure itself is dynamic
  • domain modeling and simplification of stateful systems

These topics improve the way you think, even when the code is not written in Clojure.

Do not confuse inspiration with adoption

You do not need to adopt another language every time you hear a strong idea. The point is to bring better questions back into your own work.

For a Clojure learner, a good broader FP conference should make you ask:

  • Can I model this as data instead of a class hierarchy?
  • Can I move this side effect to the edge?
  • Would a simpler pipeline or transformation model remove incidental complexity?
  • Where is my state really coordinated, and does that coordination belong here?

Those are the kinds of questions that make you stronger in both Clojure and Java.

Knowledge Check

### What is the best reason for a Clojure learner to attend a broader functional-programming conference? - [x] To strengthen judgment about software design problems that appear across languages - [ ] To memorize as many new syntaxes as possible - [ ] To replace all Clojure-specific learning - [ ] To avoid reading production Clojure code > **Explanation:** The main value is learning how different communities reason about shared engineering problems, then bringing that insight back into your own work. ### Why can a non-Clojure conference talk still help you become better at Clojure? - [x] Because the underlying problem may be about state, effects, data, or architecture rather than language-specific syntax - [ ] Because every functional language uses the same libraries - [ ] Because Clojure and Haskell compile the same way - [ ] Because conference talks automatically translate into production code > **Explanation:** Many of the most valuable lessons are conceptual. They transfer even when the concrete syntax does not. ### What is a better post-talk question than “Should I learn this other language now?” - [x] “How would I express this idea in Clojure, and where would the trade-offs differ?” - [ ] “Can I copy the syntax directly into my Clojure code?” - [ ] “Does this mean Clojure is obsolete?” - [ ] “Should I ignore anything that is not JVM-specific?” > **Explanation:** The goal is comparative understanding and better design judgment, not random language switching.
Revised on Friday, April 24, 2026
B.4.1 Clojure Conferences