Add pings clj-session (brain-dump).

It parses my ~/.pings file which contains minute-wise
`date --rfc-3339=seconds` lines. It's been quite interesting to see what
I've been up to.

However, to be actually useful the data would have to be combined with
some "was working" state, such as #key-events, name of the application
running or a combination of this.

This is definitively inspired by [Steven Wolfram's Quantified Self
post](http://blog.stephenwolfram.com/2012/03/the-personal-analytics-of-my-life/).

clj/pings.clj

@@ -0,0 +1,104 @@
(ns pings
  (:use clojure.repl)
  (:use hello-clojure)
  (:require [datomic.api :as d])
  (:import java.util.Date)
  (:import java.text.SimpleDateFormat))
(.getMethods Date)
(.getMethods java.lang.reflect.Method)
(map #(.getName %) (.getMethods Date))
(def rfc-3339-format (SimpleDateFormat. "yyyy-MM-dd HH:mm:ssXXX"))
(defn parse-date [s]
  "Parse a date (RFC3339 format with seconds). Returns nil if no date can be parsed."
  (try (.parse rfc-3339-format s)
    (catch java.text.ParseException pe nil)))
(parse-date "2013-02-14 15:52:14+01:00")
(doc-ns 'clojure.core)
(def pings
  "Minute-wise 'pings' that are generated when my laptop is running."
  (map #(-> % second parse-date)
       (re-seq #"(.*)\n" (slurp "/home/lu/.pings"))))
(defn diff-seconds [d1 d2]
  (Math/abs (/ (- (.getTime d1) (.getTime d2)) 1000)))
(defn usual-ping? [diff] (< (/ diff 60) 10))
(filter #(-> % usual-ping? not) (map #(->> % (apply diff-seconds)) (partition 2 1 pings)))
(def unusual
  (filter #(not (usual-ping? (nth % 2)))
          (map (fn [[d1 d2]] [d1 d2 (diff-seconds d1 d2)])
               (partition 2 1 pings))))
(doseq [[d1 d2 diff] unusual] (println d1 d2 (float (/ diff 60 60))))
; avg unusual
(let [[c s] (reduce (fn [[c s] [_ _ d]] [(inc c) (+ s d)]) [0 0] unusual)]
  (float (/ s c 60 60)))
(defn avg
  "Calculate the average of the values in coll, choosing values using
   keyfn (defaults to identity)."
  ([coll]
    (avg identity coll))
  ([keyfn coll]
   (let [[c s] (reduce (fn [[c s] v] [(inc c) (+ s (keyfn v))]) [0 0] coll)]
     (/ s c))))
(doseq [[d1 d2 diff] (take 10 (sort-by (fn [[_ _ d]] d) > unusual))]
  (println d1 d2 (float (/ diff 60 60))))
; avg unusual #2
(float (/ (avg #(nth % 2) unusual) 60 60))
;; interesting data (for pings):
;;  * min/max/avg/daily (graph) 'uptime'
;;  * distribution throughout the day
;;  * stretches/pauses/'busy times'
(take 10 (sort-by (fn [[_ _ d]] d) < unusual))
(take 10 (map #(float (/ (nth % 2) 60 60)) (sort-by (fn [[_ _ d]] d) < unusual)))
(def day-format (SimpleDateFormat. "yyyy-MM-dd"))
(def daily-pings (group-by (fn [d] (.format day-format d)) pings))
(defn stretches [pings]
  (first (reduce (fn [[ss start-date last-date] date]
            (if (usual-ping? (diff-seconds last-date date))
              [ss start-date date]
              [(conj ss [start-date last-date]) date date]))
          [[] (first pings) (first pings)]
          (rest pings))))
(defn print-stretches [stretches]
  (doseq [[from to] stretches]
    (println (.format rfc-3339-format from) "to" (.format rfc-3339-format to))))
(print-stretches (stretches pings))
(print-stretches (filter (fn [[from to]] (not= (.getDay from) (.getDay to))) (stretches pings)))
(def daily-stretches (group-by (fn [[d _]] (.format day-format d)) (stretches pings)))
(daily-stretches "2012-12-07")
(defn daily-total [stretches-for-day]
  (reduce (fn [s [f t]] (+ s (diff-seconds f t)))
          0
          stretches-for-day))
(def hours-per-day (map (fn [[_ v]] (float (/ (daily-total v) 60 60))) daily-stretches))
(take 10 (sort-by identity > hours-per-day))
(reduce #(conj %1 %2) #{} (map #(Math/round %) hours-per-day))
(avg hours-per-day)
(def hour-distribution
  (map (fn [[k v]] [k (count v)]) (group-by #(.getHours %) pings)))
(sort-by second > (map (fn [[h c]] [h (float (/ c 60))]) hour-distribution))