I went to clojurewest 2017 in Portland, Oregon. Good conference, lots of good information. Here are my observations, my notes, and a few pictures.
The Good
The conference was well managed. The talks were mosty interesting. The community continues to be friendly, open, and inclusive.
The Bad
I wish there had been a few more "This is something I worked on that is very cool" type presentations, but you can't force those. Maybe there just wasn't as much cool stuff in 2017 compared to previous years. I guess every year can't be a "Clojure now compiles to javascript" or "core.async, use it" kind of year.
The City
Portland is an interesting city. I didn't actually realize how small and walkable the core of the city is. In San Francisco, I have practially forgotten what it is to see families with kids on the street. It is certainly a nice place to visit. I liked the eating, the literary/craft tradition, the beer, and the people. It did have a number of younger homeless (kind of reminded me of Berkeley). It did have the feeling of a place that gets a lot of tourist (that can be tiring when you live there). I could see myself being very happy there, but I haven't heard a whole lot about the tech scene there. The public transportation is excellent and the lack of traffic is a pleasure. I don't know if it is a place to "see and be seen" but it certainly felt like a place to "live and let live". Kind of like the kind of "weird" that Austin aspires to.
The Pictures
Clojure/West 2017
The Notes
Core.Async in Use - Timothy Balridge - core.async
- Count is O(n) on a concat, as concat is lazy and only closes over two collections
- Recommends understanding transducers if you are going to continue using core.async.
- If you are going to use async code, then consider writing a framework such that the asynchronous code is hidden from the user.
- High Level:
- Keep userspace code pure
- Move complexity out of user space
- Make dependencies explicit
- Leverage this for easier testing
- Use core.async to enable cleaner abstraction, not as an end in itself.
With Great Composition Comes Great Responsibility - Elizabeth Engelman
- Datomic data is immutable
- Datomic is ACID
- Datomic is very flexible
- You can of course just concat if you want to put where clauses together
Using spec to Transparently Replace a Legacy System - Daniel Solano Gómez
- Capture a day’s worth GET and generate specs for them. Now you can generate inputs used on your system automatically.
- Maybe this is an example of actually being able to do full rewrites. If you have a endpoint system than you should be able to replace it by specing it out.
- In a odd way, kind of another argument to keep the API of your old customers live. Even if you do upgrade the code, be sure to have a backwards version of the API that older customers can continue using forever.
Testing Made Simple - Tony Kay
- In order to test something, you often end up writing a second version (generative).
- General principles
- Don’t clump
- Don’t involve more than 2 layers at once
- Name the thing under test and use a “sentence completion” around each test
- Design is more important than most things. If you ever say that your design is really hard to test, then that probably means your design is bad.
- When testing macros in can often be beneficial to use clojure.spec to write conformance. Macros should be tested for the actual code transformations, not for the side effect, that way lies madness.
- https://github.com/untangled-web/untangled-spec
Practical Clojure Profiling in Production - Gregory Sizemore
- YourKit - Great for profiling
- You should profile on production data!
- Reflection is really slow
- Usually does not matter
- Type hints can help
- Criterium - benchmarking library for clojure
- Be sure to measure and RECORD every time. You need to be able to “remember” what the performance measures were previously. Don’t rely on yourself remembering how long things took. (NewRelic is recommended)
- Clj-newrelic - gives you a macro that lets you easily trace functions
Navigating ClojureScript's Fire Swamps - Peter Schuck
- :infer-externs true
- Library cljs/oops
- Fx oget, oset, ocall, oapply
- https://github.com/binaryage/cljs-oops
- Soft-access ?, punching !,
- Prefer CLJS library or externs files, when neither exist use clojurescript externs inference or cljs-oops
- Google closure compiler can now compile node modules
- Modules have existed for 2 years! They are really good at splitting. They really suck in terms of all the boilerplate OO code you have to write in order to use them…. Probably still not worth it.
Fearless JVM Lambdas - John Chapin
- Austin conference on May 8
- Backend as a Service: Firebase, Cognito, Auth0
- Functions as a Service: AWS Lambda, Microsoft Azure FUnctions, Google Cloud Functions (run in response to events)
- Serverless = Backend as a Service + Frontend as a Service
- Excellent Serverless use cases
- Latency Tolerance, asynchronous - Data Pipelines
- Latency tolerant, synchronous - web apps, API’s
- Glue
- So if you have to use them, then go ahead and use them.
Solving Problems Declaratively - Mark Engelberg
- Dancing Links (exactly one)
- https://github.com/engelberg/tarantella
- https://en.wikipedia.org/wiki/Dancing_Links
- Boolean Satisfiability - True/False + logical constraints
- https://github.com/Engelberg/rolling-stones
- https://en.wikipedia.org/wiki/Boolean_satisfiability_problem
- Robot Repair - give the gift of Boolean Satisfiability
- Constraint Programming deals with variables that can take on a finite number of integer values, multi-valued variables + logical and arithmetic constraints
- https://en.wikipedia.org/wiki/Constraint_programming
- https://github.com/aengelberg/loco
- http://github.com/engelberg/ycover
- CodeMaster was his previous game
- You should read more Knuth stuff
UNSESSION - Spec - Alex Miller
- Just an question answer pairing on spec.
Full Stack Teleport Testing with Om Next & Datomic - António Monteiro, Mike Kaplinskiy
- At one point they said a parser query can be a mutation? Seems weird.
- Use integration test for correctness in parallel for load testing
- Run test in parallel using multiple databases
- Something about cloning the state of the database so that you can for datomic actions.
- https://github.com/vvvvalvalval/datomock
- Takeways
- Datomic is awesome
- Homoiconicity
- Om Next reified state transitions (as data!)
- Immutability (structural sharing)
ClojureScript in Your Pocket - Dom Kiva-Meyer, Lily M. Goh
- ReactNative - Fast Iterations, Familiarity, Cross-platform, Performance, Large Ecosystem
- Could you only develop ReactNative and just ignore the web
- Expo - Provides additional API’s and allows you to use without needing Mac dependencies. Is somewhat of a “walled garden” of audited features.
- Graphql voyager
- GraphiQl
- Lacinia - https://github.com/walmartlabs/lacinia
- Datomic
- Rest - swagger is probably best / graphql tooling so much better
- http://swagger.io/ - Might be good for gaend
- I still really don’t get how you go about deciding on the schema?
Power to the (Mobile) People: Clojure and GraphQL - Howard Lewis Ship
- GraphQL resultant is the same “shape” as the query
- Some queries are mutations…
- SCHEMA defines the data from graphql’s point of view
- Your job is largely to define functions that handle the different queries
It's Just Data - Bob Calco
- These are good slides, you should look at this more
- A human being with a good visualization can currently understand many things more efficiently than any amount of machine learning.
- Datomic is a great story for understanding the flows of anything through time, including bad data, which can be important for understanding the worlds understanding through time
- Datomic does not have a required field for the same reason it does not have a null value.
Irrevocable Trust are kind of cool.
- “Objects and entities are total figments of our imaginations”
- Datomic allows you to simply add attributes as the facts of those models are revealed to you.
Emulators, Immutability, and Time Travel - Angus Fletcher
- NES Emulator
- E.T. almost killed video games
- Nintendo Entertainment System saved it
** PPU is a fancy clock
- Cycle (vertical) (0-40)
- Scan Line (Horizontal) (0-261)
- Keeping everything in one place (atom) works really well
Synthesis and Verification for All - Emina Torlak
- A
solver-aided tool - Rusette allows you to implement an interpreter for your language which somehow makes your failing cases pass. I am lost.
- DSL’s are good because
- They result in less code for humans
- They have additional constraints that allow tools (like solver-aided languages) that can be exploited.
- The verify logically goes through all paths of the program and ask if any symbolic variables can be given values that cause things to not assert correctly.