Difftastic now has its own homepage! I wanted to put together a set of screenshots that showed why you might like it.
https://difftastic.wilfred.me.uk/
Feedback welcome :)
miniblog.
An interactive version of the Go 1.22 release notes! https://antonz.org/go-1-22/
This is really elegant, I'd love to see more languages have this.
After seeing yet another YAML dialect for controlling systems, I think we need a hierarchy of YAML dialect expressiveness.
(1) Has its own variable binding system.
(2) Supports if statements.
(3) Supports loops.
(4) Supports function definition.
2 seems to be the most common, but I've seen all of 1-3. Does level 4 exist in the wild yet?
What software designs require clean slate 'revolution' implementations, rather than evolution?
I can think of: borrow checking in a PL (existing code is unsafe), microkernels (architecture is too different from monokernels), and full REPLs (can't add type redefinition later).
Are users more tolerant of a slow programming language if it has good multithreading or green threads?
I'd be willing to use a PL with good ergonomics that runs at 0.5x speed if it's easy to saturate multiple threads.
(PLs focusing on single-threaded performance are common!)
One interesting side effect of software productivity increasing: libraries can become more idiosyncratic.
It's easier than ever to release important libraries as an individual. Single-maintainer projects inevitably have more personality -- for both good and bad!
Today I learnt that A* doesn't work for an arbitrary non-planar graph, you need additional structure:
https://stackoverflow.com/q/26568552/509706
This matches my experience with difftastic so far. The graph is non-planar and my best heuristic only matches Dijkstra perf in typical cases.
One underrated perk of string interpolation: it arguably simplifies type checking.
If you have a format() function you need to support variadic functions and even format specifiers in the type system.
I've just released difftastic 0.53! In this release:
* SCSS support
* Better directory diffing: .gitignore is respected and output is (optionally) sorted by filename
* Better support for Windows files (you can ignore carriage returns entirely)
https://github.com/Wilfred/difftastic/releases/tag/0.53.0
Implementing type checking as another interpreter, with short, accessible examples: https://kubyshkin.name/posts/type-checking-as-evaluation/
A really fun (10 minute) talk on developing an LLVM backend for 6502, a chip with only three registers and a teeny tiny stack: https://www.youtube.com/watch?v=2lW3WHPtmKo
There's a class of performance bugs that you can feel.
Today I inadvertently implemented "Schlemiel the Painter's algorithm", and it's obvious: performance was great at first, and then it gradually deteriorates.
I've added basic sum types to my programming language project, and it simplifies a bunch of stuff. Bool and Unit no longer need to be built-in types!
I'm now working on wrapped data, so I can implement Option :)
I still find C-style format strings to be more readable than Rust format strings.
"Player %s has score %d" vs "Player {} has score {}".
The former feels a little easier to visualise how it will look in practice.
Have I missed anything? Every format string specification I've ever looked at is surprisingly big.
Clippy has a delightful lint against 'A'..'Z' because this is an exclusive range, so it only covers 'A' through 'Y'! https://rust-lang.github.io/rust-clippy/master/index.html#/almost_complete_range
Saved me a tedious bug today.
I've written a simplistic backtrace for runtime errors in my toy programming language.
Underlines feel useful on the top stack frame, but pretty useless on all the other stack frames, which are just calls. Any opinions?
Which languages do you consider to have the biggest/smallest standard libraries?
JS and Rust have a reputation for being pretty small. C has fewer data structures, but a bunch of system APIs.
Python feels more like a kitchen sink.
Where are other languages on this spectrum?
Really thoughtful critique of the Language Server Protocol, what IDEs need to express, and the design decisions made.
https://matklad.github.io/2023/10/12/lsp-could-have-been-better.html
JSON Lines is such a delight to use. It's particular nice as a CLI interop format.
You can use dumb, fast tools (e.g. grep to quickly filter large outputs) as well as structured tools (e.g. jq).
I feel like increasing visibility of a function/type should require more verbosity. I don't know of any PL that follows this design principle for >2 levels though.
Ordered by verbosity:
public, private, protected
, pub, pub(crate)
Has any PL solved this?
Showing 1-20 of 235 posts