Using a function is strictly worse than figuring out the formatting at compile time (something Zig also does).
The derives are just shortcuts. You can write everything out long-hand like you would in C++ or Python too if you really want.
Honestly both of these complaints are essentially "why does Rust use macros to make writing code better/easier?".
Right, I'm not saying it isn't simpler in terms of syntax. The point I was making is that the syntax is simpler but in a way that makes it worse because while it's easier for computers to read, it's harder for humans.
it was only later discovered that they can be compiled down to native code.
That sounds extremely unlikely. I think you're misinterpreting this quote (which is fair enough; it's not very clear):
Steve Russell said, look, why don't I program this eval ... and I said to him, ho, ho, you're confusing theory with practice, this eval is intended for reading, not for computing. But he went ahead and did it. That is, he compiled the eval in my paper into IBM 704 machine code, fixing bugs, and then advertised this as a Lisp interpreter, which it certainly was. So at that point Lisp had essentially the form that it has today ...
As far as I can tell Lisp was always intended to be compiled and executed. That quote is about compiling the eval() function (which was just meant to explain how Lisp is executed) into a binary and using that as an interpreter.
Also I skimmed the paper that is from, and in fact Lisp was intended to be targeted by AI (in the same way that we get AI to write and execute Python to solve problems), which explains a lot. It wasn't designed for humans to write, so why bother with nice syntax; just have the machine write the AST directly!
(I expect that was only part of the motivation tbf, but still!)
Is Deno not convenient and fast? I am also interested in knowing why I would want to use Bun over Deno.
Actually chars() is pretty simple - it's just UTF-8 decoding which is elegant and simple.
The complexity is all around unicode, not UTF-8.
Corecursive easily. It's actually properly produced and very well presented. Not one of those rambling unscripted chats.
This is 14 years old by now - hardly "modern". RAII itself is even older.
Config should be pretty flat.
Why? I don't see any reason for that.
TOML rocks precisely because it nudges you into making simpler configs.
This is just "you're holding it wrong".
In most cases you don’t, and when you do, it’s possible and not unreasonable.
Really. Here's the first Gitlab CI example I could find:
lintDebug:
interruptible: true
stage: build
script:
- ./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint
artifacts:
paths:
- app/lint/reports/lint-results-debug.html
expose_as: "lint-report"
when: always
Let's see the TOML:
[lintDebug]
interruptible = true
stage = "build"
script = [
"./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint"
]
[lintDebug.artifacts]
paths = [ "app/lint/reports/lint-results-debug.html" ]
expose_as = "lint-report"
when = "always"
Gross. The tool I used to convert even added extra indentation because otherwise it is unclear.
IMO JSON5 is the best:
{
lintDebug: {
interruptible: true,
stage: 'build',
script: [
'./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint',
],
artifacts: {
paths: [
'app/lint/reports/lint-results-debug.html',
],
expose_as: 'lint-report',
when: 'always',
},
},
}
This is much clearer than TOML and less ambiguous than YAML. It could do without the outer {}, but overall it's still better.
ARM is very very obviously superior to x86. You won't be able to find anyone informed that will say otherwise.
Probably the biggest way it is better is that instructions are always 2 or 4 bytes which makes wide decoders a lot easier.
Matthias Wandel has a video on this is YouTube. He didn't talk about it they keyboard is any good though which I think is probably the most important thing.
You can count Ruby out immediately. Terrible language.
Also replace JavaScript with Typescript. It's strictly superior.
I don't think Go has any mature GUI libraries.
For desktop GUI your main options are:
For the web frontend you basically want Typescript. For the backend you can use literally any language.
I would recommend Electron for the GUI and Typescript for the web frontend and Electron GUI. It means you can use the same language everywhere and you won't need to even implement the same program twice.
If you're worried about the download size / RAM usage you can look into Tauri which uses your OS's browser engine. I've never used it though.
Functional programming doesn't just mean higher order functions. There's a range of other features that it implies.
Never? Never is a long time.
That said, by the time you can actually run a significant software company without any programmers it seems likely that you could also run most white collar firms with vastly fewer employees and then we're going to have bigger problems.