Key Concepts

Introduction

The "Key Concepts" pages can be used as a hierarchical, annotated index, but their primary purpose is to provide a "study guide" for aspiring Clojurists.

Clojure is a very eclectic programming language, based on concepts and supporting technology from a wide range of sources, eg:

  • Databases - atomicity, consistency, isolation, MVCC, transactions

  • Functional Programming (FP) - comprehensions, lambdas, pure functions

  • Java - data types, infrastructure, interfaces, object-orientation

  • Lisp - homoiconicity, prefix notation, recursion, syntactic macros

  • Perl - first-class maps and regular expressions, some syntax

Very few aspiring Clojurists will be familiar with all of these categories, let alone all of the relevant concepts and how they interrelate. For example, Lisp programmers may well have used FP techniques, but are unlikely to be familiar with the Java ecosystem.

Rich Hickey has also added his own "special sauce", finding ways to meld and/or supplement these concepts into a cohesive whole. For example, consider the sequence abstraction or his implementation of persistent, immutable data structures.

Assorted Clojurists have also been busy, porting and/or creating libraries for logic programming, web development, and more. Consequently, aspiring Clojurists have a large (and growing) body of knowledge to discover, locate, select, comprehend, and use.

Motivation

There is a wealth of Resources (eg, books, videos, web sites), so finding specific information tends to be easy. The difficulty of comprehending and using the information will vary, of course, depending on the person involved and the resources they are able to find.

However, none of this provides any focused help in detecting unknown unknowns: key concepts that the Clojurist has never encountered (or noticed). Telling the Clojurist to "read everything" isn't practical and leaving discovery up to chance is unsatisfying. So, we need an efficient way for aspiring Clojurists to find out about unknown concepts, assess their proficiency, and organize their studies.

Approach

My approach to this challenge is to create a taxonomy of concepts, implemented as a (cross-linked) tree of web pages. This structure provides the usual benefits of hierarchies: modularity, organization, and rapid navigation. It also allows rapid, straightforward navigation to a given topic page.

Each topic page (eg, Architecture) contains a collection of (brief) definitions, organized by subtopic. If a topic page would be too large for comfort, it is broken up into an index page (eg, Data) and a collection of subtopic pages (eg, Data Collections).

Note: Much of this material is adapted from clojure.org or Wikipedia. Most of the external links go to these (fine!) sites.

Usage

These pages can (and I hope, will) be used as a reference (eg, "annotated concept index"). However, they can also be used as a "check list", "reading list", etc. Basically, dip into each topic and skim all of its entries. If you find yourself saying "Heh?" (rather than "Uhuh"), you've found a problem.

Either make a note to get back to the topic later (slacker :-) or follow the embedded links and read up on it. If you run into problems, please get in touch; maybe we can improve the situation. Finally, please feel free to suggest additions and corrections!

Topics

The lists below contain links into the topical pages. Sorry for the sprawl; there's a lot to cover...

Architecture

The Architecture page discusses the overall architecture of the (JVM-based) Clojure implementation.

Data

The Data pages discuss various aspects of Clojure's approach to data.

Data (Abstract)

The Data (Abstract) page discusses abstract concepts (eg, immutability, persistence) related to Clojure's approach to data.

Data Collections

The Data Collections page discusses Clojure's approach to data collections (eg, maps, vectors).

Data Elements

The Data Elements page discusses Clojure's approach to data elements (eg, integers, strings).

Metadata

The Metadata page discusses Clojure's (novel) approach to metadata (eg, :doc, :tag).

References

The References page discusses Clojure's approach to reference data types (eg, atoms).

Support

The Support page discusses Clojure's support mechanisms (eg, garbage collection).

Functions

The Functions pages discuss Clojure's functions, etc.

Function Dispatch

The Function Dispatch page discusses Clojure's approaches to function dispatch (eg, multimethods, protocols).

Higher Order Functions

The Higher Order Functions page discusses Clojure's approach to anonymous functions, lambda expressions, etc.

Java, etc.

The Java, etc. page discusses popular approaches to using Java (etc) from Clojure. It also touches on some Java concepts (and jargon) that aspiring Clojurists need to know.

There are lots of books on Java, but very few that met my needs as an aspiring Clojurist. I recently encountered one, however, that seems to have a suitable approach and level. For example, it walks the reader through Java's object model, presenting all of the key concepts clearly and without extraneous detail, then discusses the benefits and drawbacks of the design. Strongly recommended

To Do ...

Several additional topics are already planned or in progress, eg:

  • Complexity

  • Concurrency

  • Control Flow

  • Design Goals

  • Macros

  • Refactoring


This wiki page is maintained by Rich Morin, an independent consultant specializing in software design, development, and documentation. Please feel free to email comments, inquiries, suggestions, etc!

Topic revision: r34 - 04 Apr 2016, RichMorin
This site is powered by FoswikiCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding CFCL Wiki? Send feedback