Off-and-on trying out an account over at @[email protected] due to scraping bots bogging down lemmy.today to the point of near-unusability.

  • 16 Posts
  • 1.88K Comments
Joined 2 years ago
cake
Cake day: October 4th, 2023

help-circle


  • A little bit, but normally Token Ring didn’t just keep data running around in a circle on and on — Token Ring works more like a roundabout, where you enter at a given computer on the ring and then exit at another device. Without looking, I suspect that, like Internet Protocol packets, Token Ring probably had a TTL (time-to-live) field in its frames to keep a mis-addressed packet from forever running around in circles.

    Also, I’m assuming that an implementation of Carmack’s idea would have only one…I don’t know the right term, might be “repeater”. You need to have some device to receive the data and then retransmit them to keep the signal strong and from spreading out. You wouldn’t want to have a ton of those, because otherwise it’d add cost. On Token Ring, you’d have a bunch of transceivers, to have a bunch of “exits”, since the whole point is to move data from one device to another.









  • even at JEDEC speeds.

    My last Intel motherboard couldn’t handle all four slots filled with 32GB of memory at rated speeds. Any two sticks yes, four no. From reading online, apparently that was a common problem. Motherboard manufacturers (who must have known that there were issues, from their own testing) did not go out of their way to make this clear.

    Maybe it’s not an issue with registered/buffered memory, but with plain old unregistered DDR5, I think that manufacturers have really selling product above what they can realistically do.


  • Well, cool. Hope it was helpful, then.

    I’ll also mention one other point, if you’re a big emacs and Firefox user. Won’t solve the issue for URL bars or other non-webpage text, but if you do a fair bit of writing in HTML textareas in webpages, like on Lemmy instances or something, you can hand that off to (actual) emacs.

    • Install the edit-server package for emacs (M-x list-packages, wait for the emacs package manager to load the list, go to edit-server, hit “i” to flag for install and “x” to execute, or M-x package-install and just type out “edit-server”).

    • In an emacs instance run M-x edit-server-start (or set it up to always run automatically at emacs startup but I run multiple emacs instances).

    • Grab the Edit with Emacs Firefox addon. Install.

    Now, by default all textareas will have a little blue button at the bottom reading “edit”. Click it, and your textarea will open up in emacs. C-c C-c to commit changes back to the textarea (Or C-x C-c, if you’re exiting that instance of emacs). You can also right-click on the textarea and choose “Edit with Emacs”.


  • I have, in the past, recommended, if you use Unix systems in a technical way, knowing at least how to do the following in vi (and I use emacs):

    • Close the program, discarding changes. From vim’s command mode, : q ! RET.

    • Exit writing changes. From vim’s command mode, : w q RET.

    • Move the cursor around. Today, usually you can get by with arrow keys – I haven’t been on a system where one thing or another was dicked up in a way that rendered arrow keys unusable in many years, but from Vim’s command mode, “h”, “j”, “k”, and ""l.

    • Enter insert mode to Insert text. From vim’s command mode, “i”.

    • Exit insert mode. From vim’s insert mode, ESC.

    • Search for text. From vim’s command mode, “/”, the text to search for, and RET.

    • Replace text. From vim’s command mode, “:%s/foo/bar/g” to change all instances of foo to bar in a given file.

    If you’ve got that much and you ever find yourself on a system that only has vi available (and it may not be vim), you can at least do the basics.

    But the widespread deployment of nano has made learning basic vi less important than was once the case. Even very small systems that I’ve run into tend to have nano.

    Note that busybox, a popular statically-linked shell often used in a rescue-the-horribly-broken-system scenario, does not have nano but does have a minimal “vi”-alike, so you might still want to know vi in that case.


  • If you’re specifically wanting to fiddle the Firefox keybinding the way I have (which may be too much effort for some people to deal with re-learning), the setting is:

    • Go change the GTK setting for the appropriate version of GTK. On my Debian trixie system, Firefox is using GTK 3:

        $ apt depends firefox|grep gtk
        
        WARNING: apt does not have a stable CLI interface. Use with caution in scripts.
        
        Depends: libgtk-3-0t64 (>= 3.13.7)
        $
      

      I don’t know whether it will change to GTK 4 anytime soon.

    • Go to about:config in the Firefox URL bar.

    • Set ui.key.menuAccessKey to 0. Normally, IIRC — it’s been many years that I’ve had this set, so I don’t even really remember the original behavior for certain — Firefox uses Alt in sorta the same way Windows does, to open menus. I don’t like that, and this disables that functionality entirely to free up Alt.

    • Set ui.key.accelKey to 18. This makes the now-free Alt act like Control does as regards Firefox keyboard shortcuts.

    • I also have ui.key.contentAccess set to 0. It’s been many years since I’ve set this, but…let’s see. goes to look That disables the contentAccess key, prevents webpages from grabbing Shift-Alt-key sequences, which can also collide. Like, in the Lemmy HTML textarea that I’m currently writing this in, I can hit Shift-Alt-B and Shift-Alt-F to move the cursor forward and backward by a word while selecting text, the way I could in emacs (or, in emacs parlance, move point while extending the region).

    The problem is that now you’ve got Firefox, where things like “Alt-A” will select all text, and if you use other GUI apps, other apps, which may be using “Control-A” for that, so you gotta train your muscles to deal with it. I haven’t thought about it in many years, as it’s automatic now, but I remember it being super-obnoxious when I started.

    For me, it was worth it, because I use emacs all the time and Firefox all the time, and rarely use other graphical apps, so it reduced the amount of switching. But…depends on what someone’s particular situation is, whether that makes sense for them.

    EDIT: Had accidently written ui.key.contentAccess twice. Corrected the first instance to be ui.key.menuAccessKey.


  • Anecdotal evidence, but I had both a 13th gen and 14th gen Intel CPU with the bug that caused them to over time, destroy themselves internally.

    The most-user-visible way this initially came up, before the CPUs had degraded too far, was Firefox starting to crash, to the point that I initially used Firefox hitting some websites as my test case when I started the (painful) task of trying to diagnose the problem. I suspect that it’s because Firefox touches a lot of memory, and is (normally) fairly stable — a lot of people might not be too surprised if some random game crashes.


  • The problem is that ECC is one of the things used to permit price discrimination between server (less price sensitive) and PC (more price sensitive) users. Like, there’s a significant price difference, more than cost-of-manufacture would warrant. There are only a few companies that make motherboard chipsets, like Intel, and they have enough price control over the industry that they can do that. You’re going to be paying a fair bit more to get into the “server” ecosystem, as a result of that.

    Also…I’m not sure that ECC is the right fix. I kind of wonder whether the fact is actually that the memory is broken, or that people are manually overclocking and running memory that would be stable at a lower rate at too high of a rate, which will cause that. Or whether BIOSes, which can automatically detect a viable rate by testing memory, are simply being too aggressive in choosing high memory bandwidth rates.

    EDIT: If it is actually broken memory and only a region of memory is affected, both Linux and Windows have the ability to map around detected bad regions in memory, if you have the bootloader tell the kernel about them and enough of your memory is working to actually get your kernel up and running during initial boot. So it is viable to run systems that actually do have broken memory, if one can localize the problem.

    https://www.gnu.org/software/grub/manual/grub/html_node/badram.html

    Something like MemTest86 is a more-effective way to do this, because it can touch all the memory. However, you can even do runtime detection of this with Linux up and running using something like memtester, so hypothetically someone could write a software package to detect this, update GRUB to be aware of the bad memory location, and after a reboot, just work correctly (well, with a small amount less memory available to the system…)


  • It wouldn’t be effective, because it’s trivial to bypass. There are many ways one can do a DNS lookup elsewhere and get access to the response, as the information isn’t considered secret. Once you’ve done that, you can reach a host. And any Computer A participating in a DDoS such that Comptuer B can see the traffic from the DDoS has already resolved the domain name anyway.

    It’s sometimes been used as a low-effort way for a network administrator to try to block Web browser users on that network from getting access to content, but it’s a really ineffective mechanism even for that. The only reason that I think it ever showed up is because it’s very easy to deploy in that role. Browsers often use DNS-over-HTTP to an outside server today rather than DNS, so it won’t even affect users of browsers doing that at all.

    In general, if I can go to a website like this:

    https://mxtoolbox.com/DNSLookup.aspx

    And plonk in a hostname to get an IP address, I can then tell my system about that mapping so that it will never go to DNS again. On Linux and most Unixy systems, an easy way to do this would be in /etc/hosts:

    5.78.97.5 lemmy.today
    

    On Windows systems, the hosts file typically lives at C:\\Windows\system32\drivers\etc\hosts

    EDIT: Oh, maybe I misunderstood. You don’t mean as a mechanism to block Computer A from reaching Computer B itself, but just as just a transport mechanism to hand information to routers? Like, have some way to trigger a router to do a DNS lookup for a given IP, the way we do a PTR lookup today to resolve an IP address to a hostname, but obtain blacklist information?

    That’s a thought. I haven’t spent a lot of time on DNSSec, but it must have infrastructure to securely distribute information.

    DNS is public — I don’t know if that would be problematic or not, to expose to the Internet at large the list of blacklists going to a given host. It would mean that it could be easier to troubleshoot problems, since if I can’t reach host X, I can check to see whether it’s because that host has requested that my traffic be blacklisted.



  • It was originally pico, which IIRC was bundled with the pine email client (a “tree name” pun off elm, an older email client, whose name came from “ELectronic Mail”; this pun extended to many other Unix email clients, like mulberry and such). I think that “pico” probably stood for something like “PIne COmposer”. Because it was designed to be particularly approachable, listed the basic commands at the bottom of the screen, and pine was installed on a lot of systems, it kind of got adopted as the “Unix notepad for the terminal” — a simple editor that most users could use for lightweight tasks. Then IIRC due to pine predating standard open-source licenses, the nano clone was created to be GPL.

    searches

    https://en.wikipedia.org/wiki/Pico_(text_editor)

    Yeah, it’s “pine composer”, it was indeed bundled with pine. And apparently part of the problem was that the license didn’t fully spell out the conditions under which it could be redistributed.


  • I am even starting to miss my emacs keybinds when not using emacs (especially ctrl-k for killing from your cursor position to the end of the line ctrl-a for jumping to the beginning of a line and ctrl-e for jumping to the end of a line)

    A number of software packages permit use of basic emacs keybindings.

    It’s the default in bash, which uses readline. If someone is a vi user, they can enable vi keystrokes in software that uses readline with editing-mode vi in their ~/.inputrc.

    For GTK-based apps, looking on my system:

    GTK 1: in ~/.gtkrc:

    gtk-key-theme-name = "Emacs"
    

    GTK 2: in ~/.gtkrc-2.0:

    gtk-key-theme-name = "Emacs"
    

    GTK 3: in ~/.config/gtk-3.0/settings.ini

    gtk-key-theme-name="Emacs"
    

    GTK 4 apparently can’t do this.

    Note that this can collide with other keybindings that a given GTK app has assigned to it. I moved the standard Firefox modifier key from Control to Alt to reduce the impact of that on my system. That was a little obnoxious to get worked into muscle memory, but I did ultimately manage it.