How I Switched to Plan 9

It's significantly easier to get to team-based outcomes if you can adhere to a common platform. Finding a common platform by swimming against the stream is just harder. Larger enterprises, which can provide jobs, tend to want team. The history of science/technology is littered with companies which had the courage to give small groups of people budget and time, to do things. We don't often hear about the failures, but I am sure there are many.

Bell happened to be one of those companies. You could walk into another door in Bell (or AT&T) and drive to a room much less tolerant of swimming against the stream.

In addition to what @ggm said, consider why software projects tend to employ external libraries instead of rolling their own solution. The time investment of reinventing the wheel is often immense, even though the eventual result may be objectively superior.

Peer pressure. As one of those who consciously refused the smartphone there are people in my environment who won't let any chance go by to tell me that 'if I had a smartphone' and then followed by some inane reason that is probably one of the reasons why I don't have one.

I can see people giving in just to get rid of that kind of continuous low key harassment.

Evolution. Society works better when most people fall in line with the major consensus narrative. Even a society with a suboptimal strategy that everyone follows is better than a society full of second-guessers that doesn't get anything done.

That's not to say that you need everyone to be a mindless drone, but just like reinforcement learning works best with a healthy balance (usually like 90/10) of exploitation and exploration, society works best when a few people explore new options and the majority follows the emergent consensus.

Because perhaps you see an OS not as a hobby, but as a tool, and you may swim across other streams in life such that you feel your time is spent in better ways.

For instance, I enjoyed being a janitor for my Arch Linux install for a while - it taught me a lot - but eventually I switched to MacOS because I actually wanted to ignore my OS and focus on the code I was writing and connecting to WiFi reliably.

If you are putting your time into something, it makes some sense for it to be something you value.

This so much. Handwriting quality helps me decide which paper should be tossed. If its agitated like you describe, the value of the information on it is probably trash and therefore it goes into the trash.

Wow. I think I now understand why I work so much better when using pen and paper to take notes. Thank you.

Hmm I unconsciously resort to my notepad when working through problems. This should be part of my mindfulness routine :)

That came, worked very nicely, then went with the first version or two of Google desktop search. Would search web history, local documents - word and excel included, and present it in an interface much like Google search at the time. Far as I remember all data was kept locally - it wasn't the Googleplex hoovering up yet another terabyte of your data trail or I wouldn't have touched it.

Then it started to deprecate the useful part, gain a GUI, and morph into a second-rate widget engine. By the last couple of versions I came across it was a mostly useless, very second rate copy of Konfabulator (later Yahoo Widgets). It no longer had any local document and web indexing.

Check Memex!

Full-Text Search your Web History & Bookmarks

https://worldbrain.io/

Not affiliated.

Certainly runs on Raspberry Pi - there are several mentions to that effect.

Sadly I can't help you more - best ask on mailing lists[0] or on IRC[1].

Historically Plan 9 was developed from grounds up to support several architectures, so in this case you're really asking about drivers for specific peripherals.

--

[0] http://mail.9fans.net/listinfo/9fans and http://lists.9front.org/

[1] #plan9 and #9front and #cat-v on irc.freenode.org

9front runs wonderfully well on the Pi and other SBCs.

#cat-v on OFTC is very helpful if you want to try it out.

"Because it’s there" (George Mallory, when asked why climb Mt. Everest).

Some people look for the most exotic art. Some people seek the most unusual foods. Some people want to know exactly what's out there in the universe (enough for humanity to keep chucking probes into deep space, no less). And, some people want to use their computer in a new way. Some of those people even end up deriving practical value from the exercise, but I would hesitate to claim that that's the reason we do it:)

My guess, and paraphrasing: it's like software that blocks out distractions. No modern web, he stays mostly focused on his job, which is writing. The software works in a way that suits his sensibilities - consistent, minimalist, quirky, undistracted by FB and Youtube. "More UNIX than UNIX", if you will.

Some people eat aeroplanes. He uses Plan9.

