In weniger als einer Minute können Sie mit dem Lesen von Clojure Programming auf Ihrem Kindle beginnen. Sie haben noch keinen Kindle? Hier kaufen oder mit einer unserer kostenlosen Kindle Lese-Apps sofort zu lesen anfangen.

An Ihren Kindle oder ein anderes Gerät senden


Kostenlos testen

Jetzt kostenlos reinlesen

An Ihren Kindle oder ein anderes Gerät senden

Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Keine Abbildung vorhanden


Clojure Programming [Kindle Edition]

Chas Emerick , Brian Carper , Christophe Grand
4.3 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)

Kindle-Preis: EUR 19,46 Inkl. MwSt. und kostenloser drahtloser Lieferung über Amazon Whispernet

Kostenlose Kindle-Leseanwendung Jeder kann Kindle Bücher lesen  selbst ohne ein Kindle-Gerät  mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.

Geben Sie Ihre E-Mail-Adresse oder Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 19,46  
Taschenbuch EUR 31,95  



Clojure is a practical, general-purpose language that offers expressivity rivaling other dynamic languages like Ruby and Python, while seamlessly taking advantage of Java libraries, services, and all of the resources of the JVM ecosystem. This book helps you learn the fundamentals of Clojure with examples relating it to the languages you know already, in the domains and topics you work with every day. See how this JVM language can help eliminate unnecessary complexity from your programming practice and open up new options for solving the most challenging problems.

Clojure Programming demonstrates the language’s flexibility by showing how it can be used for common tasks like web programming and working with databases, up through more demanding applications that require safe, effective concurrency and parallelism, data analysis, and more. This in-depth look helps tie together the full Clojure development experience, from how to organize your project and an introduction to Clojure build tooling, to a tutorial on how to make the most of Clojure’s REPL during development, and how to deploy your finished application in a cloud environment.

  • Learn how to use Clojure while leveraging your investment in the Java platform
  • Understand the advantages of Clojure as an efficient Lisp for the JVM
  • See how Clojure is used today in several practical domains
  • Discover how Clojure eliminates the need for many verbose and complicated design patterns
  • Deploy large or small web applications to the cloud with Clojure

Über den Autor und weitere Mitwirkende

Chas Emerick is the founder of Snowtide Informatics, a small software company in Western Massachusetts where he is the technical lead for PDFTextStream, a PDF content extraction library for Java and .NET. He has been a consistent presence in the Clojure community since early 2008, has had contributions included in the core language, been involved in dozens of Clojure open source projects, and was an invited speaker at the first Clojure Conj in 2010. Chas writes about Clojure, software development practices, entrepreneurship, and other passions at Brian Carper is a professional programmer in the field of psychological research. Since 2008 he's used Clojure for data analysis and web development at work and at home. He's the author of a Clojure-to-CSS compiler and relational database library, and writes about Clojure and other topics at Christophe Grand is an independent consultant, based near Lyon, France. He tutors, trains and codes primarily in Clojure. He joined the Clojure Community in 2008, and became a contributor to the core language. He also authored of the Enlive and Moustache libaries and is a contributor to Counterclockwise, the Clojure IDE for Eclipse. Christophe was a speaker at the first Clojure Conj and writes on Clojure at


  • Format: Kindle Edition
  • Dateigröße: 2471 KB
  • Seitenzahl der Print-Ausgabe: 630 Seiten
  • Gleichzeitige Verwendung von Geräten: Keine Einschränkung
  • Verlag: O'Reilly Media; Auflage: 1 (30. März 2012)
  • Verkauf durch: Amazon Media EU S.à r.l.
  • Sprache: Englisch
  • ASIN: B007Q4T040
  • Text-to-Speech (Vorlesemodus): Aktiviert
  • X-Ray:
  • Word Wise: Nicht aktiviert
  • Durchschnittliche Kundenbewertung: 4.3 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
  • Amazon Bestseller-Rang: #76.897 Bezahlt in Kindle-Shop (Siehe Top 100 Bezahlt in Kindle-Shop)

  •  Ist der Verkauf dieses Produkts für Sie nicht akzeptabel?

