Download E-books Clojure in Action PDF

By Amit Rathore

Summary

Clojure in Action is a hands-on educational for the operating programmer who has written code in a language like Java or Ruby, yet has no previous adventure with Lisp. It teaches Clojure from the fundamentals to complicated subject matters utilizing functional, real-world software examples. Blow throughout the idea and dive into useful concerns like unit-testing and setting set-up, all through development a scalable web-application utilizing domain-specific languages, Hadoop, HBase, and RabbitMQ.
About the Technology
Clojure is a contemporary Lisp for the JVM, and it has the strengths you'd count on: top notch features, macros, aid for sensible programming, and a Lisp-like, fresh programming style.
About this Book
Clojure in Action is a pragmatic advisor enthusiastic about utilising Clojure to functional programming demanding situations. You'll commence with a language educational written for readers who already be aware of OOP. Then, you'll dive into the use instances the place Clojure fairly shines: country administration, secure concurrency and multicore programming, firstclass code iteration, and Java interop. In every one bankruptcy, you'll first discover the original features of an issue sector after which detect the right way to take on them utilizing Clojure. alongside the way in which, you'll discover useful concerns like structure, unit checking out, and set-up as you construct a scalable net program that comes with customized DSLs, Hadoop, HBase, and RabbitMQ.

buy of the print booklet comes with a proposal of a unfastened PDF, ePub, and Kindle booklet from Manning. additionally to be had is all code from the book.
What's Inside* A fast paced Clojure tutorial
* growing net prone with Clojure
* Scaling via messaging
* developing DSLs with Clojure's macro system
* Test-driven improvement with Clojure
* dispensed programming with Clojure and more

This publication assumes you're conversant in an OO language like Java, C#, or C++, yet calls for no historical past in Lisp or Clojure itself.

==================================
Table of Contents<ol><h5>PART 1 GETTING STARTED</h5> * advent to Clojure
* A whirlwind tour
* construction blocks of Clojure
* Polymorphism with multimethods
* Clojure and Java interop
* country and the concurrent world
* Evolving Clojure via macros
<h5>PART 2 GETTING genuine </h5> * Test-driven improvement and more
* facts garage with Clojure
* Clojure and the web
* Scaling via messaging
* information processing with Clojure
* extra on practical programming
* Protocols, files, and type
* extra macros and DSLs
</ol>

Show description

Read or Download Clojure in Action PDF

Best Java books

Scientific Data Analysis using Jython Scripting and Java (Advanced Information and Knowledge Processing)

Clinical facts research utilizing Jython Scripting and Java offers sensible ways for information research utilizing Java scripting in accordance with Jython, a Java implementation of the Python language. The chapters basically disguise all points of information research, from arrays and histograms to clustering research, curve becoming, metadata and neural networks.

Additional info for Clojure in Action

Show sample text content

You’ve been bitten through the most-Javaobjects-are-not-immutable challenge. simply because d is a mutable item, and you’re calling increment-day, increment-month, and increment-year on it, you’re collecting the mutations, leading to a last date of "2010-12-01". As an aspect be aware, this additionally illustrates how effortless it's to get used to Clojure’s immutability after which to count on every little thing to act like Clojure’s center information buildings. inside a couple of days of utilizing Clojure, you’ll start to ask yourself why you ever inspiration mutable items have been a good suggestion! with the intention to tackle this challenge, you’ll go back a brand new date from every one mutator functionality. The clone approach in Java does this, and you may use it on your new definitions: (defn increment-day [d] (doto (. clone d) (. upload Calendar/DAY_OF_MONTH 1))) (defn increment-month [d] (doto (. clone d) (. upload Calendar/MONTH 1))) (defn increment-year [d] (doto (. clone d) (. upload Calendar/YEAR 1))) With this modification, the exams all move, permitting us to take on decrementing. back, commence with the try: (deftest test-decrementing-date (let [d (date "2009-11-01") n-day (decrement-day d) n-month (decrement-month d) n-year (decrement-year d)] (is (= (as-string n-day) "2009-10-31")) (is (= (as-string n-month) "2009-10-01")) (is (= (as-string n-year) "2008-11-01")))) To get this attempt to cross, you could select an analogous constitution of features that did the incrementing. The code could seem like the subsequent: Getting began with TDD 177 (defn decrement-day [d] (doto (. clone d) (. upload Calendar/DAY_OF_MONTH -1))) (defn decrement-month [d] (doto (. clone d) (. upload Calendar/MONTH -1))) (defn decrement-year [d] (doto (. clone d) (. upload Calendar/YEAR -1))) This passes the exams. you presently have code that works and a library that could settle for date strings and go back dates as strings. it could possibly additionally increment and decrement dates through days, months, and years. however the code isn’t particularly optimum, and we’re now going to enhance it. REFACTOR MERCILESSLY severe programming (XP) is an agile technique that espouses numerous particular guidance. certainly one of them is to “refactor mercilessly. ” It implies that you might want to constantly try to make code (and layout) easier through elimination litter and pointless complexity. a massive a part of attaining such simplicity is to take away duplication. You’ll do this with the code you’ve written to this point. earlier than you begin, it’s pertinent to make a remark. There’s one significant requirement to any type of refactoring; to ensure that it to be secure, there should be a suite of assessments that could be sure that not anything broke as a result refactoring. this can be one other good thing about writing exams (and TDD in general). Our checks from the former part will serve this objective. Let’s commence our refactoring by way of addressing the duplication within the increment/ decrement services. Here’s a rewrite of these capabilities: (defn date-operator [operation box] (fn [d] (doto (. clone d) (. upload box (operation 1))))) (def increment-day (date-operator + Calendar/DAY_OF_MONTH)) (def increment-month (date-operator + Calendar/MONTH)) (def increment-year (date-operator + Calendar/YEAR)) (def decrement-day (date-operator - Calendar/DAY_OF_MONTH)) (def decrement-month (date-operator - Calendar/MONTH)) (def decrement-year (date-operator - Calendar/YEAR)) After changing all six of the previous services with this code, the exams nonetheless go.

Rated 4.93 of 5 – based on 38 votes