vbsd

Even if we accept this metaphor of English as a programming language, it’s used in a highly unusual way.

With regular programming, you have a full specification of the program (the code) and it gets turned into an executable. When you want to change some behavior, you change the code parts that relate to the behavior and the whole thing is compiled again.

With agentic programming, there’s no full spec, no “codebase in English”. You write instructions but they are discarded as soon as you close your session, and what’s left is this lower level thing (the code written in a traditional programming language).

It’s almost like a difference between declarative and imperative paradigm for the process of creating software.

> A simple example where 1 + 1 + 1 = 1 is ℤ₂, the group of integers modulo 2 under addition.

That’s a good example of an algebra where 1 + 1 + 1 = 1, but the article is specifically about systems where in addition to that condition, this second condition is also true: 1 + 1 != 0 (not equal!). ℤ₂ is not an example of that.

What sort of an interleaving would produce 1? Seems provably impossible to me, assuming atomic assignments.

Ah, I missed that you were talking about the code in the appendix, not the top examples. Yeah, you’re right on every count then, aplologies.

Huh, you're right about this, thanks.

On the other hand, I maintain that this is an incidental rather than essential reason for the program finishing quickly. In that benchmark code, we can replace "sleep" with our custom sleep function which does not record start time before execution:

  async fn wrapped_sleep(d: Duration) {
      sleep(d).await
  }

The following program will still finish in ~10 seconds.

  #[tokio::main]
  async fn main() {
      let num_tasks = 100;
      let mut tasks = Vec::new();
      for _ in 0..num_tasks {
          tasks.push(wrapped_sleep(Duration::from_secs(10)));
      }
      futures::future::join_all(tasks).await;
  }

> because `tokio::time::sleep()` keeps track of when the future was created, (ie when `sleep()` was called) instead of when the future is first `.await`ed

I’m not a Rust programmer but I strongly suspect this updated explanation is erroneous. It’s probably more like this: start time is recorded when the task execution is started. However, the task immediately yields control back to the async loop. Then the async loop starts another task, and so on. It’s just that the async loop only returns the control to sleeping task no earlier than the moment 1s passes after the task execution was initialy started. I’d be surprised if it had anything to do with when sleep() was called.

Even if CockroachDB uses Postgres wire protocol, it doesn’t mean you can easily migrate all workloads supported by CockroachDB to Postgres. The scaling properties are different.

This is true but you’ll have these risks with any paid service/dependency that has non-zero migration cost. Startups still use such products all the time, assuming that a huge price spike is not that likely or that there’s going to be some viable alternative with a migration path. I’d say it’s quite different when you can’t even guess what your starting point is going to be once you hit those $10M.

But I do agree with the general argument that lock-in as this for your core technologies (a database certainly counts) should be avoided.

Yes, and this is probably a common issue with these “pricing on request” schemes. Unpleasant, yes, but this unpleasantness can still be worth it if you’re running a big business and you need the database with the properties that CockroachDB has. But for an early stage startup, there’s nothing to even talk about. I doubt they are going to give you a quote for some hypothetical future where your annual revenue beats $10M.

Maybe they actually just don’t care about attracting startups, the whole “free license for small players” thing is just so that developers can check it out, not for actual use.

There’s one problem with this model. Let’s say I’m running a pre-revenue startup and I want to use the self-hosted version of CockroachDB. The license allows me to do it for free until I get to $10M annual revenue. Well, that’s great and all but I’d like to know how much I’ll pay once I do reach those numbers. However, the pricing for self-hosted offering is a secret, it’s “pricing upon request” – I have no way to estimate these expenses and thus no way to estimate if CockroachDB is a reasonable choice for my startup in the long term.

I got a subscription and the problem is gone. There are still other issues though, for example, the instant reminder feature doesn’t seem to work, the partner doesn’t get a notification.

On an unrelated note, do you accept feature suggestions? Task deletion would be nice to have.

I might find this app useful. However, for some reason it heats up my iPhone SE (2nd gen) and everything grinds to a halt after a few seconds of using it.

Would you expand on the Python issue? I find recent Python additions either useful or non-intrusive, I wonder which ones you think are born out of FOMO.

Curious that there’s no talk about nogil. Or did I just miss it?