thethimble

Seems like it would be pretty straight forward to fine tune an LLM based on code + asm pairs to help facilitate reverse engineering.

You're welcome to short it and make lots of money if you are correct!

Have you considered using docker? Seems possibly more lightweight than a VM with more isolation than a user account based method.

If the system provides value that is greater than its cost, then paying the cost to gain the value is always worthwhile - regardless of the magnitude of the cost.

As costs drop exponentially (a reasonable expectation for LLMs, etc.) then increasing agent parallelism becomes more and more economically viable over time.

And even then if you give it Internet access you're at risk of code exfiltration attacks.

There is a related idea called "alloying" where the 2-4 candidate solutions are pursued in parallel with different models, yielding better results vs any single model. Very interesting ideas.

https://xbow.com/blog/alloy-agents

Separately, you have to consider that "wasting tokens spinning" might be acceptable if you're able to run hundreds of thousands of these things in parallel. If even a small subset of them translate to value, then you're far net ahead vs with a strictly manual/human process.

Head-of-line blocking is likely fully addressed by ssh3 where multiplexing several ports/connections over a single physical ssh3 connection should be faster.

This is actually a common/desirable feature to permit a group of people to access an ephemeral machine (e.g. engineers accessing a k8s node, etc.). Authorizing "engineers" via OAuth is much more ergonomic and safe vs traditional unix auth which is designed more for non-transient or non-shared users.

A blog post of design patterns would be really great. Again - amazing work!

I'm curious about two things:

1. What's the best way to do app deploys that update the RPC semantics? In other words how do you ensure that the client and server are speaking the same version of the RPC? This is a challenge that protos/grpc/avro explicitly sought to solve.

2. Relatedly, what's the best way to handle flaky connections? It seems that the export/import table is attached directly to a stateful WS connection such that if the connection breaks you'd lose the state. In principle there should be nothing preventing a client/server caching this state and reinstantiating it on reconnect. That said, given these tables can contain closures, they're not exactly serializable so you could run into memory issues. Curious if the team has thought about this.

Absolutely mind blowing work!

Should work anywhere that supports WS/HTTP + JS so yes

Because this program generates $1-5mm of revenue per person in addition to whatever spending and investment that person brings to the country.

It's perhaps "unfair" but it's also extremely pragmatic.

Relatedly, most of the author's concerns are solved by wrapping things in a message.

> oneof fields can’t be repeated.

Wrap oneof field in message which can be repeated

> map fields cannot be repeated.

Wrap in message which can contain repeated fields

> map values cannot be other maps.

Wrap map in message which can be a value

Perhaps this is slightly inconvenient/un-ergonomic, but the author is positioning these things as "protos fundamentally can't do this".

Importantly it’s not just any model they’re “alloying”. It’s only the two most capable models where there’s objective evidence that the combination is better than the individual parts.

In this way, it’s not really a “lowest common denominator” as you get to pick the highest performing combination (with solo models just being a special case).

What’s your take on Hickey’s talk titled “Maybe Not” which fundamentally criticizes static types? Is there a middle ground where some form of static typing makes sense in a Clojure-esque world?

https://youtu.be/YR5WdGrpoug?si=4mI8doBX6jj6PJkk

Amazing! Would love “premoves” so that I can input the next move before the first move’s animation completes. This will help maintain flow state for your more experienced users.

See chessbook for an app that does this really well.

Vision transformers effectively encode a grid of pixel patches. It’s ultimately a matter of ensuring the position encoding incorporates both X and Y and position.

For LLMs we only have one axis of position and - more importantly - the vast majority of training data only is oriented in this way.

They’re not pushing a single canonical schema.

Each team still owns its local RDF graph for concepts like actor or movie. What UDA adds is a shared graph of mappings that translate between those local models whenever another team needs them.

Traditionally such translations live in scattered adapter code, which hides lineage and adds opacity - particularly as systems proliferate. By expressing the mappings as RDF triples inside UDA’s knowledge graph, they become versioned, queryable, and reusable. No more spelunking through layers of service code to understand how one team’s actor becomes another’s.

As a result, discrete teams/domains remain independent while the interconnections/relationships become first-class and introspectable. This enables coordination without centralization.

What will the alternative to web browsers be after they become "outmoded"?

You can even alternate between sending table and node chunks! This will effectively allow you to reveal the tree in any order including revealing children before parents as well as representing arbitrary graphs! Could lead to some interesting applications.

“Copy” is ambiguous here. Of course data is copied during training. That said, OP is referring to whether the resulting model is able to produce verbatim copies of the data.

Seems like it’s actually really convenient as independent customer data ends up being nicely isolated. Deleting churned customer data is as trivial as deleting their database.

> I think lack of gems/libraries/patterns is proof of this

This would effectively disqualify any new pattern from emerging. There have been many new patterns that have challenged the consensus that ended up becoming dominant.

This is hilarious! So billions of dollars of capital invested by Google on R&D results in all of the IP being seized with a $250m/year annual obligation?

> It’d be the right direction to go

Putting the legality of this aside for a moment, the second order effects of the government seizing IP at this scale would cause a massive downscaling of R&D investment followed by IP rapidly fleeing the country.

Brainfuck is also Turing complete but that isn’t an argument that it’s a good replacement for LISP or any other language.

This is what OP is referring to in case you haven’t been enlightened https://youtu.be/y8OnoxKotPQ?si=JAK5iPMcG1yoAhiT

The plan is crystal clear:

1. When equities crash, market liquidity floods the bond market causing yields to drop

2. Refinance debt at these lower rates massively reducing interest burden

3. Cut government spending to cause rates to drop further

4. Reduced rates with a balanced budget results in non-inflationary borrowing and an economic upswing

Along the way, eliminate taxes for those earning below $150k.

If all of the above happens at the expense of equity holders so be it.

This plan has been made clear by multiple people from within the administration (namely Bessent who is one of the greatest macro investors of all time).

Now there’s many things to criticize in this plan (and lots of risk and unknown possible second order effects), but to describe it as “genuine chaos” or ineptitude is strange.

Except for GPT 4.5 and Claude 3.7 :/

If anything I feel like “Ok, so…” is wasted tokens so you’d think RL that incentivizes more concise thought chains would eliminate it. Maybe it’s actually useful in compelling the subsequent text to be more helpful or insightful.

Judging by the content this is probably for people interested in moving into investment banking.

Doesn’t look like stats or advanced math is a major prerequisite.