book

Clojure Programming

by Chas Emerick, Brian Carper, Christophe Grand

April 2012

Intermediate to advanced

628 pages

18h 42m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Who Is This Book For?Engaged Java DevelopersRuby, Python, and Other DevelopersHow to Read This BookStart with Practical Applications of ClojureStart from the Ground Up with Clojure’s Foundational ConceptsWho’s “We”?Chas EmerickBrian CarperChristophe GrandAcknowledgmentsAnd Last, but Certainly Far from LeastConventions Used in This BookUsing Code ExamplesSafari® Books OnlineHow to Contact Us
Why Clojure?Obtaining ClojureThe Clojure REPLNo, Parentheses Actually Won’t Make You Go BlindExpressions, Operators, Syntax, and PrecedenceHomoiconicityThe ReaderScalar LiteralsStringsBooleansnilCharactersKeywordsSymbolsNumbersRegular expressionsCommentsWhitespace and CommasCollection LiteralsMiscellaneous Reader SugarNamespacesSymbol EvaluationSpecial FormsSuppressing Evaluation: quoteCode Blocks: doDefining Vars: defLocal Bindings: letDestructuring (let, Part 2)Sequential destructuringMap destructuringCreating Functions: fnDestructuring function argumentsFunction literalsConditionals: ifLooping: loop and recurReferring to Vars: varJava Interop: . and newException Handling: try and throwSpecialized Mutation: set!Primitive Locking: monitor-enter and monitor-exitPutting It All TogetherevalThis Is Just the Beginning
What Does Functional Programming Mean?On the Importance of ValuesAbout ValuesComparing Values to Mutable ObjectsA Critical ChoiceFirst-Class and Higher-Order FunctionsApplying Ourselves PartiallyComposition of Function(ality)Writing Higher-Order FunctionsBuilding a Primitive Logging System with Composable Higher-Order FunctionsPure FunctionsWhy Are Pure Functions Interesting?Functional Programming in the Real World
Abstractions over ImplementationsCollectionSequencesSequences are not iteratorsSequences are not listsCreating seqsLazy seqsHead retentionAssociativeBeware of nil valuesIndexedStackSetSortedComparators and predicates to define orderingConcise Collection AccessIdiomatic UsageCollections and Keys and Higher-Order FunctionsData Structure TypesListsVectorsVectors as tuplesSetsMapsMaps as ad-hoc structsOther usages of mapsImmutability and PersistencePersistence and Structural SharingVisualizing persistence: listsVisualizing persistence: maps (and vectors and sets)Tangible benefitsTransientsMetadataPutting Clojure’s Collections to WorkIdentifiers and CyclesThinking Different: From Imperative to FunctionalRevisiting a classic: Conway’s Game of LifeMaze generationNavigation, Update, and ZippersManipulating zippersCustom zippersAriadne’s zipperIn Summary
Shifting Computation Through Time and SpaceDelaysFuturesPromisesParallelism on the CheapState and IdentityClojure Reference TypesClassifying Concurrent OperationsAtomsNotifications and ConstraintsWatchesValidatorsRefsSoftware Transactional MemoryThe Mechanics of Ref ChangeUnderstanding alterMinimizing transaction conflict with commuteClobbering ref state with ref-setEnforcing local consistency by using validatorsThe Sharp Corners of Software Transactional MemorySide-effecting functions strictly verbotenMinimize the scope of each transactionReaders may retryWrite skewVarsDefining VarsPrivate varsDocstringsConstantsDynamic ScopeVars Are Not VariablesForward DeclarationsAgentsDealing with Errors in Agent ActionsAgent error handlers and modesI/O, Transactions, and Nested SendsPersisting reference states with an agent-based write-behind logUsing agents to parallelize workloadsUsing Java’s Concurrency PrimitivesLockingFinal Thoughts
What Is a Macro?What Macros Are NotWhat Can Macros Do that Functions Cannot?Macros Versus Ruby evalWriting Your First MacroDebugging MacrosMacroexpansionSyntaxquote Versus syntax-quoteunquote and unquote-splicingWhen to Use MacrosHygieneGensyms to the RescueLetting the User Pick NamesDouble EvaluationCommon Macro Idioms and PatternsThe Implicit Arguments: &env and &form&env&formProducing useful macro error messagesPreserving user-provided type hintsTesting Contextual MacrosIn Detail: -> and ->>Final Thoughts
ProtocolsExtending to Existing TypesDefining Your Own TypesRecordsConstructors and factory functionsWhen to use maps or recordsTypesImplementing ProtocolsInline ImplementationInline implementations of Java interfacesDefining anonymous types with reifyReusing ImplementationsProtocol IntrospectionProtocol Dispatch Edge CasesParticipating in Clojure’s Collection AbstractionsFinal Thoughts
Multimethods BasicsToward HierarchiesHierarchiesIndependent HierarchiesMaking It Really Multiple!A Few More ThingsMultiple InheritanceIntrospecting Multimethodstype Versus class; or, the Revenge of the MapThe Range of Dispatch Functions Is UnlimitedFinal Thoughts

