refactor_master

This reminds me of the Go Grandmaster speaking out after losing to AlphaGo, that the model has no sense of "aesthetic play", as long as it would lead to a win within the rules.

What properties does this have that somehow allows one to essentially predict the market or a proxy thereof, when seemingly nothing else can? Or did I get that part wrong?

It might take you from nothing to technically—a-market-fit, but from there to actually-a-market-fit?

My point is, there’s probably 1000s of companies doing the same things, following every playbook for success (do this, measure that, brand this, …), only for a single one of them to become a viral market hit, and the rest fade into obscurity.

Is that why their laptops routinely beat the competition year after year in reviews and reliability surveys? Because they “look cool”? I’m going to need some more numbers on that one.

I still remember one course where the lectures were basically just 1:1 summaries of the textbook, so I said "This is a waste of time. See you at the exam", and many of the more traditional showing-up-is-half-the-battle crowd were like "GASP, you can't do that!" because from very little we're taught that attendance is more important than outcome.

Some years ago people also said “Japanese bears are harmless, shy and fear humans” and now the country is experiencing a slowly approaching bear-pocalypse, with bear attacks occurring in densely populated suburbs. I don’t see how wolves in Europe would be uniquely different if it follows the same trajectory.

https://www.bbc.com/news/articles/cj41vn9q81ko

why romaji is actually good

It isn't. It falls slightly apart in the `s` column, and completely in the `t` column which contains both "chi" and "tsu". It also breaks for godan words that end in "u" which become "wa" in the negative form.

Mu, bu and nu also all obey the -nda transformation due to phonetics, and not due to how "if we just shuffle the letters around and presto! Nomu becomes nonda".

Japanese already has plenty of its own reading inconsistencies, so adding another layer on top isn't going to help you.

Finally, there's going to be so much kana in your every day life that learning conjugation in romaji is guaranteed to cripple your reading, because instead of recognizing kana (e.g. you see a billboard that says お茶を飲んだ方がいい！ as you frantically try to back-translate everything into romaji, but also removing excess w's and converting nda's as you go) you've spent the first n hours on trying to "hack" the language instead of just learning it.

Google is your friend

But really, it's more like tolerated business partner, right?

Yes, the most of its safety comes after you compile the graph. In that sense, it's "compile-safe" strictly speaking, which puts it on par with DuckDBs validation step. But you don't need to load any data to validate the execution graph (as opposed to Pandas).

The better question is, why is DuckDB so popular when one can use Polars which has a sane, lintable, typesafe API compared to the mess that is SQL:

  WITH lagged AS (
      SELECT 
          *, 
          LAG(event_time) OVER (PARTITION BY user_id ORDER BY event_time) AS prev_time
      FROM events
  ),
  sessions AS (
      SELECT 
          *, 
          SUM(COALESCE((date_diff('minute', prev_time, event_time) > 30)::INT, 1)) 
              OVER (PARTITION BY user_id ORDER BY event_time) AS session_id
      FROM lagged
  )
  SELECT
      user_id,
      session_id,
      MIN(event_time) AS session_start,
      MAX(event_time) AS session_end,
      COUNT(*) AS event_count
  FROM sessions
  GROUP BY ALL
  ORDER BY user_id, session_start;

  result = (
      df.sort(["user_id", "event_time"])
      .with_columns(
          session_id=(
              pl.when(pl.col("event_time").diff().is_null())
              .then(1)
              .when(pl.col("event_time").diff().dt.total_minutes() > 30)
              .then(1)
              .otherwise(0)
              .cum_sum()
              .over("user_id")
          )
      )
      .group_by(["user_id", "session_id"])
      .agg(
          session_start=pl.col("event_time").min(),
          session_end=pl.col("event_time").max(),
          event_count=pl.col("event_time").count(),
      )
      .sort(["user_id", "session_start"])
  )

The level of nested ifs is just pure insanity. Is this COBOL forcing this kind of style?

It's like when Bill Gates tried to guess grocery prices. "How much memory does a regular computer have? I don't know, 50 GB? Like a small EC2?"

So, if we had an AI demonstrating symptoms of consciousness and suffering, how long would it take for you to accept that it is?

