codesections @codesections@fosstodon.org

I want to be able to tell my friends why #mastodon is better than the birdsite, so I wrote a thing: "Mastodon Is Better than Twitter: Elevator Pitch"
https://www.codesections.com/blog/mastodon-elevator-pitch/

I want this to be as persuasive as possible to outsiders, so I'd appreciate as much feedback as possible from Mastodon users

Re: ^^^ I should note that #stumpwm is written in Lisp (which I've never learned/read before today) and #dwm is written in C (which I *kind of* know at a well-I've-worked-through-K&R level).

So the fact that the stumpwm code is easier for me to read (compared even to the clean dwm code) says something about … something. The expressiveness of the languages, I guess?

I've been messing around with #stumpwm more (https://stumpwm.github.io/) and really like it.

I've got to say, this is the first time I've genuinely had the "read the source, Luke" feeling. Maybe it's a sign of the documentation having a few holes, but the source code is so clean and readable that I'm ending up understanding how it works from the code more than the docs. Cf. https://blog.codinghorror.com/learn-to-read-the-source-luke/

(And that's even true comparing it to dwm/other Suckless projects, which have very clean code)

The so-far unanimous consensus is that

x | y

is a vertical split and

x
—
y

is a horizontal split.

FWIW, that's how vim uses the terminology, but it's *not* how tmux uses it. I also agree with the consensus, but I wanted to check if my view just came from being used to vim.

Which of these is a "horizontal split" and which is a "vertical split"? And why?

(I've noticed that different programs flip the terminology—what do *you* think?)

Am I doing this right?

^^^ is getting at a bigger-picture question: Is it simpler to have multiple small tools that work together (the #unixPhilosophy), at the cost of grafting together tools written in different languages, operating with different abstractions, that weren't designed to work together?

Or is it simpler to have a single, coherent abstraction, at the cost of code bloat and sacrificing some on the one-job-per tool front?

(Related to debates I've had with @emsenn in one direction and @sir in the other)

I'm trying to decide between two window manager setups:

1)
#dwm, manage windows https://dwm.suckless.org/
#dmenu, launch programs https://tools.suckless.org/dmenu/
#passmenu, access passwords
#dlarm, set alarm https://github.com/codesections/dlarm
#tmux, manage panes https://github.com/tmux/tmux/wiki
#run-or-raise, run program or focus it if already running https://github.com/Soft/run-or-raise

2)
#stumpwm, all of the above + more with extensive lisp config, https://stumpwm.github.io/

Which of these is simpler? Better? #unixPhilosophy

Have any of y'all ever used #stumpwm? I didn't think there was a window manager out there that could lure me away from my beloved #dwm, but stump just *might* be the one to do it

(still in the testing phase, though)

https://stumpwm.github.io/