Is the Unix philosophy outdated?

Is the Unix philosophy outdated?

Attached: unix.jpg (480x333, 26K)

Other urls found in this thread:

interviews.slashdot.org/story/04/10/18/1153211/rob-pike-responds
gist.github.com/fogus/1094067
twitter.com/NSFWRedditGif

less outdated than most common philosophies

somewhat

Under the hood of every pretty GUI there is UNIX or something inspired by UNIX.

No one follows it so it's becoming less and less useful as an abstraction.

it's dead

It's not outdated, it's just ignored.
Mostly because the average consumer can't understand it and even Linux retards want to do their own thing and can't stand a single philosophy.

No, it's timeless.

>The wise programmer is told about Tao and follows it. The average programmer is told about Tao and searches for it. The foolish programmer is told about Tao and laughs at it.
>If it were not for laughter, there would be no Tao.

As an abstraction? LMAO dude you funny!

Attached: 89870349-9653172.jpg (900x900, 68K)

This

>Unix philosophy
1. Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new "features".
2. Expect the output of every program to become the input to another, as yet unknown, program. Don't clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don't insist on interactive input.

Pic related.
Is Powershell the savior of the Unix philosophy?

Attached: PowerShell_Core_6.0_icon[1].png (256x256, 9K)

>1. Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new "features".

thats fucking retarded and only works in a teminal enviroment.graphics designers would go insane if they had to use a billion fucking small programs for one task when they could just use one with every feature they need(photoshop).this is why unix is shit.

Yes, Unix was a mistake.

Depends. If the right APIs are there, it makes perfect sense.
But for it to work, you'd need a terminal-like scripting language built for creating GUIs and integrating with each other to create a single interface.
On the good side, it would ease up troubleshooting and make every single GUI program on a system standardized in looks.
On the bad side, it would be horrifyingly restrictive and probably kinda bad on performance. And make most videogames impossible.

How come Socrates et. al are still relevant?

Those who forget the past are doomed to repeat its mistakes

>2. Expect the output of every program to become the input to another, as yet unknown, program. Don't clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don't insist on interactive input.
If this was really considered then Unix wouldn't be so damn string-based and with primary IPC mechanism being output scraping. Unix philosophy is pretty much compositionality + worse is better, which is retarded because the latter part starts to work against the former eventually. Powershell is not the savior of Unix philosophy, it is the savior from Unix philosophy -- it is compositionality + the right thing.

Linux distribution based around a Powershell fork when?

Strings are universal and Unix always came with very powerful string manipulation utilities that you can chain together. People who actually know what they are doing (hint: not you) have no problems handling plain fucking text on Unix.

Yeah, let's parse file names or, even better, all file metadata in a single stream.
It's so easy to do. Completely idiot-proof. No way it isn't the best of the best.

Text has a fuckload of pitfalls. At least decide on a fucking delimiter and enforce it throughout the entire OS. Whoever allowed newline and space in file names should be shot.
And when you already got a delimiter, you could also use a structured text format. Which, in turn, is basically an object anyway.

In some ways, yes, it's outdated.

>everything is a file
>retarded file permissions system

Attached: 1071031-Dennis-Ritchie-Quote-From-an-operating-system-research-point-of.jpg (1600x900, 224K)

Yes.
gist.github.com/fogus/1094067

When you find out what fork means

Yes, it was replaced by Steve Jobs' superior philosophy.

A lot of it is still very true, just ignored by most devs who just wanna write programs with flash features and leave maintaining it to the next guy. Graphics complicate a lot of the rules. But if you look at software design trends like microservices, etc I think it's clear that they all lead right to the core of Unix Philo.

>Completely idiot-proof
See, this is the problem. Unix wasn't made for idiots. It was made by experts, for experts.
>Text has a fuckload of pitfalls.
I'm not disputing this, but all of them are avoidable with practice - which is the entire point of Unix, by the way, to be rewarding to those who put time and effort into learning it.
>At least decide on a fucking delimiter and enforce it throughout the entire OS.
Space is the delimiter most of the time, followed by colon (:) where you want spaces in fields. There's always the troublesome 1% though. But with experience, it's not hard to work around it.
>Whoever allowed newline and space in file names should be shot.
True, but the alternatives (e.g. translating them to underlines or different characters) are way worse.
>And when you already got a delimiter, you could also use a structured text format. Which, in turn, is basically an object anyway.
No. Structured formats and objects have to be explicitly supported by the programs. And running into incompatible input and output is easier than you think because the developers can't expect every possible combination. This breeds ugly workarounds, so you might as well save yourself the pain in the long run and go with the "worse is better" strings and invest in robust string-handling tools.

So basically you prefer to manually handle every case of string interaction, instead of enforcing a global standard that all programs can be expected to adhere to.

Do you mean this pragmatically, because it would break compatibility now? Or do you genuinely think that this is an ideal state of affairs?

