The raw timber was never the issue here. The environmental impact is, and exactly why this is major news now.

Removing forest soil has exposed anaerobic soil layers to oxygen. It also causes rainfall to flood into nearby freshwater. The Oulujoki river basin is now facing contamination with acidic runoff and sedimentation.

Uncontrolled hydrological changes may have an irreversible environmental impact. Similar destruction of hydrological environments was huge news in 2024, when a forestry corporation destroyed the habitat of endangered freshwater pearl mussels.

People in Finland don't take irreversible environmental damage lightly.

> The owner by default can do whatever they want with their own forest.

This is false. In Finland by default: 1) you must file a notice of any major logging in advance; 2) you need to plant the same amount of trees that you cut; and 3) zoning, key habitats or environmental impact completely prevent logging in many areas even if the land is privately owned.

Thanks for mentioning it! First time I heard about Commit Mono. The first paragraph already had me wondering how a monospace font can read this well.

Turns out it has smart kerning, ie. character positions are subtly adjusted to compensate for different character widths. For example, i is narrow and m is wide. That causes words like "commit" to look bad in standard monospace fonts. The m's in the middle are very densely spaced and there are wide gaps around the i.

I'll be testing Commit Mono in my editors. Maybe it will even make me switch SilverBullet back to a monospace config.

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.

You don't need an emulator, you can compile into GPU machine code.

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

Not requests, packets: "And according to some benchmarks Wikipedia cites, you can drop 26 million packets per second on consumer hardware."

The Number in the Title is basically fantasy. (Not based on the authors RL experience.) So is saying a DDoS is well distributed over 24 hours.

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.

Thank you! I completely agree, the complexity is definitely hidden by modern tools and abstractions. It's a challenging but rewarding project. You should give it a try, it's a fantastic way to learn!

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