slipset

(ns csv-parser.core
  (:require [clojure.string :as str]
            [clojure.data.csv :as csv]
            [cheshire.core :as json]))

(->> "./foo.csv"
     slurp
     csv/read-csv
     rest
     (map #(zipmap [:id :first-name :given-name :yob] %))

slipset

(json-gen/add-encoder org.joda.time.DateTime
                      (fn [c jsonGenerator]
                        (.writeString jsonGenerator (str c))))

(defn str->date-time [_ value]
  (try 
    (DateTime. value)
    (catch Exception e
      ::spec/invalid)))

slipset

(ns foo.core
  (:require [clojure.java.io :as io])
  (:import [java.net URL]
           [java.io FileInputStream]
           (javax.xml.bind DatatypeConverter)))


(defn- open-input-stream [^URL url]
  (if-let [user-info (.getUserInfo url)]
    (let [uc (.openConnection url)

slipset

;; import Data.Monoid ((<>))

;; prompt :: String -> IO (IO ())
;; prompt attribute = do
;;     putStrLn ("What is your " ++ attribute ++ "?")
;;     x <- getLine
;;     return (putStrLn ("Your " ++ attribute ++ " is: " ++ x))

;; runWizard :: IO (IO a) -> IO a
;; runWizard request = do

slipset

(def checkpoints (atom (list (now))))

(defn duration [checkpoints]
  (/ (double (- (first checkpoints) (second checkpoints)))
     1000000.0))

(defn new-checkpoint! [checkpoint checkpoints]
  (conj checkpoints checkpoint))

(swap! checkpoints (partial new-checkpoint! (now)))

slipset

{:paths ["resources" "src"]
 :deps {org.clojure/clojure {:mvn/version "RELEASE"}
        org.clojure/test.check {:mvn/version "RELEASE"}}
 :aliases
 {:test {:extra-paths ["test"]
         :extra-deps {org.clojure/test.check {:mvn/version "RELEASE"}}}
  :runner
  {:extra-deps {com.cognitect/test-runner
                {:git/url "https://github.com/cognitect-labs/test-runner"
                 :sha "76568540e7f40268ad2b646110f237a60295fa3c"}}

slipset

(def urls {:vg "https://www.vg.no", :ap "https://www.ap.no", :db "https://www.db.no"} )

(defn my-get-request [[k url]]
  [k (future (http/get url))])

(->> urls
     (map my-get-request)
     (reduce (fn [acc [k v]]
               (assoc acc k (deref v))) {}))

slipset

foo.core=> (def few-numbers (range 2))
#'foo.core/few-numbers
foo.core=> few-numbers
(0 1)
foo.core=> (def many-numbers (range 100))
#'foo.core/many-numbers
foo.core=> many-numbers
(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99)
foo.core=> (bench (apply + few-numbers))
Evaluation count : 543551760 in 60 samples of 9059196 calls.

slipset

(ns wc.core
  (:require [clojure.core.reducers :as r]))

(defn char-counter [key init pred]
  (fn [reducing-fn]
    (fn
      ([acc]
       (reducing-fn acc))
      ([acc c]
       (reducing-fn (if (pred c)

slipset

Technical debt for fun and profit

Mention technical debt to any normal engineer and they'll look upon you as something the cat dragged in. But is technical debt all bad? The term was coined by Ward Cunningham as a way to talk about complexity and bad code in a way that non-technical people could understand. The compound effect of interest on real-life loans was used to explain how complex, badly written code becomes increasingly harder to develop and maintain.

In this talk I'll explore the debt metaphore in more detail and see if, as in real life, there are ways we can leverage debt in our work without ending up in the software equvivalent of the Luxury Trap.