ilyagr

It's closer to a counter-flow heat exchanger, but you could still have air only go in one direction at a time. Say your indoor temperature is 20 degrees and the 3 heat exchangers are at 25, 30, and 35 degrees, and outside is 40 degrees (I'm thinking in Celsius, though 40 is a bit extreme). You blow air out until they cool to 20, 25, and 30 degrees. Then you blow air the other way until they heat back up to 25, 30, and 35 degrees, with the air coming in being somewhere in the 20-25 degree range instead of 40 degrees that the outside air is at.

This assumes that the heat exchanger has just enough thermal capacity so that raising/lowering its temperature by 5 degrees would get the air to the same temperature. In fact, it might be easier to imagine if the air doesn't blow continuously. Each chamber could fill up with air and wait for the heat exchanger and the air to get to the same temperature, before moving the air to the next chamber.

Which brings me to a question: I'm not entirely clear on the relationship between and capabilities of Sam and Acme.

Is the ability of Vis to select all instances of a regex and edit them all at once afterwards interactively (see e.g. https://asciinema.org/a/41361) Vis's own idea, or was it part of Acme? Is it part of Ad?

People should be aware of two related editors:

https://anvil-editor.net/ is more directly inspired by and similar to Acme (but makes no attempt to borrow from Vim).

https://github.com/martanne/vis is a minimalist editor that stays close to Vim but adds Sam-style regular extensions and multi-cursor editing (but not Acme-style "execute anything on screen"). For example, you can select all instances of a regex and edit them all at once afterwards interactively.

Perhaps https://news.ycombinator.com/item?id=42428537 or its parent will make sense to you: connecting 3 or more perfect constant-temperature regenerative heat exchangers in a series would make the ones at the ends work at a higher/lower temperature (of the constant-temperature heat sink for those exchangers) than the one in the middle, increasing efficiency of the overall system.

I'm not proposing this as a practical design, but it convinces me that 50% efficiency is not the limit.

Yeah, I think this makes sense. If you connect many of my heat exchangers in series, the temperature gradient increases; only the middle one will work at the average of the inside and outside temperature (the example of 3 in a row makes sense to me). At the limit, it becomes what you described.

Thanks!

I'm confused how the heat retention could be around 80-90% without expending a ton of energy.

Naively, if on average the same amount of air goes in and out, I'd expect the temperature of the heat exchanger (on average in space and time, eventually) to be the average of the outside and inside temperatures. If the outside is hotter, the air coming in would be cooler than the outside air (which is a win), but it couldn't be cooler than the average of the temperatures. So, it would still not be anywhere as cool as the inside air, which doesn't sound like 90% heat retention.

Is the heat exchanger attached to a heater or a cooler? The linked video, https://www.youtube.com/watch?v=CDCu0IbEn8Q , would suggest not, as it talks about saving the energy needed for cooling or heating. Is there another clever trick?

It's a pity that the article doesn't suggest who to give money to instead.

The most similar organization I know that probably needs the money is https://archive.org/donate. There were just some bad news about them (https://news.ycombinator.com/item?id=40754229, https://news.ycombinator.com/item?id=41895764), but it would be a real shame if the Wayback machine stopped working and we lost the internet's history.

Then there's always https://www.eff.org/.

Then there are non-tech organizations to donate to, for example https://www.givedirectly.org/ or a local food bank.

Nice tool to know about. How much storage do you need to use it?

It (and gitk) are actually Tcl scripts. Note how the "shell script" you linked exec-s itself with `wish`

> In Retcon, if a commit move results in a conflict, that doesn't matter; you can keep making changes to your history anyway, and then resolve any remaining conflicts when you're ready.

I didn't realize Retcon could do this from the website, nice!

I wonder how similar your approach is to [jj's approach to conflicts]; whether you reinvented the same way of modelling conflicts in the repo or use a different one. (See also the link to the technical docs from that page)

https://gitbutler.com/ also [borrowed this idea] from jj.

[jj's approach to conflicts]: https://martinvonz.github.io/jj/latest/conflicts/

[borrowed this idea]: https://blog.gitbutler.com/fearless-rebasing/

So, there are several tools exploring these ideas, but there are interesting differences in (for example) how close to Git each of these approaches stays.

To save people a search: https://gitbutler.com/

I'll add that while `jj` itself is a CLI, people have made GUIs on top of it that allow for drag and dropping of commits:

https://github.com/gulbanana/gg https://www.visualjj.com/

You can also `open -R file` to select that file in Finder.

I've just tried both `devenv` and `flox`, and the latter had two related niceties:

- Direnv wants to put its config inside the root of a git repo, which makes it hard to ignore. Flox's config is all in a `.flox` directory, so I could `echo * >> .flox/.gitignore` in any repo without changing the repo's gitignore.

- There seems to be no way to run `direnv` on an environment that's not the current working dir, see https://github.com/cachix/devenv/issues/67.

OTOH, `flox` was a bit harder to install in an existing nix setup and requires trusting their cache, at least if I wanted to do a cached install. You can follow the instructions in https://flox.dev/docs/install-flox/#__tabbed_1_6, or you could add yourself to Nix's "trusted users" (which makes sense only if you're the only user on the computer using Nix). See also https://github.com/flox/flox/issues/1179.

It's one thing to say these things. I'm sure Amazon has a website somewhere saying such things, for anybody who wants to read them, that's fine. It's another to obligate people to listen or to threaten them, explicitly or implicitly, about things you might do if they vote a certain way.

Illustrating this difference is why I posted https://news.ycombinator.com/item?id=41947141.

By this logic, mugging somebody at gunpoint is protected by the first and second amendment. I exercised my right to free speech and to bear arms, and then they voluntarily gave me all they had.

If a citizen claims this -- ridiculous. But if a corporation or the president did it, and with the current supreme court -- who knows.

*Update:* But see also https://news.ycombinator.com/item?id=41947360, which is a more murky issue that would need some actual legal expertise to talk about. Maybe it's just an article with a misleading headline, depending on what's actually being claimed.

They have a few blog posts about this license: https://blog.gitbutler.com/gitbutler-is-now-fair-source/, https://blog.gitbutler.com/the-future-of-open-source/

I don't think they are the first ones to open-source their code on a timer, but they are trying to popularize the idea.

How does it encode the idea of having all the numbers on each line/square?

Took me a bit to figure out a nice way to do this in the `fish` shell. I think it's `string collect < file.txt`.

I find the most benefit from `jj` when I'm preparing some commits for review and I want to make them tell a coherent story. I often want to then rearrange commits, split or merge them, move things from one to another.

For people who work on repos by themselves or with a small number of others, the advantages of `jj` would be smaller in most cases, I would think.

I hope they soon rename it into "Fully Supervised Driving".

Good to know, thanks!

I know it can create a dummy display, but can it create a window on the real display showing the contents of the virtual display?

That seems to be the flagship feature of DeskPad.

This seems completely incompetent on Apple's part and all-around awful. The supposed point of these prompts is that somebody could install screen recording software on your computer without you knowing. Now, that person can defeat the prompts, while everybody intentionally installing software has annoying hoops to jump through. Worse, they might have a false sense of security when it matters the most.

I hope these prompts get removed but, if they exist, they should not be possible to sidestep.

From this perspective, the weird part is that mutli-threaded programs can recover from panics in some of the threads (as long as `panic=unwind`). I suppose it's so practically useful that people made an exception for it, without this feature people would have to do inter-process communication (for better or worse).

I find the relationship between mutlithreading and panics' default behavior confusing.

In a single-threaded program, a panic is not supposed to be "caught" and aborts everything. If the main thread panics, the program stops.

But in a multi-threaded program, a panic terminates only the thread it happened in, and the program is allowed to handle that case without termination.

I'm guessing that setting `panic=abort` changes this behavior, but I'm not sure.

Docs: https://doc.rust-lang.org/std/macro.panic.html#current-imple..., the third sentence of https://doc.rust-lang.org/std/thread/fn.spawn.html

Thanks, this is interesting to read!

If what you're saying is true, it's a bit sad that all these large-capex industries that are so important for society to have expertise and progress in are not considered promising or competitive.

I wonder: if my sentiment from https://news.ycombinator.com/item?id=41587866 is correct and Intel is essentially giving up on innovation in chip fabrication, what, if anything, does this mean for AMD? I'm quite ignorant on how AMD works, e.g. do they even have a chip fabrication plants?

If they do, can they compete with Intel's for US govt grants, or has that ship sailed now that Intel got a grant?

If not, is there room for meaningful innovation in x86 chip design?

How about TSMC? Do they now have a monopoly on state-of-the-art chip fabrication?

I see "giving up" between the lines of:

> A key priority for Intel Foundry is to increase our capital efficiency. <...> Now that we have completed our transition to EUV, it’s time to shift from a period of accelerated investment to a more normalized cadence of node development and a more flexible and efficient capital plan.

That is, they no longer see a way and will no longer try to turn money into real innovation, at least as far as chip manufacturing is concerned.

I ended up switching to Kakoune and Dance mainly for the multiple cursor support. I treat it like `sed`, but interactive. It feels miles ahead of other editors I know, with the exception of Helix, Vis, and maybe Ki (haven't played with it enough to tell).

> The basic premise of Kakoune, which Ki seems to share, is that it's more natural to move first and then command. That's not how my brain works:

I also didn't find this as a huge benefit, though some people do. That's why I'm sorry Vis (link in another comment of mine) is not more popular; I could far more easily recommend it to other people if it was as polished as Kakoune and maybe had a VS Code plugin.

---------

Now, for some things I don't fully agree with.

> I disagree with the premise (from the Fine Article) that vi/vim is in some way less coherent as a language. Languages don't really do 'coherent', they do 'expressive'.

I think Vim is definitely less coherent. The first example that comes to mind: it's easy to get to the first line with `:1<enter>` or `gg`, while getting to the last line is `G` for some reason (Update: TIL that `:$<enter>` also works, which makes a little more sense. But `:|<enter>` does not take you to the first line). Getting to the first column is `|` I think? I can never remember it, fortunately `<Home>` works.

Now, where I do agree is that, IMO, it's an open question whether making a modal editor's language more coherent than Vim's would make it more expressive or easier to learn. Vim's language is pretty good. My personal feeling is that Kakoune maybe gets close to Vim's bar, and maybe even exceeds it, but not by enough to make it a fundamentally better language (except for its multiple selection support, where it is fundamentally better).

My hope is that Ki might be better, or that its ideas might lead to a better language. I am not certain this is the case, but it should make the situation I described two paragraphs ago better, at least.

> Code golfing, I count 12 keystrokes in your example, and 10 in stock Vim.

To me, the number of actual keystrokes matters less than how much space they take up in my mind and how easy they are to think of (or, better, perform reflexively). If I typed faster than I thought (e.g. if I was transcribing a voice recording or translating), I might feel differently.