What Is a .CLJ File?

Clojure (.clj, .cljs)

Overview

Clojure is a dynamic, functional programming language that runs on the Java Virtual Machine (JVM), Common Language Runtime (CLR), and JavaScript engines. Created by Rich Hickey in 2007, Clojure is a modern Lisp dialect that emphasizes immutability, functional programming, and concurrent programming. It seamlessly interoperates with Java and provides powerful abstractions for dealing with state and time.

Technical Details

• File Extensions: .clj (Clojure), .cljs (ClojureScript), .cljc (Cross-platform)
• MIME Type: text/x-clojure
• Category: Programming Language
• First Appeared: 2007
• Paradigm: Functional, concurrent, dynamic
• Platform: JVM, JavaScript (V8, Node.js), .NET CLR

Key Features

Functional Programming

• Immutable data structures by default
• First-class functions and higher-order functions
• Pure functions encouraged
• Lazy evaluation support

Lisp Heritage

• Homoiconic code structure
• Powerful macro system
• S-expression syntax
• Code as data philosophy

Concurrency and State Management

• Software Transactional Memory (STM)
• Agents for independent state changes
• Atoms for synchronous state
• Refs for coordinated state changes

Syntax Examples

Basic Clojure Constructs

;; Variables and basic data types
(def name "Clojure")
(def version 1.11)
(def is-functional true)

;; Functions
(defn greet [name]
  (str "Hello, " name "!"))

(defn add [x y]
  (+ x y))

