Expurple

10 ms·

121.
by Expurple 1y ago
To be fair, the post says that " over using AI [is] bad" and "problems [are] caused by widespread AI use" (emphasis mine). I beleive, they aren't against all AI use and aren't against the use that you describ
122.
by Expurple 1y ago
Indeed, the choice is actually between: - "a low quality solution" - "a low-quality solution, but you also spend extra time (sometimes - other people's time) on learning to solve the problem yourself" - "a high
123.
by Expurple 1y ago
Technically, it's still "AI discourse". It's just about the underlying ethics, rather than best practices or the underlying tech
124.
by Expurple 1y ago
> I suspect that a lot of empathy traits and adjacent characteristics are not genetic but a product of education Ah, I see. The argument makes total sense if that's the case. I'm just not used to talking about learned behaviors
125.
by Expurple 1y ago
> the sheer volume of capital behind this tech is enough to roll over all the feeble cries of impotent rage. This part is true. But at the same time, it's fairly easy to filter only real, established personal blogs and see that the
126.
by Expurple 1y ago
> Also, why hedge everything you're about to say with a big disclaimer?: Because her previous (Telegram-only) post on a similar topic has attracted a lot of unfounded negative comments that were largely vague and toxic, rather than
127.
by Expurple 1y ago
It's easy to argue that this selection is happening in business and politics. But I don't see how it could be relevant to reproduction, on an evolutionary scale. I haven't read Blindsight, though.
128.
by Expurple 1y ago
Oh, well. I guess, I'll have to translate my original Telegram comment. --- I agree with the connections that you make in this post. I like it. But I disagree that purely-technical discussions around LLMs are "meaningless" an
129.
by Expurple 1y ago
Permissively-licensed projects (which is the majority or FOSS projects out there) could always be re-licensed to proprietary. I publish most of my code under permissive licences and will continue doing that. LLM training doesn't really
130.
by Expurple 1y ago
> but in terms of power-user GUIs Windows is still has little competition Nowadays, KDE is stable and is way better at being Windows that Windows. It's a remarkable desktop
131.
by Expurple 1y ago
This is a very good description of the modern issues with slop "content" and advertising plaguing everything they touch. (including human-made slop, as the author correctly identifies) But I disagree on LLMs being "worse than
132.
by Expurple 1y ago
Well, I just have an intrinsic interest in discussing this topic deeply and understanding it deeply. So far, all of my technical posts on the blog have been about error handling
133.
by Expurple 1y ago
I'm not aware of such cases. And The Rust Reference says [1]: > If the value is Err(e), then it will return Err(From::from(e)) from the enclosing function or closure. Without a specific example, I can't help you further. [1]:
134.
by Expurple 1y ago
Can't tell if it's sarcasm or not
135.
by Expurple 1y ago
I've even decided to turn my parent comment into a blog post [1]. It also fixes numerous typos, so qoute the blog version. [1] https://home.expurple.me/posts/go-did-not-get-error-handling...
136.
by Expurple 1y ago
> almost all of the time, not 99% of the time, or 99.9% of the time, but almost every single time--you call a function, you shouldn't care what errors it can raise Sure, that's often the case. That's why dynamically-typed
137.
by Expurple 1y ago
What do you mean? At the bottom of the page, the latest update is a pull request that was opened 10 days ago: https://github.com/rust-lang/cargo/pull/15684
138.
Exception Handling in Rustc_codegen_cranelift(tweedegolf.nl)
2 points by Expurple 1y ago|0 comments
139.
by Expurple 1y ago
True, but this is being worked on now: https://github.com/rust-lang/cargo/issues/14774
140.
by Expurple 1y ago
> At least we won't repeatedly pay the penalty. Another promising solution for that is caching proc macro expansions in the compiler. "How I reduced (incremental) Rust compile times by up to 40%": https://web.ar
141.
by Expurple 1y ago
It's kinda similar, but Rust also solves the problems of checked exceptions: https://home.expurple.me/posts/rust-solves-the-issues-with-e...
142.
by Expurple 1y ago
Rust crates usually have "feature flags" [1] that help with dependency bloat. You only pull in the parts of the dependency tree that you actually use, even if the crates that you use can be configured to provide more features and
143.
by Expurple 1y ago
The boilerplate is more meaningful than it seems: https://home.expurple.me/posts/why-use-structured-errors-in-...
144.
by Expurple 1y ago
> I do not want to go to the hassle of defining some new error types everywhere, I just want to use equivalents to runtime_error or logic_error. You can use anyhow::Error everywhere. If you need to "catch" a specific wrapped er
145.
by Expurple 1y ago
That's only the case when your per-function error sets are "flat" (directly contain "leaf" errors from many layers below). You can avoid this issue if you deeply nest the error types (wrap on every level). It you ch
146.
by Expurple 1y ago
See the two articles linked in the sibling comments
147.
by Expurple 1y ago
It's a tradeoff. When you have a "flat" union like `A | B | C` that makes it easy to pattern-match "leaf" errors, you give up the ability to add any additional context in function1 and function2. Although, there are
148.
by Expurple 1y ago
> I create one error type per function/action. I discovered this here on HN after an article I cannot find right now was posted. It could be this one: https://sabrinajewson.org/blog/errors
149.
by Expurple 1y ago
I'm the author of this article, btw :) > 50% at least of these tiresome "here's why exceptions suck" articles begin by talking about how "try" is un-ergonomic. Idk about the other articles, but mine doesn&#x
150.
by Expurple 1y ago
> Overuse of macros is a symptom of missing language capabilities. Agree. > I think non-local flow control (i.e. exceptions) with automated causal chaining (like Python) is a good language design point Stronly disagree: https:/&

More ›