If you have made the switch from Windows to Linux, you probably have got that feeling of satisfaction, of things working as expected. Maybe getting everything working was harder, but it felt right. That is the feeling you get when you switch from Linux (or other Unix) to Plan 9. Yes, you lack a web browser, but it is a beautiful system. Then, there are a reduced group of people (like sl) for whom this beautiful system just works.

It is the same reason people write programs using lambda calculus or make fundamental physics research instead of engineering. We even get something useful from it from time to time, but that is just a very nice side effect. Or, as Feynman put it: "it's like sex, it may give some practical results, but that is not why we do it".

I think it's just an evolution of distro-hopping even though I don't think people like to admit it. After you've tried all of the major linux distros and you're still looking to play around with something different, the next step is to jump to something like BSD or Haiku or Plan9. You might not get a lot of people openly admitting this though, seems like it's looked down upon to try out something new like this "just for fun" versus having some super specific technical reason. Then again, the "just for fun" distro-hoppers may not stick with Plan9 long enough to tell anyone about it before they move on to something else :P

Plan 9 is the successor to UNIX. Inferno OS is the successor to Plan 9. If you use either for a while, you'll appreciate how well-designed the system is. That, in itself, is valuable. It doesn't need to bring a profit to your startup to justify its existence and use.

> We don't read and write poetry because it's cute. We read and write poetry because we are members of the human race. And the human race is filled with passion. And medicine, law, business, engineering, these are noble pursuits and necessary to sustain life. But poetry, beauty, romance, love, these are what we stay alive for.

From the movie Dead Poets' Society. Emphasis mine.

> Or, people who create enhanced versions of TempleOS, introducing to it the heresy of networking.

"Defiled OS". That might be a fun adventure on FOSS trolling.

