Tackling my first Clojure project, a Graphical HTTP Benchmarker in Clojure

[andrewvc]

http://blog.andrewvc.com/tackling-my-first-jlojure-project-a-graphical

[ibdknox]

Cool project! I looked over your code very briefly and noticed you don't tend to use destructuring very much. It was something that took me a while to get used to too, but it turns out to be very useful and makes the code much smaller. Take for example this:

    (defn stats [requests-state]
        "Returns a mapping of RequestsState http states states to counts"
        (reduce
            (fn [stats request]
            (let [r        @request
                    state    (:state  r)
                    status   (:status r)
                    statuses (:statuses stats)]
                (assoc stats
                    :total     (inc (stats :total 0))
                    state      (inc (stats state  0))
                    :statuses  (assoc statuses status (inc (statuses status 0)))
                    :progress  (if  (not=  state :untried)
                                    (inc  (stats :progress 0))
                                    (stats :progress 0)))))
                {:statuses {}}
                (flatten (:grid @requests-state))))

Could be written like so:

    (defn stats [requests-state]
        "Returns a mapping of RequestsState http states states to counts"
        (reduce
            (fn [{statuses :statuses total :total :as stats} request]
            (let [{state :state status :status} @request]
                (assoc stats
                    :total     (inc (or total 0))
                    state      (inc (stats state  0))
                    :statuses  (assoc statuses status (inc (statuses status 0)))
                    :progress  (if  (not=  state :untried)
                                    (inc  (stats :progress 0))
                                    (stats :progress 0)))))
                {:statuses {}}
                (flatten (:grid @requests-state))))

[ataggart → ibdknox]

You can also avoid the duplicated key/sym names:

    (fn [stats request]
      (let [{:keys [statuses total]} stats
            {:keys [state status]}   @request]
        ...))

[andrewvc → ibdknox]

Thanks for the tip! That's much better, I'll merge that in later today.

[daveray]

Good stuff. I'm not sure if this is an improvement, but it's a nice piece of trivia... your status range checks can be reduced a bit:

    (and (>= status 200) (< status 300))

becomes:

    (<= 200 status 299)

Go Clojure.

[andrewvc → daveray]

Very cool. It's not an easy call, as its esoteric syntax, but I think I'll put it in.

[joevandyk]

I'd love to get more into Scala and Clojure, but I don't know the first thing about Java, especially the Java ecosystem (war's, ant, jvm's, etc).

Unfortunately, most books/articles on Clojure and Scala assume you know Java.

[technomancy → joevandyk]

Knowing how to write Java is absolutely not needed at all. Knowing how to read Java can be useful depending on what libraries you need. The one thing that you have to learn no matter what is the basic IO classes, which are covered pretty well in http://copperthoughts.com/p/clojure-io-p1/.

Before the clojure.java.io namespaces was created, it used to be necessary to interact directly with those classes for even basic usage. (Kids these days! They've got it so easy.)

The web application ecosystem can be a bit intimidating to peace-loving programmers with all its talk of wars, but even that is changing with deployment options like Elastic Beanstalk and Heroku.

Anyway, you hear horror stories about Enterprise Java Beans, dependency injection frameworks, Maven, and whatnot, but you never see any of that in everyday Clojure.

[ibdknox → joevandyk]

I can't comment on Scala, but I think Clojure is starting to get to the point where you can learn just Clojure and not have to think about Java until much later. At some point you'll assuredly interact with Java some, but there are a ton of libs out there now that are simple Clojure wrappers around most common things.

Really, to get started with Clojure, all you need to do is install Leiningen (https://github.com/technomancy/leiningen) and type "lein repl" in a terminal window. No ant, wars, or jvm's to think about :)

[ihodes → joevandyk]

I tried to address the "assuming you know Java" bit here http://copperthoughts.com/p/clojurists-guide-to-java/ – I think it about covers what you need to go to get started, and it's readable in just 5 minutes or so.

Let me know if it's missing anything! You don't need to worry about any sort of jvm ant wars, either. Use Leiningen.

[andrewvc → joevandyk]

Yeah, I may have overstated the case for Java a bit. You don't need to be a Java expert, but you should know enough Java to be able to create your own classes, and make simple little programs with multiple classes.

Really though, you should know how to browse javadocs, and the java ecosystem.

It is true that you can use clojure wrappers around java libs (and its nicer too) but a lot of them don't expose the full functionality of their java counterparts, and clojure's young enough that to understand how they work you'll have to dive heavily into their java interop.