celeritascelery

Seniors are also really expensive. By some estimates you spend half of your lifetime healthcare cost in the last five years of your life. It typically takes multiple working people to support a single senior on government benefits.

I agree about the email login. It is huge barrier and it is why I use other providers for chat over Claude. I still use their API though.

It’s not either/or. The CPython speedups would be even better with the single threaded interpreter.

> That's the trade-off. Personally I think a single digit percentage slow-down of single-threaded code worth it.

Maybe. I would expect that 99% of python code going forward will still be single threaded. You just don’t need that extra complexity for most code. So I would expect that python code as a whole will have worse performance, even though a handful of applications will get faster.

The government spends about 10x the amount of money on foreign aid than the gates foundations entire budget ever year. Not to mention the hundreds billions spent on domestic aid every year. So your dream is already a reality.

What good do you think that would do?

The author says that with a 1.2GB bloom filter and 7 hash functions lookup is only 30ns. I have to assume this is because the cache has loaded all the benchmark values. My guess is that the benchmark is only testing a few elements. In real world scenarios with a bloom filter this big most of those 7 hash lookups will be into cold cache since 1.2 GB is too large. That means lookups are much longer than 30ns. Probably still faster than going to network or database though.

I had this same issue. About once a week it would prompt me for the password for an old Apple ID. I eventually started over from scratch to work around the issue.

I hope that at some point I can use AI to filter my RSS feed for me. It knows the kind of content I want and the stuff I always skip. Sure it won’t be perfect, but it would let me subscribe to more high volume feeds without having to manually filter everything.

I am not very well read on this topic, but it seems like there are other ways to make shelf stable food that doesn’t necessarily make it harder to digest. For example high salt or sugar contents, or removing most of the water. These make it harder for bacteria in the environment but don’t pose a barrier when mixed up in your gut.

Granted, you can’t do that with shredded cheese. which is why it has to be refrigerated and will eventually go bad.

Is it the actual silicon that can’t handle it, or is contraction in joints and connections that breaks?

I am curious what causes these landers to fail in the bitter cold of night? Is it the batteries? It seems like circuitry should be fine.

Thanks for writing this. I am curious if you benchmarked the giant switch implementation? While the current VM has some benefits (no bytecode, easy to pass argument's, cleaner compiler, etc ) it also has some performance overhead. Some that I am thinking of:

1. Every instruction results in functional call overhead, which is something that tail calls (with protect_none) avoid.

2. Because you are using closures the next instruction has to be heap allocated. I don’t know what closures look like in Go, but there will involve some indirection.

3. Every iteration of the loop requires a bounds check on ip.

Now, none of these may matter for SQL because as the blog post said, the instructions are quite large. And it already shows huge improvements over the AST interpreter. I am just curious how the switch would benchmark.

On an unrelated note. Using closures to write an interpreter brought to mind this talk https://m.youtube.com/watch?v=V8dnIw3amLA&list=PLFTr8ChfQg9t...

How do you reconcile that with the observation that moving to a computed goto style provides better codegen in zig[1]? They make the claim that using their “labeled switch” (which is essentially computed goto) allows you to have multiple branches which improves branch predictor performance. They even get a 13% speedup in their parser from switch to this style. If modern CPU’s are good at predicting through a single branch, I wouldn’t expect this feature to make any difference.

[1] https://ziglang.org/download/0.14.0/release-notes.html#Code-...

I recently was traveling a lot and would take a uber multiple times a day. I asked all my drivers what they thought of the gig. To my surprise, most were pretty happy about it. The ones that were happy really liked the flexibility and autonomy. They could start and stop when they wanted, work where they wanted, take vacation when they wanted, etc. the ones that were unhappy complained about the pay and lack of benefits.

It really drove home for me that a job is more than just wages. If your goal is to maximize your income, gig work is probably not for you. But the nice thing is, no one is making you do it. If you don’t like the pay, go do something else. But it seems like gig work fills a niche that works really well for some people.

I have never had it request any permissions

They are array encoded, but you still will be jumping all over the array to do your operations. Putting multiple “nodes” at the same location will mean fewer jumps, and hence fewer cache misses.

In the same way that B-trees have emerged as a more cache friendly version of binary trees, it seems like you could create a Fenwick tree that stores multiple “children” at the same location. It would probably be less algorithmically beautiful, but would be faster over all.

I love seeing photos like this, and assumed that you would need the Hubble to capture pictures of space this good. But I have been following Andrew McCarthy [1] on twitter and am amazed at how good of pictures you can get with a backyard telescope.

[1] https://x.com/ajamesmccarthy/status/1876658931717832938

There is a crate that can handle regex over non contiguous data. It had some weak points, but overall is really good

https://crates.io/crates/regex-cursor

None of the models use images, they all operate and a json format the describes the input squares.

What surprises me about this is how poorly general-purpose LLMs do. The best one is OpenAI o1-preview at 18%. This is significantly worse than the purpose-built models like ARChitects (which scored 53.5). This model used TTT to train on the ARC-AGI task specification (amoung other things). It seems that even if someone creates a model that can "solve" ARC, it still is not indicative of AGI since it is not "general" anymore, it is just specialized to this particular task. Similar to how chess engines are not AGI, despite being superhuman at chess. It will be much more convincing when general models not trained specifically for ARC can still score well on it.

They do mention that some of the tasks here are susceptible to brute force and they plan to address that in ARC-AGI-2.

> nearly half (49%) of the private evaluation set was solved by at least one team during the original 2020 Kaggle competition all of which were using some variant of brute-force program search. This suggests a large fraction of ARC-AGI-1 tasks are susceptible to this kind of method and does not carry much useful signal towards general intelligence.

No pictures though. Wish I could see some sample of the art.

I wrote some comparisons here

https://coredumped.dev/2023/08/09/text-showdown-gap-buffers-...

I have actually done some work on a rewrite of the Emacs core in rust[1], so I have thought a lot about this question. Most of the things you would want to change could be fairly easily added to the existing Emacs. The biggest ones that are hard to do with the current core is concurrency and collaborative editing. My particular core is focused on concurrency[2].

Unlike a lot of commenters here, I am trying to stay backwards compatible with elisp. It is not the best, but huge body of existing code is one of the strengths of Emacs. Unlike vimscript, elisp isn’t painful enough to be worth replacing.

[1] https://coredumped.dev/2021/10/21/building-an-emacs-lisp-vm-...

[2] https://coredumped.dev/2022/05/19/a-vision-of-a-multi-thread...

What advantage would you get by rewriting it in Rust?

All of this is possible in the current Emacs.

1. You can already define what program opens a file in dired. You could even use detach it from the Emacs process so it stays open when Emacs closes.

2 we already have vterm, which has all the features you described.

3. There are ways to make this better. I am actually in the process of writing a blog post about working efficiently over tramp.

Are all these “higher-level datatypes for key abstractions” trying to achieve first-class collaborative editing? That sounds a lot like Zed.

It would, but lisp has prefix operators, so you wouldn’t have to worry about it getting confused.

I tried doing something similar to this once. I ran into an issue where I couldn’t define symbols with a dash in them (DEFINE MY-FN…). This is because rust will split the tokens on a dash. It was a small thing, but it meant I couldn’t just copy and paste snippets from a real lisp, I had to transform everything to underscore. Is it the same in your implementation?