Project GeographyDefining and Using NamespacesNamespaces and filesA classpath primerLocation, Location, LocationThe Functional Organization of Clojure CodebasesBasic project organization principlesBuildAhead-of-Time CompilationDependency ManagementThe Maven Dependency Management ModelArtifacts and coordinatesRepositoriesDependenciesBuild Tools and Configuration PatternsMavenLeiningenAOT compilation configurationBuilding mixed-source projectsFinal Thoughts
The JVM Is Clojure’s FoundationUsing Java Classes, Methods, and FieldsHandy Interop UtilitiesExceptions and Error HandlingEscaping Checked Exceptionswith-open, finally’s LamentType Hinting for PerformanceArraysDefining Classes and Implementing InterfacesInstances of Anonymous Classes: proxyDefining Named Classesgen-classAnnotationsProducing annotated JUnit testsImplementing JAX-RS web service endpointsUsing Clojure from JavaUsing deftype and defrecord ClassesImplementing Protocol InterfacesCollaborating Partners
Interactive DevelopmentThe Persistent, Evolving EnvironmentToolingThe Bare REPLIntrospecting namespacesEclipseEmacsclojure-mode and pareditinferior-lispSLIMEDebugging, Monitoring, and Patching Production in the REPLSpecial Considerations for “Deployed” REPLsLimitations to Redefining ConstructsIn Summary
Clojure NumericsClojure Prefers 64-bit (or Larger) RepresentationsClojure Has a Mixed Numerics ModelRationalsThe Rules of Numeric ContagionClojure MathematicsBounded Versus Arbitrary PrecisionUnchecked OpsScale and Rounding Modes for Arbitrary-Precision Decimals OpsEquality and EquivalenceObject Identity (identical?)Reference Equality (=)Numeric Equivalence (==)Equivalence can preserve your sanityOptimizing Numeric PerformanceDeclare Functions to Take and Return PrimitivesType errors and warningsUse Primitive Arrays JudiciouslyThe mechanics of primitive arraysAutomating type hinting of multidimensional array operationsVisualizing the Mandelbrot Set in Clojure
Dependency InjectionStrategy PatternChain of ResponsibilityAspect-Oriented ProgrammingFinal Thoughts
Immutable Values and Pure FunctionsMockingclojure.testDefining TestsTest “Suites”FixturesGrowing an HTML DSLRelying upon AssertionsPreconditions and Postconditions
clojure.java.jdbcwith-query-results ExplainedTransactionsConnection PoolingKormaPreludeQueriesWhy Bother with a DSL?HibernateSetupPersisting DataRunning QueriesRemoving BoilerplateFinal Thoughts
Getting Set Up with CouchDB and ClutchBasic CRUD OperationsViewsA Simple (JavaScript) ViewViews in Clojure_changes: Abusing CouchDB as a Message QueueÀ la Carte Message QueuesFinal Thoughts
The “Clojure Stack”The Foundation: RingRequests and ResponsesAdaptersHandlersMiddlewareRouting Requests with CompojureTemplatingEnlive: Selector-Based HTML TransformationTesting the watersSelectorsIterating and branchingPutting everything togetherFinal Thoughts
Java and Clojure Web ArchitectureWeb Application PackagingBuilding .war files with MavenBuilding .war files with LeiningenRunning Web Apps LocallyWeb Application DeploymentDeploying Clojure Apps to Amazon’s Elastic BeanstalkGoing Beyond Simple Web Application Deployment
Just the Facts…Emphasize ProductivityEmphasize CommunityBe Prudent
(dissoc Clojure ‘JVM)ClojureCLRClojureScript4ClojureOvertonecore.logicPalletAvoutClojure on Heroku

Content preview from Clojure Programming

Preface

Clojure is a dynamically and strongly typed programming language hosted on the Java Virtual Machine (JVM), now in its fifth year. It has seen enthusiastic adoption by programmers from a variety of backgrounds, working in essentially all problem domains. Clojure offers a compelling mix of features and characteristics applicable to solving modern programming challenges:

Functional programming foundations, including a suite of persistent data structures with performance characteristics approaching typical mutable data structures
A mature, efficient runtime environment, as provided by the host JVM
JVM/Java interoperability capabilities suited for a wide variety of architectural and operational requirements
A set of mechanisms providing reliable concurrency and parallelism semantics
A Lisp pedigree, thereby providing remarkably flexible and powerful metaprogramming facilities

Clojure offers a compelling practical alternative to many who strain against the limitations of typical programming languages and environments. We aim to demonstrate this by showing Clojure seamlessly interoperating with existing technologies, libraries, and services that many working programmers already use on a day-to-day basis. Throughout, we’ll provide a solid grounding in Clojure fundamentals, starting from places of common expertise and familiarity rather than from (often foreign) computer science first principles.