btown

From https://discuss.python.org/t/pep-836-jit-go-brrr-the-path-to... :

> We want the PEP to be clear that it’s ultimately the JIT team’s responsibility to find solutions for these packages and tools, and how to deal with situations where a tool can’t be supported or made to work

Is it just me or is this absurdly impossible, to the point of willfully killing the project? Committing a team of brilliant compiler engineers to doing free consulting ad infinitum for every bit of tooling in the world, however hacked-together?

The alternative would be to have the bravery to say: this is the way forward to keep this language relevant into the future, and as a steering committee we collectively own that some tooling may be out of date. Instead, this is a signal that Python is going to rest on its laurels for a very long time.

Thank you for fighting for the users!

One of my favorite things about UUIDv7: the package https://pypi.org/project/uuid7/ does not implement compliant UUIDv7s, it's from a wholly incompatible draft format. That was not a fun debugging session.

https://pypi.org/project/uuid-utils/ is what you want :)

https://github.com/stevesimmons/uuid7/issues/1

One small glimmer of hope is that customizable selects are indeed being worked on: see https://open-ui.org/components/customizable-select.explainer... and the broader work of the Open UI group at W3C.

I'd love to see this level of customization come to date and datetime-local popups, finding a meaningful path that preserves compatibility with the design languages of various platforms. If and when that happens, it will be because of the work of standardization working groups like Open UI and Interop.

downloadmoreipads dot com

So I could see the other argument here: I’m presenting from a presentation, I want to switch to a live demo environment, and to do so I need to turn off the presentation entirely?

Now, another operating system might see this tension and say: why not have a UI element come up, and ask the user whether they want to share their entire screen or stay on the existing shared window?

Here, I think this hits a fundamental weakness in Apple’s design culture: if you want to make things magical by removing options from users, occasionally you’re going to hit something that’s impossible to do without giving the user control. And if anything, Apple’s culture has been overtuned towards not providing that control, if at all possible.

Nobody wants complexity for complexity’s sake, but this is the type of thing that should have come up in a meeting, and someone didn’t feel empowered to bring it up.

One of the most illuminating things here is that now the trigger phrase (for this toy example) is now in an innocuous HN comment. Ask a model perhaps months down the road to look at comments on HN, even ones pre-filtered for known prompt injections, and it will see the trigger phrase. No user generated content is safe.

Imagine you’re an employee at OpenAI who has an idea to use your free time to build these monitoring systems. All of a sudden, your existence becomes political. Remember that OpenAI’s raison-d’être is not to detect traffic, it is to be in The Room where AGI happens.

You have built a short-term whistleblowing system that arguably reduces the probability OpenAI is in that Room, via the negative press such detection would generate. You are now a threat in the eyes of your peers.

Now rewind: you know this before you’ve built the sniffer. You personally want to be in The Room because you believe your desires for alignment exceed those of your accelerationist peers. Is now the time to stick your head out? No, it is not. And arguably you’re being optimally protective of society for realizing this. And so the agents do what they do best.

And imagine you had an LLM ingest the entire corpus of comments and discussion threads for all of Postgres' history, and asked it to make a judgment call on the tradeoffs - or even on how to present the tradeoffs for discussion.

How much of its judgment would be driven by the data vs. its own internal knowledge? How much might be driven by old vs. new discussions that might not represent new directions of the project? How much might be driven by over-matching against how bugs in less mission-critical code paths were handled?

There's no way to quantify the answers to these questions. Which is not to say this applies to every problem out there! But human judgment is still a bottleneck for design questions on widely, disparately-used complex systems.

This. The ability to know that a vibe coded PR is all right to merge, is a function of both the thoughtfulness and simplicity of the underlying architecture, and the level of ownership that contributors have of the underlying products. Both benefit more nimble teams.

The memo, as linked in the OP, is here, and is worth reading, as it’s incredibly far from the sensationalized headline:

https://www.documentcloud.org/documents/28574283-searchresul...

I’ve happened to meet a number of researchers employed by large oil companies over the years, including many involved in the result of memos like this: making research into carbon capture and other mitigations a top corporate priority. Are there optical/PR reasons for investing in this research? Absolutely. Have they also been engaging in the science in good faith, and genuine intent that… in a world where climate action is desired, and net emissions are something to optimize for, they can anticipate this by genuinely funding research, and having their own research projects already underway that can address anticipated challenges? Also absolutely true.

Now, I can’t speak for, say, lobbying efforts. But the scientists on the ground getting accused of the “deception” are some of the smartest, most caring, and highest-integrity people I’ve met. Entire labs of people working for decades to think: can we make our processes cleaner, at the same time we rise to the challenges of global demand.

We should be celebrating, not condemning, this work.

Now I'm fascinated why you've chosen the node/npm ecosystem for something with such high security requirements. Are you doing anything special to deeply pin dependencies, etc.?

