Home > Store

Clojure Recipes

Clojure Recipes

eBook (Watermarked)

  • Your Price: $25.59
  • List Price: $31.99
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

Also available in other formats.

Register your product to gain access to bonus material or receive a coupon.

Description

  • Copyright 2016
  • Dimensions: 7 X 9
  • Pages: 288
  • Edition: 1st
  • eBook (Watermarked)
  • ISBN-10: 0-13-343008-1
  • ISBN-13: 978-0-13-343008-0

“There’s something for everyone here. . . . You can pick up and read this book and build an industry-standard system in a weekend: It has everything you need to get started with a new project. I also found it helpful in reviewing the structure of existing projects.”

—Timothy Pratley, developer 

Developers are discovering the exceptional power of Clojure’s functional programming model to quickly solve problems in domains ranging from social networking to Big Data. Clojure is fast and efficient—ideal for rapid prototyping and lean development. And it is highly expressive and extremely extensible, which makes Clojure one of today’s leading tools for software innovation. Since it targets the Java Virtual Machine, Clojure also leverages the Java platform’s maturity and enormous ecosystem.

Clojure Recipes is a wide-ranging, up-to-date “code recipe book” for this increasingly popular language. With practical and self-contained examples, author Julian Gamble illuminates Clojure’s key features and best practices, showing how to solve real-world problems one step at a time. Focusing on Clojure 1.7 and higher, Gamble fully reflects recent enhancements that ensure you’re getting the most up-to-date code for your project.

Gamble first walks you through the essential steps required to set up your Clojure development environment, from setting up the Leiningen build tool to packaging Clojure for Java EE environments. He then shows you how to build both basic and advanced REST servers, before turning to a wide range of increasingly sophisticated applications.

In this book you will find

  • Innovative Clojure code for diverse web, security, administration, and development tasks, from log reading and app monitoring to software testing
  • Detailed instructions for using concurrency primitives, writing new DSLs, simplifying cloud database development, and more
  • “Learn by doing” projects, which offer practical experience with Clojurescript, Storm, Pedestal, Datomic, and other advanced tools
  • Coverage of using Clojure with Cascalog 2.0 to write complex Hadoop queries with minimal code 

The breadth and quality of Gamble’s examples make Clojure Recipes uniquely valuable both to developers who are exploring Clojure for the first time and to those already using it in production.

Sample Content

Table of Contents

Preface xv

About the Author xix

Chapter 1: Starting Your Project with Leiningen 1

Assumptions 1

Benefits 1

The Recipe–Windows 1

The Recipe–Mac 3

Conclusion 4

Postscript–Setting Up a JDK on a Mac 4

Postscript–Setting Up a JDK on Windows 6

Chapter 2: Packaging Clojure for a Java EE Environment 11

Assumptions 11

Benefits 11

The Recipe–Common 11

Conclusion 14

Postscript–Setting Up Tomcat on a Mac 14

Postscript–Setting Up Tomcat on Windows 16

Chapter 3: Creating a REST Server in Compojure 19

Assumptions 19

Benefits 19

The Recipe–Code 19

Testing the Solution 20

Notes on the Recipe 22

Conclusion 23

Chapter 4: Creating a REST Server with Liberator 25

Assumptions 25

Benefits 25

The Recipe–Code 25

Testing the Solution 28

Notes on the Recipe 29

Context 32

Conclusion 33

Chapter 5: A REST Client in ClojureScript 35

Assumptions 35

Benefits 35

The Recipe–Code 36

Testing the Solution 38

Notes on the Recipe 39

Conclusion 40

Chapter 6: A Simple JSON Server 41

Assumptions 41

Benefits 41

The Recipe–Code 41

Testing the Solution 44

Notes on the Recipe 45

Conclusion 47

Chapter 7: A Simple Server Using the Pedestal Framework 49

Assumptions 49

Benefits 49

Context 49

The Recipe–Code 50

Testing the Solution 52

Notes on the Recipe 53

Conclusion 54

Chapter 8: A Stock Ticker on the Pedestal Framework Server 55

Assumptions 55

Benefits 55

The Recipe–Code 55

Testing the Solution 60

Notes on the Recipe 62

Conclusion 67

Chapter 9: Simplifying Logging with a Macro 69

