moozilla

This is only true for poor quality coffee. The hot temperature masks defects (bitterness). Good coffee tastes better as it cools. https://www.baristamagazine.com/the-temperature-paradox-why-...

Midjourney is not VC backed. They have a bit about this in the article:

As a reminder, Midjourney has no investors. We are a totally new kind of research lab. We've seen academic, corporate, and government labs - but we are a distinct (and curious) new thing: we are a community-backed research lab.

Last time I tried home row mods I could not get over how bad it felt having the letter not appear until I lifted the key rather than immediately on the keypress. Am I just overly sensative or is this just something you get used to over time?

I also found this bit funny:

We also suspect that the geographical and cultural factors may have influenced interaction patterns, given that all our participants were residing in Türkiye.

You could go with the title from the associated YouTube video (https://www.youtube.com/watch?v=lXUZvyajciY)?

Andrej Karpathy — “We’re summoning ghosts, not building animals”

I like to think of models leaving "useless comments" as a way to externalize their reasoning process - maybe they are useless at the end, but leaving them in on a feature branch seems to marginally improve future work (even across conversations). I currently leave them in and either manually clean them up myself before putting up a PR for my team to review or run a final step with some instructions like "review the diff, remove any useless comments". Funnily enough Claude seems pretty competent at identifying and cleaning up useless comments after the fact, which I feel like sort of proves my hypothesis.

I've considered just leaving the comments in, considering maybe they provide some value to future LLMs working in the codebase, but the extra human overhead in dealing with them doesn't seem worth it.

If anyone is curious on the context:

https://x.com/thdxr/status/1933561254481666466 https://x.com/meowgorithm/status/1933593074820891062 https://www.youtube.com/watch?v=qCJBbVJ_wP0

Gemini summary of the above:

- Kujtim Hoxha creates a project named TermAI using open-source libraries from the company Charm.

- Two other developers, Dax (a well-known internet personality and developer) and Adam (a developer and co-founder of Chef, known for his work on open-source and developer tools), join the project.

- They rebrand it to OpenCode, with Dax buying the domain and both heavily promoting it and improving the UI/UX.

- The project rapidly gains popularity and GitHub stars, largely due to Dax and Adam's influence and contributions.

- Charm, the company behind the original libraries, offers Kujtim a full-time role to continue working on the project, effectively acqui-hiring him.

- Kujtim accepts the offer. As the original owner of the GitHub repository, he moves the project and its stars to Charm's organization. Dax and Adam object, not wanting the community project to be owned by a VC-backed company.

- Allegations surface that Charm rewrote git history to remove Dax's commits, banned Adam from the repo, and deleted comments that were critical of the move.

- Dax and Adam, who own the opencode.ai domain and claim ownership of the brand they created, fork the original repo and launch their own version under the OpenCode name.

- For a time, two competing projects named OpenCode exist, causing significant community confusion.

- Following the public backlash, Charm eventually renames its version to Crush, ceding the OpenCode name to the project now maintained by Dax and Adam.

I'm surprised this doesn't get brought up more often, but I think the main explanation for the divide is simple: current LLMs are only good at programming in the most popular programming languages. Every time I see this brought up in the HN comments section and people are asked what they are actually working on that the LLM is not able to help with, inevitably it's using a (relatively) less popular language like Rust or Clojure. The article is good example of this, before clicking I guessed correctly it would be complaining about how LLMs can't program in Rust. (Granted, the point that Cursor uses this as an example on their webpage despite all of this is funny.)

I struggled to find benchmark data to support this hunch, best I could find was [1] which shows a performance of 81% with Python/Typescript vs 62% with Rust, but this fits with my intuition. I primarily code in Python for work and despite trying I didn't get that much use out of LLMs until the Claude 3.6 release, where it suddenly crossed over that invisible threshold and became dramatically more useful. I suspect for devs that are not using Python or JS, LLMs have just not yet crossed this threshold.

[1] https://terhech.de/posts/2025-01-31-llms-vs-programming-lang...

Here's an attempt at cleaning it up with Gemini 2.5 Pro: https://rentry.org/nyznvoy5

I just pasted the YouTube link into AI Studio and gave it this prompt if you want to replicate:

reformat this talk as an article. remove ums/ahs, but do not summarize, the context should be substantively the same. include content from the slides as well if possible.

Which plugins are you using? I've been looking to upgrade my zsh experience so some suggestions would be helpful.

OP is likely referring to people who call LLMs "stochastic parrots" (https://en.wikipedia.org/wiki/Stochastic_parrot), and by "doomers" (not boomers) they likely mean AI safetyists like Eliezer Yudkowsky or Pause AI (https://pauseai.info/).

Highly recommend Three-Body, the Chinese version of the Three-Body Problem. I enjoyed it much more than the Netflix adaptation, much closer to the source material, and more of a slow burn. Episodes are available on YouTube with subs (https://www.youtube.com/watch?v=3-UO8jbrIoM).

The link the article uses to source the 60 GWh claim (1) appears to be broken, but all of the other sources I found give similar numbers, for example (2) which gives 50 GWh. This is specifically to train GPT-4, GPT-3 was estimated to have taken 1,287 MWh in (3), so the 50 GWh number seems reasonable.

I couldn't find any great sources for the 200 plane flights number (and as you point out the article doesn't source this either), but I asked o1 to crunch the numbers (4) and it came up with a similar figure (50-300 flights depending on the size of the plane). I was curious if the numbers would be different if you considered emissions instead of directly converting jet fuel energy to watt hours, but the end result was basically the same.

[1] https://www.numenta.com/blog/2023/08/10/ai-is-harming-our-pl...

[2] https://www.ri.se/en/news/blog/generative-ai-does-not-run-on...

[3] https://knowledge.wharton.upenn.edu/article/the-hidden-cost-...

[4] https://chatgpt.com/share/678b6178-d0e4-800d-a12b-c319e324d2...

Couldn't find the JRE clip, but here's a recent one where he says "I don't really need more money." This is how I always understood it, he's already worth billions from past ventures, what difference does a stake in OpenAI make?

https://www.youtube.com/watch?v=PScOZzzXnDA

Here's a similar study that answers your question: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC10282813/

Drinking 1–5 cups/day of ground or instant coffee (but not decaffeinated coffee) was associated with a significant reduction in incident arrhythmia, including AF. The lowest risk was at 4–5 cups/day for ground coffee (HR 0.83; 95% CI [0.76–0.91]; P <0.0001) and 2–3 cups/day for instant coffee (HR, 0.88; 95% CI [0.85–0.92]; P <0.0001).

tl;dr Yes it has similar benefits, maybe slightly worse than "ground coffee" (I wish they had broken it down more granularly)

One point I haven't seen mentioned yet is that a11y provides obvious business value in that it forces devs to write better and more testable code. I first noticed this when using react-testing-library [1], when refactoring my code to be more easily testable became equivalent to adding a11y features.

Example from a project I worked on: I needed to test that when a button is clicked that the app showed a spinner when loading and then the content when the API call completed successfully. The spinner component was just an SVG with no obvious way to select it without adding a test-id, so instead I refactored the app to use an aria-busy attribute [2] in the container where the content is loading. The test then becomes something like this:

  test('shows spinner while loading and content after API call', async () => {
    render(<Example />);

    userEvent.click(screen.getByRole('button', { name: /load content/i }));

    expect(screen.getByRole('main')).toHaveAttribute('aria-busy', 'true');

    await waitFor(() => {
      expect(screen.getByRole('main')).toHaveAttribute('aria-busy', 'false');
      expect(screen.getByText(/content loaded/i)).toBeInTheDocument();
    });
  });

Apparently it is possible to measure how uncertain the model is using logprobs, there's a recipe for it in the OpenAI cookbook: https://cookbook.openai.com/examples/using_logprobs#5-calcul...

I haven't tried it myself yet, not sure how well it works in practice.

ChatGPT is specifically bad at these kinds of tasks because of tokenization. If you plug your query into https://platform.openai.com/tokenizer, you can see that"egregious" is a single token, so the LLM doesn't actually see any "e" characters -- to answer your question it would have had to learn a fact about how the word was spelled from it's training data, and I imagine texts explicitly talking about how words are spelled are not very common.

Good explanation here if this still doesn't make sense: https://twitter.com/npew/status/1525900849888866307, or check out Andrej Karpathy's latest video if you have 2 hours for a deep dive: https://www.youtube.com/watch?v=zduSFxRajkE

IMO questions about spelling or number sense are pretty tired as gotchas, because they are all basically just artifacts of this implementation detail. There are other language models available that don't have this issue. BTW this is also the reason DALL-E etc suck at generating text in images.

FYI you shouldn't use anything other than DI water in humidifiers. Using tap water can cause bacterial/fungal buildup and emits harmful particulates into the air.

https://dynomight.net/humidifiers/

Colemak user here, one of nicest things about Colemak IMO is that the ZXCV keys on the bottom row stay in the same location. I tried out a variant for a while that had XCDVZ and my brain could never get used to it. For other common shortcuts (Ctrl+T when browsing, Ctrl+F, etc) I didn't find it too hard; I guess some shortcuts are more muscle memory and others are associated with the letter in my mind.

I will say, having learned Colemak early on has made me give up on learning vim more than once for the same reason you highlighted -- I want to have my navigation on the homerow but the burden of remapping all of the keys without knowing what I'm doing was too high. I've heard that many people just use hjkl in the standard Colemak positions and don't remap keys at all, but that seems crazy to me, since they are spread all over and J is in the worst possible spot on the keyboard.

I was also surprised to not see this discussed in the article. Melatonin supplementation seems like the obvious solution given how cheap and easily available it is. It can also go hand-in-hand with interventions the author suggests like f.lux or using dimmer lights.

Lots of good discussion and links to studies about efficacy here: https://gwern.net/melatonin tl;dr - yes it works and is much easier/cheaper than other things

My guess is the missing ingredient is the back and forth communication with other humans. Surely if you quantified the amount of all of the information (verbal and over other channels) that is traded back and forth by humanity in a small timeframe it would dwarf the current training set. I think is the idea behind ChatGPT - your conversations with it are the next set of training data. I can see the argument that this sort of conversational data is not as valuable as say scientific journal articles, but maybe the volume makes up for that?

FWIW I'm on a 2021 16GB M1 MacBook Pro and it takes about 7min for me as well.

I've just been following the steps here with default settings: https://replicate.com/blog/run-stable-diffusion-on-m1-mac, but maybe there's a better way to run it at this point?

https://tetr.io/ is probably the best unofficial game, especially if you're into multiplayer variants.

For single player https://jstris.jezevec10.com/ or https://simon.lc/tetr.js/ are the best.

There's a variant of this idea called "KeyTris" or "Finesse", here's one implementation: https://github.com/alex-ong/Finesse

Example of someone getting sub 20 seconds with this method: https://www.youtube.com/shorts/TGW4j7LRBJk

For those interested in learning I found this to be a great introduction: https://www.youtube.com/watch?v=9GQGfdlNYyM

From the article, the fee is to support the AG enforcement, it's not meant as a meaningful punitive damage.

In addition, Amazon will pay $2.25 million to the Attorney General’s Office, which will be used to support the Attorney General’s antitrust enforcement, which does not receive general fund support.

Yeah, the proposed mechanism with cryptochromes works in the bird's retina, but it's unknown if it affects the normal visual field or is separate. There's some cool visualizations of it here: http://www.ks.uiuc.edu/Research/cryptochrome/ (from this paper: https://pubmed.ncbi.nlm.nih.gov/20655831/)

https://github.com/Defi-Cartel/salmonella

Link for the lazy, super interesting read.

Couldn't find the PR you're referring to, unless it was this one https://github.com/rapid7/metasploit-framework/pull/15007 which was added by the same author as the OP, but looks like a different exploit as far as I can tell?