esrh

ironically this is probably ai written too

Yes, i agree that unix commands should be first class. I did this for the super common stuff like ls and cp. As for substitution, I did exactly $ for substitution. You'd do something like ($ rsync -avP $src $dst), but I don't think I ever got around to implementing $() to evaluate forms. If you really need to do that then you have to quasiquote the whole expression and unquote the form you need to evaluate. This has been relatively ok for me though. I never implemented anything like pipes or redirection, I instead just send everything like that to bash.

This is not really relevant to your question, but I regret choosing janet for this, it's too opinionated and hacking on C is not as fun as lisp. I started writing my own version of schemesh in racket, but I never got far enough.

awesome! I have wanted something like this for a long time. Currently I use a janet fork <https://github.com/eshrh/matsurika> with some trivial additions, the most important of which is a `$` macro that does what the `sh` does here. I have two questions:

- I see that `sh` does not take in strings but instead lisp forms. How do you distinguish between variables that need to be substituted and commands? In my fork, the way to do variable substitution involves quasiquoting/unquoting. - Almost all of the features that make your language good for shell scripting are essentially syntactic features that can easily be implemented as a macro library for say, scheme. Why'd you choose to write in C++? Surely performance is not an important factor here. (I'm interested because I am currently working on a scheme-based shell scripting language).

A lot of wifi sensing results that have high-dimensional outputs are usually using wideband links... your average wifi connection uses 20MHz of bandwidth and is transmitting on 48 spaced out frequencies. In the paper, we use 160MHz with effectively 1992 input data points. This still isn't enough to predict a 3x512x512 image well enough, which motivated predicting 4x64x64 latent embeddings instead.

The more space you take up in the frequency domain, the higher your resolution in the time domain is. Wifi sensing results that detect heart rate or breathing, for example, use even larger bandwidth, to the point where it'd be more accurate to call them radars than wifi access points.

Think of it as an img2img stable diffusion process, except instead of starting with an image you want to transform, you start with CSI.

