Functional Thinking: Paradigm Over Syntax

Functional Thinking: Paradigm Over Syntax

by Neal Ford


$35.99 $39.99 Save 10% Current price is $35.99, Original price is $39.99. You Save 10%.
View All Available Formats & Editions
Choose Expedited Shipping at checkout for guaranteed delivery by Friday, February 22

Product Details

ISBN-13: 9781449365516
Publisher: O'Reilly Media, Incorporated
Publication date: 07/26/2014
Pages: 180
Sales rank: 1,257,694
Product dimensions: 6.90(w) x 9.00(h) x 0.40(d)

About the Author

Neal is Director, Software Architect, and Meme Wrangler at ThoughtWorks, a global IT consultancy with an exclusive focus on end-to-end software development and delivery. Before joining ThoughtWorks, Neal was the Chief Technology Officer at The DSW Group, Ltd., a nationally recognized training and development firm.

Neal has a degree in Computer Science from Georgia State University specializing in languages and compilers and a minor in mathematics specializing in statistical analysis. He is also the designer and developer of applications, instructional materials, magazine articles, and video presentations. He is also the author of 6 books, including the most recent Presentation Patterns and Functional Thinking. Given his degree, Neal is a bit of a language geek, with affections including but not limited to Ruby, Clojure, Java, Groovy, JavaScript, Scala and C#/.NET. His primary consulting focus is the design and construction of large-scale enterprise applications. Neal is an internationally acclaimed speaker, having spoken at over 300 developer conferences worldwide, delivering more than 2000 presentations. If you have an insatiable curiosity about Neal, visit his web site at He welcomes feedback and can be reached at

Table of Contents

Preface vii

1 Why 1

Shifting Paradigms 2

Aligning with Language Trends 4

Ceding Control to the Language/Runtime 4

Concision 5

2 Shift 11

A Common Example 11

Imperative Processing 11

Functional Processing 12

Case Study: Number Classification 17

Imperative Number Classification 17

Slightly More Functional Number Classification 19

Java 8 Number Classifier 21

Functional Java Number Classifier 22

Common Building Blocks 24

Filter 24

Map 25

Fold/Reduce 29

Synonym Suffering 31

Filter 31

Map 34

Fold/Reduce 36

3 Cede 39

Iteration to Higher-Order Functions 39

Closures 40

Currying and Partial Application 44

Definitions and Distinctions 44

In Groovy 45

In Clojure 47

Scala 47

Common Uses 51

Recursion 52

Seeing Lists Differently 52

Streams and Work Reordering 56

4 Smarter, Not Harder 59

Memoization 59

Caching 60

Adding Memoization 63

Laziness 70

Lazy Iterator in Java 70

Totally Lazy Number Classifier 72

Lazy Lists in Groovy 74

Building a Lazy List 77

Benefits of Laziness 80

Lazy Field Initialization 82

5 Evolve 83

Few Data Structures, Many Operations 83

Bending the Language Toward the Problem 85

Rethinking Dispatch 86

Improving Dispatch with Groovy 86

Clojure's "Bendable" Language 87

Clojure Multimethods and a la carte Polymorphism 89

Operator Overloading 91

Groovy 91

Scala 93

Functional Data Structures 95

Functional Error Handling 96

The Either Class 97

The Option Class 105

Either Trees and Pattern Matching 106

6 Advance 113

Design Patterns in Functional Languages 113

Function-Level Reuse 114

Template Method 116

Strategy 118

The Flyweight Design Pattern and Memoization 119

Factory and Currying 122

Structural Versus Functional Reuse 124

Code Reuse Via Structure 124

7 Practical Thinking 133

Java 8 135

Functional Interfaces 135

Optional 136

Java 8 Streams 136

Functional Infrastructure 137

Architecture 137

Web Frameworks 141

Databases 142

8 Polyglot and Polyparadigm 145

Combining Functional with Metaprogrammmg 146

Mapping Data Types with Metaprogrammmg 147

Infinite Streams with Functional Java and Groovy 148

Consequences of Multiparadigm Languages 150

Context Versus Composition 151

Functional Pyramid 154

Index 159

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews