I've been playing with GitHub Copilot, and it feels unlike any other completion tool I've used. In a bunch of cases, it can write short snippets that are exactly what I want.
(I tested it on a toy interpreter I'm working on. I'm tweaking how statements are represented.)
miniblog.
Are there any advantages to having a statement/expression separate in a new programming language?
I understand that it makes sense for existing languages, but "everything is an expression" seems to be increasingly popular.
I've heard of snake_case and kebab-case, but Train-Case is new to me!
I presume it's supposed to look like a train pulling a carriage?
(From https://crates.io/crates/heck)
The Zen of Emacs, and the ability to extend *anything* incrementally, contrasted with VS Code design principles: https://vivekhaldar.com/articles/a-spiritual-successor-to-emacs/
I'm fascinated to learn that people are discovering weaknesses in state-of-the-art bots for playing Go, such that a novice player can reliably win: https://goattack.far.ai/human-evaluation
This suggests that self-play doesn't always generalise: it's not sufficient to beat earlier versions.
I'm increasingly persuaded that a page-per-function organisation of docs is the best.
For example, this command in Redis has its own page: https://redis.io/commands/acl-cat/
Using a whole page enables you to have several examples without overwhelming the reader.
"If it compiles it probably works" is definitely more common in some languages.
What PL features make this more likely?
My current theory is that pattern matching on enums with exhaustiveness checking is the primary cause. Especially when null has been replaced with Option.
I'm really impressed by the styling options in https://carbon.now.sh for producing images of code.
I'm often dissatisfied with my options for displaying code samples in slides, this might be a better option. Line numbers and (light background) syntax highlighting matter.
Rust gotcha I haven't seen before: you can't move out of a vec by index, even if you own the vec.
This is because it'd leave the vec in a bad state: you need .remove() or .pop() instead.
I was looking for some basic examples of Scala syntax, and it looks like they've changed quite a bit in the 2 -> 3 transition!
It's the biggest syntax change I think I've seen in an established language.
Getting basic language infrastructure going is surprisingly labour intensive.
I've built a toy language up to hello world -- lexing, parsing, evaluating and minimal REPL. I'm already at over 100 commits and 900LOC of Rust (source: https://github.com/Wilfred/garden/tree/6b0ecf775b45047d927f00e0469e178b72c929f2).
Crikey, users are asking ChatGPT about C++ undefined behaviour! Https://news.ycombinator.com/item?id=34706438
pop_back on an empty vector is UB apparently.
Which programming languages are the closest to 'finished'? In other words, which are unlikely to expand core features or syntax such that best practices change.
C and Scheme seem to fit this, are there other languages?
I find zoxide invaluable for jumping between frequently used directories: https://github.com/ajeetdsouza/zoxide
TIL that you can also use it like cd!
$ z /foo/bar
$ z ..
Short and very accessible introduction to implementing unification, including Python sample code: https://eli.thegreenplace.net/2018/unification/
Python's GIL is well known, but many languages have limitations on multithreading (e.g. JS, Ocaml).
Perhaps this is a consequence of C as a popular implementation language? A GIL could be less common when Rust is the implementation language.
Wonderful article comparing error wording and display across many different programming languages: https://www.amazingcto.com/developer-productivity-compiler-errors/
I've released difftastic 0.43! In this release:
* Support for R
* Better behaviour on Windows
* A bunch of display bugfixes
https://github.com/Wilfred/difftastic/releases/tag/0.43.0
I'm dusting off a Rust project from 2016, and it's striking how much the ecosystem has grown. For example, I used getopts then whereas clap is delightful and does so much now.
I really like languages that store their runtime stack on the heap, such as Smalltalk.
You can write code as if you have tail call optimisation, but you still have normal stack traces for debugging.
Showing 421-440 of 7,506 posts