Assumptions 69

Benefits 69

The Recipe–Code 70

Testing the Solution 72

Notes on the Recipe 74

Conclusion 76

Chapter 10: Extending the Compiler with a Macro 79

Assumptions 79

Benefits 79

The Recipe–Code 79

Testing the Solution 81

Notes on the Recipe 82

Conclusion 85

Chapter 11: Simplifying Datomic Syntax by Writing a DSL 87

Assumptions 87

Benefits 87

The Recipe–Code 88

Testing the Solution 97

Notes on the Recipe 103

Conclusion 106

Chapter 12: Reading the SASS DSL and Generating CSS with Clojure Zippers 107

Assumptions 107

Benefits 107

Outline–Features of SASS 107

The Recipe–Code 109

Testing the Solution 121

Notes on the Recipe 122

Conclusion 133

Chapter 13: Introduction to Cascalog 135

Assumptions 135

Benefits 135

The Recipe–Code 135

Testing the Solution 137

Notes on the Recipe 139

Conclusion 141

Chapter 14: Cascalog and Hadoop 143

Assumptions 143

Benefits 143

The Recipe–Code 143

Testing the Solution 145

Conclusion 146

Postscript–Setting Up Hadoop on a Mac 146

Postscript–Setting Up Hadoop on a Windows Machine 147

Chapter 15: Loading a Data File into Cascalog 149

Assumptions 149

Benefits 149

The Recipe–Code 149

Testing the Solution 150

Conclusion 151

Chapter 16: Writing Out a Data File with Cascalog 153

Assumptions 153

Benefits 153

The Recipe–Code 153

Testing the Solution 154

Notes on the Recipe 155

Conclusion 155

Chapter 17: Cascalog and Structured Data 157

Assumptions 157

Benefits 157

The Recipe–Code 157

Testing the Recipe 159

Notes on the Solution 160

Conclusion 161

Chapter 18: Loading Custom Data Formats into Cascalog 163

Assumptions 163

Benefits 163

The Recipe–Code 163

Testing the Recipe 175

Notes on the Solution 176

Conclusion 177

Chapter 19: Connecting to Datomic from Your Application 179

Assumptions 179

Benefits 179

The Recipe–Code 179

Conclusion 188

Chapter 20: Getting Started with Storm 189

Assumptions 189

Benefits 189

The Recipe–Code 190

Testing the Recipe 192

Notes on the Recipe 192

Conclusion 195

Chapter 21: Getting Started with JMS in Clojure 197

Assumptions 197

Benefits 197

The Recipe–Code 197

Testing the Recipe 200

Notes on the Recipe 200

Conclusion 201

Chapter 22: Integrating Storm and JMS 203

Assumptions 203

Benefits 203

The Recipe–Code 203

Testing the Recipe 213

Notes on the Recipe 213

Conclusion 215

Chapter 23: A CSV Reader 217

Assumptions 217

Benefits 217

The Recipe–Code 217

Testing the Solution 219

Notes on the Recipe 219

Conclusion 220

Chapter 24: Detecting Errors with a Log Monitoring Application 221

Assumptions 221

Benefits 221

The Recipe–Code 221

Testing the Solution 223

Notes on the Recipe 223

Conclusion 224

Chapter 25: Bundling Clojure as an Ant Plug-in 225

Assumptions 225

Benefits 225

The Recipe–Code 225

Testing the Recipe 227

Notes on the Recipe 228

Conclusion 228

Postscript–Installing Ant on a Mac 229

Chapter 26: Bundling Clojure as a Maven Plug-in 231

Assumptions 231

Benefits 231

The Recipe–Code 231

Testing the Recipe 239

Notes on the Recipe 240

Conclusion 240

Chapter 27: Integrating Clojure by Scripting Web Tests 241

Assumptions 241

Benefits 241

The Recipe–Code 241

Testing the Recipe 242

Notes on the Recipe 243

Conclusion 243

Chapter 28: Monitoring Availability with a Website Status Checker 245

Assumptions 245

Benefits 245

The Recipe–Code 246

Testing the Recipe 247

Notes on the Recipe 249

Conclusion 249

Appendix A: Debugging Macros 251

Assumptions 251

Benefits 251

The Recipe 251

Conclusion 259

Index 261

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership