Sinidir

Yes these things happen as part of RL Training. Same way that you can see the "But wait ..." phrases in thinking traces. They get rewarded.

Article is seriously wrong, because it makes a huge mistake in the last part. You can't simply look at the produced tokens and that is your cost. In agentic coding there are lots of turns meaning you not only pay for the output tokens you also pay for all the input tokens sent each time (even if a lot cheaper, like 10x when cached). So this calculation does not accurately represent the api cost at all.

Second thing is you can starkly upgrade the token generation locally if you use agent teams. Single conversations are memory bandwidth bound and don't fully make use of your compute. If you can batch tokens from multiple agents you can easily 5x token generation.

Harness: a piece of equipment with straps and belts, used to control or hold in place a person, animal, or object.

So yes the generel meaning applies to test setup and running and also to the agent cli which is the harness for the model.

The K/V Cache is just an optimization. But yeah you would expect the attention for the model producing "Ok im doing X" and you asking "Why did you do X?" be similar. So i don't see a reason why introspection would be impossible. In fact trying to adapt a test skill where the agent would write a new test instead of adapting a new one i asked it why and it gave the reasoning it used. We then adapted the skill to specifically reject that reasoning and then it worked and the agent adapted the existing test instead.

Does anyone know. How would that relate to simply wrapping claude code as a subprocess?

In the example given in the article i think the correct behavior would have been to infer the type backwards from the return type of the function. Is that not why mypy actually errors here?

Its not really hard to tell.

Pipe to dev/null. Fastest database i have ever used.

It is literally true. You don't need to run a type checker.

mypy is also written in a style conducive to speed ups when compiling with mypyc

Funny i know about Proust from The Sopranos.

You don't you build solar and wind, which have different seasonal productions. Wind power is actually higher during winter. See: https://www.researchgate.net/figure/Estimated-normalized-mon...

And if you combine the graphs for solar and wind from this: https://aleasoft.com/european-solar-and-wind-energy-producti...

You can nicely see that they are complementary in terms of energy production.

Must feel especially shitty to have your freedom curtailed like this, looking at the probable end of your life.

Yeah Containers like Option<T> and Result<T> not having a proper subtyping relation to T is major flaw. I mean you are basically giving a stronger guarantee if you are returning T instead of T or an Error, yet you break every callsite.

I have been thinking about this in terms of a data oriented programming language like clojure, but having types/schemas. If you use Union Types for something like getting a value out of a map for a specific key, then if you knew the schema of a specific map you could reduce the return type from {T, Error} to just the type of the value T that you know is there.

Basically a sufficiently smart compiler with the necessary information could make you not have to deal with errors at all in certain cases. With Result/Option/Maybe this would not be possible. It would always infect the entire callstack and you would always have to deal with it.

Concurrency is not "single core parallelism". Concurrency describes tasks/threads of execution making independent progress of each other. Parallelism describes tasks/threads actually running at the same time.

They are not missing the point. The previous post was simply wrong. The halting problem is semi-decidable. So you can potentially find out wether a program halts.

They don't work nearly as well enough or in the case of hydro storage are available in enough quantity to cover a month of weak wind.

For example. The US would consume its entirety of pumped hydro storage in a third of a day.

That just gave me the idea that there could be a main instance that keeps a summary of the problem (List of paragraphs for each subproblem) and other instances that hold the larger text that these summaries are based on. Then on demand the main instance could get needed extra information for a subpoint back. Kinda like having forgein keys in a databas with which you can join in the relevant row!

How do you to zero-copy message passing if you have one heap per actor? Or am i misunderstanding and a couple of actors share a heap, but there is no giant heap?

Felt the same way after first going from eclipse to intellij. This fear, this lack off. But after a while i didn't notice anymore and i have never run into a situation where something important was lost. In the opposite. Saving and making copies and even duplicating code in a file like an older version of an sql statement is some kind of fear/hoarding impulse, that doesn't seem to pay off at all.

Thats pretty funny.

The Werther Effect is thoroughly studied effect. There are plenty of studies on the issue.

Of course.

I mean i would but i don't know wether going back in time would pass the borrow checker.

What a mindblowing attitude for a book whos contents are already freely available as blogposts. Shame.

Then you're blind.

What the hell. Why are you stealing my idea? I've been working on this for 30 years. Its about 10% done. I'll do the rest next weekend.

Because I've actually benchmarked it: https://quick-bench.com/q/ISEetAHOohv-GaEuYR-7MajJgTc 18.5 nanoseconds fits under no reasonable definition of "crazy expensive", not when a regular increment clocks in at 5.9 nanoseconds. And there is extremely few situations where you increment a reference count more than, like, 5 times. It's just not an issue.

Congratulations. You tested a construct meant for multicore/threading in a single threaded benchmark and then marvel at the low overhead.

Of course you will only start seeing the cost if there is actually contention to operate on the value between multiple threads running simultaniously. See.: https://travisdowns.github.io/blog/2020/07/06/concurrency-co...

First off, this is not why Python has a GIL, but lets leave that aside. Atomic writes are more expensive than non-atomic ones, but they are not slow operations in the grand scheme of things. If you properly implement acquire-release semantics, they are not even that slow under high contention. Compare this to a GC which literally STOPS ALL THREADS, it's nothing.

This is actually part of why Python still has the GIL. A GILECTOMY was attempted and multithreaded atomic refcounting made things a lot slower (going up with the number of threads) and even other methods were not sufficient for performance.

https://www.youtube.com/watch?v=pLqv11ScGsQ

Its not bunk. People are comparing two widely different things and not understanding the difference.

The price of $150 is capacity of a battery. If i want a battery that can store 4 kwh i pay $600.

The other number referencing $55/MWh is referencing levelized cost of storage. I have a a MWh but instead of using it right now i store it for 4 hours. Now this MWh costs its initial price + $55.

Apply this example to a KWh where i would pay $0.1 for it if i used it right now if i want to store it for 4 hours and use it later i have to add $55/1000 to the price or about $0.055. So a directly used KWh would cost me $0.1. One stored for 4 hours would cost me $0.15.

Hope that makes sense and explains these different numbers.