jules

This is very cool. My nephew will love this.

There is a difference between changing administrative things versus fighting physics.

Can you solve this by putting your lazy prompt through GPT-4o or Sonnet 3.6 and asking it to expand the prompt to a full prompt for o1?

In primary school there was a teacher who straight up hated me because I did the exercises too fast and this would cause extra work for him to keep me busy.

The modifications that this article makes to the original version [1,2] are not a good idea. The modified version in this article cannot properly be used to search an array, for example (due to the extra "sanity checks", which would cause out-of-bounds errors). The API is also made more complex, returning a pair of options of indices rather than a pair of indices. You really just want the pair of indices!

If you do sanity checks in Rust then you should panic instead of returning options. However, in this case you cannot do the sanity checks, because the contract of the function is that it will only call the predicate strictly between l and r (i.e., only on indices returned by mid). Further, given the initial sanity checks, the sanity checks inside the loop body are redundant, as the loop invariant ensures that those checks never fail.

[1] https://julesjacobs.com/notes/binarysearch/binarysearch.pdf [2] https://byorgey.wordpress.com/2023/01/01/competitive-program...

Here is a Rust implementation of the original:

  pub fn search<T: Mid, G>(predicate: G, mut l: T, mut r: T) -> (T, T)
    where G: Fn(&T) -> bool
  {
    loop {
      match l.mid(&r) {
        None => return (l, r),
        Some(m) => {
          if predicate(&m) { r = m } 
          else { l = m }
        }
      }
    }
  }

Or, traitless:

  pub fn search<T, H, G>(mid: H, predicate: G, mut l: T, mut r: T) -> (T, T)
    where H: Fn(&T,&T) -> Option<T>, G: Fn(&T) -> bool
  {
    loop {
      match mid(&l, &r) {
        None => return (l, r),
        Some(m) => {
          if predicate(&m) { r = m } 
          else { l = m }
        }
      }
    }
  }

Earley parsers should not need more than O(n^2) memory.

The eBPF termination checker is buggy anyway; you cannot rely on it.

Do computers need 10,000 examples to distinguish dogs from cats when pretrained on other tasks?

From reading the description, perhaps "urban greenery" would be a better term than "urban grass".

> Any one noticed how Sam sometimes intentionally tries to attack his own work? For example, he has said GPT-2 was very bad, GPT-3 was bad, and GPT-4 is okay. He also fed the AI doomers by talking about AGI dangers and how the world needs to watch out for a future AI catastrophe.

That is the opposite of criticism. It all translates to "GPT-(n+1) is going to be super awesome".

Not criticizing new projects is a good social norm, because starting new and ambitious projects is good and should not be discouraged. However, criticizing projects that make misleading, unsubstantiated or false claims is also a good social norm, because it discourages people from making misleading, unsubstantiated or false claims.

The article in question is about Ruby, which is garbage collected.

It's easy to get in trouble with an interconnected object graph: you mess up and hold onto a pointer that you shouldn't be holding onto, which results in a leak.

As I said, this isn't about ints, it's about pointers. What behavior will you define in C for writing to a random memory address?

What behavior would you define for

    *((int*)rand()) = 42

This is simply not true. Almost all optimisations rely on undefined behavior, see https://news.ycombinator.com/item?id=38760475

Note that I am not talking about UB like signed integer overflow. Removing that would slow down programs by a couple of percent. The important type of UB is pointer provenance. This ensures that e.g., writing to a random memory address is UB.

Sure, safe Rust has no UB. The main reason why that doesn't apply to C is that if you wanted to make every C program have a defined behavior, then you also need to define behavior for out of bounds memory writes, including writes from other threads. This means that the compiler basically cannot apply any optimisations, because another thread could be overwriting your data structures at any moment.

Yes, I do agree that you basically only need provenance, and that C has more UB than necessary. You can indeed reduce UB without any major performance impact (e.g., shifts by a large n, signed overflow). I think that would be a good idea.

I do agree that if you remove `unsafe` blocks from Rust, then you have a performant language without UB. However: (1) We are talking about C here, not Rust (2) Rust has UB due to `unsafe` (3) LLVM IR has UB.

While data races may not be a top category empirically, they are undefined behavior, which means that (a future version of) the compiler is allowed to make your program do anything at all after a data race happens. We are setting the bar incredibly low for ourselves if we just accept that things like that happen on the regular.

Undefined behavior is critical for performance. Without undefined behavior, C compilers would not be able to optimize at all. You'd be running everything at -O0 or worse.

If you think about it, it is clear that agency is not different from intelligence. The reason why current LLMs can't be trivially made into agents is not because an essential agentic spark is missing. It's simply that they aren't intelligent enough.

Everything we do affects the environment. Locally making the ocean a little bit saltier by removing water and not removing salt sounds like a very minor problem.

Would letting people vote with their phone lead to better outcomes?

I also have peeves that I find hard to let go of, but I view those as a personal flaw.

> She would tell me about every little negative thing that happened between us.

I would not want to be in such a relationship, to be honest. Just learn to accept each other's small flaws and try to be kind. Little things only build up if you let them. Verbalising everything and putting negativity into focus is actually one of those ways that scar tissue can build up. The best way for it to not build up is to let the little things go.

By spending on luxury such as expensive restaurants and hotels, you cause the economy to allocate talent and capital toward the production of those luxury goods and services, rather than toward longer term investment. Making it so that old people burn up their built-up wealth in that way is not good. It would be much better to gather the equivalent amount of tax elsewhere, if you insist that we must do so (such as with a VAT on luxury goods and services!).

Encouraging people to frivolously spend on luxury instead of saving is a terrible idea.

For comparison, adding up the Dutch tax rates for when my nephew inherits from me and buys a product with it:

- Income tax: 49.5% (36.93% on income under €73k)

- Inheritance tax: 40% (30% for inheritance under €138k)

- VAT: 21%

Thus, poor people pay 65% tax and rich 76% in such a scenario.

Wolfram Alpha is computation. So it became a computational genius in precisely the things that Wolfram Alpha can do. A better test is whether it can prove new lemmas, like the average undergraduate in mathematics. From what I tried, it cannot do that yet.

I'm convinced that doesn't require a breakthrough in the architecture or scale of LLMs, though. GPT-4 seems plenty smart enough to be able to learn that, if hooked up to a proof assistant like Lean or Coq with the right fine tuning iteration loop.

Maybe it can do this with sleep, where it gets further training on the new input and output it produced that day.