A big appeal of Emacs, the infinitely customisable editor, is that you can mold it to perfectly fix your workflow.
I have a sneaking suspicion that the Ikea Effect https://en.m.wikipedia.org/wiki/IKEA_effect increases the appeal too though.
miniblog.
Interesting, candid article exploring what happens when you try to build a high performance conservative GC: https://www.excelsiorjet.com/blog/articles/conservative-gc-is-it-really-that-bad/
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: https://exyr.org/2018/rust-arenas-vs-dropck/
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: https://github.com/Andersbakken/rtags#setup
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! https://github.com/Wilfred/elisp-def
Augmented intelligence by building UIs that are backed by ML models: https://distill.pub/2017/aia/
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! https://golang.org/doc/go1.10#gofmt
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.
Current status: working on crazy go-to-definition tool for elisp: https://github.com/Wilfred/elisp-def
It understands let, let*, global vars, functions and even macros that introduce bindings!*
*Some terms and condition apply.
Today I learnt that you can do music lessons over Skype! This seems like a brilliant way of connecting students and teachers without needing to be in the same location/country/timezone.
When you're writing static analysis tools, should you make your analysis flow or path dependent? What is the accuracy/performance tradeoff?
https://www.youtube.com/watch?v=JpK9e__q5Ts shows an elegant approach using monad transformers to make this pluggable.
Common types of implementation bugs found by RISC-V formal: https://github.com/cliffordwolf/riscv-formal/blob/master/docs/examplebugs.md
Showing 561-580 of 657 posts