rand_r

Which part? Hard to have a discussion without specifics.

The honest way to handle this, which hopefully your therapist does, is not to claim that you can magically retrieve perfect memories from before 5 because you thought about it hard. What matters is what your impression is of what happened and what messages your subconscious is sending you. Whether or not it literally happened isn't that important and it's impossible to know.

The therapeutic relief comes simply from listening to your gut/subconscious and feeling the emotions that that brings up. Being a loving friend and parent to that part of yourself. You can do that effectively without pretending that you can know if the impressions are literally true or if that message your getting is simply the best way for it to express the emotions it's holding onto.

Again, you can maintain your integrity while being empathic and loving and listening to the message.

"Trauma" is a very bad name because it sounds violent and extreme, so you can easily think it doesn't apply to you. In actual fact, it can be caused by something as routine as "sleep training" where infants are left to cry themselves to sleep, or being snapped at for expressing emotion, all before the age of 5. The years before 5 are foundational, but you usually no not have memories earlier than 5 so it's very hard to say definitely what happened especially when causes for trauma are relatively routine.

You need a trusted therapist to guide you into exposing what the subconscious mind is holding onto from infancy. It is subtle, deep, difficult, rewarding work. But I do think people discount trauma because it sounds scarier than "someone snapped at me in frustration as an infant for expressing some emotion and I learned to disconnect from myself."

The end game is adaptive query plans.

A big reason the initial plan isn't guaranteed to be optimal, even with all the right indexes, is that table statistics aren't perfect. For example, you might track a column's correlation (how closely the column's logical ordering matches its physical ordering in the heap), but that won't be broken down at a per value level. Postal code X might be very correlated, while postal code Y that is used in your query is completely uncorrelated.

The ideal solution is to pick one plan initially, and then update a temporary query-specific statistic model based on the data you actually read while executing the query. Then periodically re-evaluate if an alternative plan would be faster, switching to it in a way that doesn't throw away the current partial result.

Of course switching plans mid flight is very complicated, but Oracle and SQL server both support this feature, so hopefully it lands in Postgres at some point.

It's been quite helpful when your project needs expertise from other people, and you want them to vet your approach and find gaps. Doing the up-front work of explaining the context and structuring the project in an easy to understand way makes it more likely for busy people to engage with it and help you out. Of course, it's helpful as a rubber-duck exercise on its own, so I would err on creating one, even if just for myself, for anything high-risk or hard to change later.

That's fine, but rate limiting is a solved problem at this point. They need to rate-limit free accounts and be realistic about their limits instead of letting the system fail.

> all viewpoints covered from you populace

This is the core of the issue. We don’t actually want all viewpoints represented because that wouldn’t by itself produce any value.

You want someone to come up with the fundamental theorems of Calculus, linking the area of a curve with its anti-derivative, because that’s incredibly useful. Generically grabbing everyone’s view isn’t a competitive strategy. You need to be selective on things that are intrinsically useful and promote that.

> When I watch a movie, I don't care about the artist's life. I care about character life, that's very different.

It may seem like this, but up to now, you haven't been able to divorce a story from its creator because every story has an author, whether it's a novel like Harry Potter or a movie that has a writer and director. When you're experiencing the story, in the back of your mind, you always know that there is someone who created the story to tell you some kind of message. And so you can't experience something like a movie without trying to figure out what the actual message behind the movie was. It is always the implicit message behind the story that makes it valuable versus just the elements of the story.

The story has more weight because it is the distillation of somebody else's life and most likely, if it's a successful story or book, it is the most important lesson from that person's life and that's what makes it more valuable compared to the random generation of words from a computer.

The food analogy is that a cookie baked and given to you by a friend is going to taste far better than anything you buy in a store.

Only in as much as their product is a pure commodity like oil. Like yes it’s trivial to get customers if you sell gas for half the price, but I don’t think LLMs are that simple right now. ChatGPT has a particular voice that is different from Gemini and Grok.

There is no difference between “def f(x={})” and “def f(x=dict())”, unless you have shadowed the dict builtin. They both have exactly the same subtle bug if you are mutating or return x later.

You can use “set()”. Introducing more weird special cases into the language is a bad direction for Python.

This is something you see in movies. Cash is by nature not traceable, so invalidating notes after issue would make it impossible to trust any cash transaction.

> to see if the serial numbers are out of circulation.

Cash cannot be invalidated like this. It would ruin the value of all cash since you could no longer trust cash from anyone. Only damaged notes are taken out and replaced by the government.

Not sure what you mean!? Locks, at their core, are not implemented by languages. They’re feature of a task runtime e.g. Postgres advisory locks or kernel locks in a Posix OS.

Race conditions are generally solved with algorithms, not the language. For example, defining a total ordering on locks and only acquiring locks in that order to prevent deadlock.

I guess there there are language features like co-routines/co-operative multi-tasking that make certain algorithms possible, but nothing about Java prevents implementing sound concurrency algorithms in general.

Yes, exactly. Latency is the killer feature. Doing a video call with extra 50ms of latency is noticeable.

