Whenever you add a feature, try to remove 2 features

>Whenever you add a feature, try to remove 2 features.
What did he mean by this?

Attached: 1532221420786.jpg (460x460, 18K)

It's called software minimalism

It's called being a retard who tries to justify only being able to write basic bitch pajeet tier Linux apps.

keep it simple stupid

Attached: queen.png (460x671, 223K)

>making programs that actually do something is bloat

>pajeet tier
>linux
ms shit is actually pajeet tier and apple shit is not much better
linux tier is way above them

but this fag is literally describing the opposite of pajeet code?

>why yes I do program enterprise Hello World apps

Attached: c87.jpg (600x902, 58K)

I added a save feature then removed the load and undo features. At this rate I’ll be at negative features, am I doing this correctly?

>rigidly following other peoples rules for software dev
Yikes!

Yes, of course. The only correct software is the one that does nothing at all. The rest is bloat.

Eunuchs philosophy in a nutshell.

Attached: a-0-ignore-him-all-you-want-but-always-remember-who-26598943.png (500x654, 103K)

I don't know, but looks like Gnome devs like this.

Featureless is literally the opposite side of the same coin.

>Can't have bugs if your software does nothing

Wow, that's brilliant.

How is one even supposed to start then? How am I supposed to add the first feature at all?

What the fuck happened to this board? jwz was right.

They finally stopped sucking Unix cock.
And who the fuck is jwz? Jews?

Literally who?

Founder of Suckless.

I think I get what he's saying. If you really need a feature, just write a seperate program. Then write a program whose only purpose is linking those two programs together. If you need another feature, write another program and another program that links the new program and the original program together. And so on... You can even write a universal linking program pipes input from one program to another. To do this all your programs would need to use a simple universal interface to communicate, similar to letters and words humans use to communicate. In fact, if you used words and letters it would be easier for humans to read your programs' outputs too.
So to add a feature, you write a small program that takes text as input and produces text as output that you can pipe into other small programs, and which other small programs can pipe their output into. This way each 'feature' is a small independent entity which limits the amount of code needed and thus the number of bugs present.
Honestly, it's not a bad idea at all. It would be cool if someone could produce such a system for daily use. Why, if it was all text based, you might not even need too much graphical power to present such a system- the user interface could be text-only too!

By this logic, you would need 10 separate programs to make a basic text editor, because the operating system you're describing doesn't respect its philosophy.
Stripping applications of functionality is really just a lazy way of reducing the codebase and resource usage, instead of actually learning how to do more with less.
The Eunuchs philosophy was wrong since day 1.

Composability is a virtue. I love shit like netpbm. The format is simple enough for any idiot to write image tools that do something interesting, and the methodology lets you just slap commands together and get a result you can apply to whole folders worth of images.

still, highly integrated systems aren't bogged down with trying to glue all these pieces together and deciding what information to expose between programs
flat text is nice, except when it's not
complexity skyrockets out the ass once you do something more than a linear sequence of commands with one end going into the other
beyond that, you might as well have made each program a subroutine of your program instead of an entirely different process you need to communicate with