Link: GNOME Terminal Cursor Blinking Saga
Geoff Greer's GNOME Terminal Cursor Blinking Saga is about how to turn off cursor blinking in gnome-terminal, because the Gnome people are still in love with having their cursor blink despite it being a terrible idea and have progressively made it harder and harder to turn off.
Needing to look this up yet again did cause me to check the Gnome
bug to expose a preference UI for this, which caused
me to discover that you can actually easily turn this off these
days, although not globally; you have to do it for each profile,
turning off 'Cursor blinking'. If you have a lot of profiles and
are the right sort of person, you may want to write a shell script
that uses the
gsettings approach, which still works.
(Why I needed to know this is that for my own reasons I'm doing a from-scratch Fedora 30 install in a virtual machine, and of course it came up with a gnome-terminal setup where the cursor blinks.)
Link: ASCII table and history (Or, why does Ctrl+i insert a Tab in my terminal?)
This ASCII table page (via) answers the question it poses in its title, and the answer is quite interesting. I have a long standing interest in this area, and this page's table explains things like why Ctrl-@ is a common way to generate a 0 byte. The table also makes it clear that at least one case is handled specially, that of Ctrl-? often being DEL. So now that I look at it, the table is interesting reading, not just the history.
(The straightforward implementation of Ctrl masks off bit 7, or perhaps bits 6 and 7, which turns @, binary 10 00000, into binary 00 00000 and thus gives you NUL. But you cannot go from ?, binary 01 11111, to DEL, binary 11 11111, by masking off bits; you have to turn on a bit instead. And notice that it is common to make Ctrl-_ generate byte 31, so we have binary 10 11111 turning into binary 00 11111 through masking, so this is not a general special treatment when the low five bits are 11111.)
PS: There's also this version of a four column ASCII table, but it doesn't have the history and doesn't look as nice as this new one.
Link: A program to read AMD Ryzen RAPL information on Linux
In my entry illustrating the practical difference between CPU TDP and actual power draw, I used a Mozilla program to read Intel's RAPL (Running Average Power Limit) CPU information. In that entry I regretted that as far as I knew there was no AMD equivalent, so I couldn't get similar measurements on my AMD Ryzen based office machine. Well, it turns out I'm wrong about that. Courtesy of @email@example.com comes this information:
this project might be useful to get some readings, came up in the AUR when I searched for a rapl package to install after reading your post. https://github.com/djselbeck/rapl-read-ryzen
The repository calls it a 'a quick and dirty hack', but in my testing
on my office machine, it appears to work (ie, it appears to produce
plausible readings, both under no load and under '
In its current form, it appears to take an instant reading of the
current power level, although I'm not sure I completely understand
what's going on in the code.
My Mastodon remark about tiling window managers
Over on Mastodon, I said:
Two reasons that I'm unlikely to like tiling window managers are that I like empty space (and lack of clutter) on my desktop and I don't like too-large windows. Filling all the space with windows of some size is thus very much not what I want, and I definitely have preferred sizes and shapes for my common windows.
On the one hand, I've already written an entry on my views on tiling window managers. On the other hand, I don't think I've ever managed to state them so succinctly, and I find myself not wanting to just leave that lost in the depths of Mastodon.
(Looking back at that entry caused me to re-read its comments and realize that they may be where I found out about Cinnamon's keybindings for tiling windows, which would answer a parenthetical mystery.)
Links: A Practitioner's Guide to System Dashboard Design (with a bonus)
A Practitioner's Guide to System Dashboard Design is a four article series on system dashboard design by Cory Watson of One Mo' Gin. The parts are:
(Via somewhere that I've now forgotten and can't find again. Perhaps it was Twitter or Mastodon.)
Link: What has your microcode done for you lately?
What has your microcode done for you lately? (via) starts out being about the low-level performance of scattered writes on x86 machines but develops into a story where, well, I'll just quote from the summary:
Where the microcode comes in, and what might make this more interesting than usual, is that performance on a purely CPU-bound benchmark can vary dramatically depending on microcode version. In particular, we will show that the most recent Intel microcode version can significantly slow down a store heavy workload when some stores hit in the L1 data cache, and some miss.
I found the whole thing fascinating and I feel it deserves a wider audience. It's a bit challenging to follow if you don't already know some of the details of low-level CPU and memory access operation (it casually throws around terms like RFO), but working to understand it was interesting and taught me things, and I quite enjoyed the coverage of the issues involved in scattered write performance.
(Of course one has to speculate that the slowdown on recent microcode is due to either deliberate changes due to all of the speculative execution issues or side effects from those changes.)
Link: Vim anti-patterns
Tom Ryder's Vim anti-patterns is nominally about anti-patterns but it's really about teaching various better, more advanced ways to do things in vim. For each anti-pattern, Ryder shows a positive pattern (or several of them), and they're worth thinking about and maybe adopting. If nothing else, I learned new bits of vim.
(This is from 2012 and I believe I read it then, but it's worth re-reading every so often. Indeed I sort of think of it as a little reference for Vim things I want to remember.)
PS: I don't necessarily agree with all of Ryder's views here, but then I'm a lightweight vim user. In particular, I've not adopted either avoiding the arrow keys or using ctrl-[ for ESC, and I'm still perfectly willing to move around in insert mode to some degree, because it fits how I edit things.
Link: The IOCCC 2018 "Best of show" program
The program delivered here is both a full machine emulation of the original PDP-7 that Ken Thompson used to write the first version of UNIX and a full machine emulation of the PDP-11/40 used by subsequent UNIXes. The Makefile can build versions that can run each of the following:
- UNIX v0 for the PDP-7 (circa 1969)
- Research UNIX Version 6 (circa 1975)
- BSD 2.9 (circa 1983)
This is one of those IOCCC entries where you absolutely do want to read the full author's description of their entry, because it is fascinating all by itself. For instance, until I read this I didn't know that Unix v0 had been reconstructed from original printouts of the assembly, and it's even on Github. That is just one small part of a fascinating journey.
(The IOCCC is the International Obfuscated C Code Contest, and here are the entire 2018 results. Mills' work may be even more impressive once you know that IOCCC entries must be 4096 bytes or less of C code.)
Link: Everything you should know about certificates and PKI but are too afraid to ask
Mike Malone's Everything you should know about certificates and PKI but are too afraid to ask (via, also, also) starts off slow (and with one simplification that irritated me) but very soon gets rolling into things like X.509 and PKCS, and then gets into a thorough and solid discussion of PKI (Public key infrastructure) and the considerations of running your own internal one for (mutual) TLS authentication. I was very pleased to see this recommendation:
In any case, if you run your own internal PKI you should maintain a separate trust store for internal stuff. That is, instead of adding your root certificate(s) to the existing system trust store, configure internal TLS requests to use only your roots. [...]
Separating public 'web PKI' from your own internal PKI is an important measure to keep compromises in your internal PKI from leaking into your use of web PKI (both through browsers and through programs). It also keeps compromises in web PKI from hurting your internal PKI, which I believe is Malone's main focus.
The article isn't perfect, but it's a great introduction and overview with solid practical recommendations that goes into significant depth on some important issues.
(I'm fairly certain that I learned some new things from it, even though I'm pretty well exposed to all of this stuff already.)
Link: HTTPS in the real world
Robert Heaton's article HTTPS in the real world (via) is about the difference between HTTPS in theory, in the cryptographic world of Alice and Bob, and HTTPS in practice, in the messy real world where CAs cannot be fully trusted and people lose their keys and so on. To pick one little bit to quote:
[...] But the real world has still managed to piece together a very serviceable public-key cryptography system by patching over the holes and omissions and naivety of the introductory world with a tartan of secondary systems known collectively as “Public Key Infrastructure” (PKI).
The whole article is a clear, short, amusing, and interesting summary of the whole practical mess of HTTPS and TLS. Even though I'm pretty up on all of the issues it talks about, I still found it well worth reading.