miniblog.

Interesting, candid article exploring what happens when you try to build a high performance conservative GC:

I really like frameworks that provide a skeleton project generator. It means the initial impression shows a working project, and helps promote best practices!

Exercism has a really good summary of what great code reviews look like: https://tinyletter.com/exercism/letters/exercism-behind-the-scenes-unhelpful-insulting-and-rude-feedback-antipatterns

Cyclic graphs are hard in Rust. A lovely post demonstrating how to use arenas in Rust to build mutable graphs whilst managing lifetimes correctly:

It is profoundly confusing writing a debugger. You're accustomed to seeing a stacktrace as a sign that you've screwed up, but it means that your debugger is working correctly!

Really neat code completion tool that combines program synthesis with a debugger, so you can set a break point and ask it to generate snippets using the values available! https://youtu.be/SnkskEgcbuQ

Quicktype is a nifty project that generates type definitions from sample JSON examples: https://github.com/quicktype/quicktype It's often easy to overlook parts of software development that can be automated.

Clojure provides a mechanism for early termination from reduce expressions with 'reduced': https://clojuredocs.org/clojure.core/reduced It's unusual to see a special early termination function: most PLs only provide general control flow constructs like exceptions.

Where static analysis can't work, the JS community is exploring libraries declaring that they're pure: https://github.com/webpack/webpack/blob/master/examples/side-effects/README.md

Today I learnt that make has a --dry-run option! Tools that want to discover project includes, such as rtags, use this to discover how your project is built:

elisp-def is now feature complete! You can jump to local definitions, global definitions and distinguish functions from variables, even when you're using macros!

Augmented intelligence by building UIs that are backed by ML models:

Crellvm: verifying LLVM optimisations with Coq: https://sf.snu.ac.kr/crellvm/ Impressively, they find bugs with optimisation passes which showed no bugs with fuzz testing!

Another interesting remark from the Go 1.10 changelog: they suggest you don't enforce that your code has been gofmt'd in your CI tool!

Go 1.10 has a number of dev performance improvements. One interesting unusual choice is that 'go test' caches the test result: https://golang.org/doc/go1.10#test If you run the same passing tests on the same binary, you just get the cached output by default. Perf vs flakiness.