Wilfred Hughes @wilfredh@mastodon.social

Super low bitrate codecs are making video calls on 56kbps internet connections feasible! https://ai.googleblog.com/2021/02/lyra-new-very-low-bitrate-codec-for.html

Rust and LLVM progress in 2021: https://www.icloud.com/keynote/09ZXbPfbCKm8vCtAnWdfi2xIg

PGO in rustc is showing promise, and the Motorola 68000 LLVM backend was upstreamed just to enable usage in Rust!

Dr John Shutt, the author of the kernel lisp language and exploring f-expressions, has passed away: https://en.wikinews.org/wiki/Wikinews_mourns_loss_of_volunteer_John_Shutt

I'm finding that it's easier to write static analysis tools for language X in language X. It's less to think about.

I've been writing an analysis for JS. I really like working with typescript but it's been easier to prototype if I dogfood.

TikTok and remix culture (long read but worthwhile): https://www.eugenewei.com/blog/2021/2/15/american-idle

I like writing web applications in memory managed languages because you shouldn't get pwned by RCE. RCE in Python from *just a number* is scary.

https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-3177

I'm rewriting a Rust function transform function from `&mut Foo` to `Foo -> Foo`. It might be a little slower, but ownership makes it harder to miss parts of the Foo type when I work with values.

I've seen 'modularity shaming' for JS libraries that are big and make sites slow to load. I'm surprised to see Wikipedia start reporting on app size though!

At one point, all of Germany's air traffic control message routing was in Emacs!

https://old.reddit.com/r/emacs/comments/lly7po/do_you_use_emacs_lisp_as_a_general_purpose/gnvzisy/

Deliberately overclocking the Super Game Boy 2 so one instruction fails(!) and the ROM contents can be observed: https://gekkio.fi/blog/2015/dumping-the-super-game-boy-2-boot-rom/

Nice, accessible discussion of linear types, giving an example where you can prevent sockets being bound and listened to at the same time: https://www.tweag.io/blog/2017-08-03-linear-typestates/

Incredibly impressive: reverse-engineering and modifying SNES games so they run on the faster CPU in the cartridge, not the console CPU: https://www.retrorgb.com/vitor-vilelas-race-drivin-sa-1-hack-released.html

Lisp macros are like salt, and a little goes a long way. Looking at some code I wrote in 2013 and I was too heavy-handed then. I learnt a lot in the process though!

Today I learnt about --ignore-rev with git-blame. Super handy if git thinks moving some code made you the author.

$ git blame --ignore-rev abcdef source_file

(Turned out I was still the author, but several years earlier!)

LSP is great for providing basic IDE services across editors and language. I do wonder if it limits the best you can do.

For example, I'm not aware of any way you can add up/down arrows to the margin for exploring inheritance. Hover text or lenses seem to be your only options.

A remarkable number of developers continually undo changes or copy-paste code so they can refer to the previous implementation! https://web.eecs.utk.edu/~azh/blog/yestercode.html

I definitely use the GitHub web UI as a reference for the current code sometimes.

On the large number of similarities between software engineering and other kinds of engineering: https://www.hillelwayne.com/post/crossover-project/we-are-not-special/

Making the most of Magit, and a helpful pointer to magit-file-dispatch which was new to me:

https://emacsredux.com/blog/2020/12/10/essential-magit-file-commands/

Print debugging remains an extremely common debugging technique. This makes me wonder: what's the state-of-the-art for print debugging?

Rust's debug! macro prints a bunch of helpful information (variable name, line number) but there must be other nice tools in this space.

I average about two pull requests per week across my personal GitHub repos. It's easy to let them pile up.

Easy PRs (uncontroversial fix, green build) are fine, but harder PRs (old project, broken build, complex feature) can be a chore in aggregate.

Any tips?