You are in a maze of deeply nested maps, all alike

You are in a maze of deeply
nested maps, all alike
Eric Normand
IN/Clojure 2019

Symptom:
I can’t remember what keys belong in this map

Symptom:
I don’t even know what kind of entity I have

Symptom:
Working with deeply nested data is awkward

{:date #inst "1984-04-03T13:08:42.020"
:name "Soyuz T-11"
:spacecraft "Soyuz"
:destination "Salyut 7"
:crew [{:name "Yuri Malyshev"
:position "Commander"}
{:name "Gennadi Strekalov"
:position "Flight Engineer"}
{:name "Rakesh Sharma"
:position "Research Cosmonaut"}]}

(mapv (fn [mission]
(update mission :crew
(fn [crews]
(mapv (fn [crew]
(update crew :name
string/upper-case))
crews))))
missions)

(mapv (fn [mission]
(fn [crews]
(mapv (fn [crew]
(update crew :name
string/upper-case))
crews))))
missions)
maps

(mapv (fn [mission]
(fn [crews]
(mapv (fn [crew]
(update crew :name
string/upper-case))
crews))))
missions)
maps update

(mapv (fn [mission]
(fn [crews]
(mapv (fn [crew]
(update crew :name
string/upper-case))
crews))))
missions)
maps update
anonymous
functions

Symptom:
Long, convoluted functions

Technological Solutions
Spec
Specter

Symptoms Spec Specter
What keys?
Deep nesting
What entity?
✔
✔
✔
Long functions

Underlying Problem:
You're working at the wrong level of
meaning

