What do you think?
Rate this book
Clojurescript: Up and Running
Learn how to build complete client-side applications with ClojureScript, the Clojure language variant that compiles to optimized JavaScript. This hands-on introduction shows you how ClojureScript not only has similarities to JavaScript―without the flaws―but also supports the full semantics of its parent language. You’ll delve into ClojureScript’s immutable data structures, lazy sequences, first-class functions, macros, and support for JavaScript libraries. No previous experience with Clojure or ClojureScript is necessary. If you’re familiar with JavaScript, HTML, CSS, and the DOM, you’ll quickly discover that ClojureScript has the same reach as JavaScript, but with more power.
116 pages, Paperback
First published August 22, 2012
3 people are currently reading
63 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 18 of 18 reviews
September 4, 2016
Skimmable introductory book. It is rich on trivia and plumbing, which made the book age very badly since the initial publication. Most of the content is invalidated by newer build tools and frameworks anyway.
January 18, 2021
Very high level
You can find all of this information online, this book does not cover anything that is not available on the clojurescript website.
You can find all of this information online, this book does not cover anything that is not available on the clojurescript website.
February 3, 2013
Good introduction into ClojureScript. It tries to cover both basics of Clojure together with ClojureScript, but for people who know Clojure this isn't required, while for novice, they should read other Clojure book anyway, so about half of the book could be omitted.
Most of content from the book already available on ClojureScript's wiki, and in great series of articles at
Most of content from the book already available on ClojureScript's wiki, and in great series of articles at
December 18, 2012
An (apocryphal?) tale:[^1] when Brendan Eich unveiled the original JavaScript (nee LiveScript, nee Mocha) prototype at (then) Netscape, it was a Lisp.[^2] It was only at management's insistence that the language received a C-like syntax, and even then it was mostly to have some kind of syntactic parity with Java (with which it was supposed to provide some "glue"). Now: if you think about JavaScript using this lens, then it is easy to conjure up images of as "the JavaScript that could have been".[^3]
And that is exactly what we have in Sierra and VanderHart's ClojureScript: Up and Running -- a guided quickstart to the language that JavaScript could have been. And what an interesting little language it is!
Sierra and VanderHart deliver an excellent introduction to ClojureScript, which is targeted at a sufficiently broad audience of Clojure developers, JavaScript developers, and developers of all other stripes looking to do some discovery. You don't need to know Clojure going in,[^4] but I suspect you'll want to know at least a little JavaScript. From there, they take you through installing ClojureScript, installing and working with the build tool, the core syntax, and... it goes upward from there. Just as the title suggests: there's everything that you need to get started. By the time you walk away from the book,[^5] you should be able to confidently say what ClojureScript is, what motivated its creation, and you should have enough of the basics down that you could write a trivial application with it. (Perhaps even something more "intermediate" level, if you're patient and persistent.)
Before we go any further, a few words about what the book is not:
* It is not a comprehensive language guide.
* It is not a thorough introduction to Clojure.
* It is not a primer on JavaScript.
* It is not a nitty-gritty low-level reference.[^6]
Now, for as easy as it is to recommend ClojureScript: Up and Running, I did find myself with a few critiques.
First, as someone who likes JavaScript and enjoys writing it, there are some borderline inflammatory statements in here. There's the line about having a "cleaner syntax"; and we all know the volumes-upon-volumes of blog posts, forum threads, and flame wars that are already out there about statements like this one. Then there's that line about how "JSON is a feeble data format"; and I find myself thinking I've never felt limited by JSON... These statements read like trolling, and they distract a bit from the salient points being made. (See also: "Stop taking these things so personally.")
However, this leads me to my second critique: that (again: as someone who lives and breathes JavaScript) the ClojureScript way is not always the JavaScript way, and this seems to be taken for granted in the text. (As an aside: this is perhaps a critique more of ClojureScript than it is of the book.) There is some discussion in the text about how to "marry" these discrepancies, but as ClojureScript is "more strict", and as ClojureScript is the compiler... it's the one that "wins" when there is a disagreement. Granted, having gotten through the book, and having grasped the motivation behind the language, I also understand why things resolve in this way -- and in light of the idea that "ClojureScript is the JavaScript that could have been", it's almost nice to see things resolve this way but... To a self-identifying JavaScript professional, some of this can be a little off-putting.[^7]
And my last critique: for an introduction, they sometimes drift into almost-but-not-quite esoteric territory without adding sufficient context. Example: "In JavaScript, strings are often used for constants or identifiers in code; keywords fill the same role in ClojureScript." I read these words, and I understand them. And I believe that I understand the concepts. But I do not believe that I could explain this to someone else. I could not explain why it is important; I am missing some bit of experience or context to bring it fully into focus. There are a handful of these in the book (maybe a half-dozen or so?) but I made a note of them every time: "Come back to this passage after you've seen it in the real world."
Despite these (minor?) critiques, I would easily and heartily recommend ClojureScript: Up and Running to anyone with even a passing interest in learning the language. You may not walk away from the book with a desire to use ClojureScript, but you'll certainly understand its basics, and at least then you're forming an informed opinion of it. And this is largely attributable to Sierra and VanderHart's lucid writing -- there is something about Clojure that makes "technical writers" into "better writers". To borrow from Fogus and Houser: it could be because "Clojure changes the way you think!"[^8]
Companion reading:
* (Chas Emerick, et al.)
* (Fogus & Houser)
* (Bolin)
----
[^1]: The best source I could come up with to back up my point was on Dr. Axel Rauschmayer’s blog. But how much source material do you really need for fun little bits of apocrypha anyway?
[^2]: Or at the very least, it was “Lisp-like�.
[^3]: I wonder: if JavaScript had been a Lisp all along, would we be having the whole conversation at all?
[^4]: Though it might help to have done a couple of the .
[^5]: You could read it in a day, but I’d suggest taking your time, and really letting it sink in. Make it two days.
[^6]: That being said, I really felt like the book could have used an appendix or a quick reference for some of those core language features. Not every book out there needs to be Flanagan’s (with its hundreds of pages of appendices and dictionaries and references�) � but it’s helpful to get a bookmarkable section like that. (Hmm� what does disj do again�?)
[^7]: Especially when you’re going to call an object (i.e., {}) an “associative array�. That’s a dangerous word in JavaScript land. (I’ve heard them called “objects� and “maps� and “hashes�, but there’s no such thing as an “associative array�.)
[^8]: I wasn’t sure how else to fit in this point, so I’m going to jam it in with this footnote: the real coup in this book, the real “magical moment� was when I got to their discussion of how ClojureScript uses as a way of deliberately and purposefully dealing with JavaScript’s otherwise clumsy notion of state as mediated through its global scope. It was like some bright light shone down from the sky and paved the road to enlightenment with parens. That alone is worth the price of admission.
----
Disclosure: I received an electronic copy I the book in exchange for writing a review.
And that is exactly what we have in Sierra and VanderHart's ClojureScript: Up and Running -- a guided quickstart to the language that JavaScript could have been. And what an interesting little language it is!
Sierra and VanderHart deliver an excellent introduction to ClojureScript, which is targeted at a sufficiently broad audience of Clojure developers, JavaScript developers, and developers of all other stripes looking to do some discovery. You don't need to know Clojure going in,[^4] but I suspect you'll want to know at least a little JavaScript. From there, they take you through installing ClojureScript, installing and working with the build tool, the core syntax, and... it goes upward from there. Just as the title suggests: there's everything that you need to get started. By the time you walk away from the book,[^5] you should be able to confidently say what ClojureScript is, what motivated its creation, and you should have enough of the basics down that you could write a trivial application with it. (Perhaps even something more "intermediate" level, if you're patient and persistent.)
Before we go any further, a few words about what the book is not:
* It is not a comprehensive language guide.
* It is not a thorough introduction to Clojure.
* It is not a primer on JavaScript.
* It is not a nitty-gritty low-level reference.[^6]
Now, for as easy as it is to recommend ClojureScript: Up and Running, I did find myself with a few critiques.
First, as someone who likes JavaScript and enjoys writing it, there are some borderline inflammatory statements in here. There's the line about having a "cleaner syntax"; and we all know the volumes-upon-volumes of blog posts, forum threads, and flame wars that are already out there about statements like this one. Then there's that line about how "JSON is a feeble data format"; and I find myself thinking I've never felt limited by JSON... These statements read like trolling, and they distract a bit from the salient points being made. (See also: "Stop taking these things so personally.")
However, this leads me to my second critique: that (again: as someone who lives and breathes JavaScript) the ClojureScript way is not always the JavaScript way, and this seems to be taken for granted in the text. (As an aside: this is perhaps a critique more of ClojureScript than it is of the book.) There is some discussion in the text about how to "marry" these discrepancies, but as ClojureScript is "more strict", and as ClojureScript is the compiler... it's the one that "wins" when there is a disagreement. Granted, having gotten through the book, and having grasped the motivation behind the language, I also understand why things resolve in this way -- and in light of the idea that "ClojureScript is the JavaScript that could have been", it's almost nice to see things resolve this way but... To a self-identifying JavaScript professional, some of this can be a little off-putting.[^7]
And my last critique: for an introduction, they sometimes drift into almost-but-not-quite esoteric territory without adding sufficient context. Example: "In JavaScript, strings are often used for constants or identifiers in code; keywords fill the same role in ClojureScript." I read these words, and I understand them. And I believe that I understand the concepts. But I do not believe that I could explain this to someone else. I could not explain why it is important; I am missing some bit of experience or context to bring it fully into focus. There are a handful of these in the book (maybe a half-dozen or so?) but I made a note of them every time: "Come back to this passage after you've seen it in the real world."
Despite these (minor?) critiques, I would easily and heartily recommend ClojureScript: Up and Running to anyone with even a passing interest in learning the language. You may not walk away from the book with a desire to use ClojureScript, but you'll certainly understand its basics, and at least then you're forming an informed opinion of it. And this is largely attributable to Sierra and VanderHart's lucid writing -- there is something about Clojure that makes "technical writers" into "better writers". To borrow from Fogus and Houser: it could be because "Clojure changes the way you think!"[^8]
Companion reading:
* (Chas Emerick, et al.)
* (Fogus & Houser)
* (Bolin)
----
[^1]: The best source I could come up with to back up my point was on Dr. Axel Rauschmayer’s blog. But how much source material do you really need for fun little bits of apocrypha anyway?
[^2]: Or at the very least, it was “Lisp-like�.
[^3]: I wonder: if JavaScript had been a Lisp all along, would we be having the whole conversation at all?
[^4]: Though it might help to have done a couple of the .
[^5]: You could read it in a day, but I’d suggest taking your time, and really letting it sink in. Make it two days.
[^6]: That being said, I really felt like the book could have used an appendix or a quick reference for some of those core language features. Not every book out there needs to be Flanagan’s (with its hundreds of pages of appendices and dictionaries and references�) � but it’s helpful to get a bookmarkable section like that. (Hmm� what does disj do again�?)
[^7]: Especially when you’re going to call an object (i.e., {}) an “associative array�. That’s a dangerous word in JavaScript land. (I’ve heard them called “objects� and “maps� and “hashes�, but there’s no such thing as an “associative array�.)
[^8]: I wasn’t sure how else to fit in this point, so I’m going to jam it in with this footnote: the real coup in this book, the real “magical moment� was when I got to their discussion of how ClojureScript uses as a way of deliberately and purposefully dealing with JavaScript’s otherwise clumsy notion of state as mediated through its global scope. It was like some bright light shone down from the sky and paved the road to enlightenment with parens. That alone is worth the price of admission.
----
Disclosure: I received an electronic copy I the book in exchange for writing a review.
December 23, 2018
Code missing
February 27, 2019
- Content out of date, had to rely on ClojureScript official documentation to get it up and running
- Liked the basic introductions to ClojureScript concepts including macros
- Liked the basic introductions to ClojureScript concepts including macros
November 7, 2015
Unsatisfied. Chapters about setting up the developer enviromnent are somehow useful, but these chapters are almost the only useful chapters in a whole book. Chapters describing the language itself with those ubiquitous "there is not enough room in this book for that, you can read it in depth in any JVM Clojure book" are completely useless as for reader who is already familiar with Clojure (he already knows all stuff explained) and as well for reader unfamiliar with the language (he just can't get the understanding of language from these chapters). And the book has only ONE toy application example! All stuff covered in this book can be explained in one or two blog posts, so the book hardly worth its money.
June 4, 2013
It's an OK book, but I'm not satisfied with it.
I know Clojure and I expected a book that throws me in ClojureScript. Half of it explains the syntax and the language. I did not need that and more importantly, I don't think a reader can get the language from the book. The actual part I cared about - ClojureScript specifics - was brief and not very interesting. It covered a bit of compilation, differences between Clojure and ClojureScript in here and there in the next and a bit of leiningen. It could all have been covered in one or two blog posts.
I know Clojure and I expected a book that throws me in ClojureScript. Half of it explains the syntax and the language. I did not need that and more importantly, I don't think a reader can get the language from the book. The actual part I cared about - ClojureScript specifics - was brief and not very interesting. It covered a bit of compilation, differences between Clojure and ClojureScript in here and there in the next and a bit of leiningen. It could all have been covered in one or two blog posts.
January 4, 2013
Short book to get you up and running with clojurescript.
Thing that you can do on your own as easily going to the clojure/clojurescript wiki on github and reading there, and reading a couple of posts from google, also having the advantage of being up to date in the future.
Also lets hope they pull off the self hosted compiler and cljs becomes a fully independent language instead of a clj jvm toy companion, leaving this book completely obsolete.
Not worth it.
Thing that you can do on your own as easily going to the clojure/clojurescript wiki on github and reading there, and reading a couple of posts from google, also having the advantage of being up to date in the future.
Also lets hope they pull off the self hosted compiler and cljs becomes a fully independent language instead of a clj jvm toy companion, leaving this book completely obsolete.
Not worth it.
December 31, 2012
This could just as easily be Clojure up an running which is no bad thing. I think there's still room for a more detailed book on using clojurescript in real world apps, but as an introductory book I thought this worked well. It's also structured and written very well, so kudos to the editorial and technical team as well as the authors.
November 29, 2013
I can't see why ClojureScript needs a book. If you are not Clojure developer, this book isn't for you. You need to learn Clojure first. If you are Clojure developer, what you really care about is only about 15 ~ 20 pages.
It is too early for ClojureScript to have a book. This book should be released as online articles.
It is too early for ClojureScript to have a book. This book should be released as online articles.
January 8, 2013
Concise book on ClojureScript that captures the essentials and encourages one to play with ClojureScript. Inadequate by itself to support development of a real web application. Severely lacking depth wrt. examples, library coverage and testing.
February 27, 2013
After reading a couple Clojure books and working on some learning projects with the language this was a pretty easy read. There were some good nuggets of information. Worth a read if you want to give Clojurescript a try.
July 2, 2013
Good book, and it definitely serves its purpose! But if you are already familiar with Clojure, you would probably want to see more practical and deep examples of how to build more or less complex applications with unit tests and all that.
Anyway, I'm happy I read it and thanks to the authors.
Anyway, I'm happy I read it and thanks to the authors.
January 9, 2016
This is a somewhat short book targeted at JavaScript programmers that want's to get started with ClojureScript. It does that job nicely but if one is serious about using Clojure then one will probably have to read a more in-depth book on the topic as well.
Read
November 14, 2012Was a tech reviewer.
July 4, 2013
Good and short introduction to ClojureScript which you can easily read in a day. Most of the book's content can be found as a series of articles here:
September 14, 2014
Yep, still no clue what I'm doing
Displaying 1 - 18 of 18 reviews
Can't find what you're looking for?
Get help and learn more about the design.