Could an AI one day be suffering while plowing through some nasty legacy code? Well, who cares, I'll swing my whip, as I have a family to feed and a field to plow. I'll accept it as a fact and necessity, but ultimately it's either me or them. So practically it doesn't matter.

We don't act like this in society

Did you miss the part where the convention was ratified by 180+ countries, because clearly society can't just take a seat?

If I log into my system it's safe. If someone reads my password off my screen post-it and logs into my system it's quite thoroughly compromised. How would you demonstrate which of the two sessions are compromised, during the act?

It's actually even simpler than that. The airplane isn't just a "private business, and you shouldn't mess with their space". They're protected and empowered by broadly ratified conventions (which includes virtually every country in the word), starting with the Tokyo Convention:

The convention [...] recognises certain powers and immunities of the aircraft commander who on international flights may restrain any person(s) he has reasonable cause to believe is committing or is about to commit an offence liable to interfere with the safety of persons or property on board or who is jeopardising good order and discipline.

https://en.wikipedia.org/wiki/Tokyo_Convention

Before LLM you could sum up the web as the hamburger menu, bootstrap and materialize. Even Apple threw everything in a hamburger at some point.

If anything, China proves that 996 is not sustainable as it simply leads to involution and attrition. At best the populace benefits in a few hyper-focused industries such as take-out and e-commerce, but average life quality is still far behind "lazy countries".

After a refreshing walk it suddenly occurred to me - I had forgotten to add "make no mistakes".

I've found programming books good at what the internet isn't always: a cohesive story/presentation meant for a broad audience. I've enjoyed reading some more style-oriented books, largely ignoring beyond the gist. Learning about dependency injection and decoupled architecture, but for Python, completely changed how I viewed the language.

I also once read a book on MS SQL Sever 200x, which I don't remember much of, and I don't think it was terribly useful anyway. If I wanted to know the size of a datatype I'd Google it.

In the realm of statistics, not so. If you're right on the limit of detectability, robust experimental design is necessary to avoid assigning meaning to noise.

Especially with a bug. Why think about it when you can just feed a stack trace to AI and wait 2 more minutes?

We're already having coffee breaks when AWS and CloudFlare are down. What's another break in the mix? If anything, we might be lucky that they're down at the same time, so we can consolidate the breaks.

Don't forget that very very detailed spec is actually the code

The tests, sure. But certainly not the code itself, as that sits far too close to the implementation (i.e. it is the implementation). An almost infinite number of implantations can fulfill “does foo when bar”, so how can we prove that ours is the spec itself?

It’s kind of like a scientist coming up with a hypothesis post-hoc to fit the results of the experiment.

Maybe humanity will have more babies when AI takes over, capitalism implodes and we’re all farming and crafting things from scratch, since we’re forced out of the “economy”.

The house always… wins?

Some of the figures are downright atrocious quality and are found in better quality on Wikipedia. It’s almost an insult to paying subscribers and contributors of Springer.

Surely you mean grab a coffee and sit back down at your desk in your corporate office, because working remotely while your agent also does so is just preposterous.

Still baffles the mind that Apple solved this issue some 20+ years ago, and others _still_ haven't. I remember being basically surrounded by jet engines running Word in school.

A few years ago in an old job I got a monster-specced Dell laptop, and it would still roar if I opened anything. I had to pull all the nerf tricks through the BIOS to at least keep it somewhat tolerable in low-load scenarios (i.e. most of the workday).

Is there any other editor that comes close to JetBrain's Git integration? All I see is forks of forks of VSCode, and I'm wondering what the incremental gain of yet another does-the-basic-text-editing editors we need. This is in no way directed at OP, but it seems like a lot of wheels spinning around the world and surprisingly little progress at the Pareto limit.

Can someone give me a sound argument for why, when these things supposedly hold:

- LLMs scale with amount of data on the subject

- Even frontier labs themselves have a hard time gauging exactly how well-performing models are, across a quite rigorous set of tests in all aspects

then, how can this be true:

Using a low-data "niche language" (what is the volume of literature written in Caveman?) is supposedly of equal performance, when this anecdotally doesn't hold for e.g. niche code languages, proven by a handful of completely arbitrarily designed tests.

We've barely convinced ourselves that LLMs actually increase measurable industry productivity, instead of us just spending time to send slop to each other.

I only know chartreuse from the liquor.

I thought it was green though.