dancek

This seems correct to me. Of course you'd need to build a CPU emulator to run CPU code. A single GPU core is apparently about 100x slower than a single CPU core. With emulation a 1000x slowdown might be expected. So with a lot of handwaving, expect performance similar to a 4 MHz processor.

Obviously code designed for a GPU is much faster. You could probably build a reasonable OS that runs on the GPU.

The article talks about 26M requests per second. It's theoretical, of course.

Awesome work! Thank you for showing it to the world!

I've considered writing a network stack myself. It's much more complex than most people can imagine. We have great tooling for TCP and that makes people believe it's simple technology. It's not.

Does Asahi Linux now run efficiently? I tried it on M1 about two years ago. Battery life was maybe 30% of what you get on macOS.

https://github.com/mystor/git-revise is great for just this. Of course there's also `git commit --fixup=<commit>` and `git rebase --autosquash` if you don't want to install extra software. But the ergonomics of `git revise` are better.

I've also tried git-absorb before. It was buggy at least back then. Uninstalled when it crashed and lost my changes, and even reflog didn't help.

But as people are predisposed differently, either advice might make sense in different circumstances.

This is a very good point. Life is a balancing act. Different people may need the opposite advice. Or you may need the opposite advice at different times. Not just in this case, but in life in general.

I wrote a quick and dirty bash script that launches a tmux dashboard for a legacy linux server. The team has been happy with it. It does seem like an evolutionary dead end to be honest, but it was very quick to set up.

Note that the dashboard is read-only and mostly just shows journalctl for different units (we use systemd for process management). And we assume it's only used by a single user at once and everything is stopped on detach.

Here's a simplified sample of setting up a 3x2 layout with some placeholder content:

    #!/bin/sh
    set -e

    SESSION=example
    WINDOW=dashboard

    tmux new-session -d -s $SESSION -n $WINDOW "journalctl -fk"
    tmux set-option -t $SESSION -g mouse on

    tmux split-window -h -t $SESSION:$WINDOW "journalctl -fu nginx"
    tmux split-window -h -t $SESSION:$WINDOW "journalctl -fu postgresql"
    tmux select-layout -E

    tmux split-window -v -t $SESSION:$WINDOW "echo '<Ctrl-b d> to detach' && read"
    tmux select-pane -t $SESSION:$WINDOW.0
    tmux split-window -v -t $SESSION:$WINDOW "watch uptime"
    tmux select-pane -t $SESSION:$WINDOW.2
    tmux split-window -v -t $SESSION:$WINDOW "watch df -h"

    tmux attach-session -t $SESSION
    # after detaching, close session
    tmux kill-session -t $SESSION 2>/dev/null || true

I have a client that actively asks me to use AI more and more. They expect to get better quality code faster, ie. to reduce costs. (That's not my experience but that's beside the point).

The author didn't submit it to HN, so criticizing it being on HN seems unfair to me.

It's a cool piece of alpha-quality software. It may or may not be meant to be used, that's beside the point. As I see it HN isn't a platform for software recommendations, it's for discussing interesting geeky things. Which this definitely is, even if it was completely unusable today.

In Finnish (spoken in another Nordic country) it's plural "legoja" / "legot", with the singular only used as attribute, e.g. "legoukkeli". It's been this way at least since the 80s.

That's indeed the biggest flaw in the Github PR model. I've been hoping for a gerrit-like code review experience in a Github alternative for years. I'll be sure to try Radicle.

Years ago I made an ANSI art viewer with modem speed emulation. It has an outdated mirror of https://16colo.rs/ so most ANSI art that's ever been published is viewable. See e.g.

curl ansi.hrtk.in/ungenannt_1453.ans

That's an understatement. According to that data, the most dangerous cars are infinitely more dangerous than the safest cars (205 driver deaths per million registered vehicle years vs. 0). Even more interestingly, the fifth safest car is infinitely more dangerous than the safest four cars (2 vs 0).

Also note that this is the driver death rate. The death rates for other people are vastly different.

You shouldn't jump to conclusions from the data, either. A Dodge Challenger (3rd most driver deaths) is probably not unsafe per se, it just attracts people that want to take unnecessary risks.

Driving is quite safe on average. In my home country there's 5.1 deaths per a billion vehicle kilometers. That's about one death every 2.5 million hours of driving at highway speed. Many other things carry a greater risk of death.

That is quite a depressed take on life. Many people find all of life good. Why not set up your life so you can cherish every moment?