{:date #inst "1984-04-03T13:08:42.020"
:name "Soyuz T-11"
:spacecraft "Soyuz"
map

{:date #inst "1984-04-03T13:08:42.020"
:name "Soyuz T-11"
:spacecraft "Soyuz"
character

Space travel
Bytes
Characters
Clojure Syntax
Clojure Semantics

Space travel (domain)
Bytes
Characters
Clojure Syntax
Clojure Semantics
Reader
read
eval
your code

Clojure core
Libraries
Domain code

(def user-info (reagent/atom {}))
(defn favorite-color-button [color] ;; reagent component
[:button {:on-click (fn []
(swap! user-info assoc :favorite-color color))
:style {:background-color color}}
color])
(defn favorite-color-panel []
[:div
[:h2 "Favorite color"]
[:h3 "Current: " (:favorite-color @user-info)]
[:h3 "Change it by clicking below"]
[favorite-color-button "green"]
[favorite-color-button "blue"]
[favorite-color-button "red"]])

user-info
favorite-color-button
assoc :favorite-color
(String)

user-info
(String)
favorite-animal-selector
assoc :favorite-animal
(Keyword)

user-info
(String)
(Keyword)
favorite-fruit-selector
assoc :favorite-fruit
(Keyword)

marital-status-indicator
assoc :marital-status
(Keyword)
elementary-school-chooser
assoc :elementary-school
(Integer)
user-info
(String)
(Keyword)
favorite-fruit-selector
assoc :favorite-fruit
(Keyword)

Clojure core
Libraries
Domain code
your head is up here

Clojure core
Libraries
Domain code
your head is up here
your code is down here

(assoc user-info :favorite-color color)
Clojure core and libraries

(defn set-favorite-color [user-info color]
(assoc user-info :favorite-color color))
Clojure core and libraries
domain

(swap! user-info set-favorite-color color))
color])
[:div

(ns my-app.user-info)

(ns my-app.user-info)
(defn set-favorite-animal [user-info animal]
(assoc user-info :favorite-animal animal))
(defn set-favorite-fruit [user-info fruit]
(assoc user-info :favorite-fruit fruit))

Objection:
But Eric, isn't that a lot of code?

(swap! user-info set-favorite-color color))
color])
[:div

Con:
3x the code
Pro:
Find things in ⅓ the time
Probably duplicated operations
Parts can evolve separately
Less to keep in your head

The biggest regret I hear frequently is
doing data operations everywhere.

Clojure core
Libraries
Domain Layer 1
Domain Layer 2
Domain Layer 3
Domain Layer 4

{:date #inst "1984-04-03T13:08:42.020"
:name "Soyuz T-11"
:spacecraft "Soyuz"
:crew {:commander {:name "Yuri Malyshev"
:favorite-color "blue"}
:flight-engineer {:name "Gennadi Strekalov"
:favorite-fruit :banana}
:research-cosmonaut {:name "Rakesh Sharma"
:favorite-animal :sheep}}}

You are in a maze of deeply nested maps, all alike

(assoc-in mission [:crew :research-cosmonaut :training :centrifuge :status] :pass)

mission
(update-in mission [:crew :research-cosmonaut :training :centrifuge :status] :pass)
person training

(ns my-app.training)
(defn set-status [record training status]
(assoc record training status))
(ns my-app.person
(:require [my-app.training :as training])
(defn set-training-status [person training status]
(update person :training training/set-status training status))
(ns my-app.mission
(:require [my-app.person :as person]))
(defn set-training-status [mission position training status]
(update-in mission [:crew position] person/set-training-status training status))

Clojure core
Libraries
Training
Person
Mission
UI

Law of Demeter
a given object should assume as little as possible about
the structure or properties of anything else (including its
subcomponents)

Objection:
But Eric, aren't you encapsulating?
Isn't the point of Clojure that it's all data?

Summary:
We are encapsulating and it's still data.

Map Entitytension
● enumerate keys
● serialize to json
● print
● compare with =
● hash code
● try out data operations at
REPL

Map Entitytension
● enumerate keys
● serialize to json
● print
● compare with =
● hash code
● try out data operations at
REPL
● domain operations
● maintain invariants
● program at a high level
● easier to understand

Chemistry (heat, acids, proteins, starches, etc)
Applying heat
Ingredients (vegetables, meats, oils, spices)
Basics (sauces, masalas, dough)
Dishes
Stratified Design
Chopping

Applying heat
Dishes
Stratified Design
Chopping
changes faster
changes slower
Principle:
separate things according to rates of change

Applying heat
Dishes
Stratified Design
Chopping
Principle:
each layer can only require downward

Applying heat
Dishes
Stratified Design
Chopping
Principle:
be careful if you skip layers

Constructors
Functions for generating entities
Benefits
● Define the entity's keys
● Check required keys
● Check types
● Check invariants
● Default values
● Calculated values

Constructors
(defn ->person [& {:keys [name
trainings]
:or {trainings []}}]
(assert (string? name))
(let [name (string/trim name)]
(assert (not (empty? name)))
{:name name
:trainings trainings}))
key names
default
type + required
calculation
invariant

Combining Operations
Functions that combine 2 or more entities of the same type
Benefits
● Hardest type of operation first
● Constrain the design (good thing)
● Biggest potential for algebraic reasoning

Combining operations
(ns my-app.training)
(defn combine-training-status [a b]
(cond
(= :pass a) :pass
(= :pass b) :pass
:else :fail))
(defn combine-trainings [a b]
(merge-with combine-training-status a b))
two statuses
two training records

Meaning
Data
you want to be working up here

Meaning
Data
you want to be working up here
but you're stuck down here

Smell:
Deep paths with get-in, update-in, assoc-in

Smell:
Large hashmaps with lots of keys

{:id 1232
:email "eric@lispcast.com"
:phone "504-982-9167"
:street1 "332 Main St"
:street2 "Apartment 54"
:city "New Orleans"
:state "LA"
:zip "70117"
:favorite-color "blue"
:favorite-animal :orangutan
:favorite-fruit :apple}

{:id 1232
:email "eric@lispcast.com"
:phone "504-982-9167"
:street1 "332 Main St"
:city "New Orleans"
:state "LA"
:zip "70117"
:favorite-color "blue"
:favorite-animal :orangutan
:favorite-fruit :apple}
do these go together?

{:id 1232
:contact-info {:email "eric@lispcast.com"
:phone "504-982-9167"
:address {:street1 "332 Main St"
:city "New Orleans"
:state "LA"
:zip "70117"}}
:favorites {:color "blue"
:animal :orangutan
:fruit :apple}}

Smell:
Using 3rd party API results directly

{:tags [21 134 353 386 388],
:format "standard",
:date "2017-04-24T11:59:33",
:slug "kjetil-valle-and-bendik-solheim-lambdaconf-2017-interview",
:meta {:_edd_button_behavior []},
:ping_status "closed",
:yst_prominent_words [3680 979 1318 497 505 849 3783 495 3938],
:featured_media 8087,
:content
{:rendered
"<p>......",
:protected false},
:modified_gmt "2018-04-11T11:31:44",
:excerpt
{:rendered
"<p>......",
:protected false},
:type "post",
:custom
{:seen_in_lesson_rss "0",
:markdown_content
"......",
:s3_filename "",
:availability "Paid",
:wistia_download_link "",
:tweet_ids "",
:tweet
"....",
:video_length "",
:footer_script "",
:language "a:1:{i:0;s:7:"Clojure";}",
:inline_featured_image "0",
:last_tweet_time "",
:git_tag "",
:github_repo "",
:header_script "",
:wistia_id "",
:autopause_times ""},
:template "",
:modified "2018-04-11T11:31:44",
:title
{:rendered
"# ...."},
:author 652,
:date_gmt "2017-04-24T11:59:33",
:comment_status "closed",
:categories [123],
:sticky false,
:status "draft",
:link "https://purelyfunctional.tv/?p=8086",
:id 8086,
:_links
{:version-history

{:id 143
:video-id "44fvv3"
:sequence-number "003"
:name "Concurrent Clojure"
:duration 34223
:programming-language 4
:cover nil
:course-id 74
:s3-links {:original {:filename "ConcurrentClojure.mp4"
:filesize 321554}
:hd {:filename "ConcurrentClojure.mp4"
:filesize 321443}
:md {:filename "ConcurrentClojure.mp4"
:filesize 54443}
:phone {:filename "ConcurrentClojure.mp4"
:filesize 3223}}}

Know what level of meaning you are at
● Look for semantic layers
● Avoid crossing semantic layers
● Organize your entities and operations
● Think about combining operations
● Add a layer of indirection between your service and other systems
● Use constructors to make getting it right easier
● Name operations to give things meaning

Eric Normand
Follow Eric on:
Eric Normand @EricNormand
eric@lispcast.comlispcast.com

You are in a maze of deeply nested maps, all alike

More Related Content

What's hot (20)

Similar to You are in a maze of deeply nested maps, all alike (20)

More from Eric Normand (9)

Recently uploaded (20)

You are in a maze of deeply nested maps, all alike