Today I learnt that you can tell GitHub which files in a repo are generated, so they're not shown in the default pull request view! https://docs.github.com/en/github/administering-a-repository/customizing-how-changed-files-appear-on-github
miniblog.
Codecov has published a bunch of interesting statistics about CI! Ruby has the highest average coverage, GH Actions is already the biggest CI provider, and 13% of projects have 100% coverage.
Moving all my elisp projects from Travis to GitHub actions has been a hassle, although it's getting easier with practice.
I ported emacs-racer today: https://github.com/racer-rust/emacs-racer/blob/master/.github/workflows/test.yml
I've learnt the hard way that it's worth testing your code both with and without byte-compilation too.
It's a little surprising how few programming languages have first-party/official LSP implementations. It's such a valuable part of the user's experience!
(cf Smalltalk where the environment is often more important than the syntax or libraries.)
VS Code is mostly open source, but sadly there are some major exceptions. Open source forks can't access the official package repository apparently: https://bugs.archlinux.org/task/67780
Want coding to feel more like gaming? Apparently you can show your VS Code editor status in Discord now: https://github.com/iCrawl/discord-vscode
Apparently you can even get programmable watches with attachable qwerty keyboards now! https://www.tindie.com/products/ttgo/lilygor-ttgo-t-watch-keyboard/
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!
Showing 281-300 of 345 posts