acmiyaguchi

The youtube video covering it has an interesting run through of the desktop environment in the final section https://www.youtube.com/watch?v=eGS9su_inBY&t=2418s. But I agree a screenshot or two wouldn't hurt.

The live-feed is super cool. I wish I had a machine large enough to run this locally. It'd be nice if the ollama pro tier would allow running these historical models to play with at some point.

I/(claude?) created a gist that can be loaded into tampermonkey to expand the live-feed to make it easier to view on a bigger screen. [0] It's been fun to watch.

[0] https://gist.github.com/acmiyaguchi/ed72be6ff56130481f820169...

This feels like an AI agent doing it's own thing. The screenshot of this working is garble text (https://github.com/sophiaeagent-beep/n64llm-legend-of-Elya/b...), and I'm skeptical of reasonable generation with a small hard-coded training corpus. And the linked devlog on youtube is quite bizzare too.

This does exist to some degree, as far as I understand, along the lines of style-transfer and ControlNet in visual domains. Anthropic has some research called "persona vectors" which effectively push generative behaviors toward or away from particular traits.

[0] https://www.anthropic.com/research/persona-vectors [1] https://arxiv.org/abs/2507.21509

The idea of using stenographic techniques to exfiltrate data is interesting, but I don't quite follow the general method outlined in the repository -- either through the generated documentation or code. The threat model and case studies seem contrived. I find it hard to believe that folks would expose data via RAG that they wouldn't want users of the underlying system to be privy to.

There's too much fluff here to be useful. I imagine having something that is concise and concrete would make it more appealing to others. But as-is, it's missing a good technical summary and demonstration.

The first paragraph seems self-explanatory, and the templating language is simple enough that you can infer what it does when it runs. There's nothing about this that seems JS ecosystem specific, other than being implemented in a language that itself is implemented in javascript. I can imagine building a stamp interpreter in Python for example, it's not doing very much other than touching and catting text into files.

Getting an interview for global entry is actually pretty easy, you can just do it on the return leg of international travel with no appointment needed.

Interesting, is this how they're currently structured? It sounds a lot like Mozilla with the Mozilla Foundation and Corporation.

A first or second year (undergrad) student doing theoretical science to this level is astounding to me. It was an upper-division course for me, albeit a prerequisite for things like compilers and cryptography, so I'm sure it could be put earlier in the journey.

Sipser's "Introduction to the Theory of Computation" was the book I had to read, and it certainly makes this post more accessible.

I agree, it changes the semantics of dictionaries in a way that doesn't feel right. There are several things that are off-putting, but another example in vein with the mixed key types is the implicit ordered dict.

I was a bit suspicious of the claim, but found evidence that this might actually be the case. Here's a page focused on research related to non-native earthworms in North America that seems like a good start: https://www.nyisri.org/2016/09/underground-invaders-impacts-...

This paper looked familiar to me, and it turns out it's because it's part of the 4th edition of Readings in Database Systems (or the Red Book). The 5th edition is freely available to read online, and is worth the read/skim.

http://www.redbook.io/

This is an interesting talk! I love reading about applications of math/computer science to ecology. The parent page has links to relevant papers that are worth reading, too. [0] The species similarity paper has some concrete examples on coral, butterflies, and gut microbiomes that I felt missing from the slides. [1]

[0] https://www.maths.ed.ac.uk/~tl/genova/

[1] https://www.maths.ed.ac.uk/~tl/mdiss.pdf

As I understand it, part of the value proposition are the features that simplify distributed computation [0]. You define a function, and then you can refer to it by some internet global hash. The packaging reminds me a bit of Val Town, which has been featured here a few times [1].

[0] https://www.unison-lang.org/learn/the-big-idea/ [1] https://www.val.town/

Modeling is a process to help explain phenomena. I'm doubtful a particular deep neural network architecture can replace even the few examples provided in the article. It might be a useful tool to augment, but it won't replace the high level idea of being able to build and interpret computer models.

The language is not a limiting factor here. Python is an excellent scripting language, and works plenty fine in distributed computation. The Python interface to Spark is a wrapper on the underlying Scala API. You don't lose out on performance when you're building up a lazy chain of computation that's executed by an engine written in a more performant language.

Fugue is a layer to abstract out these distributed computation backends, and it looks like a nice programming interface.

There’s nothing stopping you from writing a compiler or interpreter in a non-imperative language like prolog.

Also performing the equivalent of a table join in a non-declarative query language is going to be a burdensome task. It’s certainly beneficial to let a query planner figure out the details for you, instead of iterating over all the rows of your data.

This article reminds me of one business student's criticism of the "critical positivity ratio" idea. This article by the Guardian [1] sums up the entire saga, and the actual rebuttal is titled "The Complex Dynamics of Wishful Thinking: The Critical Positivity Ratio" [2].

[1] https://www.theguardian.com/science/2014/jan/19/mathematics-...

[2] https://physics.nyu.edu/sokal/complex_dynamics_final_clean.p...