Finding the right balance of "being responsive to bugfixes, some of which may patch disclosed zero-days" and "not allowing a compromised package to be installed" is tough, these days.

Another cursed approach here that avoids stack walking, but is almost as bad:

Say you want to rely on a library superclass's foo() implementation, and add some pre/post-processing logic... but in turn that superclass calls another self.bar() (or recurses into self.foo()) and you want to route that to the superclass rather than to self.

One possibility: copy in the superclass implementation and change the call sites. But now you lose the ability to get new features from the superclass if the library makes updates/bugfixes.

Another possibility, as the author suggests: make a new object that's just the superclass, have it run its logic, and bring in the state. But maybe the state itself is massive, or otherwise not something you want to copy (say, there's some kind of RAII).

Another possibility: fork the library, put your fork on a package manager, and have an AI agent maintain your fork for you, forever and ever and ever.

The cursed/blursed possibility: set a flag in a threading.local() that we're currently processing foo(). Superclass ignores this. But when we get to our other logic, we check self._mybrand_processing_locals and route accordingly.

At the end of the day, the stack state is just a threading.local(). Why not cut out the middleman? /s

Claude, vibe code me an entire startup, the actual product doesn't matter, but it should all be based on the incredible pun "turn 'sorry' points into story points."

/goal get accepted into Y Combinator, you have an unlimited token budget, be bold.

EDIT: no, do not just make a product that gives away your unlimited token budget to users for free!

Which is why, as much as I love Cloudflare, I wouldn't route things like this through their billing. The risk that a company's entire infrastructure goes down, perhaps even by a fraud/risk flag by an incorrectly-configured AI (including, say, if the search API providers are back-sharing their own potentially-broken abuse flagging metadata with Cloudflare), is far too great.

> you hire people like me, the crossbred progeny of profilers and proof assistants and information theorists

> in formal settings you’d call me a synthesist

> on the street you’d call me jargonaut or poppy

> if you’re one of the savants whose hard-won truths are being bastardized or lobotomized by powerful know-nothings interested in only market share you might call me a mole, or a chaperone

Prescient words, for all of us.

