I’ve always wondered how this works when we only observe the final output and not the internal state that’s used to generate the output.
The LLM presumably generates f(input, RNG) but we only can observe f(RNG).
321 karma · joined May 16, 2023
The LLM presumably generates f(input, RNG) but we only can observe f(RNG).
> Funny story no one will believe, but it’s true. A good friend of mine joined a startup as CTO 10 years ago, high growth phase, maybe 200 devs… In his first week he discovered the company had a microservice for generating new UUIDs. One endpoint with its own dedicated team of 3 engineers …including a database guy (the plot thickens). Other teams were instructed to call this service every time they needed a new ‘safe’ UUID. My pal asked wtf. It turned out this service had its own DB to store every previously issued UUID. Requests were handled as follows: it would generate a UUID, then ‘validate’ it by checking its own database to ensure the newly generated UUID didn’t match any previously generated UUIDs, then insert it, then return it to the client. Peace of mind I guess. The team had its own kanban board and sprints.
Supposedly they used a game engine to render their TUI but I’ve never had an FPS game do that.
In other words, a weapons missle defense system is equivalent to an attack one.
I think that applying this thinking to software is a mistake. A lot of commercial software uses open source libraries under the hood, and and while the large corporations might have access to Mythos/Fable/gpt 5.6, the open source library maintainers typically don’t. That leaves them vulnerable to foreign adversaries who do have access to AI models. Attackers don’t need Mythos-level capability then, they just need to outperform whatever the maintainers are using.
Which means that Anthropic’s decision to restrict security research on even Sonnet makes that gap (and thus an attackers opportunity) even larger.
I say this as a coder who wants to release some of my internal libraries to open source. The risk now is that I open up my own products (which use those libraries) to vulnerability scanners while not having those kinds of detection methods myself. This, it’s safer to not release and keep internal than to risk increasing my own attack risk.
Hopefully we will come to see that software is not equivalent to missle defense — writing safe code is different than attacking others’.
The last year has shown that’s not true anymore (even for web servers).
It’s not even about philosophical disagreement as much as future career
A/B testing can’t measure preference, only interaction.
And this whole “they’re 50 steps ahead of you” nonsense is the same kind of stuff we heard from NFT or crypto bros, that we just couldn’t comprehend the infinite wisdom of a post currency world. Sometimes bad arguments are just bad arguments.
A lot of interventions o work differently based on APOE 4 status, so difficult to know whether this study will apply generally.
Doubt. What field of study?
The predominant calculation helper was slide rules, which were allowed in engineering exams in the 60s and 70s.
Besides, in engineering you had to show all of your work and that had a large impact on the grade you got.
See: the Sackler family
My guess: they know they can get more money from the insurer than the individual (or a combination of both!) so they want to scare you from not allowing them to negotiate with the insurers.
In contrast, the ollama dev team is doing useful work (creating an easy interface) but otherwise mostly piggybacking off the already existing infrastructure
My conclusion was that the goal was not to provide insight into databases but rather into category theory, which seemed backwards to me.
Instead I picked up some books on the relational algebra/logic for databases, and those books were actually useful — you could show that some set of transformations would be mathematically identical.
At some point, too high level of abstraction is not useful. For category theory, it seemed that the point was to show how all these different things were “similar” but in a way that didn’t allow you to do anything with it.
Compilers? Used to produce executables form source code.
Programming language? Allows us to write code using higher abstraction.
Distributed systems? Allows us to build systems across multiple machines, users, continents, etc.
GPU? Allows us to speed up heavily parallel code for graphics and scientific applications.
Assembly? Allows us to write closer to the hardware.
CPU architecture? Allows us to understand what our code runs on.
If anything, this list shows how category theory is not like the other things programmers could spend time on. If the goal is “learn a bunch of math to expand your math skill”, then maybe category theory makes sense. If the goal is to become a better programmer then I think there are better uses of time.