Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP


New text (after fixing merge conflicts) #29

wants to merge 4 commits into from

2 participants


Merged! I closed the previous pull request and issued a new one directly from the master branch - easier than shuffling branches for me.


Merged and deployed. Thanks.

@Raynes Raynes closed this
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Commits on Nov 24, 2012
  1. @nusco

    change text

    nusco authored
  2. @nusco

    fix typo in <em> html tags

    nusco authored
    (they're styled out anyway, but that may change)
  3. @nusco

    fix typo

    nusco authored
Commits on Nov 25, 2012
  1. @nusco
This page is out of date. Refresh to see the latest.
4 resources/public/javascript/tryclojure.js
@@ -166,8 +166,8 @@ var controller;
$(document).ready(function() {
controller = $("#console").console({
- welcomeMessage:'Enter some Clojure code to be evaluated.',
- promptLabel: 'Clojure> ',
+ welcomeMessage:'Give me some Clojure:',
+ promptLabel: '> ',
commandValidate: onValidate,
commandHandle: onHandle,
12 resources/public/tutorial/page1.html
@@ -1,15 +1,7 @@
- This tutorial isn't entirely complete yet. More fun content is to be written. Stay tuned.
+ I'll take you on a 5-minutes tour of Clojure, but feel free to experiment on your own along the road!
- Above, you have your REPL. Please try the examples as we go along, and by all means experiment
- with concepts independently. Should you refuse, you will promptly be IP banned from this
- website, and a teddy bear will eat your candies. ctrl+v to paste and ctrl+c to copy like you
- would normally expect, but you can't paste with your browser's right-click menu.
- You can type 'next' to move forward, 'back' to go back to the previous step, and 'restart' to
- restart the tutorial. Go ahead and type 'next' to begin
+ You can type <code>next</code> to skip forward, <code>back</code> to return to the previous step, and <code>restart</code> to get back to the beginning. Let's get started: type <code>next</code>.
35 resources/public/tutorial/page10.html
@@ -1,30 +1,35 @@
-<p>Awesome. Now you can call this function just like we called the old square function.</p>
+ Success! Now you can call this new <code>square</code> function just like you called the old <code>square</code> function.
- Clojure has a great set of immutable and persistent data structures. Vectors, lists, maps, sets,
- I get chills.
+ By now, you know that lists are quite important in Clojure.
+ But Clojure also has other data structures:
Vectors: <code class="expr">[1 2 3 4]</code><br/>
Maps: <code class="expr">{:foo "bar" 3 4}</code><br/>
- Lists: <code class="expr">'(1 2 3 4)</code><br/>
Sets: <code class="expr">#{1 2 3 4}</code><br/>
- Vectors and lists are sequential and ordered collections. You'll see vectors used much more than lists.
- Maps are typical hash-maps - unordered collections indexed by keys. The keys can be any object. Here,
- we've used a keyword, <code>:foo</code> as a key. Keywords make excellent keys. We also used a number.
- Sets are mathematical sets.
- Clojure's collections are one of the most imporant parts of Clojure. Being a functional language, Clojure
- encourages immutability and as little state as possible. Therefore, instead of for loops mutating variables
- and such, most of the time you'll see higher order functions doing transformations on immutable data and
- returning new collections rather than ever modifying the old one.
+ Vectors and lists are sequential and ordered collections.
+ Sets are not ordered, and they cannot contain duplicate elements.
+ Maps are key-value collections, where the keys can be any object.
+ Here, we've used what Clojure calls a <em>keyword</em> (<code>:foo</code>) for one of the keys, and a number for the other key.
+ Now I'll tell you another thing that may surprise you: Clojure collections are <em>immutable</em> - they can never change.
+ When you do anything on a list, including adding and removing elements, you actually get a brand new list.
+ (Fortunately, Clojure is amazingly efficient at creating new lists).
+ In general, Clojure encourages you to have as little mutable state as possible.
+ For example, instead of "for" loops and other state-changing constructs, most of the time you'll see functions doing transformations on immutable data and returning new collections, without changing the old one.
- A prime example of this is <code>map</code>. We can use map, a higher order function (which is a function
- that takes functions as arguments or returns functions), to 'map' a function to every element of a sequence.
- Let's use this to increment each number in a vector. Type <code class="expr">(map inc [1 2 3 4])</code> to continue.
+ A prime example of this is <code>map</code>. <code>map</code> is a <em>higher order function</em>, which means that it takes another function as an argument.
+ For example, you can ask <code>map</code> to increment each number in a vector by passing it the <code>inc</code> function, followed by the vector.
+ Try it for yourself: type <code class="expr">(map inc [1 2 3 4])</code> to continue.
13 resources/public/tutorial/page11.html
@@ -1,8 +1,11 @@
-<p>Excellent work.</p>
+<p>Great job!</p>
- Well, that's all there is right now. This tutorial is still a work in progress, and I'm working on more
- steps. If anybody wants to contribute, you can find a link to the Github repository on the 'about' page.
- Furthermore, if you're just a brand new Clojure developer looking for some learning experiences, check
- out the 'links' page. You'll find links to some tutorials and such there.
+ We've only scratched the surface of Clojure and its mind-bending power.
+ This tutorial is still a work in progress, and I'm working on more steps.
+ Meanwhile, you can learn more about Clojure by visiting the 'links' page.
+ Welcome to your adventures in Clojure, and be prepared to be surprised and delighted every step of the way!
7 resources/public/tutorial/page2.html
@@ -1,6 +1,7 @@
- I bet you're curious to find out what Clojure code looks like, aren't you? Sure you are.
- Well, I've give you a hint: it's made up of lists. Let's do some arithmetic.
+ The first thing you may notice about Clojure is that common operations look... strange.
-<code class="expr">(+ 3 3)</code>
+ For example, try typing <code class="expr">(+ 3 3)</code> in the REPL.
13 resources/public/tutorial/page3.html
@@ -1,12 +1,13 @@
- Excellent work! There are other arithmetic functions.
+ That was a strange way to say "three plus three", wasn't it?
- Try them out. Save <code>/</code> for last (don't worry, I have a reason!).
+ A Clojure program is made of <em>lists</em>.
+ <code class="expr">(+ 3 3)</code> is a list that contains an operator, and then the operands.
+ Try out the same concept with the <code>*</code> and <code>-</code> operators.
-<p>Once you're finished playing around, try <code class="expr">(/ 10 3)</code>.</p>
+ Division might surprise you. When you're ready to move forward, try <code class="expr">(/ 10 3)</code>.
8 resources/public/tutorial/page4.html
@@ -1,8 +1,4 @@
- I bet that caught you by surprise, didn't it? Don't fear! Clojure simply has a built in Rational type.
- We can prove that we've got a rational by running <code class="expr">(type (/ 10 3))</code>. Rationals are more
- concise and precise than floating point numbers. However, we can force Clojure to do floating point
- division by just making one of our numbers floating point.
+ Now, that was a bit surprising: Clojure has a built in Rational type.
+ You can still force Clojure to do floating point division by making one of the operands floating point: type <code class="expr">(/ 10 3.0)</code> to continue.
-<p>Type <code class="expr">(/ 10 3.0)</code> to continue.</p>
9 resources/public/tutorial/page5.html
@@ -1,11 +1,6 @@
- Another neat thing about Clojure is that functions can take an arbitrary number of arguments.
- Functions are allowed to specify a 'catch-all' to put an optional and arbitrary number of arguments
- into. Because of this, a lot of Clojure's core functions have interesting capabilities. For example
- the arithmetic functions we've already played with are not limited to two arguments! No sir, they can
- take any number of arguments they wish.
+ Many Clojure functions can take an arbitrary number of arguments.
+ Try it out: type <code class="expr">(+ 1 2 3 4 5 6)</code> to continue.
-<p>Try it out. Type <code class="expr">(+ 1 2 3 4 5 6)</code> to continue.</p>
9 resources/public/tutorial/page6.html
@@ -1,7 +1,8 @@
-<p>Alright, that's enough math. Let's do some fun stuff, like write functions.</p>
- You can define functions in Clojure with <code>defn</code>
+ That's enough math. Let's do some fun stuff, like defining functions.
+ You can do that in Clojure with <code>defn</code>.
-<p>Type <code class="expr">(defn square [x] (* x x))</code> to continue!</p>
+ Type <code class="expr">(defn square [x] (* x x))</code> to define a "square" function that takes a single number and squares it.
13 resources/public/tutorial/page7.html
@@ -1,12 +1,13 @@
-<p>Oh boy! We wrote our very own function! It's a lovely one, isn't it?</p>
+<p>Congratulations - you just defined your first Clojure function. Many more will follow!</p>
- Our <code>square</code> function takes a single argument -- a number -- and squares it.
+ <code>defn</code> takes the name of the function, then the list of arguments, and then the body of the function.
+ I told you that a Clojure program is made of lists, right?
+ The entire <code>defn</code> is a list, and the function body is also a list.
+ (Even the arguments are collected in a vector, which is similar to a list - we'll talk about vectors soon).
- Take a look at how our defn form looks. First comes the name of the function, then the argument list
- (which is a vector, and not an actual list), then the body of the function.
+ Oh, sorry for talking so long - you probably want to try out your brand new function!
+ Type <code class="expr">(square 10)</code>.
-<p>But wait! We don't even know if our function works or not! Let's try it out. Type <code class="expr">(square 10)</code>.</p>
17 resources/public/tutorial/page8.html
@@ -1,17 +1,20 @@
<p>Yay! It works!</p>
- You know, Clojure is a functional programming language. As such, it has first-class and
- anonymous functions. Let's write our square function as an anonymous function.
+ By now, you probably think that Clojure is very different from the programming languages you already know.
+ Indeed, it belongs to a different family than most popular languages' - the family of "functional" programming languages.
+ Like most functional languages, Clojure can define a function without even giving it a name:
<code class="expr">(fn [x] (* x x))</code>
- If you run this in the REPL above (as you should), you'll note that some very weird and
- cryptic thing is printed. Functions are just normal values like a number, a string, or
- anything else. The cryptic thing is simply how they look when printed.
+ If you run this code, you'll see some cryptic output.
+ In Clojure, functions are just normal values like numbers or strings.
+ <code>fn</code> defines a function and then returns it.
+ What you're seeing is simply what a function looks like when you print it on the screen.
- Our anonymous function isn't very useful if we don't call it. Let's do it. Type
- <code class="expr">((fn [x] (* x x)) 10)</code>
+ But wait - an anonymous function isn't very useful if you can't call it. Try to define a new anonymous function and call it straight away: <code class="expr">((fn [x] (* x x)) 10)</code>.
16 resources/public/tutorial/page9.html
@@ -1,12 +1,16 @@
- Yay! Notice how we called our anonymous function? We just wrapped the function in parentheses,
- placing it as the first element in this new list and passing it arguments just like we did earlier
- with the arithmetic functions. Awesome, huh?
+ Let's see what you just did: you evaluated a list where the first element is the function itself, defined on the spot - and the other elements are the arguments that you pass to the function.
+ That's exactly the same syntax that you used earlier on to call functions like <code>square</code> or even <code>+</code>.
+ The only difference is that now you defined the function in the same place where you called it.
- You may not know this, but <code>defn</code> is actually just a bit of sugar around <code>def</code>
- and <code>fn</code> to create named functions. We can create named functions without <code>defn</code>
+ Remember <code>defn</code>?
+ Now I can tell you a secret: <code>defn</code> is actually just a bit of syntactic sugar around <code>def</code> and <code>fn</code>.
+ You've just seen <code>fn</code> at work: it defines a new function.
+ <code>def</code> binds the newly defined function to a name.
-<p>Type <code class="expr">(def square (fn [x] (* x x)))</code> to continue.</p>
+ If you want, you can create a named functions without using <code>defn</code>: type <code class="expr">(def square (fn [x] (* x x)))</code> to continue.
36 src/tryclojure/views/home.clj
@@ -15,26 +15,28 @@
(defpartial about-html []
- "Please note that this REPL is sandboxed, so you wont be able to do everything in it "
- "that you would in a local unsandboxed REPL. Keep in mind that this site is designed for "
- "beginners to try out Clojure and not necessarily as a general-purpose server-side REPL."]
+ "Welcome to Try Clojure - a quick tour of Clojure for absolute beginners."
+ ]
- "One quirk you might run into is that things you bind with def can sometimes disappear. "
- "The sandbox wipes defs if you def too many things, so don't be surprised. Furthermore, "
- "The sandbox will automatically be wiped after 15 minutes and if you evaluate more after that,"
- "It'll be in an entirely new namespace/sandbox."]
+ "Here is our only disclaimer: this site is an introduction to Clojure, not a generic Clojure REPL. "
+ "You won't be able to do everything in it that you could do in your local interpreter. "
+ "Also, the interpreter deletes the data that you enter if you define too many things, or after 15 minutes."]
- "TryClojure is written in Clojure and JavaScript (JQuery), powered by "
- (link-to "" "clojail")
- " and Chris Done's "
- (link-to "" "jquery-console")]
- [:p.bottom "Design by " (link-to "" "Andrew Gwozdziewycz")])
+ "TryClojure is written in Clojure and JavaScript with "
+ (link-to "" "Noir") ", "
+ (link-to "" "clojail") ", and Chris Done's "
+ (link-to "" "jquery-console") ". "
+ " The design is by " (link-to "" "Andrew Gwozdziewycz") "."
+ ])
(defpartial home-html []
- "Welcome to Try Clojure. See that little box up there? That's a Clojure repl. You can type "
- "expressions and see their results right here in your browser. We also have a brief tutorial to "
- "give you a taste of Clojure. Try it out by typing " [:code.expr "tutorial"] " in the console!"])
+ "Welcome to Clojure! "
+ "You can see a Clojure interpreter above - we call it a <em>REPL</em>."
+ ]
+ [:p.bottom
+ "Type \"tutorial\" in the REPL to begin."
+ ])
(defn root-html []
@@ -65,9 +67,7 @@
[:a#about.buttons.last "about"]]
[:div#changer (home-html)]]
- [:p.bottom "©2011-2012 Anthony Grimes and numerous contributors. Built with "
- (link-to "" "Noir")
- "."]]
+ [:p.bottom "©2011-2012 Anthony Grimes and numerous contributors."]]
"var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-27340918-1']);
Something went wrong with that request. Please try again.