The encoder itself is trained on latent embeddings of images in the same environment with the same subject, so it learns visual details (that are preserved through the original autoencoder; this is why the model can't overfit on, say, text or faces).

I'd suggest reading https://dl.acm.org/doi/abs/10.1145/3310194 (2019) for a survey on early methods and https://arxiv.org/abs/2503.08008.

As for low level:

The most common early hardware was afaik esp32s & https://stevenmhernandez.github.io/ESP32-CSI-Tool/, and also old intel NICs & https://dhalperi.github.io/linux-80211n-csitool/.

Now many people use https://ps.zpj.io/ which supports some hardware including SDRs, but I must discourage using it, especially for research, as it's not free software and has a restrictive license. I used https://feitcsi.kuskosoft.com/ which uses a slightly modified iwlwifi driver, since iwlwifi needs to compute CSI anyway. There are free software alternatives for SDR CSI extraction as well; it's not hard to build an OFDM chain with GNUradio and extract CSI, although this might require a slightly more in-depth understanding of how wifi works.

This is my paper (first author).

I think the results here are much less important and surprising than what some people seem to be thinking. To summarize the core of the paper, we took stable diffusion (which is a 3-part system of an encoder, u-net, decoder), and replaced the encoder to use WiFi data instead of images. This gives you two advantages: you get text-based guidance for free, and the encoder model can be smaller. The smaller model combined with the semantic compression from the autoencoder gives you better (SOTA resolution) results, much faster.

I noticed a lot of discussion about how the model can possibly be so accurate. It wouldn't be wrong to consider the model overfit, in the sense that the visual details of the scene are moved from the training data to the model weights. These kinds of models are meant to be trained & deployed in a single environment. What's interesting about this work is that learning the environment well has become really fast because the output dimension is smaller than image space. In fact, it's so fast that you can basically do it in real time... you turn on a data collection node and can train a model from scratch online, in a new environment that gets decent results with at least a little bit of interesting generalization in ~10min. I'm presenting a demonstration of this at Mobicom 2025 next month in Hong Kong.

What people call "WiFi sensing" is now mostly CSI (channel state information) sensing. When you transmit a packet on many subcarriers (frequencies), the CSI represents how the data on each frequency changed during transmission. So, CSI is inherently quite sensitive to environmental changes.

I want to point out something that most everybody working in the CSI sensing/general ISAC space seems to know: generalization is hard and most definitely unsolved for any reasonably high-dimensional sensing problem (like image generation and to some extent pose estimation). I see a lot of fearmongering online about wifi sensing killing privacy for good, but in my opinion we're still quite far off.

I've made the project's code and some formatted data public since this paper is starting to pick up some attention: https://github.com/nishio-laboratory/latentcsi

They also don't mention the famous paper by Ha & Schmidhuber (https://arxiv.org/abs/1803.10122).

The worst part is that they namedrop many other tangentially related and/or outright fraudulent "ai experts" like Hinton, Bengio, and LeCun.

Yeah, i wish more programs worked like this.

I wrote something similar on a smaller scale for the keihin-kyuukou line in japan: https://rail.esrh.me. Now I live in tokyo and there's several transit options closeby so I would love to have some always on display like this in my room.

Unfortunately, while public transit in the US and Europe seem to be tracked by services with developer friendly APIs, this is not the case in Japan as far as i know -- not that much of a problem back then, i just needed to do some light web scraping.

I wrote all of the scraping/data and processing/frontend code in clojure and clojurescript, and wrote a small blog post about it here: https://esrh.me/posts/2023-03-23-clojure

One thing is that CL has a huge ecosystem and a wide variety of compilers for every purpose you might have. Quicklisp probably beats racket and scheme in this regard, but today clojure might have an edge.

When you use racket and clojure specifically, you're kind of walling yourself into one compiler and ecosystem (two, for clj/cljs). This is a significant disadvantage compared to scheme and CL.

CL the way most people write it is way too imperative and OO for me; it reads like untyped java with metaprogramming constructs. Clojure and scheme in my opinion guide you towards the more correct and principled approaches.

Out of all the lisps, regardless of which ones I like the most, I objectively write emacs lisp the most. This is has definitely influenced my opinions on CL syntax; like my weird love hate relationship with the loop macro: on one hand it's a cool, tacit construct that's impossible in a non-lisp, but on the other hand it hides a lot of complexity and is sometimes hard to get right.

Smile 3.x Avoided due to licensing

Smile 3.x is GPL-licensed, which poses some potential conflicts for some end users...The community consensus is converging around moving away from Smile due to the GPL-relicensing issue, focusing instead on Tribuo...

(tribuo is developed by oracle)

It's a really great thing that the java community has a high performance and well accepted (~5x stars than tribuo) ML package that's GPL. CF python where the top two libraries are developed by google and facebook. The GPL protects individual, independent developers.

I don't think it's right to recommend that new users move away from the package because of licensing issues; the fact that it's GPL now is a good thing for everyone except corporate users (probably a great part of readers). The people who might have GPL problems already know themselves when they'll have a problem.

It's also not visible on mobile

Very cool!

I also like these hand drawn 3d illustrations of stations: https://architizer.com/blog/inspiration/industry/x-ray-visio...

I used to use par before I switched to far (https://cgdct.moe/blog/far/) which produces better looking paragraphs in my opinion by minimizing the variance between lines while using the fewest number of lines possible.

There is a native emacs version as well, at https://github.com/eshrh/far.el (i wrote it)

The cli tool qalc is usually bundled with libqalculate

https://esrh.me

Not a whole lot, some mix of japanese, emacs and lisp. Static site made with hakyll.

Thanks for the tip! Anyone wanna be my cofounder?

It's to be freer than china

Is it really that hard to imagine a rebel group of newly unemployed desperate people bombing an openai data center?

I use console emacs and nov.el (https://depp.brause.cc/nov.el/) for this. You can then use emacs features like keyboard navigation and dictionaries.

I also used this with anki, but i wanted some interactivity and practice actually physically writing stuff out combined with spaced rep.

Resulted in some pretty gnarly code using kanjivg, pygame and ankiconnect: https://github.com/eshrh/anki-kunren

Sikhs being affluent makes it ok? You do know which other group is often singled out for this right?

"Everyone's made fun so it's ok" is on the same level as "I'm not racist i hate everyone." It's veiling what people actually think, and thereby not addressing the issue (or even admitting one exists, really)

As for democracy: https://en.m.wikipedia.org/wiki/Censorship_in_India

But if you mean "total democracy" in the sense of unchecked oppression of the minority by the majority i think you'd be closer to the truth.

rx is a great example here. Add in the fact that you can manipulate rx forms with macros and you're dealing with some serious power.

With that said, I think the most ergonomic string searching tool I've used is the PEG implementation in Janet:

https://janet-lang.org/docs/peg.html

If the author was that serious about this as a business they would've done it server side -- or better yet sold the unburdened source code at a one-time price.

If you are running someone else's code on your computer you are entitled to change it, morally. The fact that most other programs make this hard to meaningfully do is another problem.

I read desert solitaire on a road trip (ironically) through arches natl. park and colorado. Really fantastic book -- his thesis can be summed up in a page or so, but his passionate ideas are nearly viral.

I especially enjoyed the contrast between really beautiful descriptions and anecdotes of nature and polemic political rants that go on for tens of pages at a time.

I feel like your campaign would benefit from explaining a little bit about who you are, what you've written before, and why we should believe you can actually accomplish this (understandably big project). People like to feel like they're paying a person, not an idea...

cl-lib is practically indispensable in modern emacs lisp programming. It can be pretty annoying to write some patterns without cl-loop, for instance, which like the real loop macro in CL is stupidly powerful (think, DSL for describing loops).

I'm not sure what you mean by "that direction," but if it implies doing CL, writing emacs lisp won't get you there, even if it might give you a head start from cl-lib, eieio, and general lisp ideas.

i did this on the software side for the longest time, before I DIY'd a keyboard and got this feature hardware-side using q/tmk: https://qmk.fm/. Some prebuilt keyboards also support QMK, like the DROP CTRL.

I also use dvorak, and the keyboard setup every time i used different keyboard was getting a bit annoying.

After getting very used to C-w (delete back work) and C-h (delete character backward) on readline, it really bugged me that these aren't default on emacs, even though readline is often advertised as giving emacs muscle memory.

I ended up globally remapping C-w and moving the help prefix, C-h to C-x h and making C-h backspace, because i was pressing it incorrectly that often.

- testing short code in various repls

- using qalculate! for complex calculation (think physical constants, unit mixing, trig), currency and unit conversion, simple symbolics

- ffmpeg. i have aliases for video compression, stripping audio, etc

- converting between file formats, imagemagick and pandoc

- untarring files, encrypting files, batch renaming

- sending files somewhere else via scp

- remote controlling computers

- it's possible to set up a vnc server and a full gui desktop environment, for a highly portable system that gets you the same program and file setup on any computer supporting a vnc client.

Once you build up a collection of aliases / shell functions it can be very powerful even with a small virtual keyboard. The fish shell is also a great qol addition.