Mehr über die Autoren

Entdecken Sie Bücher, lesen Sie über Autoren und mehr


4 Sterne
2 Sterne
1 Sterne
4.3 von 5 Sternen
4.3 von 5 Sternen
Die hilfreichsten Kundenrezensionen
5 von 5 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Ausgezeichnete Einführung mit Tiefgang 18. Mai 2012
Von kb
Format:Taschenbuch|Verifizierter Kauf
Das ist eine Einführung in Clojure, die diesen Namen wirklich verdient: die Autoren schaffen es, Clojure nicht nur als "noch eine JVM-Sprache mit komischer Syntax" zu vermitteln, sondern wirklich von Grund auf die besonderen Eigenschaften der Sprache (und ihrer Vorfahren) zu erklären. Das hilft ungemein, sich hineinzudenken und auch zu sehen, wie das Ganze elegant mit dem Java-Ökosystem verflochten ist. Die unzähligen Tips zu Stil und Organisation zeigen, dass Emerick et al. aus Praxiserfahrung schöpfen - und so fühlt man sich mit dem Buch durchaus gerüstet, auch etwas größere Projekte anzugehen. Der Text basiert auf Clojure 1.4 und ist somit per Mai 2012 am aktuellsten Stand.

Ein großes Lob auch ans Lektorat: der Schreibstil ist flüssig, freundlich, und doch ohne irrelevantes Geschwätz. Man bleibt auch nicht ständig an Rechtschreib- oder Grammatikfehlern hängen, wie das bei vielen schleißig produzierten IT-Fachbüchern der Fall ist.

