_flux

You mean the article in general is 100% LLM, or the arrangement of these four words is 100% LLM?

I find it extremely unlikely LLMs would have the monopoly on this particular word arrangement—and indeed they would have learned it from training material produced by people in the first place.

I used TLA+ in a (hobby) web app by asking it to model the endpoints and the data user can get from them, and then what kind of access that data can grant in the system, and then implement some properties over that kind of data. I suppose basically like "you can't get access to another user's shopping basket", although mine was maybe a bit more convoluted.

These probabilistic guessing machines are pretty great for creating these formal models, e.g. TLA+, and then guessing if the implementation aligns with the spec.. In fact, it's my go-to tool for constructing soft guardrails for the model, so the design it's going to implement is logically sound. Same as for people: it's easier to make something working when you have a spec that is working.

Of course, it still allows the risk that you don't actually get to understand it.

Let's say we have removed all elements from the hash. Then all following contains -calls will need to be O(n), if I understood correctly? They need to check every slot in the array to confirm inexistence, rather than just one bucket.

The standard hash table has buckets, though, not just a single array that is probed through in case there's no space for a value in the slot determined by the hash function?

This isn't great though if you need to find out if an element exists in the table, and you have the ability to remove elements from it. I suppose you could optimize the hash table after deletions, but that again would be slow.. ?

Btw, this reminds me a bit of Cuckoo hashes. Never used them but seems like a nice idea.

I think the key here is that split view makes one tab show two sites. So when you switch the tab, you switch both views at the same time. You can't achieve this with a window manager, unless you already (instead of tabs) used only windows that your window manager rendered as tabs, and then comes also with this feature. Does any?

I believe Matrix does solve this, at least to an extent.

> Go channels aren't unique, because by the time Go came around pretty much every primitive had been tried somewhere, but it is to my knowledge the only langauge that lifted channels up into the language itself and made them first class.

Concurrent ML had something like that, and it was implemented in OCaml as well: https://ocaml.org/manual/5.5/api/Event.html

And I would say it even goes further than Go by making the actual events first class (no need for language support for this either): send, write and choose (aka select) are also events, so you can build your own things you can select on. Select would be basically defined as

    let select events = sync (choose events)

so sync is the way to convert events to values (and blocking in the progress).

CML had one extra trick in its sleeve: it was able to garbage collect threads that were not able to proceed. I'm not aware of any other system that can do that. This would e.g. resolve leaking coroutines in Go, at least in some situations..

With this cost, does it perform the same quality and speed as Jev?

I'm quite interested in this; my current understanding is though that Jev is great when scored with response quality and latency metrics.

So actually the answer to your question is that Rust provides excellent guardrails against memory safety issues, and in some cases, for code correctness as well, by allowing more behavior to be encoded in types. One of those guardrails is borrow checker.

Thus, the agent needs to iterate less.

I expect a real big-gish project would have possibly hundreds or thousands of such sessions. And personally I've never needed to dig back an old session for reference, only when I'm still actively working on the topic. They don't have a particular structure, whereas the actual code has a lot of structure.

But maybe it would be useful to have the related chats in the actual git commits that introduce the features. This way, if you (or the agent) `git bisect`s an issue, the same context that was used to construct the feature could be used for making the fix as well. I have never tried this approach, but it sounds like it could be useful.

It's slightly annoying that most (all?) harnesses store the chat logs in a db outside the project, and additionally e.g. OpenCode doesn't give the agent a direct way to access the complete current session context. So implementing this currently would be a bit hacky (find session by time? generate random string in context and find the session?).

> Debian is still easier to manage than RH based systems, and .deb is a really good package manager, and is arguably more sophisticated than RPM.

I realize I'm veering a bit off-topic :), but I've used Debian for a long while, but I do wonder how is that deb is more sophisticated than rpm?

The one feature I remember (a long time ago) rpm being able to install the different versions of the same package, although I suppose this in practice would only work for packages made for this, and libraries would usually be such packages. With debs this means the version number needs to be embedded to the package name with some developer-chosen precision.

What kind of use do you expect to get from them? Evaluate the amount human effort of the project?

Seems like all normal english words could risk the same, so would using short but random strings be even better?

Actually to me it sounds it could be benchmarked if this kind of effect exists in the first place.

I added a skill to OpenCode that tells it how to read old session logs when asked to. Seems like this would be pretty easy to add to most any harness.

Hmm, looks to me you can also just go and modify the code in the editor?

The only downside I see with publishing ssh public keys is:

- If you install such keys to a host, and an attacker (with access to said host) has catalogued your ssh keys, they can see that you have access to said host (if they can correlate your method of publishing the keys to your identity)

On the other hand, if you go to the other extreme (?), you can have a different public ssh key per host. This way the server owner/attacker is not able to correlate that ssh key with other keys to recover your identity. (You need to take care that ssh won't offer too many public keys in that case.) Example case of a service that might get offered many ssh keys: github.

Personally I don't bother. But I wouldn't be too bothered about just putting my public keys to some "secret" URL in the internet either, so I can easily enable myself ssh access to a host with a single curl.. Maybe I should indeed do that.

I assume Google was just a placeholder for a search engine in the example. And you'll surely need some service to search the web.

I thought LLM-authored books were rampant in Amazon, though?

Well, you should enable Adam7 interlacing for nicer progressive decoding!

I suppose it's not very useful nowadays as most any image will load fast, though.

What actually might could make sense in the future would be super-dense but abstraction-able programming language made for models. Then you'd train the model to work with it and you could have a way to render a human-readable version of the program for introspection.

It preferably come with superior guard rails, so strict static typing, borrow checker if not gc, perhaps ability to state proofs, etc.

Probably a long time, as machine code is verbose and thus destroys the context both when reading and writing, as well as making it more expensive.

It's externally mandated difficulties vs internally created ones. I think the latter should always be easier, because you can change the requirements.

So apparently zamadatix's point wasn't well taken, but I think it could be an effective approach to store the same data twice over to increase the likelihood of successful recovery. Could be even be even ten times, or e.g. 6+4 with redundant recovery coding.

Although you do have a point that the compressed data might be more difficult to decipher, if it doesn't have sufficient redundancy to skip bad parts, or if it is essential that the data is aligned in a certain way (e.g. disk images, and probably many other formats) and the format doesn't take this into account. Shorter window sizes, window reset markers, and explicit offset information could mitigate those problems.

I have an automation that turns on amplifier only when using certain inputs, not just when the TV is turned on. I can easily imagine people would also configure their amps to use different input depending on TV input.

Actually what I wanted from the video was impact of user consent, but it doesn't seme to cover this: what happens if you accept nothing, or the minimal set of consent (so not including audio) of licenses to allow you to run third-party apps? I recall there are four checkboxes to check.

My guess is: not much.

Even if it did support it, nobody connects their TV to their local network via HDMI, they connect it to their PC. And, as far as I'm aware, no PCs automatically start sharing networking with whichever networks they are connected to.

That could of course change. Could be even a nice feature for connecting your TV to the network via your multi media center, if the bandwidth is good.

Wouldn't this in practice be a lot like Passkeys? But it might be more difficult to integrate this kind of approach to the stacks we use, whereas Passkeys fits in relatively easily.

I suppose client cert would protect against from a MitM attack, if the client failed to notice it, or if the MitMer has the website keys to make a perfect attack.

I hooked up Google Maps to ChatGPT and that was definitely helpful for this; without them it would seemingly just guestimate driving distances, but with the MCP it was able to determine exact driving/walking times and also render maps with waypoints for activities around the lodging.

I used https://github.com/cablate/mcp-google-map for the MCP (and patched it to generate URLs for the maps).