book

The Clojure Workshop

Name: The Clojure Workshop
ISBN: 9781838825485

by Joseph Fahey, Thomas Haratyk, Scott McCaughie, Yehonathan Sharvit, Konrad Szydlo, Kirill Erokhin, Punit Naik, David Parker, John Stevenson, Erwin Rooijakkers, Prashant Rathod

January 2020

Beginner

800 pages

16h 19m

English

Packt Publishing

Read now

Unlock full access

Preface
About the BookAudienceAbout the ChaptersConventionsBefore You BeginInstalling JavaInstalling ClojureEditors and IDEsInstalling the Code Bundle
1. Hello REPL!
IntroductionREPL BasicsExercise 1.01: Your First DanceExercise 1.02: Getting around in the REPLActivity 1.01: Performing Basic OperationsEvaluation of Clojure CodeBasic Special FormsExercise 1.03: Working with if, do, and whenBindingsExercise 1.04: Using def and letExercise 1.05: Creating Simple Functions with fn and defnActivity 1.02: Predicting the Atmospheric Carbon Dioxide LevelTruthiness, nil, and equalityExercise 1.06: The Truth Is SimpleEquality and ComparisonsExercise 1.07: Comparing ValuesActivity 1.03: The meditate Function v2.0Summary
2. Data Types and Immutability
IntroductionSimple Data TypesStringsNumbersExercise 2.01: The Obfuscation MachineBooleansSymbolsKeywordsCollectionsMapsExercise 2.02: Using MapsSetsExercise 2.03: Using SetsVectorsExercise 2.04: Using VectorsListsExercise 2.05: Using ListsCollection and Sequence AbstractionsExercise 2.06: Working with Nested Data StructuresActivity 2.01: Creating a Simple In-Memory DatabaseSummary
3. Functions in Depth
IntroductionDestructuringExercise 3.01: Parsing Fly Vector's Data with Sequential DestructuringExercise 3.02: Parsing MapJet Data with Associative DestructuringAdvanced Call SignaturesDestructuring Function ParametersArity OverloadingVariadic FunctionsExercise 3.03: Multi-arity and Destructuring with ParenthmazesHigher-Order ProgrammingFirst-Class FunctionsPartial FunctionsComposing FunctionsExercise 3.04: High-Order Functions with ParenthmazesMultimethodsExercise 3.05: Using MultimethodsActivity 3.01: Building a Distance and Cost CalculatorSummary
4. Mapping and Filtering
Introductionmap and filtermapExercise 4.01: Working with mapfilterExercise 4.02: Getting Started with filterOther Members of the filter Family – take-while and drop-whileExercise 4.03: Partitioning a Sequence with take-while and drop-whileUsing map and filter TogetherThreading MacrosUsing Lazy SequencesExercise 4.04: Watching Lazy EvaluationExercise 4.05: Creating Our Own Lazy SequenceCommon Idioms and PatternsAnonymous Functions Keywords as FunctionsExercise 4.06: Extracting Data from a List of MapsSets as Predicates Filtering on a Keyword with comp and a SetExercise 4.07: Using comp and a Set to Filter on a KeywordReturning a List Longer than the Input with mapcatMapping with Multiple InputsExercise 4.08: Identifying Weather TrendsConsuming Extracted Data with applyExercise 4.09: Finding the Average Weather TemperatureActivity 4.01: Using map and filter to Report Summary InformationImporting a Dataset from a CSV FileExercise 4.10: Importing Data from a CSV FileReal-World LazinessExercise 4.11: Avoiding Lazy Evaluation Traps with FilesConvenient CSV ParsingExercise 4.12: Parsing CSV with semantic-csvExercise 4.13: Querying the Data with filterExercise 4.14: A Dedicated Query FunctionExercise 4.15: Using filter to Find a Tennis RivalryActivity 4.02: Arbitrary Tennis RivalriesSummary
5. Many to One: Reducing
IntroductionThe Basics of reduceExercise 5.01: Finding the Day with the Maximum TemperatureInitializing reducePartitioning with reduceLooking Back with reduceExercise 5.02: Measuring Elevation Differences on SlopesExercise 5.03: Winning and Losing StreaksReducing without reducezipmapExercise 5.04: Creating a Lookup Table with zipmapMaps to Sequences, and Back Againgroup-byExercise 5.05: Quick Summary Statistics with group-bySummarizing Tennis ScoresExercise 5.06: Complex Accumulation with reduceIntroduction to EloExercise 5.07: Calculating Probabilities for a Single MatchExercise 5.08: Updating Player RatingsActivity 5.01: Calculating Elo Ratings for TennisSummary
6. Recursion and Looping
IntroductionClojure's Most Procedural Loop: doseqLooping ShortcutsExercise 6.01: An Endless Stream of GroceriesRecursion at Its SimplestExercise 6.02: Partitioning Grocery BagsWhen to Use recurExercise 6.03: Large-Scale Grocery Partitioning with recurWhat about loop?Exercise 6.04: Groceries with loopTail RecursionSolving Complex Problems with RecursionExercise 6.05: Europe by TrainPathfindingExercise 6.06: The Search FunctionExercise 6.07: Calculating the Costs of the RoutesA Brief Introduction to HTMLActivity 6.01: Generating HTML from Clojure VectorsSummary
7. Recursion II: Lazy Sequences
IntroductionA Simple Lazy SequenceConsuming a SequenceExercise 7.01: Finding Inflection PointsExercise 7.02: Calculating a Running AverageLazy Consumption of DataLazy TreesExercise 7.03: A Tennis History TreeExercise 7.04: A Custom take FunctionKnowing When to Be LazyExercise 7.05: Formatting the MatchesActivity 7.01: Historical, Player-Centric EloSummary
8. Namespaces, Libraries and Leiningen
IntroductionNamespacesExercise 8.01: Investigating Namespaces Started by Default in REPLExercise 8.02: Navigating NamespacesImporting Clojure Namespaces Using the refer FunctionExercise 8.03: Using the refer Function to Import a NamespaceAdvanced Use of the refer FunctionExercise 8.04: Using the :only KeywordExercise 8.05: Using the :exclude KeywordExercise 8.06: Using the :rename KeywordImporting Clojure Functions with require and useExercise 8.07: Importing Clojure Functions with require and useActivity 8.01: Altering the Users List in an ApplicationWhen You Want use versus When You Want requireLeiningen—A Build Tool in ClojureExercise 8.08: Creating a Leiningen ProjectInvestigating project.cljExercise 8.09: Executing the Application on the Command LineExercise 8.10: Executing Application on the Command Line with argumentsActivity 8.02: Summing Up NumbersWorking with External LibrariesExercise 8.11: Using an External Library in a Leiningen ProjectCreating and Executing a jar with LeiningenExercise 8.12: Creating a Jar FileLeiningen ProfilesExercise 8.13: Adding Leiningen Profiles to a ProjectUser-Wide ProfilesExercise 8.14: Using User-Wide ProfilesUseful Clojure LibrariesActivity 8.03: Building a Format-Converting ApplicationSummary
9. Host Platform Interoperability with Java and JavaScript
IntroductionUsing Java in ClojureExercise 9.01: Importing a Single Java Class in ClojureWorking with Time in JavaExercise 9.02: Importing Multiple Java Classes in ClojureExercise 9.03: Macros That Help Us Use Java in ClojureWorking with Java I/OImmutability in ClojureExercise 9.04: Coffee-Ordering Application – Displaying a MenuExercise 9.05: Coffee-Ordering Application – Saving and Loading OrdersWorking with Java Data TypesExercise 9.06: Java Data TypesActivity 9.01: Book-Ordering ApplicationUsing JavaScript in ClojureScriptExercise 9.07: Working with JavaScript Data TypesFigwheel TemplateReactive Web Programming Using RumExercise 9.08: Investigating Figwheel and Rum Drag and DropExercise 9.09: JavaScript Interoperability with Drag and Drop Exceptions and Errors in Clojure Exercise 9.10: Handling Errors and Exceptions in ClojureErrors in JavaScriptClojureScript Leiningen TemplatesExercise 9.11: Handling Errors in ClojureScriptActivity 9.02: Creating a Support DeskSummary

