rybosome

Fun! From the repo[0]:

> Your function must be self-contained, such that someone could copy-paste it into their code and not get an error. It also must not effect the environment outside it if at all possible (no #define or mutating globals). It must be as "pure" and self-contained as the language will allow.

This is an interesting restriction, actually, with respect to style. The “natural” way I would program such an algorithm certainly doesn’t adhere to this requirement.

Producing functions that are still correct, idiomatic and legible while producing minimal changes to environment or state requires a non-beginners understanding of the runtime nature of the language.

[0]: https://github.com/oliverkwebb/moonphase?tab=readme-ov-file#...

I’ve used this exact pattern.

However, in Python I prefer to use true DI. I mostly like Injector[0] because it’s lightweight and more like a set of primitives than an actual framework. Very easy to build functionality on top of and reuse - I have one set of modules that can be loaded for an API server, CLI, integration tests, offline workers, etc.

That said, I have a few problems with it - 2 features which I feel are bare minimum required, and one that isn’t there but could be powerful. You can’t provide async dependencies natively, which is not usable in 2025 - and it’s keyed purely on type, so if you want to return different string instances with some additional key you need a wrapper type.

Between these problems and missing features (Pydantic-like eval time validation of wiring graphs) I really want to write my own library.

However, as a testament to the flexibility of Injector, I could implement all 3 of these things as a layer on top without modifying its code directly.

[0]: https://pypi.org/project/injector/

Thanks for letting me know, I wasn’t aware that was possible!

Agreed. I wonder if this is somewhat revealing of the mental processes of the creators.

To me, if my cursor is a few lines away from another line, the easiest way for me to get there is by either using h/j a few times, or looking at the absolute line number and doing that with gg.

Relative jumps are only useful to me in macros. Calculating a relative jump myself would 100% pull me out of the flow state where I just want to go up/down a few rows.

I have no proof of this, but I’d guess that the creator of this pattern didn’t feel the same way.

I have far more ideas about this than time to execute it, but for a long time I’ve had this fantasy about a robot bandmate.

The idea is I’d go on stage singing and playing guitar with a looper and some samples, then bring a robot toy and introduce the robot “controlling” the looping and sampling as the bandmate.

It’s a gimmick that’s been done before, but with LLMs driving verbal interaction and now I could use this to animate a robot…it becomes pretty compelling. I’d plug the LLMs into the audio feed so I could banter with it and get responses then have the robot avatar animate accordingly.

If only my full time job saw value in this project.

To be honest with you, it being stochastic is exactly why you should post it.

Having data is how we learn and build intuition. If your experiments showed that modern LLMs were able to succeed more often when given the llm-min file, then that’s an interesting result even if all that was measured was “did the LLM do the task”.

Such a result would raise a lot of interesting questions and ideas, like about the possibility of SKF increasing the model’s ability to apply new information.

Here is a short link - http://pythonwise.blogspot.com/2011/09/on-importance-of-play...

Thanks for the write-up!

I’m curious how you found the quality of the results? This gets into evals which ML folks love, but even just with “vibes” do the results eyeball as reasonable to you?

Thank you for clearly and concisely articulating why this is dangerous from the securities aspect.

I think the immorality of it for consumers is obvious on the surface, but the backend financial stupidity of it is slightly less obvious. At least to me, I felt that it was risky but couldn’t clearly articulate why until reading this.

The only difference may be how many people buy into these. I don’t imagine BNPL securities to have the reach of 2008 for a few reasons, but perhaps I’m being naive.

> Is financing your lunch a sign of societal decay? Maybe, maybe not. But it’s definitely an evolution in Market Completion.

Yeah this is a fucking crazy statement, as if the “but” justifies the former statement because it touches a Proper Noun.

“Is getting beaten to death in broad daylight a sign of societal decay? Maybe, maybe not. But it’s definitely an evolution in Practical Fitness.”

Feynman has an excellent write-up on this very point.

TL;DR - some of his Nobel-winning work began as dicking around.

> They’ve done it again.

Indeed they have. Similar improvement in performance on my side.

It is so fast that I thought it must have failed and not actually checked my whole project.

This is a great premise, and that underlying pipeline you mention sounds like a generally useful system for live commentary with the appropriate abstractions.

I’m curious to know more about how you retrieve from this ecosystem of data to add color. You mentioned nearest neighbor search, is that over game state? How is the data stored and queried?

As it happens, I’ve been thinking about a library I’d like to develop in F# as an exercise to learn the language.

I have a hand-rolled proxying inference framework written in Python that is similar in purpose to something like LangChain but much more stripped down, less abstraction. Similarly to many other Python tools, it leverages the reflective capabilities of the language to do things like ask LLMs for responses conforming to a data class, or pass native Python functions as tools. Best of all, it relies on native Python constructs like docstrings to provide additional context to the inference APIs, making clean and well documented code a secondary programming model in a sense.

Perhaps it’s vanity, but at least in Python I find the resulting code quite elegant. I became curious what it would be like to port this to other languages, and surprisingly found that F# would, to my eyes, end up with the most lovely analogue.

Even languages I expected to be expressive and terse, like Haskell, couldn’t express the same ideas as understandably yet concisely as F#.

This comment made me wonder about the idea of harvesting lightning as a power source. Obviously it’s incredibly challenging, but I wondered if we had magic sci-fi technology that allowed it, how useful would it be?

Back of the napkin math suggests that even with theoretically perfect prediction, capture, storage and distribution you’d still get at best ~1% of the US’ energy through lightning capture.

Interesting idea - is the chunking deterministic? It would have to be to be useful, but I’m wondering how that interacts with the neural net.

I see, thanks for the clarification.

Yes, that’s true - the current notion of instructions and data are too intertwined to allow a pure data construct.

I can imagine an API-level option for either a data message, or a data content block within an image (similarly to how images are sent). From the models perspective, probably input with specific delimiters, and then training to utterly ignore all instructions within that.

It’s an interesting idea, I wonder how effective it would be.

That’s the intention with developer messages from o1. It’s trained on a 3-tier system of messages.

1) system, messages from the model creator that must always be obeyed 2) dev, messages from programmers that must be obeyed unless the conflict with #1 3) user, messages from users that are only to be obeyed if they don’t contradict #1 or #2