>this is why unix is shit.
No, this is why GUIs are shit. You sacrifice maintainability and customizability for superficial convenience, and you shall have neither.

That depends on the environment and how it's represented. Small and independent doesn't necessarily mean disorganized. Composable GUI applications haven't really been a thing though, sadly.

>So basically you prefer to manually handle every case of string interaction
Most of them fit into a very narrow spectrum, the rest is still doable with the right tools.
>instead of enforcing a global standard that all programs can be expected to adhere to.
And who do you think would enforce this? Even the most centralized systems like Windows have poor track record with standards, let alone Unix which was always a loose collaboration of different subjects.
>Do you mean this pragmatically, because it would break compatibility now?
The compatibility would never be achieved in the first place. Unix runs on natural selection, not some artificial standard. The one successful standard (POSIX) was only possible because it was severely restricted to the lowest common denominator and allowed anything beyond that narrow scope. And Linux and BSDs mostly ignore everything they don't like about POSIX, so I'd consider it at most a voluntary proposition, rather than a standard. There's no indication some other standard would fare better. (On the contrary, look what happened to LSB.)
>Or do you genuinely think that this is an ideal state of affairs?
I'm a pragmatist. Something that works now is better than an ideal that will never be attained.

Unix was never meant to be a real operating system. Ken Thompson was just dicking around with a spare computer at Bell Labs and was making a computer game. He added a file system to it and it grew into an operating system. Because Bell Labs wasnt allowed to sell software they gave it away free to universities and industry, this is before open source existed. And so its a toy OS that took over the entire IT industry because it was so easy for self taught hacks to work with it. Its not a philosophy, its a shit OS that killed all work being done on operating systems in the entire IT industry.

/thread

Did you even read the posts you replied to?

This is the current state of the tech industry, brainlets who think they are IT gods because they can tweak a everything-from-source distro

No, it's the current state of Jow Forums.

>Powershell fork
Why fork? PowerShell is open and available on most distros. Unfortunately it has a slower startup than other shells.

>made for experts
>needs practice
>needs experience
You know when you've to put all those together it just sounds like talking bullshit, right?

you sound like you consider yourself an expert, but you seem to have poor knowledge of OS concepts outside of unix

unstructured text streams are indeed the weakest point of unix

have fun with your scripts when some asshole puts a newline in a filename

hint: this problem has been solved in other operating systems

These. Some philosophies are only useful for certain situations and people, for example nihilism.

This.

You're a faggot and a dumbshit

Being an expert in a subject requires a lot of practice and experience.
Are you really so mediocre this required explanation?

>photoshop
Winbaby detected. Use gimp like a man.

Summer AF

Bro, stop feedin the troll

>Being an expert in a subject requires a lot of practice and experience.
It does, doesn't it? That's why I mentioned it.
>Are you really so mediocre this required explanation?
Asking me this verifies that post I was replying to was really bullshit.

Operating systems are abstractions that help you use the actual hardware they run on. Though, amazingly enough, megacorps are abstracting on top of Unix with puppet/chef/ansible, and now people don't even know how to use an OS.

>the right thing
Invoke-WebRequest throwing out whatever you download is the right thing? Imagine curl, wget, whatever, using your bandwidth, downloading something, then sending it to /dev/null.

>Most of them fit into a very narrow spectrum, the rest is still doable with the right tools.
I would vastly prefer if I didn't have to fuck around with sed just to make a simple script for time-based folder deletion work.

>And who do you think would enforce this? Even the most centralized systems like Windows have poor track record with standards, let alone Unix which was always a loose collaboration of different subjects.
How strongly is the actual Linux kernel modified by distributions? Same for GNU.
Do distributions fuck with either of these to a major degree?
If there was a standard, it would need to come from there.

Just make it so that a system that doesn't follow the standard will either be fucked up or not work at all. For example, make the default shell of the new distribution check the pipeline for syntax - fuck up the syntax (e.g. malformed XML if XML is the chosen standard) and the pipeline will drop your output. Then your users will tell you to fucking fix the syntax so that they can pipe your tool properly. (Or cry about the shell, I guess, but I prefer to be optimistic)
Would make for some good pressure.
The system works through critical mass. You just need to start the avalanche.

How tightly does it integrate currently?
I've only used it on the Windows side and I'm not sure how it interacts with Linux.

No.
Its because we want to do things with computers that wasnt possible to do in 70s to begin.
Following that design guidelines would be crypling ourselves.

This.
And now we are trying to implement MULTICS on it.

as if you can do what Plan 9 or symbolic machine do in the same straightforward way. keep dreaming tuxtard

>And who do you think would enforce this? Even the most centralized systems like Windows have poor track record with standards, let alone Unix which was always a loose collaboration of different subjects.
How does a compiler enforce programs to be well typed? By _requiring_ the programs to be well typed.
FYI, what's needed for command shells isn't far from this example--imagine, a statically, strongly typed shell...