It's surprisingly fiddly to parse unfinished multiline expressions in a REPL.
In Garden, my toy language, the parser distinguishes 'incomplete' from other others, so I can keep appending text and re-parsing until something useful comes out.
miniblog.
The Tomorrow Corporation has built its own game programming stack with live reload, time travel debugging, and even the ability to serialise the entire game state and replay it between testers!
https://www.youtube.com/watch?v=72y2EC5fkcE
Solving Fizzbuzz using Euler's totient theorem rather than conditionals: http://philcrissman.net/posts/eulers-fizzbuzz/
@nachobarrientos@emacs.ch Gosh, really? Helpful has reasonable unit tests IMO, although it definitely uses a bunch of obscure Emacs APIs.
The next version of difftastic will support Ada!
Are there any FOSS licensees that explicitly allow people to train AI models on the source code?
This seems like a useful addition, and there's already precedent with the "classpath exception" for the GPL.
On building a full-featured REPL, handling errors, and the different REPL APIs in the Clojure ecosystem: https://tonsky.me/blog/clojure-sublimed-3/
Displaying value information in an IDE is tricky.
For union types, it's more helpful to see the inferred type (Option<Player> versus null). For product types it's often nicer to see an example value.
For primitive types I almost always want a value (0 versus int).
Software is typically malleable. What software is the hardest to change?
For me, the obvious cases are APIs near the bottom of the stack (e.g. imagine changing a Linux syscall) or systems with a large number of users (due to Hyrum's Law).
I really appreciate that GitHub has separate icons for pass and fail in CI. I've worked with Jenkins plugins that rely on red/green colour too much.
TIL that you can give your threads names! https://doc.rust-lang.org/std/thread/index.html#naming-threads
I've released difftastic 0.44! In this release:
* Support for Racket and Newick
* Better handling of parse errors
* Nicer syntax highlighting
https://github.com/Wilfred/difftastic/releases/tag/0.44.0
A surprising amount of important software functions by developers doing each other favours by reviewing pull requests.
Generated Code Generates Overconfident Coders: https://www.deeplearning.ai/the-batch/issue-180/
A study of programmers found that using a LLM for completion produced buggier code but users were more confident in it.
I wonder if this generalises to other completion techniques?
TIL that coreutils has a lightweight version of the `finger` command, appropriately named `pinky`!
Another unusual feature of Elm's error messages: it uses the first person ("I was partway through parsing a record, but I got stuck here").
It reads pretty well to me, but this is a surprisingly divisive topic.
https://elm-lang.org/news/compiler-errors-for-humans mentions the importance of layout and paragraphs for compile error messages.
Perhaps tools should do line wrapping if the terminal is very wide? It's definitely more comfortable to read.
I think GitHub Copilot (and LLMs for coding more generally) are best seen as a complement to traditional IDE completion.
Textual word completion is useful even when you have type-aware method completion. Copilot feels like a more powerful case of word completion.
https://github.com/repository-settings/app is an elegant use of GitHub apps: you can define a .toml for repository settings, which lets you change these settings with a commit!
Playing with VS Code also reminds me how overloaded the tab key can be. It might do indentation, or LSP completion, or snippet completion, or Copilot completion.
In Emacs I've configured these operations on separate keys (e.g. yasnippet on SPC) which is less surprising.
Showing 401-420 of 7,506 posts