whacked_new

haha I forgot I had hackertube opened in a tab, then when I saw it, I was like, wait, youtube recommendations are actually good? ... oh

I literally just type into the input what functionality I want. In the beginning it was capability exploration: "integrate draw.io", which was quick work, but I never actually used it.

Then I threw actually useful things at it: find this directory of pdf scans, and create an interface where I can browse the files, preview them, and query an lmstudio server, and auto-rename the pdf based on the content.

Another is to ssh to a remote machine that has a particular file organization structure, and give me a preview gallery.

Nothing is particularly complex, but I couldn't be bothered to making that myself. It's also something that I would've used in emacs (the preview function is like dired-preview-mode in emacs), but a graphical interface would perform better.

I agree, it's an awesome concept in principle (and Girba is graciously welcoming people in discord). Working with an agent in GT, the agent will just look at the data and figure out how to express it in the graphical framework.

But in practicality, at least at this point, bb wins out by sheer expansiveness of ecosystem. I was working on a mishmash of an editor interface that combined obsidian with heptabase, directly in GT. It kind of worked. And the amazing thing is, everything has just a single representation: window positions displayed as text automatically have 2 way bindings across widgets, because they are the same data. But even with agents doing everything, 2 things creep up.

First is in JS/TS, all these binding problems are solved 1000x already. You can fake shared memory with callbacks and the agent won't lose track. In GT you move the cursor around, and have to decide at what point do you convert a widget representation to source representation, and when to restore the widget: is it a delay? is it after changing lines? is it after you move off the text? before or after the whitespace? There's a package for that somewhere in npm that answered all these questions, and it has tables, and it's performant. It doesn't do the 2% stuff that GT does using its magical shared memory representation (which also makes TS->smalltalk porting not straightforward), but you can still tape over it with sheer optimized code.

The second thing is that GT got really slow with all the data structure re-interpreting and rerendering. As "dirty" as bb is in reloading dynamic code, the runtimes are so optimized, I wanted the markdown nodes to be GPU-accelerated in bb, and it turns out they already were.

I spent some time exploring Glamorous Toolkit [1] for agent-assisted custom UI development, in an emacs fashion, where you'd modify the interface you're working with on the fly. It was a pretty good experience and the built-in data exploration was top notch.

Ironically after watching glamorous toolkit videos on youtube, I was recommended a talk by Geoffrey Litt about dynamic documents [2] and at the end of his talk I learned about bb [3], which has much better agent integration compared to GT. Like @thelazydogsback said, with agents, the programming language matters less.

[1] https://gtoolkit.com/

[2] https://www.youtube.com/watch?v=MccJdr61xnc

[3] https://getbb.app/

Best comment in <duration>*

* dependent on velocity

This is great! I remember being extremely impressed by Boris Johnson's "great supine protoplasmic invertebrate jellies" insult. How does one come up with such a string of words? I would've used this as a study resource.

I guess there's going to be a perfume that breaks down 2-noneal on the market soon.

Tangentially, in my 20s I was in an audience seating and sat next to an old person. And I smelled a new kind of odor. It was displeasing, but not like body odor. I quickly realized it's an old person smell. It really just makes you think "old person". I assume there's some biological wiring in there.

It's also because exercise requires exertion, which is effortful, and most people who need the exercise would rather spend money to not have to exert.

Does it pain me to say it? Nah, I'm numb :-/

I'm convinced this is true, and think music piracy in the classical sense will be mostly dead in the near future, thanks to AI, which already absorbed most of the pirating and has token-tumbled all the elements so that what most people listen to is already generated from the pirated elements

Here's one that I just ordered myself: https://www.waveshare.com/esp32-s3-epaper-1.54.htm

temperature, humidity, audio in AND out!!!

Ouch, shade on the SensorPush. I had 2 and I got 2 more. It requires an app, but they're quite well made imho.

But yes, open source would be better. If physical portability is not a requirement, Xiaomi hygrometer 2 with this custom firmware https://github.com/atc1441/atc_MiThermometer is quite excellent

I'm really happy to see these rewrites. It shows what's possible, especially as the projects get more and more complex.

And maybe Remacs will get reactivated https://github.com/remacs/remacs/wiki/Progress

Maybe even I'll be able to do it when I wait for the bus!

q3dm17 in the browser... what a time to be alive

this is low key one of the few things that I think of doing for the rest of my life, though my bias is towards seaweed farming and related ecosystems

Somewhat related is stavros's method to compress 500KB to something like 50 bytes https://www.stavros.io/posts/compressing-images-with-stable-...

main drawback is that it's not lossless ;-)

but this is great. I hope this actually becomes a format that wraps the weights and transformer module (maybe this can also be NAS-optimized too?). Maybe it would even work for video?

It's like calling gzip but instead of compression level you choose kolmogorov complexity level

Another potential weakness that isn't immediately clear from this experiment is if the experiment was run much longer (disregarding cost) then perhaps then the agent's memory could be susceptible to more long term memory compaction corruption and thus made more compliant?

If the threat model was weighted by the stakes, then I wonder how the author would reassess their comfort level. Put to the extreme, the experiment could be whether the AI assistant could be trusted to keep a dangerous AI in a box a la https://rationalwiki.org/wiki/AI-box_experiment where the stakes are assumed much higher

In my interpretation, 躺平 (tang ping / "lay flat") and 摆烂 (bai lan / ..."let it rot" I guess) overlap in meanings in the "do nothing" aspect, but in the tang ping / lay flat case, it is out of learned helplessness / nihilism, while bai lan / let it rot case, it is out of purposeful negligence / noncompliance, which suits geohot's vibe