(this is where I'd put some sort of Windows Vista joke)

I think the real flaw is thinking that there is single axis of quality: really, there are multiple axes. There's code quality: Plan 9 probably is superior to Linux, Windows or macOS. There's popularity: Plan 9 is inferior to the Big Three. There's orthogonality: Plan 9 is superior to the Big Three. There's availability of fundamental software like w web browser and emacs: Plan 9 is inferior to the Big Three. There's performance: Plan 9 might actually be better because it does less, but worse at truly intensive loads? I don't actually know. There's API surface: Plan 9 has a much smaller API, which is both superior (cleaner) and inferior (less features out of the box) — I think it's a net win, but reasonable people can disagree.

That said, once you've played around with Plan 9's filesystem ideas, they are IMHO clearly and inarguably correct, and should be adopted.

Last I checked, it does far more than just connect to the machine over SSH. It pushes up a nodejs executable and then also pulls down other stuff from the web. And it will also leave an agent running on the host you ssh into, even after you exit vscode.

I can see this being okayish when logging into a dev EC2 instance or something ephemeral but it's not something I would ever want to do on something important.

Assuming a mainstream terminal emulator, [CTRL] + [SHIFT] + [C/V] works well enough most of the time. Copying that way does break if you tile though.

nano isn't very weak, I have modified nanorc substantially and also have binded many keys. It works better than, say, notepad++ on windows.

For those who aren't touch typists, or occasional users, nano is just more comfort than vim or emacs.

And there is a editor named `micro`, which is similar to nano but has more features including bracket completion etc.. I am delaying switch because it is written in go (being unavailable in repos) and anyway I haven't found time to configure it. But it is scriptable in lua..

> the program is not aware of where you clicked. Fixing this would also require patching the world.

No, that exists for a long time and is widely implemented among terminal software. Demo: https://github.com/tinmarino/mouse_xterm

> And you can't easily patch mouse selection into the existing system because there is too much seperation between the terminal and the content - the terminal is not aware of the intended text formatting, and the program is not aware of where you clicked.

I'm sorry, but this is plain wrong.

gpm [0] supplies a mouse server for the console, and has been around for a very long time (the oldest release I could find was 1995). SSH, nano, vim and more all understand the events driven by it. This should even work under a raw tty, rather than a terminal emulator, in any shell, from ash to zsh.

The terminal absolutely understands the mouse, you just need to enable the bridge that lets it all work.

[0] https://linux.die.net/man/8/gpm

Leafpad hasn't been maintained in the last decade or so, is buggy and based on GTK 2. Please don't recommend it to anyone. Gedit is much more sensible as a replacement.

For example pasting a piece of code in the middle of a typed line is more convenient with a “mouse” driven cursor.

I use a Macbook as my keyboard/trackpad combo, so my “mouse” is actually extremely close to the keyboard, and I don’t have to move my hand much.

Writing email. Viewing logs. Configuring servers. Setting reminders can be done in cron. Probably lots I don’t know about offhand too.

So, like how in Linux, a lot of system manipulation is presented as psuedo text files in /proc and and /sys, but expanded to the rest of the system. So like the window manager is manipulated by creating fake files (fake as in they don't exist in any persistent storage device) and writing text to them that describes the state of the windows. Rather than socket() and setsockopt(), under the hood it's opening something like /dev/net/tcp/google.com/80/ctrl and reading and writing text about the state of the connection.

Because of this the whole system is introspectable via cating interesting files.

I agree. Program execution is rarely linear too in a codebase of any real size, so viewing the source of a program as a linear page of text doesn't make much sense.

I think there's an opportunity for a big player in the dev tools space to create a mainstream visual programming language and associated tooling. Many are trying, like Luna (https://github.com/luna/luna-studio) and Dark (https://darklang.com/) but I'm worried they're not established enough to gain traction.

Unfortunately programming with a text editor has become so mainstream that investing time in learning potentially better tools nets a lot of friction and not to much gain.

Sure they have caught on, among the C++, Delphi, Java and .NET communities, less so among other ones.

IDEs are the continuation of those models.

Excel does just fine.

> I personally find the idea of programming through text editors and files to be archaic and primitive.

You have to think about 9p as an RPC protocol with files representing objects within the file server program. Reading/writing those files is how you interact with said objects. And it doesn't have to be text, it can be binary. Though text is used when a human has to interact with something. This is why you can do a lot of neat tricks using just a shell script as you can directly interact with a program using a standardized interface. No other operating system can claim such a high level of homogeneity.

As a hypothetical example, take the game Doom. We modify it to serve a file system to expose all of the players stats as a file tree. So a file called health is an rpc call to read and write the players health. This means you can '% echo 100 >/n/doom/player/health' to set your health to 100. It also means you eliminated the need to reinvent the wheel and integrate a console shell in the game. This saves the programmer invaluable time and eliminates duplicate code. Now we can use shell scripts or helper programs to interact with the game. And they can be in any language as all they have to do is open(/path/to/file) and read() write(). Imagine how much code you can eliminate and how much flexibility you gain by exposing your programs innards in such a standard manner? At this point, you might be thinking "So, if it's a file server, does that mean I can export it to the network?" Yes. You can have another computer mount that doom file server and interact with it.

You can also export your USB controller or other hardware using the same method. The level of flexibility is intoxicating and I don't care if it doesn't play youtube (that's what archaic and primitive 70's os's running in vmx(3) are for :-).

Modern plan 9 and resources: http://9front.org/ (highly active community and recommended if you pan to investigate) http://ants.9gridchan.org/ (pop on the grid and say hello! also recommended) http://postnix.pw/ (resources)

Legacy and Labs stuff (some activity still): http://9legacy.org/ (labs 9 and patches) http://9p.io/ (labs mirror, needs updating)

It does: Plan 9 was one of the first operating systems (probably the first) to go all-in on UTF-8

9p is perhaps a bit more advanced/clean/general? than REST endpoints/HTTP. You can still use whatever serializable formats you want.

The people working on or using plan9 (front) today are different. Just look at the cat-v harmful section and you'll see the blatant elitism. They will keep the completely flawed concepts like the chorded mouse interface for ever for two reasons:

1. To keep normal people out

2. Because their "gods" (Richie, Pike, Kernighan, ...) can't ever be wrong. Claiming otherwise would be heresy.