This is a great point. Life is tough because we are all competing in a game. Tweaking the rules of the game so that each basket is worth more points doesn’t make the game easier for any player.

From Henry George:

> Now, to produce wealth, two things are required: labor and land. Therefore, the effect of labor-saving improvements will be to extend the demand for land. So the primary effect of labor-saving improvements is to increase the power of labor. But the secondary effect is to extend the margin of production. And the end result is to increase rent.

> This shows that effects attributed to population are really due to technological progress. It also explains the otherwise perplexing fact that laborsaving machinery fails to benefit workers

I don’t know why they couldn’t do the friggen obvious move of asking the police to unblock the roads by force, and impounding the vehicles for repeat offences. Going after bank accounts was a coward move that never made sense. If I just sat down in the middle of a subway tunnel, I would be removed by force immediately, no matter what I was protesting. They created problems for themselves by not doing the obvious solution.

Blocking a road is a fire hazard and should never have been tolerated by local police for that reason alone. You cannot impede transit in a city.

Nothing prevents explicit error handling in Python either. Forcing explicit error handling just creates verbosity since no system can functionally prevent you from ignoring errors.

> never handled correctly

I’ve seen this argument, but if you look at real golang code and examples, it’s just a bunch of “if err <> nill” copy pasta on every line. It’s true that handling errors is painstaking, but nothing about golang makes that problem easier. It ends up being a manual, poor-man’s stack-trace with no real advantage over an automatically generated one like in Python.

Interesting! I wonder how this plays into AWS pricing. They charge a flat fate for MBps of IO. But I don’t know if they have a rule to round up to nearest 4K, or they actually charge you the IO amount from the storage implementation by tracking write volume on the drive itself, rather what you requested.

I know what you mean, and you’re probably right, but there’s a deeper problem, which is the overuse of adjectives and overall wordiness. It’s quite jarring because it reads like someone trying to impress rather than get an important message across.

Frankly, ChatGPT could have written this better with a simple “improve the style of this text” directive.

Example from the start:

> MySQL v8.0 offered a compelling proposition with its promise of substantial performance enhancements.

That could have just been “MySQL v8.0 promised substantial performance improvements.”

This is sort of an aside, but a very interesting thing about Postgres is that it can efficiently combine independent column indexes together, so there is much less of a need, compared to older databases, to even create multi-column indexes. It's a feature from 8.1 called "Bitmap Scan". Basically, if you create an index on column X and an index on column Y, it can use them to do queries involving either or both columns pretty efficiently (for any number of columns).

It's not as fast as a multi-column index, but the savings of not having to worry about all the combinations of columns that can be queried together could well be worth it.

- https://www.postgresql.org/docs/release/8.1.0/

- https://www.postgresql.org/docs/current/indexes-bitmap-scans...

Something I’ve been curious about recently, is how did Linux get away with straight C for so long, considering how complex of a project it is. Did they end up reimplementing a bunch of C++ features?

Actually, regarding sophisticated projects, there’s quite some complicated projects that succeed without C++ power, like Postgres and Python.

Using hardware floating point types is not suitable if mathematical correctness matters, and is largely a deprecated practice. Check out Python’s fraction module for example, for exact arithmetic[0].

[0]: https://www.geeksforgeeks.org/fraction-module-python/

It is true that DB compute is relatively expensive, but doing a join on the DB itself is obscenely more efficient vs doing it manually in a nested loop on an app server.

Also, the DB is generally a lot smarter than doing quadratic operations. The usual worst case is a Merge Join which involves sorting both tables first, to do an efficient join in nlogn time. It’s just not feasible to compete with the DB for efficiency without reimplementing a DB, which is pretty yikes.

See https://www.cybertec-postgresql.com/en/join-strategies-and-p...

Yes, exactly! We found out the hard way just how unreliable Redis-based locks are, and switched to Postgres locks. It works reliably since our code is already in a Postgres transaction.

Created a “lock” table with a single string key column, so you can “select key for update” on an arbitrary string key (similar UX to redis lock). I looked at advisory locks, but they don’t work when the lock key needs to be dynamically generated.

Development speed and conciseness is what sells Python. Something simple like being able to do `breakpoint()` anywhere and get an interactive debugger is unmatched in Go.

Well the 192 case would probably have an external IP + Port uniquely mapped to it in the router’s NAT table. I think you’re missing the larger point though. No one said IPs are exclusively used as GUIDs. Just that they are used as GUIDs, which they are in the majority of cases, and those GUIDs are re-assigned over time.

My Macbook Pro currently has unique IP + Port, associated with a single process listening to it over NAT and packets you send are routed to its network interface. Next week, someone else’s laptop could have that same IP + Port. That’s the main idea here, not these exceptions.

Because of NAT, it’s actually “IP + Port#” that is globally unique, and ultimately associated with a single physical network interface on a device (e.g an ethernet port on a PC).

There’s exceptions like broadcast IPs, but the point is that it is a system for uniquely locating devices and listening OS processes with IDs routinely shifting around.