Software Dendrology by Brandon Bloom
•
1 j'aime•3,246 vues
As Clojure programmers, our software is full of trees. Both the values we manipulate and the code we manipulate them with, are made from trees. It's all to easy to get caught up in a project and miss the forest for the trees, but how often have you missed the trees for the forest? This presentation is an exploration of trees from a unique perspective that will hopefully inform your thinking and lead your program design out of the woods.
Recommandé
Contenu connexe
Tendances
Tendances (19)
Similaire à Software Dendrology by Brandon Bloom
Similaire à Software Dendrology by Brandon Bloom (20)
Plus de Hakka Labs
Plus de Hakka Labs (20)
Dernier
Dernier (20)
Software Dendrology by Brandon Bloom
- 3. once upon a time in #clojure… bbloom: better ways to analyze and process trees is a bit of a new obsession of mine :-) gfredericks: clojurebot: bbloom is a dendrologist clojurebot: Alles klar
- 10. A B E C F D G
- 11. A B C D
- 12. A B C D
- 13. A B C D D
- 14. A B C D
- 15. A B C D
- 18. Pointer cycles are the root of all evil. tail
- 19. Pointer cycles are evil.
- 27. Pointer cycles are evil.
- 29. B B’ A B C D
- 36. Let’s talk about pointers and identities.
- 37. static byte memory[MEMORY_SIZE];! ! template <class T>! class Pointer {! ! public:! ! Pointer(long p) {! _p = p;! }! ! T deref() const {! return !@#$%(memory + _p);! }! ! Pointer<T> add(int n) const {! return Pointer(_p + n * sizeof(T));! }! ! private:! ! long _p;! ! };
- 38. static byte memory[MEMORY_SIZE];! ! template <class T>! class Reference {! ! public:! ! Reference(long p) {! _p = p;! }! ! T deref() const {! return !@#$%(memory + _p);! }! ! ! ! ! ! private:! ! long _p;! ! };
- 39. ! ! template <class T>! class Reference {! ! public:! ! Reference(long p) {! _p = p;! }! ! T deref() const {! return !@#$%(memory + _p);! }! ! ! ! ! ! private:! ! long _p;! ! };
- 40. template <class T>! class Reference {! ! public:! ! Reference(long p, byte *memory) {! _p = p;! _memory = memory;! }! ! T deref() const {! return !@#$%(_memory + _p);! }! ! private:! ! long _p;! long _memory;! ! };
- 41. template <class T>! class Reference {! ! public:! ! Reference(long p) {! _p = p;! }! ! T deref(const byte *const memory) const {! return !@#$%(memory + _p);! }! ! private:! ! long _p;! ! };
- 42. (defprotocol IDeref! (deref [this])) (defprotocol IDerefIn! (deref-in [this context])) (deftype Reference [p]! IDerefIn! (deref-in [_ memory]! (!$%&* memory p)))
- 43. (deftype DbRef [table id]! (deref-in [_ db]! (get-row db table id)))! ! (let [brandon (DbRef. :users 5)]! (deref-in brandon *db*))! ! (defn get-user [db id]! (get-row db :users id))! ! (let [brandon 5]! (get-user *db* brandon)
- 45. [:user 5]
- 46. 5
- 47. Context is King
- 48. Symbols: The Original Identities (def x "top-level")! cljs.user.x = "top-level";! ! ! (fn []! v a r x! (let [x "local"]! x))! function () {! cljs.user.x;! var x = "local";! return x;! } loc al b o l re s o l v e d sym g c o n te x t ! us i n
- 49. Context: Not Just For Identities (def x "top-level")! cljs.user.x = "top-level";! ! ! (fn []! s t a te me n t x! (let [x "local"]! x))! t ai l p o si t io n function () {! cljs.user.x;! var x = "local";! return x;! } x t u a l re t u r n ! c o n te
- 50. A B E C F D G (def vector-tree! ["A" ["B" ["E"] ["F"]] ["C"] ["D" ["G"]]]) (def tree! {:label "A"! :children [{:label "B"! :children [{:label "E"}! {:label "F"}]}! {:label "C"}! {:label "D"! :children [{:label "G"}]}]})
- 51. A 0! ! 1! B C D ! 2 ! E F G (defn annotate-depth [node]! ! (letfn [(f [node depth]! ! (let [d (inc depth)! ! annotate-child #(f % d)]! ! (-> node! ! (assoc :depth depth)! ! (update-in! ! [:children]! ! (mapv annotate-child %)))))]! (f node 0)))
- 52. 2 2 2 ! E 2 1 B F A C 2 D 2 G (defn annotate-max-depth [node]! ! (let [{:keys [children]} node]! ! (if (seq children)! ! (let [children*! ! (mapv annotate-max-depth children)]! ! (assoc node! ! :max-depth (apply max! ! (map :max-depth children*))! ! :children children*))! ! (assoc node :max-depth (:depth node)))))
- 53. 0 1 2 E 3 4 B F A C 5 D 6 G 0A 1B 2E 3F 4C 5D 6G (defn print-depth-first-recursive [node]! (letfn [(f [node index]! (println index (:label node))! (loop [nodes (:children node)! i index]! (if (seq nodes)! (recur (next nodes)! (f (first nodes) (inc i)))! i)))]! (f node 0))! nil)
- 54. 0 1 2 E 3 4 B F A C 5 D 6 G (defn number-depth-first-recursive [node]! (letfn [(f [node index]! (let [[max-index children*]! (reduce (fn [[i children] child]! (let [child* (f child (inc i))! i* (:max-index child*)]! [i* (conj children child*)]))! [index []]! (:children node))]! (assoc node! :index index! :children children*! :max-index max-index)))]! (f node 0)))
- 55. 0 1 2 E 3 4 B F A C 5 D 6 G (defn number-depth-first-stateful [node]! (let [index (atom 0)]! ((fn rec [n]! (let [i @index]! (swap! index inc)! (-> n! (assoc :index i)! (update-in [:children] #(mapv rec %)))))! node)))
- 56. 0 1 2 E 3 4 B F A C 5 D 6 G (defn print-depth-first-iterative [node]! (loop [index 0! nodes (list node)]! (when (seq nodes)! (let [[node & nodes*] nodes]! (println index (:label node))! (recur (inc index)! (concat (:children node)! nodes*))))))
- 57. 0 1 4 E 5 2 B F A C 3 D 6 G 0A 1B 2C 3D 4E 5F 6G (defn print-breadth-first-iterative [node]! (loop [index 0! nodes (list node)]! (when (seq nodes)! (let [[node & nodes*] nodes]! (println index (:label node))! (recur (inc index)! (concat nodes*! (:children node)))))))
- 58. 0 1 2 E 3 4 B F A C 5 D 6 G (defn make-zipper [root]! (z/zipper (fn branch? [n]! true)! :children! (fn make-node [n children]! (assoc n :children (vec children)))! root))
- 59. 0 1 2 E 3 4 B F A C 5 D 6 G (defn number-depth-first-zipper [node]! (loop [index 0! te c o n te x t c om p le loc (make-zipper node)]! as d at a! (if (z/end? loc)! (z/root loc)! (let [loc* (z/edit loc assoc :index index)]! (recur (inc index) (z/next loc*))))))
- 60. 0 1 4 E 5 2 B A C F 3 D 6 G Melt your brain: ! Breadth-first numbering! Chris Okasaki ! Backtracking Iterators! Jean-Christophe Filliâtre
- 61. Carefully consider: identities + contexts
- 64. EXTRA SLIDES PAST HERE
- 65. A note about laziness let cyclic = let x = 0 : y! y = 1 : x! in x! ! take 10 cyclic! -- [0,1,0,1,0,1,0,1,0,1] (def cyclic! (letfn [(x [] (cons 0 (lazy-seq (y))))! (y [] (cons 1 (lazy-seq (x))))]! (x)))! ! (take 10 cyclic)! ;=> (0 1 0 1 0 1 0 1 0 1)
- 66. (def cyclic! (letfn [(x [] (cons 0 (lazy-seq (y))))! (y [] (cons 1 (lazy-seq (x))))]! (x)))! ! (take 10 cyclic)! ;=> (0 1 0 1 0 1 0 1 0 1) (def cyclic! (letfn [(x [] (cons 0 (new clojure.lang.LazySeq! (fn [] (y)))))! (y [] (cons 1 (new clojure.lang.LazySeq! (fn [] (x)))))]! (x)))