dancek

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.

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/