Deep in your innermost being, you’ve always known you were destined to learn Clojure. Every time you held your keyboard aloft, crying out in anguish over an incomprehensible class hierarchy; every time you lay awake at night, disturbing your loved ones with sobs over a mutation-induced heisenbug; every time a race condition caused you to pull out more of your ever-dwindling hair, some secret part of you has known that there has to be a better way.

Now, at long last, the instructional material you have in front of your face will unite you with the programming language you’ve been longing for.

Criterium measures the computation time of an expression. It is designed to address some of the pitfalls of benchmarking, and benchmarking on the JVM in particular.

This includes: - statistical processing of multiple evaluations - inclusion of a warm-up period, designed to allow the JIT compiler to optimise its code - purging of gc before testing, to isolate timings from GC state prior to testing - a final forced GC after testing to estimate impact of cleanup on the timing results.

This library is a full implementation of Facebook's GraphQL specification.

Lacinia should be viewed as roughly analogous to the official reference JavaScript implementation. In other words, it is a backend-agnostic GraphQL query execution engine. Lacinia is not an Object Relational Mapper ... it's simply the implementation of a contract sitting between the GraphQL client and your data.

Lacinia features:

• An EDN-based schema language, or use GraphQL's Interface Definition Language.
• High performance parser for GraphQL queries, built on Antlr4.
• Efficient and asynchronous query execution.
• Full support for GraphQL types, interfaces, unions, enums, input objects, and custom scalars.
• Union types in SDL now support an optional leading vertical bar (|) before the first member, following the GraphQL specification. For example:

  union Searchable =
    | Business
    | Employee

• Full support for GraphQL subscriptions.
• Full support of inline and named query fragments.
• Full support for GraphQL Schema Introspection.

Fast serialization library for Clojure

Clojure's rich data types are awesome. And its reader allows you to take your data just about anywhere. But the reader can be painfully slow when you've got a lot of data to crunch (like when you're serializing to a database).

Nippy is a mature, high-performance drop-in alternative to the reader.

It is used at scale by Carmine, Faraday, PigPen, Onyx, XTDB, Datalevin, and others.

Why Nippy?

• Small, simple pure-Clojure library
• Terrific performance: the best for Clojure that I'm aware of
• Comprehensive support for all standard data types
• Easily extendable to custom data types
• Robust test suite incl. coverage of every supported type
• Mature and widely used in production for 12+ years
• Optional auto fallback to Java Serializable for safe types
• Optional auto fallback to Clojure Reader (including tagged literals)
• Optional smart compression with LZ4 or Zstandard
• Optional encryption with AES128
• Tools for easy + robust integration into 3rd-party libraries, etc.
• Powerful thaw transducer for flexible data inspection and transformation

A lot of us feel a little lost as we start to use Clojure and try to make sense of how we should model data. If we came from a schema or type-based system many of us are tempted to apply those skills directly. We have a notion (reinforced by talks we watch) that these namespaced keywords are important, but we often struggle to apply those concepts pragmatically.

In this talk, I’ll discuss how the ideas of context-free federated names (a.k.a. namespace-qualified keywords) have become more concrete and pragmatic to me during my use of them at NuBank. I’ll talk about my realizations on how they can be used in practical ways that lead to a high level of clarity in our data models and communication systems, and open up better flexibility and reach.

Finally, I’ll relate these concepts to recent advances in the communication of this kind of data at the systems level as a graph, and show how industry standards like GraphQL continue to suffer from problems of composition and generality, while Clojure’s approach leads to an open information system with maximal utility: the Maximal Graph.

Fast Idiomatic Pretty-Printer

Fipp is a better pretty printer for Clojure and ClojureScript.

Like clojure.pprint, this pretty printer has a linear runtime and uses bounded space. However, unlike clojure.pprint, Fipp's implementation is tuned for great performance and has a functional, data-driven API.

The data interface is agnostic to the source language. Printers are included for Edn data and Clojure code, but it is easy to create a pretty printer for your own language or documents: Even if they're not made out of Clojure data!

Fipp is great for printing large data files and debugging macros, but it is not suitable as a code reformatting tool. (explanation)

The claypoole library provides threadpool-based parallel versions of Clojure functions such as pmap, future, and for.

A Clojure/Datomic library for idempotently transacting datoms (norms) into your database – be they schema, data, or otherwise.

In the simplest sense, conformity allows you to write migrations and ensure that they run once and only once.

In a more general sense, conformity allows you to declare expectations (in the form of norms) about the state of your database, and enforce those idempotently without repeatedly transacting schema, required data, etc.

Pull is a declarative way to make hierarchical (and possibly nested) selections of information about entities. Pull applies a pattern to a collection of entities, building a map for each entity. Pull is available

• via the standalone pull API Peer | Client
• via the standalone pull-many API in Peer
• as a find specification in query