Which programming languages are the easiest/hardest to google?
Go (a common word) and Rust (also a computer game) can both be tricky. Yet I've not seen 'rubylang' used to help Ruby searches.
Perhaps a novel word (Kotlin) or a misspelling (Perl) is a better choice for new languages?
miniblog.
A really nice explanation of lisp semantics, using userland code!
For example, you can define let in terms of let* and vice versa.
https://www.plover.com/~mjd/misc/hbaker-archive/MetaCircular.html
I've seen several companies offer a backup internet, e.g. Xfinity has "storm proof wi-fi", which is a battery powered cellular data connection. Eero Pro has something similar.
I can understand the incentive, but it competes with using a phone. It shows there's a market for data all the time!
I've released difftastic 0.54! In this release:
* Added support for the Salesforce Apex programming language
* Improvements to Clojure and Haskell parsing
* Difftastic will now show if file permissions changes
https://github.com/Wilfred/difftastic/releases/tag/0.54.0
Do any programming languages offer an official syntax highlighter for the web?
It feels like it would really help adoption, allowing early adopters to write readable blog posts.
@castarco I regularly use it with git! 😊
https://difftastic.wilfred.me.uk/git.html
Interesting data from JetBrains on the most common rust compiler errors people encounter: https://blog.jetbrains.com/rust/2023/12/20/the-most-common-rust-compiler-errors-as-encountered-in-rustrover-part-2/
I've compiled the parser for my Garden programming language to wasm, so I can offer a web playground: https://www.garden-lang.org/
It's over 600KiB of wasm just for a function that returns a parse error message! I'm not sure if that's a lot (cf JS) or a little (cf typical binaries).
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 :)
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.
Showing 241-260 of 7,506 posts