miniblog.

Writing a tracing macro in Elixir: https://www.theerlangelist.com/article/macros_5 Lovely non-trivial example of where macros shine!

A discussion of IBM's revenue also shows the remarkable trajectory of Microsoft. MS may not have a foothold in mobile, and Windows is at saturation, but they're still growing! https://www.zdnet.com/article/ibm-shows-growth-after-22-straight-quarters-of-declining-revenues-but-has-it-turned-the-corner/ I believe this is largely Azure.

A wonderful talk on a Common Lisp implementation (CCL), language community dynamics, and how things evolve: https://thisoldlisp.com/talks/els-2018/

Excellent overview of what WebAssembly enables today, and the features it will enable in future: https://hacks.mozilla.org/2018/10/webassemblys-post-mvp-future/ (High performance sandboxed execution! Better dev tools!)

Interestingly, Emacs lisp considers the literal 1. to be an integer literal, whereas most languages consider a decimal point to always mean a floating point number.

Awesome GitHub feature: if you link to a line of code at a specific commit, it will render as a little code preview! Relevant docs:

People running successful open source projects: what do you do when the rate of PRs grows beyond what you can handle? How do you ensure that PRs have had at least one collaborator respond, without being drowned in notifications/emails yourself? Please RT for reach.

The problem with being a software developer is that you stop seeing software as a fixed artifact that you can take or leave. Instead you start noticing things like 'this input would be better with type=email' and it's harder to accept poor designs.

Hyde: https://github.com/adobe/hyde generates C++ docs by parsing source code and generating separate docs for users to add to. Example output: https://stlab.cc/libraries/stlab2Fcopy_on_write.hpp/copy_on_write3CT3E/ They're absolutely right that inline docs can eventually become overwhelming when you're trying to read code.

An excellent retrospective on the design of Stack Overflow and the fundamental challenges in its purpose:

Stable proc macros! Nicer namespaces! Many nice new features in Rust 1.30:

I love the idea of an AST level blame tool. I'd like to ask questions like "who added this function call?"

The secret to uncontroversial pull requests often seems to be fixing a bug/adding a feature in as few characters as possible.

Esy is a JS preprocessor that lets you define your own blocks: https://www.npmjs.com/package/esy-language It's a macro system, but it doesn't overlap with function call syntax (unlike e.g. lisp). It makes it a little easier to spot macros, without a whole separate namespace (like foo! in Rust).

The long term trend in software UIs seems to be away from 'saving'. Games autosave, websites save settings as soon as you change them, and online document editors don't even allow you to manually save!