fogus

;; lenses in Clojure again, van Laarhoven-style this time

(defprotocol Lens
  (through [lens x cont]))

(extend-protocol Lens
  clojure.lang.Keyword
  (through [k x cont]
    (cont #(assoc x k %) (k x))))

fogus

module rec VariantMod
  : sig
    type t = Int of int | Map of t OrderedValMap.t
  end = VariantMod
and OrderedVal
  : sig
    type t = VariantMod.t
    val compare : t -> t -> int
  end
  = struct

fogus

(require '[clojure.walk :refer [macroexpand-all postwalk]]
         '[clojure.pprint :refer [pprint]])

(def ^:dynamic *platform* :clj)

(defmacro +clj [form]
  (if (= :clj *platform*)
    form
    ::elide))

fogus

;   Copyright (c) Rich Hickey. All rights reserved.
;   The use and distribution terms for this software are covered by the
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   which can be found in the file epl-v10.html at the root of this distribution.
;   By using this software in any fashion, you are agreeing to be bound by
;   the terms of this license.
;   You must not remove this notice, or any other, from this software.

(set! *warn-on-reflection* true)

fogus

This is a plain-text version of Bret Victor’s reading list. It was requested by hf on Hacker News.

---

Highly recommended things!

This is my five-star list. These are my favorite things in all the world.

A few of these works have had an extraordinary effect on my life or way of thinking. They get a sixth star. ★

fogus

(ns foami.core
  "FOreign Asynchronous Mechanism Interop"
  (:require [clojure.core.async :as async]))

(def ^:private abandon (doto (async/chan) async/close!))

(def ^:private pending-writes (async/chan))

(defn put!
  "Tries to put a val into chan, returns either: true if put succeeded, false if chan is

fogus

if(typeof require != "undefined") {
    var lodash = require("lodash"),
        _      = require("underscore");
}

var MapTransformer = function(f, nextTransformer) {
    this.f = f;
    this.nextTransformer = nextTransformer;
};

fogus

Found way fewer than I expected with bibliographies. But also way fewer 2009-present books. The select few w/ nice beefy bibliographies:

• The Joy of Clojure (Fogus/Houser)
• The Linux Programming Interface (Kerrisk)
• Systems Performance (Gregg)
• The Art of Multiprocessor Programming (Herlihy/Shavit)
• Machine Learning (Flach)

I counted 8/18 tech books on my shelf since 2009 with bibliographies - way fewer than I'd have guessed. This is even w/ some selection bias towards the type of book that would have a bibliography, I suspect.

fogus

; there are some obvious micro optimizations, I left them out for clarity
; the relative ordering of read and writes with volatile and plain array should be thread-safe (if not, point it out)

; @wagjo asked "Have you found use for such concept? Must be pretty slow compared to unchunked one"
; The idea came out of a discussion on transducers so not used for real, yet.
; Once you optimize it (remove the boxing induced by the volatile, switch to unchecked math) there should not be much
; of an overhead.
; When you have one big composed reducing fn (eg several mapping stages) then each item is going to be processed in 
; each stage, each stage of the mapping may evict from the data cache stuff used by previous stages. So you have cache
; misses for each item.

fogus

(comment ; Fun with transducers, v2

  ;; Still haven't found a brief + approachable overview of Clojure 1.7's new
  ;; transducers in the particular way I would have preferred myself - so here goes:

  ;;;; Definitions
  ;; Looking at the `reduce` docstring, we can define a 'reducing-fn' as[1]:
  (fn reducing-fn ([]) ([accumulation next-input])) -> new-accumulation

  ;; We choose to define a 'transducing-fn' as: