TikTok and remix culture (long read but worthwhile): https://www.eugenewei.com/blog/2021/2/15/american-idle
miniblog.
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?
My favourite programming model is single machine, single thread. It's so much easier to reason about when you have fewer failure possibilities.
I really like compiler tools that give concrete lists of the optimisations they do. Binaryen is a great example of this:
https://github.com/WebAssembly/binaryen#binaryen-optimizations
Is there a good term for projects that maintain a set of patches, but still track upstream? For example, IceWeasel and Firefox.
The term "fork" tends to mean divergence and has a slightly more hostile vibe.
Abusing ELF files to see how few bytes you need for linux to still allow execution! https://www.muppetlabs.com/~breadbox/software/tiny/teensy.html
Showing 1,161-1,180 of 7,508 posts