Recent comments

Peter Neubauer, on 2015/08/31

These images are awesome. You should do some in mapillary.com and try it out (monitored by Riemann :)

/peter

PW, on 2015/08/31

Grammatical mistake within first 4 words:

So there’s a a

Chris, on 2015/08/30

This is absolutely amazing work. Thank you very much! I’m finally coming to grips with lisps, and specifically clojure. Please do keep it up, and let me know when I can get the book!

Katherine McCartney, on 2015/08/30

Hi Dave. I just had a neighbor take down a 100 ft Douglas Fir fine grade 50 year old tree. Although heartbreaking it’s boughs were falling and destroying cars and garages. I was lucky enough to get a 3 inch round from the thickest part of the sizable trunk and it’s diameter is about 4.5 feet. It’s outside right now, it was cut last week. I wonder if you have any tips for me in terms of drying it so that it doesn’t crack? It has a hairline crack in it already.

Gopal Patwa, on 2015/08/30

Indeed great article, since ES 2.0.0 beta 1 is released. It is possible with 2.0.0 release this issue might resolve.

Magnus, on 2015/08/29

How would the result be affected if you run Chronos controlled by Maraton? I think that is the recommended way by many and helps to recover from some failure states.

tim, on 2015/08/21

Keep the awesome tests going.

Something must work!

Aphyr, on 2015/08/21

Compared to SQS? Well, as far as I know SQS isn’t in the habit of throwing away data when a partition occurs, but I don’t have any solid evidence there since I can’t test SQS’s internals. :)

darkfader, on 2015/08/20

Thanks, I had so much fun reading this!

Jeff, on 2015/08/19

Hi Kyle,

Thanks for the amazing clojure tutorial; I’m really enjoying it so far!

One question about the complex problem at the end of this one: I’m pretty sure that in your solution, you’re taking the first 1000 pairs of odd integers rather than pairing the first 1000 odd integers. From my understanding, the solution to the problem as stated should read:

(reduce + 
  (map 
    (fn [pair] (* (first pair) (second pair))) 
    (partition 2 1 
      (take 1000 
        (filter odd? 
          (iterate inc 0))))))

Clam Chowder, on 2015/08/19

How does this compare to Amazon SQS in terms of durability?

Ian Miell, on 2015/08/19

This is a fantastic post. Thank you. Ian

EthanMellor, on 2015/08/18

This information is very useful for theoretical studies.

YellowApple, on 2015/08/18

Here you go: Tue Aug 18 12:11:14 PDT 2015

Charlie HOover, on 2015/08/18

I need a date ! help!

Aphyr, on 2015/08/18

Cassandra also claims to offer monotonic read consistency, which means that if a client has seen any particular value for a key, it will never read an older value.

See the linked Jira ticket for a more thorough discussion.

tribeca, on 2015/08/17

What does “monotonically consistent” even mean?

Zaar, on 2015/08/16

Do you have plans to review the new cluster model in Redis >= 3.0?

Kenneth R. Beesley, on 2015/08/12

Trying to sort out delay, future and promise, I came up with the following summary. Please correct as necessary.

delay The delay definition specifies code to set/bind the identity, but it doesn’t execute that code. When the delay is dereferenced, only then is the code is executed, and the dereference will effectively need to wait/hang until that code is finished. The result of the dereference is cashed, so if the identity is dereferenced again, the previously computed result is simply looked up and returned.

future The future definition specifies code to set/bind the identity, and it creates a thread and immediately starts executing the code in that thread. When the identity is dereferenced, the execution will have to wait/hang if and only if the code launched in the thread has not yet terminated.

promise The promise definition does NOT specify code to set/bind the identity; it simply creates an “empty” promise, with the assumption that some other code somewhere/somehow will ‘deliver’ a value to that identity. The deference of the promise identity will have to wait/hang if and only if a value has not yet been ‘deliver’-ed to the promise.

Kenneth R. Beesley, on 2015/08/11

On the issue of swap!, when the indicated function’s operation is not commutative, it might be useful to point out that the old value of the atom is used as the first argument to the function. E.g. in the example

(def x (atom 1))
(swap! x + 1 2)

it doesn’t matter if the old value of x is used as the first or last argument to + because + is commutative. But in

(def x (atom 4))
(swap!  x  -  1 2)

using the - function/operation, the old value of x is definitely used as the first argument to 1, and the resulting value is of x is 1, e.g.

(swap! x -  <oldvalueofx> 1 2)

Kenneth R. Beesley, on 2015/08/11

Oops. Code disappears. Let me try again with a marked up Clojure code block. First try:

(def xs (atom #{}))
(dotimes [i 5] (future (swap! xs conj i)))
@xs

The output is shown as

#{0 1 2 3 4 5 6 7 8 9}

which might imply that the order is preserved.

Kenneth R. Beesley, on 2015/08/11

Let me first repeat that you explain Clojure with remarkable skill and readability. You should definitely write a book. On one little point, the following example might be a bit misleading:

(def xs (atom #{}))

(dotimes i 10))

The output is shown as: #{0 1 2 3 4 5 6 7 8 9}, which might imply that order is maintained. Earlier in the presentation, it is stated that “All updates with swap! complete in what appears to be a single consecutive order.” However, sets being sets, the order of elements is insignificant, and the output may appear different when printed.

AgasthyaH, on 2015/08/09

Thank you for the excellent and invaluable series. Just wanted to point put a philosophical irony ( unrelated to your series ). That is that most sources which teach about functional programming paradigm use a procedural paradigm :)

Alex, on 2015/08/09

This is by far the best explanation of how and why things behave in Clojure. Thank you a lot for all your work and keep going!

Betty, on 2015/08/03

Hi guys,

Here are my solutions to the problems. Hope some of you find them helpful.

1.

(defn palindrome? [x]

(= (seq x) (reverse (seq x)) )

)

2.

( (frequencies (seq “abracadabra”)) \c )

3.

(defn my-filter [f x] (reduce (fn [output element]

(if (f element)
      (conj output element)
      output
    )
  )
[]
x
)

)

4.

(defn isprime? n) (range 2 n)))))

(take 10 (filter isprime? (iterate inc 0)))

Martijn, on 2015/07/30

Have to write another enthusiastic post. The doc and source macros finally make me understand how awesome it is that code is data. I’ve explored some Clojure before but this is the first introduction that makes this concept so clear so early on. Thanks so much for sharing this!

Martijn, on 2015/07/30

One of the best reads on Clojure I’ve seen. Hope you’ll finish the book some day.. would definitely buy it.

dave, on 2015/07/17

Am dave would like order(walnut slab)Kindly list the price and sizes you in stock or provide me the website for me to choose my kind of walnut slab ,also what type of payment do you accept.

Jean-Francois Contour, on 2015/07/13

Since this issue is related to in-flight documents. Do you think there is a risk to loose existing document during primary shard relocation (cluster rebalancing after adding a new node for instance )?

Ashutosh Pandit, on 2015/07/11

This is how tutorials should be. Precise and crisp! Thank you! This is my official “learn clojure in 3 days” guide :)

William, on 2015/07/10

love this post, im trying to determine which DB to use and was wondering your thoughts on amazon aurora?

Duy Do, on 2015/07/07

Thanks for the article. Can you run this with Elasticsearch 1.6?