jhaberstro

http://courses.cms.caltech.edu/cs179/
http://www.amd.com/Documents/GCN_Architecture_whitepaper.pdf
https://community.arm.com/graphics/b/blog
http://cdn.imgtec.com/sdk-documentation/PowerVR+Hardware.Architecture+Overview+for+Developers.pdf
http://cdn.imgtec.com/sdk-documentation/PowerVR+Series5.Architecture+Guide+for+Developers.pdf
https://www.imgtec.com/blog/a-look-at-the-powervr-graphics-architecture-tile-based-rendering/
https://www.imgtec.com/blog/the-dr-in-tbdr-deferred-rendering-in-rogue/
http://developer.amd.com/tools-and-sdks/opencl-zone/amd-accelerated-parallel-processing-app-sdk/opencl-optimization-guide/#50401334_pgfId-412605
https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-pipeline-2011-index/
https://community.arm.com/graphics/b/documents/posts/moving-mobile-graphics#siggraph2015

mmrko

git config --global alias.checkoutr checkout
$EDITOR /usr/local/share/zsh/site-functions/git-completion.bash

...and then modify the file as follows...

-__gitcomp_nl "$(__git_refs '' $track)"
+if [ "$command" = "checkoutr" ]; then
+    __gitcomp_nl "$(__git_refs '' $track)"
+else

sw1nn

;; Based on https://clojuredocs.org/clojure.core/condp#example-542692cbc026201cdc326bea

(defn parse-arg [s]
  (condp (comp next re-matches) s
    #"([+-])(\w+)" :>> (fn [[f k]] [(keyword k) (= f "+")])
    #"(\w+)=(\w+)" :>> (fn [[k v]] [(keyword k) v])
    (throw (IllegalArgumentException. s))))
  
(parse-arg "+foo")    ;=> [:foo true]
(parse-arg "-foo")    ;=> [:foo false]

swannodette

(defui Artist
  static IQuery
  (query [cl _]
    [:db/id :artist/name])
  Object
  (render [{:keys [props]}]
    (dom/div nil (:artist/name props))))

(defui ArtistList
  static IQuery

oakes

Contents

• Why care about Rust?
• The Toolchain
• Creating a New Project
• Modules
• Crates
• Types
• References
• Mutability

ptaoussanis

(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:
  (fn reducing-fn ([]) ([accumulation next-input])) -> new-accumulation
  ;; (The `[]` arity is actually optional; it's only used when calling
  ;; `reduce` w/o an init-accumulator).

martinklepsch

(def foo {:bar 1 :moo {:event {:_value 2} :ter {:_value 1} :ber {}}
          :floors [{:area {:_value 10} :height {}} {:area {} :height {:_value 5}}]
          :roofs [{:area {}}]})

(defn parse [cursor]
  (clojure.walk/postwalk (fn [m]
                           (if-let [v (:_value m)]
                             v
                             (cond
                              (and (map? m) (empty? m)) nil

vmarcinko

import kafka.server.KafkaConfig;
import kafka.server.KafkaServer;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Properties;

john2x

Clojure Destructuring Tutorial and Cheat Sheet

(Related blog post)

Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.

Vectors and Sequences

philandstuff

EuroClojure 2014, Krakow

Fergal Byrne, Clortex: Machine Intelligence based on Jeff Hawkins’ HTM Theory

• @fergbyrne
• HTM = Hierarchical Temporal Memory
• Slides

big data

• big data is like teenage sex
  • noone knows how to do it
  • everyone thinks everyone else is doing it