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.

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.

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
  }

  #[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;
  }

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.

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

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.

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

You don't need to invoke group selection to explain dying though. Dying might be an evolutionary advantage, not to you, but to the genes that make you. Which is not the same as the species, at all [2]. Organisms die not to make space for others but because building the mechanisms to keep young indefinitely is not worth the price compared to spending these resources on reproduction mechanisms. Or because the right combination of genes that allow you to have free lunch just wasn't reached yet. If there was a magic mutation that prevents mammals from ageing without any other effects, I'm pretty sure that gene would spread. Quite possibly to the detriment of the species.

(Beware, not an evolutionary biologist, just somewhat interested in the topic.)

[1] https://en.wikipedia.org/wiki/Group_selection

[2] https://en.wikipedia.org/wiki/Gene-centered_view_of_evolutio...

> In 2021, there were 10,064 MAID provisions reported in Canada, accounting for 3.3% of all deaths in Canada.

> The number of cases of MAID in 2021 represents a growth rate of 32.4% over 2020. All provinces continue to experience a steady year over year growth.

https://www.canada.ca/en/health-canada/services/medical-assi...

Comments URL: https://news.ycombinator.com/item?id=32583070

Points: 1

# Comments: 0