Then, the model is trained heavily on adversarial scenarios with conflicting instructions, such that it is intended to develop a resistance to this sort of thing as long as your developer message is thorough enough.

This is a start, but it’s certainly not deterministic or reliable enough for something with a serious security risk.

The biggest problems being that even with training, I’d expect dev messages to be disobeyed some fraction of the time. And it requires an ironclad dev message in the first place.

Ok - not wrong at all. Now take that feedback and put it in a prompt back to the LLM.

They’re very good at honing bad code into good code with good feedback. And when you can describe good code faster than you can write it - for instance it uses a library you’re not intimately familiar with - this kind of coding can be enormously productive.

Lovely API, great work on that.

Agreed. Severe CVE seems like the ticket here given the context.

I believe that an authoritative implementation of an MCP server was just created in the last couple weeks, which explains the flurry of initial posts.

The value is that this interface is the other end of a socket; implement it, and your LLMs will have magic tools. Sure it’s just another JSON-RPC adapter, but it’s a JSON-RPC adapter that works and has working integrations.

Give it a try, if you remain open minded to the potential I suspect you can find a use case and application that would shock you in its efficacy.

Linear types are an interesting idea.

I really liked the way that each transformation of the file was a separate File object, reminded me of functional style immutable data structures where each transformation returns a new structure.

I believe the post you are replying to was referring to the fact that you could take actions in that unsafe block that would compromise the guarantees of rust; eg you could do something silly, leave the unsafe block, then hit an “impossible” condition later in the program.

A simple example might be modifying a const value deep down in some class, where it only becomes apparent later in the program’s execution. Hence their analogy of the wet dog in a clean room - whatever beliefs you have about the structure of memory in your entire program, and guaranteed by the compiler, could have been undone by a rogue unsafe.

Imagine a very fat king standing before his starving populace, explaining why there would be even less food this winter as he munched on a turkey leg.

I know executives have different rules and laws that govern them. But I can remember a time when they would’ve had the decency, shame or whatever else to attempt to obscure this. That HR VP could have come into the office for one day, the day that he was explaining his RTO mandate to the entire company.

That he didn’t feel embarrassed about delivering this mandate while very visibly defying it himself is beyond differentiated treatment, it is open disdain for the (upper) working class.

I was at Google during their initial “return to office” mandate.

During the TGIF (company all hands) discussing this, the architect of the policy, someone high up in the HR org, explained why it was necessary.

I don’t recall what they said, but I do recall that they happened to be working remotely at the time, after the policy against remote work had already gone into effect.

The brazenness of lecturing us on why remote work was harmful to Google while working remotely was shocking. Predictably, the internal anger over this was enormous.

Rules for thee but not for me, some animals are more equal than others, etc.

I hear this sort of thinking repeated often, and it makes sense at an intuitive level.

However, my experience is that this isn’t always the case. My company has a medium-large Python web app in production, and having viewed performance profiles, I can say definitively that Python code execution occupies a non-trivial amount of processing time. Of course the single largest time sink is the LLM requests we make, but if we could magically nullify the Python processing time, our latency would significantly improve.

The culprit in this case may be specific to FastAPI and Pydantic rather than Python generally, but the point still holds that not all web frameworks and resultant apps are equivalent.

That said, I’ve been dreaming of rewriting large chunks of it in golang. I’ve always known Python was relatively slower than other languages, but I saw a recent benchmark measuring golang as 50x faster than Python. Perhaps the benchmark won’t translate to real world performance, but still - 50x is difficult to ignore.

> The father of five children under 10, who made his living from fixing, building and digging, can no longer work and so his children no longer go to school.

Was this the sentence you were referring to?

What a sad situation, I can't imagine the stress of being disabled and unable to provide for my young children.

Ah great, I will definitely give this a try later then, thanks!

I’m curious if this is becoming something that you are using in your own day-to-day, or if your focus right now is on building it?

The context for my question is just a general interest in the transition to AI-enabled workflows. I know that I could be much more productive if I figured out how to integrate AI assistance into my workflows better.

This is a really cool effect. How do you envision this being used?

Thinking about it as a product, I’d want a way to easily slip in and out of “LLM please respond” so it wasn’t constantly trying to write back the moment I stopped the stylus - maybe I’d want awhile to sketch and think, then restart a conversation. Or maybe for certain pages to be LLM-enabled, and others not.

Does it require any sort of jailbreak to get SSH access to the device?