miniblog.

Plotting TODOs over time for different OSS projects is a really interesting way to look at project development: https://schleiss.io/plotting-source-code-todos-for-open-source-projects There's often a bump before a major release. Most projects increase over time (perhaps it's proportional to LOC?).
Photo
scc is a fast, polished tool for counting lines of code: https://github.com/boyter/scc The author has several great posts discussing LOC tooling, including this one on exploring codebases with it:
grex is a really impressive tool that generates a small regex for a given set of string inputs: https://github.com/pemistahl/grex#53--examples-top- There's a live instance you can play with at:
Fascinated (and slightly surprised) that Google found ~50% of security bugs occur in code written in the last 12 months. So maintained code that isn't actively developed is often good!
2
Super impressed that I received an elisp PR that discusses backwards compatibility to 1997!
One nice property of autoformatters: they're a really fast way to do a quick syntax check. Especially with a slow build process, it's a good check for dumb mistakes.
8
It's now possible to compile small Rust programs with libgccjit! This will enable Rust on a bunch more architectures. https://blog.antoyo.xyz/rustc_codegen_gcc-run-core-tests Admittedly these programs don't run correctly yet, but getting something basic working often takes 80% of the work in PL.
The Rust documentation host, https://docs.rs/, has a really cute nudge to make sure your code has documentation. It exposes the docs coverage percentage in the UI!
Photo
Blog comments work best when the author has a large following, and they actively engage their community. I don't think many blogs reach this scale. For a typical blog, it's probably better to have comments on link aggregators (Reddit etc) instead.
1
I'm coming to the view that NP-complete problems are harder to work with than tasks equivalent to the halting problem. For the halting problem, you know you're never going to solve the general case. For NP-complete problems there's a slew of complex algorithms to explore.
21
The Nintendo Switch has a clever way of preventing firmware downgrades: upgrading the firmware blows an internal fuse! https://news.ycombinator.com/item?id=27202766 This means that the hardware knows a newer firmware exists.
1
Writing a REPL that evaluates-as-you-type, keeping the UI responsive and staying defensive against runaway memory usage: https://scattered-thoughts.net/writing/making-live-repls-behave/ It's a really hard problem for PLs, but even this small live demo has a lot of complexity.
An amazing font concept: adjusting letter size based on how you typed then!
3
The OCaml compiler saw a huge jump in contributors after moving to GitHub, and the effect has persisted. Source:
Photo
256
This is really neat: an online collection of programs that can pass the type checker but fail at runtime, in a bunch of languages (Java, Scala, OCaml, Haskell, Rust): https://counterexamples.org/runtime-misinformation.html It also discusses the design tradeoffs that led to these behaviours.
Showing 211-225 of 345 posts