Needs a sandbox, otherwise blindly executing generated code is not acceptable

Anthropic themselves support this style of tool calling with code first party now too.

This kind of LLM’s non-determinism is something you have to live with. And it’s the reason why I personally think the whole agents thing is way over-hyped - who need systems that only work 2 times out of 3, lol.

I’ve just acquired the latest gen Kindle and I’m absolutely blown away by how fast it is.

The real colour screens are used on the remarkable (eink gallery) and they are indeed slow for full page updates though remarkable seems to have done a lot of smarts for local updates while drawing.

What do you mean? The programmers work is literally combining the existing patterns into solutions for problems.

There is also 2 phase commit, which is not without downsides either.

All in all, I think the author made a wrong point that exact-once-processing is somehow easier to solve than exact-once-delivery, while in fact it’s exactly same problem just shaped differently. IDs here are secondary.

Having Discovery's awful content push out quality HBO content was already a major blow.

Yes, the price of one subscription. I think some cable packages in the US are $200 per month?

The only explanation I can think of is that most of the subscribers are elderly folks who signed up long time ago and didn’t bother to look into current bills.

Also maybe some ardent sport fans?

The only way to keep Internet/TV costs low is to threaten to cancel or switch every year, and actually be willing to do it. For some that isn't an option because there is only 1 provider, and others I've talked to hate that idea because you have to learn a new channel lineup. It's amazing how much people will pay to not be slightly inconvenienced.

Another is broadband deployment. Choice is low in many parts of the country, and bundled service offerings are frequently priced near the "internet only" offerings to nudge customers into a "might as well" posture.

Did you by chance went through this process yourself? If yes, would you mind describing the process in more detail?

At first glance you can just use static variable of a type supporting interior mutability - RefCell, Mutex, etc…

They're not.

  fn main() {
      unsafe {
          COUNTER += 1;
          println!("COUNTER = {}", COUNTER);
      }
  
      unsafe {
          COUNTER += 10;
          println!("COUNTER = {}", COUNTER);
      }
  }

  use std::sync::Mutex;

  static LIST: Mutex<Vec<String>> = Mutex::new(Vec::new());

  fn main() -> Result<(), Box<dyn std::error::Error>> {

      LIST.lock()?.push("hello world".to_string());
      println!("{}", LIST.lock()?[0]);

      Ok(())
  }

It doesn't increment anything for starters. The example would be more convoluted if it did the same thing.

And strings in rust always delivers the WTFs I need o na Friday:

    "hello world".to_string()

    use std::sync::Mutex;
    fn main() -> Result<(), Box<dyn std::error::Error>> {
        static PEDANTRY: Mutex<u64> = Mutex::new(0);
        *PEDANTRY.lock()? += 1;
        println!("{}", PEDANTRY.lock()?);
        Ok(())
    }

  static mut COUNTER: u32 = 0;

If on 2024 edition, you will additionally need

  #![allow(static_mut_refs)]

And that’s where a number of people blow a gasket.

Since 1.80 the vast majority of uses are a LazyLock away.

And in the gym, it raises your heart rate so that hurts exercise, but without it I can't do any cardio because I get so bored 5 minutes in I have to stop.