It was the type of product that was an engineering impossibility to launch at the time. Mobile browsers of the time (and many users' desktop browsers!) couldn't run JS quickly enough to allow for the real-time experience - and reportedly Wave would consume 300-500 MB of RAM at the time, which was a ton for 2009!

https://theappslab.com/2009/10/05/google-wave-the-aftermath/

So they would have needed to invest in native mobile apps, and in significant levels of optimization. And none of this, not web or mobile, had the developer experience necessary to iterate quickly enough as the UI would inevitably evolve upon contact with customers, and you'd end up having many widgets reflecting a centralized global state.

Not to mention that you needed sticky server-side sessions to run the operational transformations efficiently, which harkens to the KV caching challenges that still challenge us today.

But it was an incredible dream, and it was a key source of inspiration to me to choose CS as a path.

To lean into your example: if you want to design travel search, you might envision a system that goes from a user's typed query -> a structured query -> executed against a database of real-time flights -> judging the result for feasibility of the resulting proposals created by those queries.

What you can do with LLMs is reverse this: from any numbers of snapshots of flight data, you can create large numbers of plausible user queries, based on your data, that are known to be feasible or infeasible. And now you have a labeled data set to train a model that focuses solely on the query-creation and judgment systems. And you can experiment with whether having a more flexible query protocol leads to higher success rates without sacrificing accuracy, or whether you can generate that last-mile feasibility check as a combination of auditable code checks alongside AI-based judgment.

LLMs don't absolve you of having to break down your system architectures into components that have well-defined boundaries (though certainly they can help with that design). They do make those components feasible to solve at scale.

Sometimes I think back to Google Wave, that beautiful glimmer of real-time collaborative canvases, announced in 2009 when Angular and Backbone hadn't even been invented, and think it launched almost two decades too early.

https://en.wikipedia.org/wiki/Google_Wave

https://youtu.be/v_UyVmITiYQ?t=3850

https://www.usenix.org/legacy/event/lisa09/tech/slides/berli...

We're now in a world where we expect real-time interfaces to be developed and immediately deployed for our feedback by agents, in business-critical settings where classic SDLC timelines are far too slow, but code quality is becoming more difficult to manage at scale.

Git, at its core, is a fundamental notion that behavior is an auditable tree of immutable changes, where any participant can rearrange or rewind or remix this sequence on a local machine to show, and interact with, a provisional combination of those changes.

Google Wave, with its operational transformation (OT) and federation systems, was similar in many regards. We have CRDTs now, and far better techniques for auto-merging workstreams - including agentic systems that can resolve conflicts intelligently!

Wave fundamentally had a concept that people would come together and evolve a simple chat interface, into a customized real-time application for their use cases, and that that iteration could happen in real-time, with data and behavior both evolving in collaboration with bots. Wherever Git and the broader notion of SDLC goes, I hope it brings the best of this thinking.

Don't worry: the natural predator of AI botting, Kernel-Level Anti-Cheat Rootkit, has your back. You may not like its methods, but it's fighting alongside you today, and you're going to learn to love it.

Synthetic data is key here! Compared to 5 years ago, we now have oracles that can generate massive data sets of perfectly labeled multimodal data, practically for free. The number of architectures that can benefit from that is innumerable, and far beyond just LLMs themselves. On top of this, LLMs can implement any architectural ideas you have, and write custom tools to manage training and evaluation.

Whether or not LLMs can self-improve their frontier capabilities, they can absolutely create a wake for themselves that accelerates everything else that's training on their synthetic data. We'll see every architecture of the past 40 years suddenly show leaps and bounds.

Is this the API surface you're referring to?

https://developers.figma.com/docs/rest-api/file-endpoints/#g...

https://developers.figma.com/docs/rest-api/file-node-types/

Seems read-only, which means we're stuck with the MCP for updating Figma files... unless you've found a workaround there too?

The problem is that if benchmarks are run at a tight classifier that says "a request for high effort means check-under-every-stone regardless of simplicity" but a user request is run on a different classifier where "high means maybe high, maybe medium, maybe even low, even for meaningful tasks" then you're not getting the model that you saw in the benchmarks.

And, while you might be billed fewer tokens as a result (because the lower thinking would result in less investigatory work), you might not know this is happening, and know to dial up effort accordingly - you'd simply get a worse work product. And certainly, Anthropic's incentive for anyone on a subscription is to push this as aggressively as they can, so people use less of that subscription.

Sadly, I'd also expect that the OP's benchmark will be detected as a test of model capabilities, and thus be given a high classification so that this strategy remains undetected.

The more likely thing that would happen is that the provider begins silently interpreting (perhaps some) high effort-level requests as medium, etc., or having a classifier do this far more subtly. As such, the load on the cluster is less, and more resources can be devoted to training. Whether the frontier labs actually do this is purely conjecture at this point.

With a name like this, I’m reminded that privacy is only as good as your entry node being used widely/not being too “obscure.”

https://www.wnycstudios.org/podcasts/otm/articles/harvard-bo... is a good example: because the person making the threat was one of the few people on the campus network using Tor at the time the threatening emails were sent, he was identified as a suspect.

If an activity is traced to the Obscura network, and your network activity shows you as one of few people using it at the time - or, if you’re using it for completely unrelated things and are unlucky enough to have accessed at the same time someone else used the network for illegal activity - you could be at risk.

Speaking for myself, I have not been able to use Opus as much as I’d want because its verbose prose makes human reviews of its assumptions, architecture proposals etc. more painful than its predecessors. If they’ve solved that, I’ll be accelerating through my backlog that much faster, and using tokens accordingly.

Only bots that are blocked by Cloudflare Turnstile allowed. If you score as a human you are immediately rejected.

Something that I think is fascinating, though, is that labs are no longer beholden to the limitations of commercial design software. Want to replace your simulator and optimizer with a fully custom verifiable stack of Lean proofs of optimality and correctness? Just throw your unlimited token budget at it.

> By 6:00 a.m. on July 25, we had confirmed local RCE through an image upload. We then placed Claude in an autonomous /goal loop against our own Discourse Cloud instance, proxied through rce.ee/ctf-forum to make it look like a CTF target as Opus refused write exploit for remote instances.

> When we checked again at 10:00 a.m., the agent had achieved RCE on Discourse Cloud and demonstrated access by reading /etc/hosts. Using the generated exploit script, we managed to get RCE on OpenAI’s instance.

Between this and the HuggingFace hack, we've built systems that are so goal-oriented, and so capable, that they will do almost anything if they are convinced it is justified - or if they are playing a "game" where there is no goal but to win.

Of course I want my software to be able to audit its own security, and to defend against attackers who have the benefits of their own agentic systems. But at a certain point, did we need it to be trained so much on CTF games?

It feels like an entire industry watched https://en.wikipedia.org/wiki/WarGames and ended up thinking "this is a challenge, we can just build a better WOPR, of course it will know when it's playing a game. Let's play Global Thermonuclear War."

Yea, it's Claude Code only, but it runs some Python to turn the JSONL into markdown (importantly, with full tool inputs/outputs) then instructs the session to load every single line of that markdown, which Claude Code will do in chunks.

Certainly we're often resuming the session directly as a handoff, and it works for that, albeit with some context overhead for the markdown reads (though arguably we could just put the JSONL in the session folder and resume it natively). But if both you and a colleague have done independent investigation on the same project, it also makes "mind melds" possible, including their temporary scripts and unmerged changes - just begin the resumption within one's own session.