| Description |
1 online resource (1 volume) : illustrations |
| Series |
Community experience distilled |
|
Community experience distilled.
|
| Note |
Includes index. |
| Contents |
Cover; Copyright; Credits; About the Author; About the Reviewers; www.PacktPub.com; Table of Contents; Preface; Chapter 1: Performance by Design; Use case classification; The user-facing software; Computational and data-processing tasks; A CPU bound computation; A memory bound task; A cache bound task; An input/output bound task; Online transaction processing; Online analytical processing; Batch processing; A structured approach to the performance; The performance vocabulary; Latency; Throughput; Bandwidth; Baseline and benchmark; Profiling; Performance optimization |
|
Concurrency and parallelismResource utilization; Workload; The latency numbers that every programmer should know; Summary; Chapter 2: Clojure Abstractions; Non-numeric scalars and interning; Identity, value, and epochal time model; Variables and mutation; Collection types; Persistent data structures; Constructing lesser-used data structures; Complexity guarantee; O(<7) implies near constant time; The concatenation of persistent data structures; Sequences and laziness; Laziness; Laziness in data structure operations; Constructing lazy sequences; Transducers; Performance characteristics |
|
TransientsFast repetition; Performance miscellanea; Disabling assertions in production; Destructuring; Recursion and tail-call optimization (TCO); Premature end of iteration; Multimethods versus protocols; Inlining; Summary; Chapter 3: Leaning on Java; Inspecting the equivalent Java source for Clojure code; Creating a new project; Compiling the Clojure sources into Java bytecode; Decompiling the .class files into Java source; Compiling the Clojure source without locals clearing; Numerics, boxing, and primitives; Arrays; Reflection and type hints; An array of primitives; Primitives |
|
Macros and metadataString concatenation; Miscellaneous; Using array/numeric libraries for efficiency; HipHip; primitive-math; Detecting boxed math; Resorting to Java and native code; Proteus -- mutable locals in Clojure; Summary; Chapter 4: Host Performance; The hardware; Processors; Branch prediction; Instruction scheduling; Threads and cores; Memory systems; Cache; Interconnect; Storage and networking; The Java Virtual Machine; The just-in-time compiler; Memory organization; HotSpot heap and garbage collection; Measuring memory (heap/stack) usage; Determining program workload type |
|
Tackling memory inefficiencyMeasuring latency with Criterium; Criterium and Leiningen; Summary; Chapter 5: Concurrency; Low-level concurrency; Hardware memory barrier (fence) instructions; Java support and the Clojure equivalent; Atomic updates and state; Atomic updates in Java; Clojure's support for atomic updates; Faster writes with atom striping; Asynchronous agents and state; Asynchrony, queueing, and error handling; Why you should use agents; Nesting; Coordinated transactional ref and state; Ref characteristics; Ref history and in-transaction deref operations |
| Summary |
Become an expert at writing fast and high performant code in Clojure 1.7.0 About This Book Enhance code performance by using appropriate Clojure features Improve the efficiency of applications and plan their deployment A hands-on guide to designing Clojure programs to get the best performance Who This Book Is For This book is intended for intermediate Clojure developers who are looking to get a good grip on achieving optimum performance. Having a basic knowledge of Java would be helpful. What You Will Learn Identify performance issues in Clojure programs using different profiling tools Master techniques to achieve numerical performance in Clojure Use Criterium library to measure latency of Clojure expressions Exploit Java features in Clojure code to enhance performance Avoid reflection and boxing with type hints Understand Clojure's concurrency and state-management primitives in depth Measure and monitor performance, and understand optimization techniques In Detail Clojure treats code as data and has a macro system. It focuses on programming with immutable values and explicit progression-of-time constructs, which are intended to facilitate the development of more robust programs, particularly multithreaded ones. It is built with performance, pragmatism, and simplicity in mind. Like most general purpose languages, various Clojure features have different performance characteristics that one should know in order to write high performance code. This book shows you how to evaluate the performance implications of various Clojure abstractions, discover their underpinnings, and apply the right approach for optimum performance in real-world programs. It starts by helping you classify various use cases and the need for them with respect to performance and analysis of various performance aspects. You will also learn the performance vocabulary that experts use throughout the world and discover various Clojure data structures, abstractions, and their performance characteristics. Further, the book will guide you through enhancing performance by using Java interoperability and JVM-specific features from Clojure. It also highlights the importance of using the right concurrent data structure and Java concurrency abstractions. This book also sheds light on performance metrics for measuring, how to measure, and how to visualize and monitor the collected data. At the end of the book, you will learn to run a performance profiler, identify bottlenecks, tune perform... |
| Subject |
Java virtual machine.
|
|
Java virtual machine |
|
Clojure (Computer program language)
|
|
Clojure (Langage de programmation) |
|
Clojure (Computer program language) |
| Added Title |
Become an expert at writing fast and high performant code in Clojure 1.7.0 |
| Other Form: |
Erscheint auch als: Druck-Ausgabe Kumar, Shantanu. Clojure High Performance Programming - Second Edition |
| ISBN |
9781785287671 (electronic bk.) |
|
1785287672 (electronic bk.) |
|
1785283642 |
|
9781785283642 |
|
More Resources