Clojure/West 2013 in 30 mins

Clojure/West 2013 in 10-ish mins

Leonardo Borges
@leonardo_borges
http://www.leonardoborges.com
http://www.thoughtworks.com
Saturday, 30 March 13

Day 1


DDD in Clojure - Amit Rathore @amitrathore



OO can still teach us a thing or two



In OO:
- nouns
- processes owned by nouns
- nouns are classes
- processes are methods



In OO: In Clojure:
- nouns - verbs
- processes owned by nouns - domain model: functions that
- nouns are classes transform data
- processes are methods



A few general guidelines for your domain:
- no side-eﬀects
- no dependencies on external services
- validate outside the model boundary (validateur, bouncer, clj-
scheme)
- no illegal state in domain functions (slingshot)



When you have no idea:

- zolo.homeless.*



Still relevant:

- SOLID principles
- Few public fns (lots of private, helper fns)
- small fns (3-4 lines)
- optimize for readability


RESTful Clojure - Siva Jagadeesan



Richardson Maturity
Model



Richardson Maturity
Model

?


Richardson Maturity Model:
- Level 0
- Level 1: Resources
- Level 2: HTTP Verbs
- Level 3: Hypermedia



Level 0
- GET /api?action=create_order&param1=val1
- GET /create_order?param1=val1



Level 1 - Resources
- GET /orders?action=create&param1=val1



Level 2 - HTTP Verbs
- GET /orders
- POST /orders ( includes body payload)



Level 3 - Hypermedia
- GET /orders



Level 3 - Hypermedia
- GET /orders
{
"id": 1,
"items": [
{
"id": 2
}
],
"link": {
"rel": "delete",
"href": "/orders/1"
}
}

Engines of Abstraction - Jim Duey


Ah, one more monads talk!

- Monoids in clojure - list, concat, set, union, hash-map...

- Functors - a context datatype and a fn (fmap) to apply a function to each
value inside that context

- Applicative Functors - a context datatype and two functions:
one that wraps a value in the context type 'amap' applies fns wrapped in
the context to parameters wrapped in the context

- Monads - context data type, fn that wraps values, fn (bind) to apply a fn
to wrapped values. The applied fn takes a value and returns a wrapped
value.


Who wants a monads talk at #cljsyd? :)


Clojure in the Large - Stuart sierra



Lisp is a ball of mud
- not a lot of structure: namespaces and vars. That’s it.
- namespaces: not ﬁrst-class modules
- def and defn are global by default

Also talked about encapsulation and global state



Encapsulation anti-pattern:

;; Tempation to share it promiscuously!
(def state-a (ref {}))

;; Hidden dependencies
(defn op1 []
(dosync
(alter state-a ...)))



Encapsulation: use local-state instead

;; Well-defined initial state. 'Go together' semantics
(defn constructor []
{:a (ref {})
:b (atom 0)})

;; Makes function dependencies clear
(defn op1 [state]
(dosync
(alter (:a state) ...)))



with-* macros:
- assumes body starts and ends in a single thread
- assumes doesn’t return lazy seqs
- limits caller to one resource at a time



Anti-pattern - thread-bound state:

(def ^:dynamic *resource*)

(defn- internal-op1 []
... *resource* ...)

;;another hidden dependency
(defn op1 [arg]
(internal-op1 ...))



Local state with dynamic extent: nested with-resources
;; Pass around "context" argument
(defn op1 [context] ;; not confined to a single thread
;; acquire resources
(let [resource (::resource context)]
;; use namespace qualified keys
(assoc context ::result1 ...)))

;; still need to manage resource lifecycle
(defn finish [context]
(update-in context [::resource] dispose))


When is it safe to use global Vars?
- True constants: (def ^:const gravity 6....)
- True singletons: (def runtime (Runtime/getRuntime))
- For REPL dev
- Private dynamic vars are OK:
(def ^:private ^:dynamic *state*)

(binding [*state* ....]
...)


Pedestal

No point in showing it here. Go to http://pedestal.io/


Beyond contracts - Paul deGrandis


Beyond contracts - Paul deGrandis

core.specs: automatically generate tests and
documentation and contracts from REPL explorations:

https://github.com/ohpauleez/sterling


Day 2


PuppetDB - centralised DB for Puppet developed in
Clojure


PuppetDB - centralised DB for Puppet developed in
Clojure
Why Clojure?
- Issues with Ruby: slow, GIL, garbage collection

Puppet DB is a layer on top of PostgreSQL

Write pipeline:
- async, parallel, MQ-based, automatic retry

Read pipeline:
- DLS, AST-based, transferred over the wire using JSON
- you can write your own

Securing Clojure Web Apps/Services with Friend -
Chas Emerick


Chas Emerick

- Authentication and Authorization library for Clojure
- Ring middleware


Chas Emerick
Batteries included:
- Authentication workﬂows
- form-based "interactive" login
- HTTP basic (Digest, soon)
- OpenId (Google, Yahoo, Wordpress etc...)
- "Channel enforcement" (e.g. require HTTPS)

- Authorization Options
- Roles based on Clojure's ad-hoc hierarchies
- functions, macros, and ring middleware for enforcinf role-based
auth policy
- Arbitrary imperative control

Chas Emerick

https://github.com/cemerick/friend


pallet.clj - Infrastructure project ﬁle


pallet.clj - Infrastructure project ﬁle

pallet-lein plugin: https://github.com/pallet/pallet-lein

create pallet.clj ﬁle

> lein pallet up <-- local

or on EC2...


clj-v8 and the dieter asset pipeline


clj-v8 and the dieter asset pipeline

JS/CSS miniﬁcation, concatenation and cache busting:
https://github.com/edgecase/dieter


Day 3


Ritz - The missing Clojure tooling:
https://github.com/pallet/ritz


Macros vs. Monads


Macros vs. Monads

Synthread: https://github.com/LonoCloud/synthread
- Presented as an alternative do the state monad:

(require '[synthread :as ->])

(-> {}
f1
f2
f3)


Macros vs. Monads

And it’s got lots of other useful macros:
->/do
->/if
->/when
->/for
->/assoc
->/update-in


The End
Questions?

Leonardo Borges
@leonardo_borges
http://www.leonardoborges.com
http://www.thoughtworks.com

Clojure/West 2013 in 30 mins

Recomendados

Recomendados

Más contenido relacionado

Más de Leonardo Borges

Más de Leonardo Borges (13)

Clojure/West 2013 in 30 mins