10. Testing
IntroductionWhy Testing Is ImportantFunctional TestingNon-Functional TestingClojure Unit TestingExercise 10.01: Unit Testing with the clojure.test LibraryUsing the Expectations Testing LibraryExercise 10.02: Testing the Coffee Application with ExpectationsUnit Testing with the Midje Library Exercise 10.03: Testing the Coffee Application with MidjeProperty-Based TestingExercise 10.04: Using Property-Based Testing in the Coffee-Ordering ApplicationActivity 10.01: Writing Tests for the Coffee-Ordering ApplicationTesting in ClojureScriptExercise 10.05: Setting Up Testing in ClojureScriptExercise 10.06: Testing ClojureScript CodeTesting ClojureScript Applications with FigwheelExercise 10.07: Tests in Figwheel ApplicationsExercise 10.08: Testing a ClojureScript ApplicationActivity 10.02: Support Desk Application with TestsSummary
11. Macros
IntroductionWhat is a Macro?A Very Minimal MacroCompile Time and Run TimeRuntime ParametersSyntax QuotingExercise 11.01: The and-ors MacroExercise 11.02: An Automatic HTML LibraryExercise 11.03: Expanding the HTML LibraryMacros in ClojureScriptMacro HygieneAvoiding Variable Capture with Automatic GensymsExercise 11.04: Monitoring FunctionsWhen to Use Manual gensymsActivity 11.01: A Tennis CSV MacroInterface DesignImplementationSummary
12. Concurrency
IntroductionConcurrency in GeneralAutomatic Parallelization with pmapExercise 12.01: Testing RandomnessFuturesExercise 12.02: A Crowdsourced SpellcheckerCoordinationAtomsConcept: RetriesRefs and Software Transactional MemoryExercise 12.03: Stock TradingMore Cohesion with refsExercise 12.04: Keeping up with the Stock PriceAgentsAtoms in ClojureScriptExercise 12.05: Rock, Scissors, PaperWatchersExercise 12.06: One, Two, Three… "Rock!"Activity 12.01: A DOM Whack-a-mole GameSummary
13. Database Interaction and the Application Layer
IntroductionConnecting to a DatabaseExercise 13.01: Establishing a Database ConnectionIntroduction to Connection PoolsExercise 13.02: Creating a Connection PoolCreating Database SchemasPrimary KeysForeign KeysExercise 13.03: Defining and Applying a Database SchemaManaging Our DataInserting DataInserting Single RowsInserting Multiple RowsExercise 13.04: Data InsertionQuerying DataExercise 13.05: Querying Our DatabaseManipulating Query Return ValuesExercise 13.06: Controlling Results with Custom FunctionsUpdating and Deleting DataExercise 13.07: Updating and Removing Existing DataIntroduction to the Application LayerExercise 13.08: Defining the Application LayerActivity 13.01: Persisting Historic Tennis Results and ELO CalculationsSummary
14. HTTP with Ring
IntroductionHTTP, Web Servers, and RESTRequest and ResponseExercise 14.01: Creating a Hello World Web ApplicationRequest RoutingUsing CompojureExercise 14.02: Introducing Routing with CompojureResponse Formats and MiddlewareExercise 14.03: Response Rendering with MuuntajaHandling a Request BodyExercise 14.04: Working with a request BodyStatic FilesExercise 14.05: Serving Static FilesIntegrating with an Application LayerAccessing path and query Parameters in CompojureExercise 14.06: Integrating with an Application LayerActivity 14.01: Exposing Historic Tennis Results and ELO Calculations via RESTSummary
15. The Frontend: A ClojureScript UI
IntroductionHiccup instead of HTMLGetting Started with ReagentThe Virtual DOM and Component LifecycleExercise 15.01: Creating a Reagent ApplicationExercise 15.02: Displaying an Image with StyleManaging Component StateExercise 15.03: A Button that Modifies Its TextComponents with Children ComponentsExercise 15.04: Creating a Grid of ImagesHot ReloadJavaScript InteropExercise 15.05: Fetching Data from an HTTP EndpointActivity 15.01: Displaying a Grid of Images from the InternetActivity 15.02: Tennis Players with RankingSummary
Appendix
1. Hello REPL!Activity 1.01: Performing Basic OperationsActivity 1.02: Predicting the Atmospheric Carbon Dioxide LevelActivity 1.03: The meditate Function v2.02. Data Types and ImmutabilityActivity 2.01: Creating a Simple In-Memory Database3. Functions in DepthActivity 3.01: Building a Distance and Cost Calculator4. Mapping and FilteringActivity 4.01: Using map and filter to Report Summary InformationActivity 4.02: Arbitrary Tennis Rivalries5. Many to One: ReducingActivity 5.01: Calculating Elo Ratings for Tennis6. Recursion and LoopingActivity 6.01: Generating HTML from Clojure Vectors7. Recursion II: Lazy SequencesActivity 7.01: Historical, Player-Centric Elo8. Namespaces, Libraries and LeiningenActivity 8.01: Altering the Users List in an ApplicationActivity 8.02: Summing Up NumbersActivity 8.03: Building a Format-Converting Application9. Host Platform Interoperability with Java and JavaScriptActivity 9.01: Book-Ordering Application Activity 9.02: Creating a Support Desk10. TestingActivity 10.01: Writing Tests for the Coffee-Ordering ApplicationActivity 10.02: Support Desk Application with Tests11. MacrosActivity 11.01: A Tennis CSV Macro12. ConcurrencyActivity 12.01: A DOM Whack-a-mole Game13. Database Interaction and the Application LayerActivity 13.01: Persisting Historic Tennis Results and ELO Calculations14. HTTP with RingActivity 14.01: Exposing Historic Tennis Results and ELO Calculations via REST15. The Frontend: A ClojureScript UIActivity 15.01: Displaying a Grid of Images from the InternetActivity 15.02: Tennis Players with Ranking

Overview

The Clojure Workshop is a comprehensive guide intended to empower programmers with the skills needed to develop robust applications using Clojure and ClojureScript. By focusing on a hands-on approach, the book walks you through key concepts of functional programming, providing insights into immutability and hosted language interoperation, while emphasizing practical applications.

What this Book will help me do

Gain proficiency in writing idiomatic Clojure and ClojureScript.
Understand and put to use functional programming principles like immutability.
Build applications step-by-step while learning patterns and best practices.
Master interactive programming methods using the REPL environment.
Develop scalable and maintainable projects with Practical Clojure concepts.

Author(s)

The authors of The Clojure Workshop bring a wealth of experience teaching and practicing software development. They are committed to making functional programming accessible and enjoyable. With a passion for clear explanations and practical examples, they guide learners to become proficient in Clojure programming.

Who is it for?

This book is suitable for developers curious about functional programming, who have prior knowledge of a language like Java or JavaScript. Readers aiming to deepen their understanding of immutability, REPL workflows, and scalable design will find this book particularly beneficial. If you're looking to advance your programming career using Clojure or ClojureScript, this is an excellent starting point.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781838825485

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills