Fitting a respectable C compiler into a 512 *byte* binary! https://xorvoid.com/sectorc.html
miniblog.
I'm writing an experimental PL and I want to exercise it on real programs asap. These need to be useful (so I actually try them), but simple (my PL is unfinished).
My current ideas:
* A git fuzzy branch switcher (shell commands)
* dotfiles sync (filesystem access)
Suggestions?
TIL that PGP keyservers no longer support 'web of trust' chains of signatures, as they were being spammed by people uploading massive signature chains: https://inversegravity.net/2019/web-of-trust-dead/
I'm still figuring out where Copilot fits in my workflow, and I find it works really well *when I know exactly what code I want*.
When I have e.g. two lines in mind, I can see if it will write them (saving me the typing), and it's trivial to validate correctness.
When you start a greenfield project, there will be parts of your code that you write and will never need to modify again.
It's weird, and I don't think this phenomenon really occurs in established projects.
GitHub tracks download counts for releases, so I can see that macOS releases of difftastic downloaded are downloaded much less frequently!
I don't know if it's proportional to usage though. All these operating systems have several package managers.
https://somsubhra.github.io/github-release-stats/?username=Wilfred&;repository=Difftastic&page=1&per_page=5
Optimising GHC, implementing assembly pretty-printers, and the tradeoffs of implementing against an interface: https://www.tweag.io/blog/2022-12-22-making-ghc-faster-at-emitting-code/
I've released difftastic 0.47! In this release:
* Language detection is now completely overridable. You can do things like DFT_OVERRIDE='*.json:yaml' to treat all .json files as YAML.
* Added support for the Solidity language.
https://github.com/Wilfred/difftastic/releases/tag/0.47.0
An introduction to devcontainers, the advantages of a reproducible local dev environment and where it makes sense: https://www.infoq.com/articles/devcontainers/
It's so easy to overlook the importance of tooling around a language, unlike (say) syntax.
Are there any languages that explicitly put tooling first? Maybe Kotlin or Pharo?
It's really impressive to see hibernation support on RISC-V land in Linux, when you can't even buy RISC-V laptops yet! https://www.phoronix.com/news/RISC-V-Hibernation-Support
"origin" is such a long default name for git origins. I've started naming all my GitHub origins to just "gh".
One of the challenges with PLs that build on top of others (Typescript to JS, Scala/Clojure to Java, C++ to C) is documentation. You often have to read two sets of docs with two distinct syntaxes.
Which languages do this best? Sometimes I wish there was a TS version of MDN.
I certainly see the appeal of ChatGPT as a conversational interface for knowledge questions, but it's wrong often enough that I can't trust it.
Prompt: What does :extend do to an Emacs font face?
This is wrong (it's confused with :inherit) and it's hallucinated a version constraint.
On storing ASTs in flat arrays for performance, and the relationship with bytecode interpreters: https://www.cs.cornell.edu/~asampson/blog/flattening.html
A wonderful article explaining how compiler drivers work, clarifying the relationship between the preprocessor, the compiler proper, and the linker: https://fabiensanglard.net/dc/driver.php
Reflecting on the niceties and tricky parts of building systems with OCaml: https://borretti.me/article/two-years-ocaml
(The author's experience match my own in a bunch of cases.)
I'm never sure what version of Rust to target for my projects.
For difftastic I pinned to rust 1.57 and I haven't needed to bump it so far.
Debian stable is still on 1.48 though! https://tracker.debian.org/pkg/rustc
@nihilazo @eli_oat @technomancy @csepp The thing I like about lisps is the ability to build functions around snippets until I've written a whole program. It's interactive and pleasant.
I agree that the advocacy is distracting. The book Let Over Lambda has interesting ideas but it's *so* convinced that lisp is always the best.
I sometimes find it hard to read too. It's easy for different patterns to look visually similar.
Tests may not guarantee correctness, but they are often suggestive.
When I have a bunch of regression tests for *real* issues, I feel a lot more confident. I'm covering ways I've failed in the past.
Showing 101-120 of 235 posts