Wow, Android is throwing significant weight behind RISC-V: https://arstechnica.com/gadgets/2023/01/google-announces-official-android-support-for-risc-v/
miniblog.
Diffing comments is surprisingly hard. In difftastic, I'm colouring the whole changed comment, but also underlining the changed words.
This works OK, but punctuation is harder to read (see second image) and sometimes there's code in comments (see third image).
Difftastic now handles tab characters precisely! This sounds like a small thing, but it's crucial when parsing Makefile syntax.
Makefiles look way better now.
(Technically tabs are also syntactically significant inside string literals, and that case is fixed too.)
Most of the gradual type systems I've seen are targetting existing languages: you want to interact with existing libraries that don't have type annotations.
Are there many greenfield languages with gradual types? It's a useful technique in other cases, such as refactoring.
I *love* that GitHub's Ctrl-F search still gives you the option of going back to the browser text search!
It's reasonable to override Ctrl-F in a website, but sometimes you really do want the normal browser tooling.
Programming languages aren't sports teams: you don't have to choose one to root for!
They're more like music genres, you can enjoy more than one.
I avoid language stickers for this reason. I don't want my identity to be "I'm an X programmer".
I've released difftastic 0.40! In this release:
* Faster, more efficient diffing courtesy of QuarticCat :)
* `--list-languages` is now more helpful
* Better support for older distros
https://github.com/Wilfred/difftastic/releases/tag/0.40.0
It's weird that some language communities have a thriving wiki, and others simply do not.
It doesn't seem to relate to community size, nor docs quality (e.g. the Emacs manual is great), nor the age of the language.
I don't care what your project's test coverage is, but the fact that you're measuring it is a great sign.
Discoverability on Mastodon is hard: I find myself using hashtags more to discover people.
I'm not aware of any suggestion tools here ("you follow A and B, you might want to follow C").
I'm getting a stream of new followers, which is a great way of finding people, but some users have no toots at all yet.
I suspect every programming language eventually becomes dated.
As soon as you commit to 1.0, you will have design decisions that (with hindsight) are mistakes, and you can't fix them.
Design best practices change over time too. Immutability is a more common default now.
Too many new languages describe themselves as "clear syntax" or "strong types". These features aren't very interesting, and are often subjective.
It's better to say what's unique, e.g. "a PL for IoT on boomerangs" would certainly be interesting!
Lisp is the only language I've seen where it's idiomatic to have some locals scoped to the *middle* of a function. It's a consequence of let blocks.
It's neat, but I rarely miss it elsewhere. I'm happy with "scoped from here to the end of the block" in e.g. C or Rust.
Using Miri, the Rust interpreter, as a profiler to find bottlenecks: https://medium.com/source-and-buggy/data-driven-performance-optimization-with-rust-and-miri-70cb6dde0d35
On the challenge of measuring spam prevalence externally, because historical data tends to be cleaner: https://cyber.fsi.stanford.edu/io/news/content-moderation-survivor-bias
I've released difftastic 0.39! In this release:
* Erlang support!
* Added `--check-only` and `--exit-code`, making difftastic useful in shell scripts
* Fixed some nasty display and file detection bugs
https://github.com/Wilfred/difftastic/releases/tag/0.39.0
One nice property of key-value punning is how it reduces the risk of accidental reordering.
Point { x, y, z } is less verbose than Point { x: x, y: y, z: z } and less error-prone than Point(x, y, z).
I'm slightly surprised that Rust has implemented the Default trait for booleans: https://doc.rust-lang.org/src/core/default.rs.html#205
The default is false, but it feels very arbitrary. Maybe it makes more sense next to integers, where the default value is 0.
Effects and code as a database in Unison: https://jaredforsyth.com/posts/whats-cool-about-unison/
Unison is looking at changing their program representation to plain sqlite!
I'm adding Erlang support for difftastic! The basic diffing works, but I'm still tweaking syntax highlighting.
The grammar distinguishes between "strings" and 'atoms', but I'm not sure if I should highlight both the same way.
Showing 481-500 of 7,506 posts