;; Anonymous functions
(def square (fn [x] (* x x)))
(def double #(* 2 %))

;; Function calls
(greet "World")
(add 5 3)
(square 4)
(double 10)

Data Structures

;; Lists
(def my-list '(1 2 3 4 5))
(def another-list (list 1 2 3 4 5))

;; Vectors
(def my-vector [1 2 3 4 5])
(def names ["Alice" "Bob" "Charlie"])

;; Maps (hash maps)
(def person {:name "John" :age 30 :city "New York"})
(def config {"host" "localhost" "port" 8080})

;; Sets
(def unique-numbers #{1 2 3 4 5})
(def colors #{"red" "green" "blue"})

;; Accessing data
(:name person)           ; :name is a keyword function
(get person :age)        ; Alternative way
(person :city)           ; Maps are functions too
(first my-vector)        ; Get first element
(rest my-vector)         ; Get rest of collection

Control Flow and Conditionals

;; if expressions
(defn classify-number [x]
  (if (pos? x)
    "positive"
    (if (neg? x)
      "negative"
      "zero")))

;; cond for multiple conditions
(defn grade [score]
  (cond
    (>= score 90) "A"
    (>= score 80) "B"
    (>= score 70) "C"
    (>= score 60) "D"
    :else "F"))

;; when and when-not
(defn process-positive [x]
  (when (pos? x)
    (println "Processing positive number")
    (* x 2)))

;; case expressions
(defn day-type [day]
  (case day
    (1 2 3 4 5) "weekday"
    (6 7) "weekend"
    "invalid"))

Functional Programming Patterns

;; map, filter, reduce
(def numbers [1 2 3 4 5 6 7 8 9 10])

(map square numbers)                    ; Square each number
(filter even? numbers)                  ; Keep only even numbers
(reduce + numbers)                      ; Sum all numbers
(reduce + 0 (map square (filter even? numbers)))  ; Sum of squares of evens

;; Threading macros
(->> numbers
     (filter even?)
     (map square)
     (reduce +))                        ; Same as above, more readable

(-> person
    :name
    .toUpperCase)                       ; Java interop with threading

;; Partial application and composition
(def add-ten (partial + 10))
(def multiply-by-two (partial * 2))
(def process (comp multiply-by-two add-ten))

(process 5)                             ; ((5 + 10) * 2) = 30

Sequences and Lazy Evaluation

;; Infinite sequences
(def naturals (iterate inc 1))          ; 1, 2, 3, 4, ...
(def fibonacci (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

;; Taking finite parts of infinite sequences
(take 10 naturals)                      ; First 10 natural numbers
(take 10 fibonacci)                     ; First 10 Fibonacci numbers

;; Lazy sequence generation
(defn primes []
  (letfn [(sieve [s]
            (cons (first s)
                  (lazy-seq (sieve (filter #(not= 0 (mod % (first s)))
                                         (rest s))))))]
    (sieve (iterate inc 2))))

(take 10 (primes))                      ; First 10 prime numbers

Macros and Metaprogramming

Basic Macros

;; Simple macro
(defmacro unless [condition & body]
  `(if (not ~condition)
     (do ~@body)))

;; Usage
(unless false
  (println "This will print")
  (println "So will this"))

;; Debugging macro
(defmacro debug [expr]
  `(let [result# ~expr]
     (println "Debug:" '~expr "=>" result#)
     result#))

;; Usage
(debug (+ 2 3))                         ; Prints: Debug: (+ 2 3) => 5

;; When-let macro equivalent
(defmacro my-when-let [binding & body]
  `(let [~(first binding) ~(second binding)]
     (when ~(first binding)
       ~@body)))

Advanced Macro Techniques

;; Macro for creating getters
(defmacro defgetters [record-name & fields]
  `(do
     ~@(for [field fields]
         `(defn ~(symbol (str "get-" (name field))) [record#]
            (~field record#)))))

;; Usage
(defrecord Person [name age email])
(defgetters Person name age email)

;; Now you have get-name, get-age, get-email functions

Concurrency and State Management

Atoms (Synchronous State)

;; Create an atom
(def counter (atom 0))

;; Read the value
@counter

;; Update the value
(swap! counter inc)                     ; Increment
(swap! counter + 10)                    ; Add 10
(reset! counter 0)                      ; Reset to 0

;; Compare and set
(compare-and-set! counter 0 100)       ; Set to 100 if currently 0

Refs and Software Transactional Memory

;; Bank account example with refs
(def account-a (ref 1000))
(def account-b (ref 500))

(defn transfer [from to amount]
  (dosync
    (alter from - amount)
    (alter to + amount)))

;; Transfer $200 from account-a to account-b
(transfer account-a account-b 200)

;; Check balances
[@account-a @account-b]                 ; [800 700]

Agents (Asynchronous State)

;; Create an agent
(def log-agent (agent []))

;; Send actions to the agent
(send log-agent conj "First entry")
(send log-agent conj "Second entry")

;; Check the value (may not be immediately updated)
@log-agent

;; Wait for all actions to complete
(await log-agent)
@log-agent                              ; ["First entry" "Second entry"]

Java Interoperability

Calling Java from Clojure

;; Import Java classes
(import '(java.util Date Calendar)
        '(java.io File))

;; Create Java objects
(def now (Date.))
(def file (File. "/path/to/file.txt"))

;; Call methods
(.toString now)                         ; Instance method
(.getTime now)                          ; Another instance method
(Date/parse "2023-01-01")              ; Static method

;; Java property access
(System/getProperty "java.version")

;; Chaining method calls
(-> "hello world"
    .toUpperCase
    (.replace "WORLD" "CLOJURE"))       ; "HELLO CLOJURE"

Creating Java-compatible code

;; Generate classes that can be used from Java
(gen-class
  :name com.example.Calculator
  :methods [[add [int int] int]
           [multiply [int int] int]])

(defn -add [this x y]
  (+ x y))

(defn -multiply [this x y]
  (* x y))

ClojureScript (JavaScript Target)

Basic ClojureScript

;; ClojureScript compiles to JavaScript
(ns my-app.core)

;; JavaScript interop
(js/alert "Hello from ClojureScript!")
(js/console.log "Debugging message")

;; DOM manipulation
(def element (.getElementById js/document "my-div"))
(set! (.-innerHTML element) "New content")

;; Async with core.async
(require '[cljs.core.async :as async :refer [go chan >! <!]])

(defn example-async []
  (let [c (chan)]
    (go (>! c "Hello"))
    (go (println (<! c)))))

Web Development

Ring and Compojure (Server-side)

(require '[ring.adapter.jetty :as jetty]
         '[compojure.core :refer :all]
         '[compojure.route :as route])

(defroutes app-routes
  (GET "/" [] "Hello World!")
  (GET "/user/:id" [id] (str "User ID: " id))
  (POST "/api/data" request
    (str "Received: " (:body request)))
  (route/not-found "Not Found"))

;; Start server
(jetty/run-jetty app-routes {:port 3000})

Reagent (React wrapper)

(require '[reagent.core :as r])

(defn simple-component []
  [:div
   [:h1 "Hello from Reagent!"]
   [:p "This is a React component written in ClojureScript"]])

(defn counter []
  (let [count (r/atom 0)]
    (fn []
      [:div
       [:p "Count: " @count]
       [:button {:on-click #(swap! count inc)} "Increment"]])))

(r/render [counter] (.getElementById js/document "app"))

Testing

clojure.test

(ns my-project.core-test
  (:require [clojure.test :refer :all]
            [my-project.core :refer :all]))

(deftest test-addition
  (testing "Addition function"
    (is (= 4 (add 2 2)))
    (is (= 0 (add -1 1)))
    (is (= -5 (add -2 -3)))))

(deftest test-string-manipulation
  (testing "String functions"
    (is (= "HELLO" (.toUpperCase "hello")))
    (is (= 5 (count "hello")))))

;; Run tests
(run-tests)

Development Tools

Build Tools

• Leiningen: Build automation and dependency management
• Clojure CLI Tools: Official tooling
• Boot: Alternative build tool
• Shadow CLJS: ClojureScript compilation

IDEs and Editors

• Emacs with CIDER
• IntelliJ IDEA with Cursive
• VSCode with Calva
• Vim with vim-fireplace

REPL-Driven Development

# Start REPL
lein repl

# Connect to running application
lein repl :connect 7888

# Evaluate code in editor and send to REPL

Notable Applications

• Walmart: E-commerce platform
• Netflix: Data processing and analytics
• Nubank: Financial services
• Puppet: Infrastructure automation
• CircleCI: Continuous integration platform

Learning Resources

• "Clojure for the Brave and True" by Daniel Higginbotham
• "Programming Clojure" by Stuart Halloway
• "The Joy of Clojure" by Michael Fogus
• ClojureDocs.org for examples and documentation
• Clojure community forums and Slack channels

Clojure offers a unique approach to programming that emphasizes simplicity, immutability, and powerful abstractions for concurrent programming, making it particularly well-suited for data processing, web applications, and systems that require robust state management.