artrax
A reevaluation from a IPCC7 lead author puts estimates that the median with current policies is 2.7 degrees C. https://journals.sagepub.com/doi/10.1177/29768659241304854
Thats not great, and we should put in more effort to get it lower, but it doesn't warrant unnecessary doomerism.
https://github.com/nebulastream/nautilus
It allows us to implement operators or functions without having to write them in terms of LLVM IR DSL (or similar). Rather, you write your functions over a wrapper type (and returning one), for which there is an overload of anything which you can overload in c++.
You can instantiate a wrapper from some c++ value, in which case the wrapper will just forward everything to this value, which was nice for debugging in the preagentic era. But, you can also instantiate such a wrapper as a tracer, and the result of the functions evaluation will be a trace.
For controlflow, we record whenever a wrapper type is evaluated as a bool, first return true, and when we reach the end of one branch, throw an exception to get back to the beginning, and start all over again, but evaluate it to false.
The resulting trace we can turn into LLVM IR and compile, or run for example in wasm
Big OLAP vendors like Snowflake do have the workloads of their customers, but you cannot just evaluate your optimizations on all workloads because its too expensive. You will only notice after deployment, when the customer calls you to complain. Or worse, they won't even consider you, because your novel workloads are too slow.
My point is not that specialized implementations can't deliver big performance gains, but that deciding when to use optimizations that have downsides reliably is very hard. Even for a classical problem, well isolated problem, like join-order optimization, even if you have perfect cardinality estimates (which you don't), its still NP-hard, and still, even optimizers that are considered advanced, will choke.
Anything engine/implementation specific is far worse, with smaller gains and much bigger downsides, which every systems routinely screws up because its just really difficult to decide when to use what.
Thats the core issue of database query optimization, and thats why (good) optimizer target the 99% percentile, not the peak, or the average.
Not blowing up is the most important criteria to be able to rely on a system.
No more "Do not do x, do not do y, only focus on z".
I also think that its hypocritical of Anthropic to spend a year suggesting that no one will need to look at code anymore, just to add a diff viewer into the TUI. How does this help with anything? I need to look at the context, go to definitions, etc. I already have an IDE for that.
So I build a pi extension that lets me click on a mentioned file, and opens it in CLion (or any jetbrains IDE) at the correct line.
The only thing I would like to see in Pi is better background process management and being able to start processes with a TTY, it was the only thing that took me a bit more time. Its now better then CC since it moves all bash calls into the background after 15s, no more hung up agents.
But now, subagents are just a skill, that tells pi to start another pi. Its one abstraction for everything. Most subagents are one-shot anyway, but I also added an extension that lets pi create sockets which get fed into the agentic loop, allowing for background processes to notify it, let it be subagents or some monitoring script.
And so many other things, like working image paste over ssh with kitty, one line tool calls (what am I supposed to do with these 4 lines of output??), etc.