exfalso

7 ms·

31.
by exfalso 9mo ago
Highly recommend https://grml.org/zsh/ For nixos users: https://discourse.nixos.org/t/using-zsh-with-grml-config-and... Super easy to setup, and works very well
32.
by exfalso 10mo ago
Although it's sad, I have to agree with what you're alluding to. I think there is huge overhead and waste (in terms of money, compute resources and time) hidden in the software industry, and at the end of the day it just comes d
33.
by exfalso 1y ago
Same experience here, using new models. Every time it's a disappointment. Useful for search queries that are not too specialized. That's it.
34.
by exfalso 1y ago
Wow one of the most insightful takes I've read in a long time, hidden in the depths of a HN thread. The mechanism you talk about is all too real, and it can be semi-consciously exploited. A bit off-topic, but the way genocides happen
35.
by exfalso 1y ago
Mostly feeling like a caveman. I've been trying and failing to use it productively since the start of the hype. The amount of time wasted could've been used for actual development. I just simply don't get it. Productivity del
36.
by exfalso 1y ago
Hmmmm.. I am working in a niche domain (Confidential Computing) and the work is fairly creative, although I wouldn't say I asked it domain-specific things. I didn't ask it to come up with encryption schemes or security protoco
37.
by exfalso 1y ago
Hmm not my experience. I've been aggressively trying to use both Cursor and Claude Code. I've done maybe 20-30 attempts with Code at different projects, a couple of them personal small projects. All of them resulted in sub-par res
38.
by exfalso 1y ago
Eh. It's a stretch to call it "broken"
39.
by exfalso 1y ago
My reading of the status quo is that people who use it for toy or greenfield projects written from scratch are having a blast. Until the project reaches a certain complexity in size and function when it starts to break down. People working
40.
by exfalso 1y ago
Also tried it with Python. The autocomplete there was ok-ish(although to me the "wait for it -> review suggested code" cycle is a bit too slow), but getting it to code even standalone well-defined functions was a clear failure.
41.
by exfalso 1y ago
Exact same experience. I have no clue what other people are doing. I was hunting for use cases where it could be used and it kept not working. I don't get it.
42.
by exfalso 1y ago
I was skeptical at first, but after trying to use it several times for work (Cursor/Claude) I concluded that it's worse than I thought. Lot more time wasted for little to no results. Maybe for boilerplate frontend code or TODO app
43.
by exfalso 1y ago
I'm more and more confident I must be doing something wrong. I (re)tried using Claude about a month ago and I simply stopped using it after about two weeks because on one hand productivity did not increase(perhaps even decreased), but
44.
by exfalso 2y ago
It is not as easy to see as with GraphQL because the term is overloaded/ill defined, and there is a large number of ways to interpret how OOP should be used. Probably why it took so long to realize the issues and move away from the con
45.
by exfalso 2y ago
They don't have a "hard" persistence layer, it's all in-memory, which is the only reason they can have any sort of performance. In terms of the actual queries, you'll find a bunch of prefetch calls and dumping of al
46.
by exfalso 2y ago
GraphQL is an abysmal technology. In terms of destructive power to the software industry it's almost on the level of OOP. The one positive seems to be that engineers are catching on to this fact at a much faster rate(5-10 years instead
47.
by exfalso 3y ago
Yes, 100%. I've mostly only dealt with IO-bound computations, but the contention issues arise there as well. What's the point of having a million coroutines when the IO throughput is bounded again? How will coroutines save me wh
48.
by exfalso 3y ago
It's interesting to see an almost marketing-like campaign to save face for async/await. It is very clear from my experience that it was not only a technical mistake, it also cost the community dearly. Instead of focusing on langua
49.
by exfalso 3y ago
Avoiding context switches is not a problem async solves. A threadpool popping work items from a queue(or something like lmax disruptors) has the same effect on context switches. The only thing one could argue is that the async runtime'
50.
by exfalso 3y ago
Suspendable computations like regex statemachines are actually a good example use case. However I'd still categorize this as extremely marginal. I have seen literally zero Rust crates that handle suspendable computations (ofc outside o
51.
by exfalso 3y ago
TLDR summary: 1. Straw man 2. Talk about an unrelated paper 3. Conclusion: I am smart and those people are dumb On a somewhat related note: I'd say 95% of the software I've written was IO bound(and if it wasn't at the beginni
52.
by exfalso 3y ago
Hah, sounds like a fun debugging session! Those are exactly the kinds of problems I've encountered with "too many processors for too few resources". At the workplace where we used Java we used a library called Quasar which im
53.
by exfalso 3y ago
That's not my point. The issue is that when the blocking happens, with coroutines control is yielded to the scheduler which will now schedule other tasks. Those tasks may again request and block on resources. This is where the le
54.
by exfalso 3y ago
They do happen with threads indeed, but it's a lot easier to manage and the code is straightforward. You can essentially tie your resources to your threads, and your threadpool's size becomes your resources' allocation limi
55.
by exfalso 3y ago
I'm not talking about whether the scheduler can block the task on IO. This is trivial. Let's see a couple of examples. Database connection contention: async function() { let connection = getConnection().await; /
56.
by exfalso 3y ago
I think coroutines are one of those abstractions that are easy to fall in love with, but in reality they do more harm than good. There are extremely few circumstances where coroutines are useful, and those are not the ones most people use
57.
by exfalso 3y ago
Reading about it, the FoundationDB testing does look very good. If you control all of the atomic events and build a fuzzer on top, you can indeed end up with reproducible scenarios testing concurrency, up to the atoms' scope. In the
58.
by exfalso 3y ago
> Obviously, that's not always true. Having a way to do deterministic testing in a single process is helpful. It is, but then you're not testing a distributed system. > You do not want non-determinism in your tests just beca
59.
by exfalso 3y ago
On first read this looks almost completely useless for actual distributed systems. So first off, distributed systems use different software for different tasks. These will not be/were not written in Rust, and even if they were, they ma
60.
by exfalso 4y ago
Tried psilocybin mushrooms once. It was not a pleasant experience, but for some reason afterwards the need for social validation through alcohol usage completely evaporated. The effects of alcohol became almost boring. I literally started

More ›