English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 15h 14m | 2.27 GB
The Joy of Clojure, Second Edition is a deep account of the Clojure language. Fully updated for Clojure 1.6, this edition goes beyond the syntax to show you how to write fluent Clojure code. You’ll learn functional and declarative approaches to programming and will master techniques that make Clojure elegant and efficient. The book shows you how to solve hard problems related to concurrency, interoperability, and performance, and how great it can be to think in the Clojure way.
The Clojure programming language is a dialect of Lisp that runs on the Java Virtual Machine and JavaScript runtimes. It is a functional programming language that offers great performance, expressive power, and stability by design. It gives you built-in concurrency and the predictable precision of immutable and persistent data structures. And it’s really, really fast. The instant you see long blocks of Java or Ruby dissolve into a few lines of Clojure, you’ll know why the authors of this book call it a “joyful language.” It’s no wonder that enterprises like Staples are betting their infrastructure on Clojure.
Inside:
- Build web apps using ClojureScript
- Master functional programming techniques
- Simplify concurrency
- Covers Clojure 1.6
Table of Contents
1 Clojure philosophy
2 Clarity
3 Why a(nother) Lisp
4 But what’s with all the parentheses
5 Functional programming
6 Why Clojure isn’t especially object-oriented
7 Most of what OOP gives you, Clojure provides
8 Drinking from the Clojure fire hose
9 Floating-point numbers
10 Putting things together – collections
11 Making things happen – calling functions
12 Functions with multiple arities
13 Locals, loops, and blocks
14 Preventing things from happening – quoting
15 Using host libraries via interop
16 Exceptional circumstances
17 Dipping your toes in the pool
18 Nil pun with care
19 Destructuring with a map
20 Using the REPL to experiment
21 Putting it all together
22 On scalars
23 Trying to be rational
24 When to use keywords
25 Symbolic resolution
26 Regular expressions—the second problem
27 Collection types
28 Sequence terms and what they mean
29 Big-O
30 Vectors – creating and using them in all their varieties
31 Vectors as stacks
32 Vectors as map entries
33 Lists – Clojure’s code-form data structure
34 How to use persistent queues
35 Persistent sets
36 Thinking in maps
37 Putting it all together – finding the position of items in a sequence
38 Being lazy and set in your ways
39 Structural sharing – a persistent toy
40 Laziness
41 Losing your head
42 Putting it all together – a lazy quicksort
43 Functional programming
44 Higher-order functions
45 Pure functions
46 On closures
47 Sharing closure context
48 Thinking recursively
49 Tail calls and recur
50 Don’t forget your trampoline
51 Putting it all together – A_ pathfinding
52 Macros
53 Syntax-quote, unquote, and splicing
54 Defining control structures
55 Macros combining forms
56 Using macros to control symbolic resolution time
57 Using macros to manage resources
58 Combining data and code
59 Expose only what’s needed
60 Exploring Clojure multimethods with the Universal Design Pattern
61 Ad hoc hierarchies for inherited behaviors
62 Types, protocols, and records
63 Protocols
64 Sharing method implementations
65 Building from a more primitive base with deftype
66 Clojure implementation
67 Mutation and concurrency
68 Using refs for a mutable game board
69 The things that STM makes easy
70 Refactoring with refs
71 Vulgar change with ref-set
72 When to use agents
73 The difference between send and send-off
74 When to use atoms
75 When to use locks
76 Vars and dynamic binding
77 Dynamic scope
78 Parallelism
79 Futures as callbacks
80 When to use promises
81 Parallel operations
82 A brief introduction to reducer_fold
83 Java.next
84 A simple dynamic web service
85 Anaphoric proxy
86 Clojure gen-class and GUI programming
87 Clojure’s relationship to Java arrays
88 All Clojure functions implement …
89 Using Clojure data structures in Java APIs
90 The definterface macro
91 Be wary of exceptions
92 Handling exceptions
93 Why ClojureScript
94 Compiler internals – analysis vs. emission
95 Web Audio
96 Advanced compilation
97 Generating an externs.js file
98 Compile vs. run
99 Data-oriented programming
100 Common ways to derive information from data
101 Data as data
102 The benefits of value
103 Tagged literals
104 Data as code
105 Case study – simple event sourcing
106 Simulation testing
107 Code as data as code
108 Putting parentheses around the specification
109 Performance
110 Transients
111 Chunked sequences
112 Memoization
113 Understanding coercion
114 Reducibles
115 More reducing function transformers
116 Performance of reducibles
117 The fold function – reducing in parallel
118 Thinking programs
119 A brute-force Sudoku solver
120 Thinking data via unification
121 Substitution
122 An introduction to core.logic
123 Subgoals
124 Constraints
125 Solving Sudoku with finite domains
126 Clojure changes the way you think
127 Implementing a SQL-like DSL to generate queries
128 Testing
129 Contracts programming
130 Invisible design patterns
131 Clojure’s first-class design patterns
132 Iterator pattern
133 Error handling and debugging
134 Debugging
Resolve the captcha to access the links!