tlarkworthy

And a fricken great build tool because it speaks typescript, jest and bundling out of the box so you remove several layers of partially compatible tools (eg. Esm, jest and typescript don't really work that well together), yet still end up with a blob of js and the end so it's transparent to the browser end user

I think their point is bun is not a runtime either because you can use it to spit out a blob of js that is run by the browser as normal. Which is how I use it to build js libs. Bun is then just the build and test tooling, and the various runtime bugs do not affect my downstream users (but it can impact testing).

When I think of short session expiry I think that access_tokens have a limited timespan so if they get accidentally logged the remote end or the person is fired their access lapses. This is a good idea.

If we are talking about bounding the lifetime of a refresh token, I agree with the articles, but that is not what I think of when I think about credential expiry. Credentials that you send to third parties should be short lived. I think without that underlying distinction the article is dangerously confusing. Time-bound credentials have many useful features.

considered and rejected because triggers complicate other database operations like restores. Triggers to me are like global operations, they really make a strong statement about storage which does not tend to be true over longer time horizons when you consider all the stackeholders of the data storage system. They make sense as an application feature, but they are implemented as globals, and this is where the problems begin.

Because they are o(n) complexity to refresh so either you settle for eventual complexity or have expensive writes. By forwarding just the index data to the right table you maintain an consistent idiomatic index at 0(1) write cost

Yes this is the exact situation where sql falls short. You can't make cross-table indexes to serve OLAP-esq queries, and the most recent X is the common one for pagination in applications. I prefer to denormalize manually at write time in a transaction, rather than use triggers or materialized views.

I agree with the author. It's subtle but it's about signal to noise. A screen full of whitespace has no signal and it's an artificial impediment to the knowledge transfer from screen to brain.

Unfortunately auto-formatting is a better for other reasons so we don't have much wiggle room here but left alone I adopt the authors style

I think extension service workers might be the modern replacement that can deal with SSL https://developer.chrome.com/docs/extensions/mv3/service_wor...

It's not a particularly new idea. See robotshare, robobrain or robot google

This German webhost does not include SSL in it's bare bones package without surcharge. Thus my kita had no SSL certificate, and thus I could detect my ISP or some hacked router injecting ads (Berlin) when I used that site.

There are plenty of local http sites due to German's (reasonable) distrust of US companies and a propensity to roll their own

https://m.all-inkl.com/webhosting/privat/#&ui-state=dialog

Still do in Germany

I prototyped this using computational tree logic (CTL). You can express the non existence of trap states and reachability of all states quite nicely and fully explore the state space symbolically. The drawback is you can't really do numbers in it.

I keep staring at the output of sqlalchemy's "select in" eager loader trying to figure out if has managed to pipline the follow up queries into a single DB round trip for the problem of tree shaped data. Still don't know, maybe someone does.

https://docs.sqlalchemy.org/en/14/orm/loading_relationships....

Experience shifts your beliefs in a Bayesian information thoeretic way. It's the same thing of extra information entering the system but with more diffused probability distributions compared to hard knowledge like "the prize is not in that door". But the overall effect that the fuzzy information improves your outcomes holds

I fix lots of things and there is no experience like doing something, there is also this weird cross-pollination thing going where knowledge acquired in one domain helps you in another. So while I am well aware that most of my repair jobs are net negative in terms of actual material value generation for me, the gradual increase in my capabilities in many different domains ends up helping me even in my chosen specialisation. By this point I am just generally at an advanced beginner stage of anything after some basic research (which I have naturally becomes quite good at).

There is also a skin in the game effect that even a paid random plumber is not actually that invested in doing a good job and, while you cannot compete in terms of speed of executing a fix, or possession of special tools, you can compete - and exceed - on final quality simply because you really care about the final outcome.

and DuckDB came out of academia too and is not based on Postgres either (highly relevant and notably absent in the authors list of academic DBs at the end of the article)

https://duckdb.org/pdf/SIGMOD2019-demo-duckdb.pdf

EDIT: oh the article is old

No your life experiences narrow the choices. You don't randomly emigrate. While the reasoning is wonky, there is , in reality, only a small pool of choices under consideration. Life is the 3rd party that reveals duds.

I don't think it really affects anything if the prize is decided after opening the door.

The analogy only really fails if your internal value system values predictability... Which for some people is true.

But for others who have a vague feeling of dissatisfaction then the chances are that the unknown door picked from a shortlist of options will yield better results than staying put with the option given to you via external factors

I have a theory that this is the Monty hall problem effect in practice [1]. When you blow up your life you are opening an unknown door... But after you have narrowed your options, so the outcomes are likely to be better than your status quo.

[1] https://link.medium.com/N6HaHXgyAAb

I would probably go for immutability, which unlocks memoization, which unlocks reuse of parsing computation. Then do everything strictly (no cancellation) so the whole this is super fast for the common case. I do wonder if grabase collection is too hard to solve though for memory managed languages. Reference counting?

Firebase (which I was part of). Dunno if you count it as an acquihire if the product survives but I am pretty sure we did what the big G hoped we would

The worse thing is that WASI doesn't support browsers as a target anymore.

Edit: this supports browsers!!! Amazing!!!

I think the only sane model for openai wrappers is user's bring their own API key.

equilibriocepted 9 times as far

[1] https://nautil.us/we-should-count-balance-as-one-of-the-sens...

V8 JS and Python (JVM too?) don't do tail call optimization, so the advice of not using the stack for high recursive algorithm is actually the right choice in the majority?

The idiomatic calculator interface is actually very hard to implement without bugs

https://mitadmissions.org/blogs/entry/designing-a-calculator...

FSM don't help with the bugs. You need analysis on top to actually make a dent in the bug count

They still go into trap states. If you try to remove default transitions your source code complexity explodes.

I find I got the same issues even with state machines. If the problem is complex, you have to consider every edge case with or without state machines. The essential complexity is the same.

I use observablehq notebooks so I have programming reactively attached.

https://observablehq.com/@tomlarkworthy/colossal-cave-chatgp...

A materialized view is another approach but thats still essentially denormalization. I prefer using indeces as they are a bit more of a 1st class relational concept in my mind. With a MV you are copying ALL table data, but with an index you can concentrate on just the ordering columns (you can make a few column MV too and then join but you are now reinventing indexes).

You cannot get an index to be used across a join in most relational DB system. But joins pop up everywhere when you normalize.

This query is a fairly distilled example of it https://stackoverflow.com/questions/16402225/index-spanning-...