Fazit: eine bessere Clojure-Einführung wird man derzeit kaum finden. Ein Buch "for Dummies" ist es aber nicht, die Lernkurve ist durchaus nicht zu unterschätzen.
War diese Rezension für Sie hilfreich?
5.0 von 5 Sternen An excellent introduction 23. April 2014
Format:Kindle Edition|Verifizierter Kauf
This book doesn't just tell you how to do things in Clojure, it also tells you why you're supposed to do them that way, which is probably the one thing that makes a programming book great, at least in my eyes. Clojure is a very consistent, simple and (in my opinion) well-designed language which is focused on a few core concepts. This book does a very good job at highlighting the core concepts of the language. Immutability, pure functions, functions as first-class values and homoiconicity are emphasized throughout the book. The more practical aspects of the language, such as very simple Java interop and type hints are explained as well. There is also a very good chapter on concurrency and parallelism with Clojure. The writing style is neither academic nor too laid back and jokey and the supplied code examples (such as an implementation of Conway's Game of Life, Mandelbrot fractal, a maze generator) are a lot more interesting than in most programming books and well-explained.
War diese Rezension für Sie hilfreich?
Format:Kindle Edition|Verifizierter Kauf
Das Buch ist fuer sehr erfahrene Entwickler geeignet. Es geht aber dafuer aber sehr in die tiefe was Clojure alles kann. Leider fehlt es oft an Beispielen. Ich musste weil es auch nach vielen Kapiteln trocken war, dann abbrechen. Ich hoffe ich schaffe es mal zu Ende zu lesen, wenn ich mit einem anderen Buch etwas Uebung bekommen habe.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf (beta) 4.4 von 5 Sternen  38 Rezensionen
39 von 40 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Practical and accessible 22. April 2012
Von Publius - Veröffentlicht auf
This is the most practical book on Clojure I've seen yet. At this point I've almost completely made my way through it. I bought it directly from O'Reilly (not Amazon) because I wanted it in PDF format.

I think what I like most about this book is that the authors have most often chosen to explain things in reference to scripting languages like Ruby and Python, and from business and mundane-data examples, rather than using examples from mathematics or computer science. This choice has made Clojure's power very accessible and easy for me, coming from a linux (Bash, Python, C) and web development (PHP, Ruby, Javascript), background and without any math or CS degrees. I am very grateful to the authors for writing it in such a down-to-earth way so that I have been able to absorb it easily.

I also enjoyed the extensive chapters on the practical use of the language, for things like web development, database access, tooling, and packaging. Also, their approach to discussing Java interop was very helpful to me not having dealt with Java much in the past.

Their extensive use of footnotes to comment their code examples is very helpful. When I find myself reading a line of example code and wondering why they did it that way, the footnote answers my question clearly and simply. I might have preferred actual inline comments rather than footnotes-- less jumping around in the PDF-- but the content is great.

In general, while reading it, every question that comes up in my mind seems to be answered within that paragraph or the next one (or in a footnote); the overall flow of the book and the path they've taken for building one concept upon another seemed very natural to me.

Even though it's easy to read linearly, I also found it very easy to skip around as well. I found many of the chapters in the Practicum section to be as good or better than the documentation for the projects they describe. The authors seem to account for the fact that readers might do that, and provide links throughout those chapters to earlier chapters of the book. I tend to reach for the book instead of for the documentation for some projects; it's useful as a HOW-TO.

I don't know if people who have a lot of lisp experience or CS degrees would be as grateful for this book as I am. But it has made learning a very powerful language into a fairly painless and straightforward process for me.

If you're coming to Clojure from languages like Ruby, Python, Javascript, etc., I'd recommend "Clojure Programming" as your first step.
23 von 24 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A clear, comprehensive, and effective guide to Clojure 23. April 2012
Von Avi Flax - Veröffentlicht auf
Before reading this book, I was proficient with Java, JavaScript, Python, and a few other languages -- all primarily object-oriented and ALGOL-derived. Lisp and Functional Programming (FP) seemed alien and bizarre. But after hearing that people were getting real work done using FP with Scala and Clojure, and hearing Rich Hickey, the creator of Clojure, speak at Strange Loop, I was inspired to get over my apprehension and learn functional programming and Clojure.

I decided it would be unwise to try to learn FP and Clojure at the same time, so I first wrote a program using FP in languages with which I was already familiar: CoffeeScript and Scala. It didn't take long for me to build an appreciation for the paradigm.

Once I felt that I had a decent understanding of FP, I asked on Twitter whether anyone could recommend a book, and got a very enthusiastic recommendation for this one from Sean Corfield. It was available under O'Reilly's pre-release program, so I was able to buy and read pre-release PDFs of the book.

The bottom line is that this book gave me a solid understanding of Clojure and enabled me to learn the language and gradually start using it. The concepts are presented in a thoughtful sequence wherein each one builds on the next, and it's made clear how each element of the language relates to the others.

The writing, examples, and organization are all excellent. And the book gets extra points for going beyond just explaining the language and how to use it, by being extra-comprehensive and covering how to really use the full Clojure ecosystem to build really useful software.

This is worth highlighting: if the book had been comprised of only chapter 1, "Down the Rabbit Hole", and the first 2 parts, "Functional Programming and Concurrency" and "Building Abstractions", it would have been an excellent book which I'd be recommending wholeheartedly. The inclusion of the subsequent parts, "Tools, Platform, and Projects", "Practicums", and "Miscellanea" make the book an invaluable resource and a fantastic value.

Ultimately, the book succeeds in conveying not only Clojure the language, but also the Clojure way, best practices, and key resources.
11 von 11 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen outstanding Clojure introduction for smart programmers 19. Mai 2012
Von R. Friesel Jr. - Veröffentlicht auf
In "Clojure Programming", the preface asks "Who is this book for?" It's for a lot of people: experienced JVM developers, curious Rubyists, dissatisfied Pythonistas... Developers of all stripes that are looking to get introduced to, and become proficient in, Clojure. I myself have been circling the Clojure drainpipe for a while now, very nearly getting completely sucked in on numerous occasions. I've followed no one's advice though--I have not started small, and instead keep jumping into sophisticated middle parts and getting mired. [1] I think I would have benefitted from this book a year ago; I'm certainly benefitting from it now.

At 587 pages [2], "Clojure Programming" is hardly a tome, but it is comprehensive, appreciably thorough, and makes a concerted effort to be accessible to the Clojure and JVM neophyte. That being said, the book is also far from short, and makes no pretenses about easing you into the language: you'll be programming a naïve REPL by the end of chapter one. But this head-first approach is one of the reasons to love this book.

Emerick et al. found an excellent format for organizing the book, logically sequencing the material, and peppering chapters and sections with the right kind of illustrative, "koan"-style sample problems, eschewing the alternative of walking you through some contrived and over-arching application built one concept (and thus one chapter) at a time. As such, the book is broken into five sections:

1. Functional Programming and Concurrency (the foundation);
2. Building Abstractions (the sophisticated stuff);
3. Tools, Platform, and Projects (the eco-system);
4. Practicums (Clojure in the real world); and
5. Miscellanea (other important stuff).

What's marvelous about this structure is that you can decide for yourself whether to read it cover-to-cover, or whether to cherry-pick just the chapters relevant to your immediate challenges. What's helpful is that the book cross-references itself for many key concepts. In the thick of chapter one and you don't know what this "classpath" nonsense is? Jump ahead to chapter eight! [3] Deep into chapter nine and you're lost about how Clojure protocols relate to Java's interfaces? A footnote steers you back to chapter six! The care taken to create these kinds of cross-references is tremendously valuable because it allows you to opt-in to some advanced concepts early on, getting a preview of the powerful features ahead of you.

Though "Clojure Programming" is overflowing with thoughtful, detailed, and well-composed information, where it really shines is the "Practicums" section. When I first started skimming the chapters in this section, the first thought that occurred to me was: "Herein lies the true esoterica." I read about Clojure's numerics and mathematics, about its intriguing use of "rationals", about unchecked operations. I read about how to idiomatically implement different design patterns in Clojure. The deeper I got into this section though, the more that I realized that this was not a bunch of "out there" riddles and puzzles whose only purpose was to show off the sparkling fringes--no, this section was to demonstrate Clojure's solutions to "real world" problems, and the kind of advantages afforded you by its functional style. [4] That being said, I appreciated how Emerick et al. were vigilant in observing when different approaches or language features would serve you well, and when you would be wise to avoid them.

A few other items that I feel compelled to point out:

* The chapter on Java and JVM interoperability is strong. Anyone looking to introduce Clojure into their (JVM-based) organization would be wise to memorize this information...
* ...and then also memorize the chapter that specifically addresses how to go about introducing Clojure to your organization.
* As with the other Clojure texts I've read, their is a focus on discussing "idiomaticity", and differentiating between "working" or "valid" Clojure code, and <em>idiomatic</em> Clojure code. Seeing this again makes me wish that more authors writing about other languages put this much emphasis on idiomatic style.
* Also, I am filled with tremendous gratitude that Emerick et al., when they cite Wikipedia at all, cite particular articles as "a jumping off point" or as "a surprisingly good resource" for the subject matter. I have read several books recently that cite Wikipedia as an authoritative reference and... Well, I find that to be in bad form.

I find it easy to recommend "Clojure Programming" to anyone with an interest in the language. There is enough "introductory" material that smart programmers will be guided in the right directions as they get started, but there is also enough detailed coverage that the book will grow right along with you. The chapters on the Clojure eco-system will help to steer you toward the right tools and resources to organize, manage, and scale your projects--as well as how to integrate them laterally within the JVM. Lastly, the practicums give you concrete and balanced approaches to answering some of the questions that you go into the whole endeavor already asking. I will be referring to this book often as I continue my explorations into Clojure.


[1] Case study: the first significant chunk of time I spent with the language was with early drafts of The Joy of Clojure: Thinking the Clojure Way. "JoC" is definitely an "intermediate-to-advanced" book.

[2] Not counting the preface and index, which brings that up to 630.

[3] Which, I'd like to add, is currently my favorite semi-layman's explanation of the JVM's classpath.

[4] I suppose this should have been obvious from the name of the section. (What can I say? I got caught up in the details of rational numbers.)
11 von 12 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Most well-rounded Clojure title yet 26. Juni 2012
Von Brian - Veröffentlicht auf
Prior to reading Clojure Programming, I had read several Clojure books, including Programming Clojure, Clojure in Action, and The Joy of Clojure.

Clojure Programming strikes a great balance between the practical and the abstract. The book is full of practical advice such as how to use build tools, how to compose several libraries (ring, compojure, and enlive) into a web stack, and how to use popular database libraries, there is also a lot of great advice on more abstract ideas, such as how to move from an object-oriented perspective to a functional programming perspective (Chapter 12, Design Patterns, is great for some quick examples of how design patterns in some programming languages just go away because of some of the facilities of a functional programming language such as Clojure). I think the book is very approachable for programmers coming from another language such as Ruby, Python, or Java. In fact, there are even code samples translated from those languages to Clojure.
15 von 18 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Good exposition 15. Juli 2012
Von Matan - Veröffentlicht auf
Format:Kindle Edition|Verifizierter Kauf
This book is a good exposition. It is extremely well written - the quality of editing is superior. The writing is crystal clear and eloquent.
Whether it is a book you can read (or practice the examples contained therein) and then go write your first purposed Clojure programs? not sure yet. I am not sure it was meant to be, but in any event it is probably not. Not enabling writing real-purposed code probably relates to the organization, which is story-like and evolving rather than making sure it could also be used to later find what you need to recollect in more of a reference style. Acknowledging many programming books are like that, this is not particular to this book. And so my 3 star rating relates to not fulfilling this expectation of going from background-only to coding-ability along with reading the book, which probably means much about me not only about the book. Otherwise it would be 4.

Apart from the above, I have several specific comments that may possibly be useful to consider for some future edition. Chapter 6 dealing with datatypes and protocols is not as clear in my mind as I could wish for. It leaves me wondering how is it all related to the long discussions of functional beauty that precede, and a bit unclear as to when should they be used, likewise the discussion about multi-methods in chapter 7. It seems the book should be more careful in connecting these topics to the long discussions about pure functional programming and data immutability spread throughout the book. Discussions of mutating data should deal with the overall aspect of encouraging immutability in a more balanced way, rather than 'slipping them through' as if you won't notice they break that paradigm. The last chapters should optimally be not a book chapter but an online site.

Clojure showtime-readiness seems to be over glorified in the book. I found the power of the REPL a bit over-glorified. The sections about using the REPL in production and hot-swapping code in production seem to be representing a bit of a naive approach, which perhaps should have been curbed or better delineated. Likewise some of the mentioned IDE setups don't work that well or are just laborious or barely documented in detail on the Internet. Comments about performance penalties and mentioning of 'performance hinting' are spread around raising some doubts about scaling the code. Clojure compilation errors are very ugly, blending Java and somewhat vague Clojure error descriptions. Working with Clojure is much more brittle than the book tries to imply, waiting for the light-table project to improve that... so this book may portray the correct picture that will exist a year from now when these 'language readiness aspects' are more carefully dealt with in the community, but bestows excessive credit to ease-of-use at present. These problems relate to the Clojure ecosystem but the book could have been more realistic in acknowledging them. It could have said that Clojure is a cutting-edge ecosystem and you can get cut when dealing with the cutting edge until you get it tamed.

I disclaim that I am not a battle-proven Java, Ruby or Python developer, and so my review should be taken in this context and may not apply to those who are.
Indeed perhaps I am not the audience for this book. Whether you can *learn* a new language from a book is questionable. This book is a very good exposition. The many code snippet examples require using your head not just reading abstract texts, so be ready to exercise your neurons while reading this book. It will give you a good basis in exchange for many hours of reading, but will leave you looking for practical ways to learn the language into your fingers.

You have to appreciate that Clojure information on the Internet is scant and possibly at times misleading.
Without this exposition, maybe you would not even be able to start off. I would say this book is an exposition to practicing in and to learning in a more deliberate way. Frankly, as such it may serve its purpose very well!
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Erster Beitrag:
Eingabe des Log-ins

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen

Ähnliche Artikel finden