distance(clojure-code, production)→ 0

Clojure is capable of leveraging everything your JVM provides. And you are convinced of the benefits this LISP brings to your productivity. In this workshop, we target bridging the gap between your expressive and beautiful Clojure code, and the huge, daunting world of the Enterprise. With some small, helpful steps.

We'll specifically target

  • Going beyond the linear flows - making core.async practical
  • Confidence building measures - Clojure spec
  • Demystifying the wormhole - JVM interop
  • Practical tidbits - Introducing Clojure to your existing apps
  • Graduating - Build tooling and publishing for both library and standalone application use-cases
0 favorite thumb_down thumb_up 0 comments visibility_off  Remove from Watchlist visibility  Add to Watchlist

Outline/Structure of the Workshop

Functions → Namespaces → Libraries → Processes → Concurrent Process

We'll guide you on moving beyond the linear flows, building on your simple functions and data-structures. With the use of a very few basic features of the language, and this compelling implementation of CSP for clojure - core.async - to give you the confidence for constructing non-trivial applications.

Adding confidence to your code

With the absence of an enforced type system, Clojure depends on its simplicity, immutable-by-default datastructures and developer discipline for aiding correctness. We'll talk about Clojure Spec as a useful tool in ascertaining key properties and invariants about your data. We'll also briefly delve into the larger philosophy of Clojure's approach towards ensuring correctness in general, and patterns in the small that help support those ideas.

Understanding the underpinnings of Clojure - The JVM substrate

While Clojure is designed to depend on a host system for execution, the primary engines of its growth have been the JVM and Javascript. We'll cover some fundamental aspects of Clojure's JVM relation to help the participants not only understand the working of Clojure better, but also leverage their existing knowledge of, and codebase/libraries in, Java. Clojure stays very true to some of the most fundamental interfaces in the core Java library, making interop a breeze. Additionally, its tooling completely embraces Java's dependency management mechanisms, and allows for fluent mixing of Clojure and Java code in cases where you need to step down into the Java world for any reason.

Java, meet Clojure.

We'll pick an example from a familiar domain for our Java interop - and show how Clojure seamlessly sits besides your Java, carving a niche for itself. Literally.

Tying it together, and shipping

The code that resides in your private space and doesn't ship, is just a hobby. And you're looking to bridge that gap between hobby and work. With the entire day behind us, this will very likely be an anti-climactic session. But we'll discuss how Clojure code can be built, shipped, and deployed for use in either library or standalone app scenarios.

Learning Outcome

This workshop should help the participant in taking the next step - introducing their working clojure code (with library dependencies) to their existing Java world.

Even after a high-level buy-in, introduction of a different technology stack requires a buy-in at various steps after the code-writing phase. We aim to equip the participant with enough knowledge and tools to enable them to take their code forward from their code repositories. From living harmoniously with existing libraries and frameworks, to bundling for straightforward consumption by existing systems, to packaging for production use as stand-alone applications.

Target Audience

If Clojure has captured your imagination, but you're still looking for help to help your code take the next leap into merging with your mainstream, production infrastructure, this workshop is targeted towards you.


Working familiarity with

  • Clojure
  • The JVM

Dev setup

  • JDK 8+
  • Lein/boot/your-own-build-tool.sh
  • REPL
  • IDE/editor
  • Docker

While there's no recommended list of tools, the assumption is that the attendees bring their own setup that allows them to follow along.

Preferably on Linux or MacOS. Or Windows with your UNIX-y subsystem configured (git-bash, WSL, or even Docker).

schedule Submitted 5 months ago

Public Feedback

comment Suggest improvements to the Speaker