AdrianoKF

I've noticed the same when I tried to replace my ultrawide 34" with a Dell U3225QE for my home office the other day. I really wanted to like the Dell since I love the specs, but my head would hurt from the perceived bulge in the middle of the screen, where the curve used to sit farthest before. Stupid brains, really.

Reminds me of the AGNES [0] (Age Gain Now Empathy System), developed at MIT AgeLab. Saw it in action there back when I worked at the lab in the early 10s - I found the broad range of applications in research quite intriguing.

[0]: https://agelab.mit.edu/methods/agnes-age-gain-now-empathy-sy...

Reminds me of the experimental version of Stanford's CS 140/212, CS 140e, which used Rust to develop a simple operating system kernel for the Raspberry Pi 3B:

- Course web page: https://cs140e.sergio.bz/

- Accompanying material by the instructor: https://github.com/dddrrreee/cs140e-24win

Disclaimer: I've only worked through the course materials when it launched in '18, haven't actually taken the course physically, so YMMV.

Does this intend to fill a similar spot in the Rust ecosystem as fsspec (https://filesystem-spec.readthedocs.io/en/latest/) does for Python, or am I getting the wrong idea?

I love how it was already clear that it would be Raymond Chen's blog just from the title and domain name. I really enjoy The Old New Thing and his coverage of obscure details that might otherwise be long forgotten.

At least in Germany (where I live), it is entirely normal for the pedestrian lights to be synchronized with the road parallel to it, meaning that turning cars will cross the path of walking pedestrians. However, by law pedestrians have the right of way in these situations (since cars are crossing their path), and generally that is being respected. I'd say that's what sets it apart from the US in that regard. We even have right on red in some metro areas, though admittedly that's where things can get quite dangerous at times.

Not that it takes away from any confusion that arises from the wording, but (at least) it is consistent with the definitions from PEP 440:

> A version identifier that consists solely of a release segment and optionally an epoch identifier is termed a “final release”.

https://peps.python.org/pep-0440/#final-releases

Well there went an hour of my life.. Thanks for sharing the link!

I was actually wondering if the driving factor is legal documents. ID cards show names in all-caps letters, which creates the dilemma that your ID might not show your actual name (notwithstanding international standards for travel documents that prescribe transliteration of non-latin characters; see ICAO Doc 9303 Part 3, section 6 [0] for examples)

[0]: https://www.icao.int/publications/Documents/9303_p3_cons_en....

Small nitpick: uppercase ẞ was added to Unicode 5.1 in 2007 (https://unicode-table.com/en/1E9E/) and is considered correct German orthography since 2017 (see §25 E3 in https://grammis.ids-mannheim.de/rechtschreibung/6180#par25E3)

You can also use iodine (https://github.com/yarrick/iodine/) to tunnel IPv4 data through DNS (useful e.g. when on a captive portal network that doesn't block DNS requests). Performance isn't great obviously, but the concept is fascinating nonetheless.

I love Inkscape, but I really wish it could work with CMYK colors natively (and not simply transform them into RGB internally).

While I haven't personally tried it (and have since given up on BT audio in my setup), there seems to be a way to extract the pairing key from Windows and have the Linux Bluetooth stack use it (see e.g. [0]), effectively making the Windows and Linux host appear identical to the paired device.

[0]: https://brokkr.net/2015/09/26/bluetooth-dual-booting-sharing...

I recently wanted to give my current RPi4 home server a GitOps makeover, migrating services (Home Assistant, Nextcloud and others) to k3s in the process.

What has been an obstacle is the availability of officially maintained Docker images for some of the components I've been wanting to use - afaict neither Argo CD nor Rook have official armv7/aarch64 images (though it seems Argo will release one soon).

Until then, I'll hold off on that pet project until I get my hands on a reasonably priced x86 SFF PC (the ThinkCentre M700 Tiny from TFA looks interesting!).

Thanks for providing some context! Reading your response makes me realize that my initial assumption was probably way too pessimistic - and that the project serves a nice educational purpose.

On top, sparking interest in tech and ham in kids is always a good thing, a reminder about the possible side effects can always come at a later time :)

Not a ham operator, but I'd assume that a transmitter like this will emit a significant amount of noise across the RF spectrum (also, make sure to check your local laws before transmitting in potentially reserved frequency bands, e.g. with the FCC [0], or the Bundesnetzagentur in Germany [1]).

Other than that, looks like a fun little project!

[0]: https://www.fcc.gov/engineering-technology/policy-and-rules-... [1]: https://www.bundesnetzagentur.de/SharedDocs/Downloads/DE/Sac...

"Working great" in the sense that the modification and integration was pretty painless. In terms of output quality, I've only done a few smoke tests (pun intended) - cooking, blowing smoke over the sensor - with decent results.

I have a Vindriktning with the ESP8266 makeover sitting on the desk behind me, feeding its data into my Home Assistant instance. So far it's working great, except for one annoying detail: I'd much prefer the forced airflow fan to be on at all times, since the constant on-off cycling (around every ~10s) is quite audible and distracting in a quiet environment.

There's also RFC 8058 [0] that proposes to refine the `List-Unsubscribe` header for one-click unsubscriptions. It uses the `List-Unsubscribe-Post` header to indicate that an HTTP POST request can be used to unsubscribe with a single click.

It specifically mentions in section 3.2 that mail receivers are not to crawl this URL without user consent:

> The mail receiver MUST NOT perform a POST on the HTTPS URI without user consent. When and how the user consent is obtained is not part of this specification.

I haven't seen any statistics on how widespread adoption of this RFC is among the major mail providers, though.

[0]: https://datatracker.ietf.org/doc/html/rfc8058

I've recently discovered pacdiff [0] to solve that problem, which helped me clean up about 30 leftover .pac[diff|new] files from my everyday desktop machine.

[0]: https://wiki.archlinux.org/title/Pacman/Pacnew_and_Pacsave#p...

One interesting use case of overwriting `builtins.__import__` I've encountered was the automatic hooking by ClearML [0] (experiment tracking, ...) into all sorts of common libraries like Matplotlib, Tensorflow, Pytorch, and friends.

The implementation is surprisingly straightforward, once you've come to terms with the basic idea, see [1] and the rest of the `clearml.binding` package.

[0]: https://clear.ml [1]: https://github.com/allegroai/clearml/blob/master/clearml/bin...

I'm in the same boat as you! Just started working on proper touch-typing a few weeks ago, as I sometimes found myself being ashamed of my self-taught ~7-finger typing system.

Commenting primarily to see what others have to say about your idea, since I can notice that sometimes when I don't pay full attention I tend to use my "old" mental keymap and cheat a little bit.

Which is precisely what for example Mapbox does - they allow consumers to specify a worldview, which adjusts borders and other geographic features based on the specified culture: https://docs.mapbox.com/help/glossary/worldview/

Or potentially even socat (http://www.dest-unreach.org/socat/), which could be used (among many other things) to model the use case of GP, forwarding a socket to a pipe.

Interesting (but probably not too surprising) to see that DTN research is alive and kicking!

I wrote a short seminar paper on DTN protocols as an undergrad in '09, so thanks for the trip down memory lane!

Sorry, I missed your reply..

Here's my workflow in a nutshell: I use the Zotero browser extension to add items to Zotero, the extension takes care to automatically attach a snapshot of the web page or paper to the newly created entry in Zotero. For academic papers or blog posts, I'll try and extract additional web links (e.g. Github repos) and add those to the entry as well. Within Zotero I have a nested structure of collections/folders to roughly structure the entries by type (papers, blog posts, reports, books, ...).

I make liberal use of tags to classify the content and keep track of my reading status (Reading List and Read), for which I have saved searches in Zotoro, so I can easily find something to read, whenever I have a bit of time.

For academic papers that I've read in-depth, I'll extract the most relevant references and add them to the library as well and cross-reference them using the "Related" feature. This feature is what I was mentioning in my original post - it only allows for a single generic "related" association between entries. If I could customize the type of relation, I could model almost arbitrary knowledge graphs here.

I mostly use QOwnNotes (https://QOwnNotes.org) for Markdown-based note taking, synced to my private Nexzcloud instance. If it ever goes away, I'll still have the plain markdown files plus metadata in a SQLite database.

For bookmarks and long-reads I've mostly made the transition from Pocket to Zotero (https://www.zotero.org), originally intended for literature management. One feature I wish it had is support for more complex semantic relationships between items to be able to create a more comprehensive knowledge graph (e.g., A cites B, X is related work to Y, a URL is the implementation of an abstract algorithm in a research paper). Anybody know of a suitable plugin maybe?

Something along the lines of

  COALESCE(my_column, -1)

might work for you in this case. See [1] for documentation on it in Postgres (it is in ANSI SQL though).

[1]: https://www.postgresql.org/docs/current/functions-conditiona...

Can't wait to find out if this release fixes a bug (https://bugzilla.mozilla.org/show_bug.cgi?id=1557160) that was preventing correct rendering of extension popup windows/context menus when the APZ zooming was enabled (which allows pinch-to-zoom gestures, e.g. on the MS Surface).

Update: Just got to try it out, seems like it indeed works now. Yay Firefox 72!

They do have an issue for merging their fork back into upstream LLVM in their repo: https://github.com/espressif/llvm-xtensa/issues/8

Not sure how fast that's gonna happen, but one may hope!