Somehow the Chinese phrases 内卷 https://en.wikipedia.org/wiki/Neijuan and 摆烂 ("let it rot" https://zh-yue.wikipedia.org/wiki/%E6%93%BA%E7%88%9B) are quite appropriately used, even in stylistic tone. Don't know how much Chinese geohot actually speaks but it's a nice touch.

I recently sifted through a bunch of tagged entries in a text file, where each entry had a json array of image names, but the images resided on a remote server. I basically wanted a program that could detect if the cursor was on an image name, and display it on the right.

There's a bajillion ways to do this, some might even involve writing an html file and launching a remote server and tunneling and using a browser and what not. But no! ChatGPT wrote 20 lines of elisp code. I add a tramp basepath, open the text file, and got exactly what I needed. Need any behavior changes, callbacks, transformations? Modify, eval expression, new behavior!

I asked ChatGPT what other system I can use to achieve the same effect. The best answer it gave was neovim. No, neovim can't do that with the same degree of ease.

Disappointing and amazing at the same time.

The drawback of the emacs approach in my case is the tramp latency. To speed things up we'd want to add prefetch and that's gonna be much more than 20 lines and C-x e

I work a lot in the terminal and so vim/nvim is what I open the most, but the rise of LLMs has actually increased my use of Emacs recently. It fits in a niche of rapid interactive text processing. For example, I just found myself having to sort through a bunch of markdown files in a directory. While a tool like ranger could give dynamic preview, I wanted the preview to work with a todo list so I could mark which files still remain.

In the past, coding up this interaction would be a chore, but Gemini makes quick work of the elisp. After a minute, it's doing exactly what I need: cursor on markdown link, open to right pane, C-c C-c toggles the todo item and closes the pane; C-u C-c C-o opens in obsidian. This functionality can be achieved in any number of ways but Emacs is fantastically well suited for a problem like this.

wait, I'm intrigued, it says the blog itself is lean code. How? It's rendered, like pollen?

I'm a little sad that VSO languages didn't start the computing revolution because if they did, we would all be writing LISP. But instead, we are relegated to Python and JavaScript!

I think another part of it is culture. Outside of Western tech circles there's far less a culture (it feels) to invent new languages. To my knowledge Ruby's Matz is the only notable exception, and he's highly unusual as a Japanese. Then, using non-ascii-friendly character set is an even greater challenge.

Non-ascii encodings are harder to program in due to the need to switch in and out of input methods.

That said, some languages like Arabic and Japanese (and possibly Korean and Hindi) lend naturally to VSO token ordering, which maps directly to LISP syntax, so it's unfortunate that there isn't a lot of interest in this. It would be lots of fun. Maybe agents will make this possible!

Here are some interesting examples.

    - https://github.com/nasser/--- (Arabic)
    - https://honoka.nukenin.jp/Introduction/Loop.html (Japanese)
    - https://github.com/wenyan-lang/wenyan (Chinese, which is SVO like English)

Circa GPT-3.5 to GPT-4o I was involved in some research in figuring out how to make LLMs funny. We tried a bunch of different things, from giving it rules on homonym jokes [1], double-entendre jokes, fine tuning on comedian transcripts, to fine tuning on publicly rated joke boards.

We could not make it funny. Also interesting was that when CoT research was getting a lot of attention, we tried a joke version of CoT, asking GPT4 to explain why a joke was funny in order to produce training set data. Most of the explanations were completely off base.

After this work, I became a lot less worried about the GAI-taking-over narrative.

Funny is very, very hard.

[1] without a dictionary, which at first seems inefficient, but this work demonstrated that GPT could perfectly reconstruct the dictionary anyway

What sillysaurusx said, good on you.

I spent some time reorganizing the code in my gist into a repo for better change tracking at https://github.com/whacked/inline-interactive-forms.el

I also pulled vui.el into the dev setup and basically instructed the agents to reach feature parity. I ran out of CC credits fast so switched to codex. Codex makes a lot of unbalanced parenthesis mistakes even in agent, although it does eventually get it right by telling it to run emacs itself. Codex wasn't able to reach feature parity though, like the background color indications (I supply a video in the readme). I didn't look too deep yet.

I haven't thought through the entire use case. But it loosely revolves around the interaction designs provided by org-mode, ipython/jupyter notebooks, atuin desktop, aka "interactive documents", where the execution intent is embedded in text.

Jupyter is objectively more powerful from an interactivity standpoint, but the cell-based editing strategy has always fell short from a navigation and versioning standpoint. OTOH text-only interaction is sometimes too free, so after all these years, I still haven't found anything that feels just right.

Say you are writing devops documentation. Skipping the many ugly ways you can achieve this in jupyter (e.g. you need ssh logins and creds), or even slightly less ugly in atuin, in org-mode you'd use a begin_src / end_src block and eval that block. The block kind of breaks the text flow. A possibly better interaction mode would be a text "button", borrowing from GNU Hyperbole's terminology.

Continuing the button use case, say the devops document says "<run this> to check the uptimes of our servers". That button is simple enough. You can evaluate this and get a buffer, or like org-babel, insert the output into a block inline. Now we want to extend the functionality: "<query the ps of a given server>". We want parameterization, but without breaking flow. So here I'm thinking of injecting a disposable form at cursor. In a web-based toolkit, we'd use a popup or expandable form, but that switches focus out of the document and into a modal. Does that make sense?

I'm not sure how well it will all fit, but every now and then I feel the same itch, and it seems like in 10+ years of using different tools, Emacs is still the best for providing "structured, validated input for in-document interaction".

Here's a rust one: https://github.com/BeaconBay/ck

I haven't used it extensively, but semantic grep alone was kind of worth it.