I highly recommend trying BQN [0]. It's a lot of fun indeed. It retains the array programming paradigm but modernizes a lot of things -- and has excellent documentation (but not much in terms of ecosystem, yet). The main implementation is GPLv3.

[0] https://mlochbaum.github.io/BQN/

For these kinds of things, there's a wiki nowadays: http://www.sizecoding.org/wiki/Main_Page

It's a very welcoming scene. Highly recommended, though I'll warn you that sizecoding can be an addictive hobby.

Would we mental workers dread reading how physical workers fight exhaustion by doing crosswords?

I wouldn't call it make-pretend when you can drop electronics in any supermarket and they'll take care of recycling. I don't have statistics but anecdotally people here in Finland seem to recycle electronics as intended.

Real-mode assembly is even more fun. I highly recommend something like http://www.sizecoding.org/wiki/Getting_Started if you're into that sort of thing.

The even older DCT3 generation of Nokia phones worked much better than Symbian ever did. Nokia 6210 is still a great phone if you only need to call and receive SMS. But anything with a color display from that era is really showing its age by now.

Yes, obviously there's no way to tell what proportion of users think the same way.

they strip away features that existed before, and completely ignore and talk down to users who tell them that the feature is very useful and much wanted.

I'm under the impression that GNOME strives for similar UX to macOS. This behavior sounds just like Apple to me, so maybe it's just the correct way to do it.

I've used both macOS and GNOME as daily drivers and got frustrated with both. I'd certainly get frustrated if an employer forced me to use unsuitable equipment (and some have in the past). But that's not the fault of GNOME developers.

You can even use the same .jnewsrc for multiple NNTP servers, so just running `NNTPSERVER=some.url slrn` works for me. But I'm hoping for a way to use multiple servers without re-launching the client.

EDIT: the subscribed groups need to exist on all the servers, though. Otherwise slrn drops missing ones.

I've heard this from a couple of power users before. But maybe GNOME does not optimize for power users?

When you have enough users, any change will make hordes of them unhappy, just because 0.01% is already a horde.

dictatorial power over 100s of users

GNOME has tens of millions of users.

I do understand your sentiment. I don't like GNOME myself. But there are alternatives. If you don't like it, try using something else, contributing patches with configurable behavior or maintaining a fork.

FLOSS maintainers are a rare breed. We as a community need to find ways to not burn them out. Even if you have millions of happy users, just a couple of really toxic ones can make it feel not worth it.

This sounds like a great UI for reddit and I'm surely going to try it out! I'm not very familiar with NNTP though, so I have a couple of questions.

1. Is mapping subreddits to the global namespaces a good idea? If I were to read NNTP news from multiple sources, wouldn't it be better to have a reddit.* hierarchy alongside the alt.* etc hierarchies? (I assume there's a way to use multiple NNTP servers at once; maybe by hosting my own NNTP server that pulls from multiple servers.)

2. Are slrn and tin the state of the art in TUI clients? Surely someone has a recent promising hobby client?

It's not very active (and I'm not active there either), but tildeverse has its own NNTP server. https://news.tildeverse.org/

IMHO you could just use

    # Page title
    
    # 1. First heading

But your point is a good one, and made me wonder how the documentation of Gemini itself handles the issue. And behold, the Gemini FAQ [0] itself has the first level 1 heading as

    ## 1. Overview

    # 2. Protocol design

[0] https://proxy.vulpes.one/gemini/gemini.circumlunar.space/doc...

True, text/gemini is not really suitable for UIs. I did write a wiki engine where the editing is done with sed commands and all responses are text/gemini. It works but people used to modern web apps are not going to love the UX.

You can serve other mimetypes over gemini (the protocol). That's useful for some use cases (eg. ansi.hrtk.in serves modem download emulated versions of ANSI art; requires a streaming-capable client).

But all in all, Gemini tries hard to not be an application platform. These exercises in stretching the limits are fun and IIRC have also guided the development of the spec. But the focus of the project is on text-based content.

what little it's saying doesn't need to be said, of all times, right now.

The philosophy of life and death needs to be considered and discussed especially when humankind is faced with difficult choices of life and death. The choice of optimizing saved life-years may be the right one now, but we as human beings must not become cynical. The value of life can not be measured in terms of events and activity.

I do understand your point of view. For someone who has lost much to Covid-19 and realizes how much we will lose, it is easy to read the article as childish and arrogant. But that is not the only way to read it.