The Clojuring: (hit rubber road)
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
Outline/structure of the Session
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
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.
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.
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
- The JVM
- JDK 8+
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).