Table Of ContentClojure: High Performance
JVM Programming
Explore the world of lightning fast Clojure apps
with asynchronous channels, logic, reactive
programming, and more
A course in three modules
BIRMINGHAM - MUMBAI
Clojure: High Performance JVM Programming
Copyright © 2017 Packt Publishing
Published on: January 2017
Published by Packt Publishing Ltd.
Livery Place
35 Livery Street
Birmingham B3 2PB, UK.
ISBN 978-1-78712-959-7
www.packtpub.com
Preface
In the last few years, we have seen a widespread tendency to create new languages
for JVM. There are all sorts of new languages with different paradigms and different
ways of working. Clojure is one of those languages, one that we believe is worth
learning.
The Java Virtual Machine plays a huge role in the performance of the Clojure
programs. Clojure brings functional programming to the Java Virtual Machine
(JVM), and also to web browsers through ClojureScript.
With the recent rise of parallel data processing and multicore architectures,
functional programming languages have become more popular for creating software
that is both provable and performant. Like other functional programming languages,
Clojure focuses on the use of functions and immutable data structures for writing
programs. Clojure also adds a hint of Lisp through the use of symbolic expressions
and a dynamic type system.
What this learning path covers
Module 1, Clojure for Java Developers, introduces you to Clojure and how opinionated
it is. You will learn why immutable objects are not only possible, but it is a good idea
to use them. You will also learn about functional programming and see how it fits
the concept of immutable programs. You will understand the very powerful idea of
representing your code as a data structure of the same language. Further, we will
find similarities and differences from the Java language that you already know, so
you can understand how the Clojure world works.
Module 2, Clojure High Performance Programming, Second Edition, increases the focus
on the JVM tools for performance management, and it explores how to use those.
This module will equip the you with performance measurement and profiling tools
and with the know-how of analyzing and tuning the performance characteristics of
Clojure code.
Module 3, Mastering Clojure, walks you through the interesting features of the Clojure
language. We will also discuss some of the more advanced and lesser known
programming constructs in Clojure. Several libraries from the Clojure ecosystem
that we can put to practical use in our own programs will also be described. You
won’t need to be convinced any more about the elegance and power of the Clojure
language by the time you’ve finished this module.
What you need for this learning path
You need the Java SDK. You should be able to run samples on any OS; our samples
should be easier to follow in environments where there is a shell available. (We focus
mainly on Mac OS X.)
You should acquire Java Development Kit version 8 or higher (which you can obtain
from http://www.oracle.com/technetwork/java/javase/downloads/) for your
operating system to work through all the examples. This book discusses the Oracle
HotSpot JVM, so you may want to get Oracle JDK or OpenJDK (or Zulu) if possible.
You should also get the latest Leiningen version from http://leiningen.org/, and
JD-GUI from http://jd.benow.ca/.
You’ll also need a text editor or an integrated development environment (IDE). If
you already have a text editor that you prefer, you can probably use it. Navigate
to http://dev.clojure.org/display/doc/Getting+Started for a list of
environment-specific plugins to write code in Clojure. If you don’t have a preference,
it is suggested that you use Eclipse with Counterclockwise (http://doc.ccw-ide.
org/) or Light Table (http://lighttable.com/). Some examples in this book will
also require a web browser, such as Chrome (42 or above), Firefox (38 or above), or
Microsoft Internet Explorer (9 or above).
Who this learning path is for
This learning path is targeted at Java developers who are comfortable with building
applications and now want to leverage the power of Clojure.
Reader feedback
Feedback from our readers is always welcome. Let us know what you think about
this course—what you liked or disliked. Reader feedback is important for us as it
helps us develop titles that you will really get the most out of.
To send us general feedback, simply e-mail [email protected], and mention
the course’s title in the subject of your message.
If there is a topic that you have expertise in and you are interested in either writing
or contributing to a book, see our author guide at www.packtpub.com/authors.
Customer support
Now that you are the proud owner of a Packt course, we have a number of things to
help you to get the most from your purchase.
Downloading the example code
You can download the example code files for this course from your account at
http://www.packtpub.com. If you purchased this course elsewhere, you can visit
http://www.packtpub.com/support and register to have the files e-mailed directly
to you.
You can download the code files by following these steps:
1. Log in or register to our website using your e-mail address and password.
2. Hover the mouse pointer on the SUPPORT tab at the top.
3. Click on Code Downloads & Errata.
4. Enter the name of the course in the Search box.
5. Select the course for which you’re looking to download the code files.
6. Choose from the drop-down menu where you purchased this course from.
7. Click on Code Download.
You can also download the code files by clicking on the Code Files button on the
course’s webpage at the Packt Publishing website. This page can be accessed by
entering the course’s name in the Search box. Please note that you need to be logged
in to your Packt account.
Once the file is downloaded, please make sure that you unzip or extract the folder
using the latest version of:
• WinRAR / 7-Zip for Windows
• Zipeg / iZip / UnRarX for Mac
• 7-Zip / PeaZip for Linux
The code bundle for the course is also hosted on GitHub at https://github.com/
PacktPublishing/Clojure-High-Performance-JVM-Programming. We also have
other code bundles from our rich catalog of books, videos, and courses available at
https://github.com/PacktPublishing/. Check them out!
Errata
Although we have taken every care to ensure the accuracy of our content, mistakes
do happen. If you find a mistake in one of our courses—maybe a mistake in the text
or the code—we would be grateful if you could report this to us. By doing so, you
can save other readers from frustration and help us improve subsequent versions
of this course. If you find any errata, please report them by visiting http://www.
packtpub.com/submit-errata, selecting your course, clicking on the Errata
Submission Form link, and entering the details of your errata. Once your errata are
verified, your submission will be accepted and the errata will be uploaded to our
website or added to any list of existing errata under the Errata section of that title.
To view the previously submitted errata, go to https://www.packtpub.com/books/
content/support and enter the name of the course in the search field. The required
information will appear under the Errata section.
Module 1: Clojure for Java Developers
Chapter 1: Getting Started with Clojure 3
Getting to know Clojure 4
Installing Leiningen 4
Using a REPL 5
Creating a new project 10
Using Cursive Clojure 12
Getting started with Clojure code and data 14
Clojure's data types 17
Summary 20
Chapter 2: Namespaces, Packages, and Tests 21
Namespaces in Clojure 22
The classpath and the classloader 23
Testing in Clojure 32
Summary 39
Chapter 3: Interacting with Java 41
Using Maven dependencies 41
Clojure interop syntax 43
Writing a simple image namespace 46
Writing the tests 48
Destructuring in Clojure 51
Exposing your code to Java 54
Proxy and reify 58
Summary 60
Chapter 4: Collections and Functional Programming 61
Basics of functional programming 61
Persistent collections 63
Types of collections in Clojure 64
The sequence abstraction 66
Specific collection types in Clojure 67
Summary 79
Chapter 5: Multimethods and Protocols 81
Polymorphism in Java 82
Multimethods in Clojure 84
Protocols in Clojure 91
Summary 95
Chapter 6: Concurrency 97
Using your Java knowledge 98
The Clojure model of state and identity 99
Promises 101
Futures 104
Software transactional memory and refs 105
Atoms 110
Agents 112
core.async 114
Summary 118
Chapter 7: Macros in Clojure 119
Lisp's foundational ideas 119
Macros as code modification tools 120
Writing your first macro 126
Debugging your first macro 128
Macros in the real world 133
References 134
Summary 134
Module 2: Clojure High Performance Programming, Second
Edition
Chapter 1: Performance by Design 137
Use case classification 138
A structured approach to the performance 141
The performance vocabulary 142
The latency numbers that every programmer should know 147
Summary 148
Chapter 2: Clojure Abstractions 149
Non-numeric scalars and interning 150
Identity, value, and epochal time model 151
Persistent data structures 153
Sequences and laziness 157
Transducers 162
Transients 164
Performance miscellanea 165
Summary 169
Chapter 3: Leaning on Java 171
Inspecting the equivalent Java source
for Clojure code 171
Numerics, boxing, and primitives 174
Arrays 176
Reflection and type hints 178
Using array/numeric libraries for efficiency 182
Resorting to Java and native code 186
Summary 188
Chapter 4: Host Performance 189
The hardware 189
The Java Virtual Machine 194
Measuring latency with Criterium 202
Summary 203
Chapter 5: Concurrency 205
Low-level concurrency 205
Atomic updates and state 208
Asynchronous agents and state 212
Coordinated transactional ref and state 216
Dynamic var binding and state 222
Validating and watching the reference types 223
Java concurrent data structures 224
Concurrency with threads 228
Clojure parallelization and the JVM 232
Parallelism with reducers 235
Summary 238
Chapter 6: Measuring Performance 239
Performance measurement and statistics 239
Performance testing 244
Performance monitoring 251
Profiling 254
Summary 257
Chapter 7: Performance Optimization 259
Project setup 259
Identifying performance bottlenecks 262
Profiling code with VisualVM 268
The Monitor tab 269
Performance tuning 274
Summary 278
Chapter 8: Application Performance 279
Choosing libraries 280
Logging 282
Data sizing 285
Resource pooling 289
I/O batching and throttling 290
Precomputing and caching 293
Concurrent pipelines 294
Applying back pressure 295
Performance and queueing theory 298
Summary 299
Module 3: Mastering Clojure
Chapter 1: Working with Sequences and Patterns 303
Defining recursive functions 303
Thinking in sequences 309
Working with pattern matching 332
Summary 335
Chapter 2: Orchestrating Concurrency and Parallelism 337
Managing concurrent tasks 338
Managing state 344
Executing tasks in parallel 364
Summary 369
Chapter 3: Parallelization Using Reducers 371
Using reduce to transform collections 372
Using fold to parallelize collections 382
Processing data with reducers 387
Summary 390
