Bloatware Is Proprietary

There is a big problem with a lot of free software nowadays, and that's bloat. There's a really good article put out by the suckless community on this issue (suckless.org/philosophy). This page does good at describing the practical problems of bloated software, but I want to talk about the ethical issues surrounding "bloatware".

Now, technically, all bloatware put under a free licence is free software. But that doesn't mean that you can edit it, at least not easily. Freedom 1 of the Four Essential Freedoms states that the user has the freedom to "study how the program works." How the hell can you study the program if it's all jumbled up? This produces the same problem that proprietary blobs do: a gateway from studying how the program works. It may be easier than machine program to read, but given enough lines, the program becomes virtually unreadable.

What are some examples of this?

Now, how can we solve this? Start by using simple software. Don't use urxvt, use st. Don't use i3, use dwm. Now that's not to shill the suckless community. But they're really the only ones pushing on this issue, even though they only come at it from a practical perspective. Start by rolling up your sleeves and learning how to patch these programs so they do the things you want them to do.

Another good idea is to build a LFS build using only simple programs. Rather than the GNU utilities, use some of the BSD utilities, or Plan 9. Ideally this should be available in a distro, but that probably won't happen for a while. If anyone wants to work on this with me over the long term, let me know in this thread.

Pic not related, but it is awful programming.

Attached: the_worst_javascript.jpg (225x150 76.04 KB, 141)

Other urls found in this thread:

curl.haxx.se/docs/security.html),
sel4.systems/
genode.org/
myredditvideos.com/
twitter.com/NSFWRedditImage

It does. You have to thank diversity (in hardware) for that.

Nothing screams "virgin" more than a tech autist masturbating over how sui generis he is for using minimal software. Let's not forget: the C programming language is an extremely unsafe, hacky language in which everything is a member pointer. It has no array bounds checking, you can return pointers to temporary stack memory, and the language is so bad that compilers for the language will remove integer overflow and underflow checks because those checks use undefined behavior, you can use variables which are uninitialized and thus contain junk memory.

dohoho post discarded.

Let's also not forget your post went through several hundred million lines of C to reach me and it went quite well, while webdevs like in the OP have trouble writing 100 lines of code without creating a disaster.

More like featureless. Gotta love recompiling all my shit just to slightly customize it.

So, you have no idea what you're talking about.

GNU software is bloated because when it was developed the quality wasn't the goal, the goal was to provide a free alternatives to proprietary tools. If instead of bitching and making more "alternatives" people would just contribute to GNU we wouldn't have such a problem.

And in case of Linux, you're looking at the problem from top. OpenBSD might be more minimal but it doesn't support nearly as much hardware as Linux does. Before "fixing" the software consider "fixing" the hardware first.

do not take 's bait

Then you just patch the kernel so it supports your hardware. Ideally companies should provide the patches themselves, but community patches are cool too.

Patching st takes absolutely no time at all. It's just as easy as making changes to your vimrc file. I don't know a lick of C, and yet I am able to run patch and make. Fuck right off.


this gives me a smug anime face

Argumentum ad populum. Ada has advanced support for type checking, you can create types with specific ranges (e.g. an integer with values from 0 to 12), you can write modules, exceptions (in other languages the system gives you an error code you can't just ignore or the software will crash), 'generics' which means you can write a data structure (like lists) which will work on different kinds of data, like integers, floating point numbers, and strings. So, by writing just one function for all data types instead of writing functions for all data types specifically, the language has run-time checking and so many other features.
The kicker of Ada is that it's a higher level language than C and about a million times safer. The GCC compiler framework generates the fastest code for C, but GCC also supports Ada and the code generated for Ada is nearly as fast as the code for C. It also supports every architecture/platform that is supported by GCC.
You'd think, why do programmers hate Ada? C programmers in the 80's would use so many bullshit excuses like that the compilers for the language were expensive, or the language is too complicated (it's much simpler than C in day to day usage). The real reason is because they're just too lazy to learn Ada.
The reason for 'bloat' is because C makes it difficult to write good, maintainable, secure code. To you morons everything that isn't C is "bondage-and-discipline". Imagine the horror of using 1950's programming language features and practices.
>and it went quite well, while webdevs like in the OP have trouble writing 100 lines of code without creating a disaster.
C/UNIX idiots have a hard time writing curl/wget (pure C) without a thousand vulnerabilities (which they have an attitude about, and refuse to fix).

What sort of argument is that?
If his kernel had keep written in Ada, it would've been serveral hundred million lines of Ada. Or Rust. Or Erlang, or Elixir, or Lisp, or Java, or whatever. You're making an inane argument that C is better because it's more popular - that's not even an argument. Maybe it's worse, because it's so easy to learn even retards are using it.

...

Attached: DgzSF_0XUAE3Zsb.jpg (640x479, 148.26K)

Bloat is not a problem for free software. It's your own problem if you refuse to maintain your own free software that has the bloat trimmed away.

The user can't predict when a project gets to such a state. All he can do is leave the project when it does happen, or try and improve it.

Also why should the users fix the program, rather than have the program not be bloated/broken in the first place?

this will never ever get fixed on linux

suckless is a bunch of nazis, they literally did a tiki torch march only a month after the charlottesville murder

array bound checking slows down the program defintly with high array orientated workloads. also it is not really needed unless you are a nigger monkey and cant design a way to put it in yourself for arrays in the program that will have the problem.

If that's meant to be dissuasive, you're on the wrong board kiddo.

Is there really that much that can be achieved from making software understandable, when for the past 40 years the hardware it's running on is a proprietary black box?

I can't

Who the fuck other than retards need this? Do your damn math before you write code.

It's not an easy problem to solve, but avoiding Linux and GNU/Aids is a huge step in the right direction. Despite being maligned for its "cuck" licensing, BSDs are far more community driven than Linux, which is basically another arm of the military industrial complex at this point.

If you write your code reasonably well you can minimize this. Loops that iterate over a whole array don't have any more checks than a c program.

bounds checking fags are weak

look faggot your computer can deal with a few extra MB of RAM usage and a few extra clock cycles for bounds checking. It's not 1987 any more.

Exactly that's why modern software is so fast.

do you happen to be indian

Enjoy your buffer overflows larper.

Attached: dfb3158079aac511dfb594ea085fe60bc14c55a33992b014a9c3110f0a72a8a5.jpg (600x450, 32.03K)

you know you can implement your own bounds checking when debugging and for certain applications where you could get an over flow. its really not that hard. you dont need a compiler to hold your hand.

Yeah you can also implement your own exceptions, core data types, socket api. But we don't because that's fucking retarded.

Thank god you can just run ASan these days and catch most things.

Perhaps the epitome of open sores bloat. Ignoring its abundance of technical flaws, it's a good example of a nonfree interaction paradigm, because it hits that sweet spot where it's valuable enough that it changes the way people perceive the problem it solves and thus necessitates its use for many–but too blobby and ambiguous in structure for any real competing software to crop up. And it's borderline violating the GPL, because you can't fucking compile it unless you use his own homebrew of qt hacks.

Intentionally obscure commentary, buggy, broad stack for no good reason, not packaged for pip, and distributed under the broken wtfpl license (e.g. might as well be copyright). Equally as brilliant as Calibre, horribly done. You can't blame him, though; he probably doesn't know better. Even a layman can see he's inexperienced, and he's part of that weird niche of Windows users who also write mostly free software. Hydrus is a technically-flawed piece of software, but it's really valiant in thought.

Without a good up front definition, "bloat" is a buzzword.
It doesn't help when you use shit logic such as
to devolve into "no true free software" retardation.
Also claiming no program ever needs 5M LoC is insanity.

Maybe you're just shit at reading code?
Pic related is a breakdown of the linux source by disk usage. hint: drivers are hard, so is supporting ten different arches

Attached: lin-usage.png (627x533, 62.93K)

bspwm is better

Every time someone says this they have no idea how to use dwm and use it like some retarded tiling wm.

It's less about the diversity in hardware and more because we no longer directly program it.
Operating systems are bloated today primarily because of the driver model and hardware not being directly programmed.

Yes because what we all need is for every program to manually implement the driver every fucking time. That will really save us headache i'm sure.

never used bspwm but why is it better than dwm, in your gay opinion? i3 is nice as well but nothing beats dwm in terms of functionality, speed and minimal mental overhead. yes it's a fuck to tweak and re-compile, but this has an added benefit that once you've got a config to your liking, you are less likely to fuck with it every 10 minutes like some bored housewife.

You've read my words but I don't think you understand what I'm saying.
How about just reading from and writing to some memory? That's exactly how it was done before(look at almost any 1980's computer) and it worked quite well.
The AMD Radeon R9 290X saw a 50% performance increase when they removed part of the Radeon driver and used Mantle to interact directly with the GPU. You can get rid of the driver bloat and increase performance; there just has to be enough interest to stop wasting resources on fancy unnecessary abstractions.

lmao, unicucks strike again

No. Linux is bloated cuz don't have a proper interface and driver architecture so they just put the code for each driver in the same repo.

I'm not going to dumb down my code just because a brainlet doesn't understand it.

Your argument is flawed. With bounds checking you still need to make sure you are within the bounds yourself, else your program will be terminated. If you think C is better by having a more dangerous side effect if you get it wrong then you are being silly. Thinking you elite by using at inferior tool makes to sense. It's like thinking that using a rock is better to nail nails because it is harder to do.

The suckless crowd is a bunch of sperglords. Yeah, thanks for dmenu, but everything else you make sucks LOL dick.

Oh, by the way, how's that Static Linux project going? :^)))))

I will say, as a die-hard Emacs user, I love almost everything suckless does to death, especially surf. There are a lot of idiots out there who think adhering to "true Unix" tradition means a bunch of shitty ncurses interfaces, but suckless is one of the few groups that really understands the appeal of Unix tools, because they're not shitty ncurses interfaces, and they're not even shitty, interactive CLI interfaces; Unix tools are one-dimensional. They're singular in there application, with no superlatives or quality-of-life features, and a pleasant side-affect of that is that they're light and pipe-able. Emacs works best as a frontend for software like that. Surf is somewhat neutered, so it depends on dmenu to sort of carry things from point "A" to point "B", something that what otherwise be poorly-implemented by the browser itself, like issuing search search queries and searching for arbitrary text, but the funny thing is, Emacs does precisely that, except better. I can interact with Surf via Emacs in precisely the same way dmenu is used to interact with Surf, and that simply wouldn't be possible if it weren't for suckless' paradoxically humble elitism. Emacs loves simple applications, because it's easy to take something intentionally shallow and effectively create your own toolkit with Elisp. Whereas traditionally, you would rely on a normal window manager to handle all your surf sessions, you can handle all your surf sessions with a number of Emacs interaction paradigms, you can sort them by name, by window element, by buffer type and manipulate multiple buffers at once–all with fuzzy search, because Emacs is a window manager, too, with EXWM, and whereas modern DE's struggle to even talk to other components even within itself, consummate integration is a necessary prerequisite of Emacs.

Only tards not knowing the price of a branch on most µarchs will promote bound checking. Now, bound checking for debug builds is sensible.

Because, unlike dwm, keybinding is left to a separate application, talking with an appropriate RPC client to bspwm itself, as it should be. Its config file isn't parsed, too, it's just a shell script, since everything (including configuration) is configured with the RPC client (bscpc).

Come on, there's st too.

Also, there's no builtin status bar. I should also add that it uses XCB, instead of Xlib.

That problem is caused by C. Doing anything in C needs a lot of code. Code is duplicated many times and everyone has to reinvent wheels instead of doing it once and sharing the code. Better languages can do more with less code.

It's over 16 million now.


Those checks could be done in hardware at almost the same speed as not doing them. Lisp machines can check array bounds in parallel.


That means C really sucks if it needs that much code to send and process a few hundred bytes of text. Lisp machines, Xerox computers, mainframes, and so on could do a lot more with a lot less code. Checking for overflows in assembly is one extra instruction or part of the same instruction if it traps. In C, it's complicated bullshit code that has to be repeated over and over again and can't be optimized for the hardware you're using. The PDP-11 had an overflow flag, so you can't blame hardware for this mistake.


That's a "feature" of all UNIX software. AT&T's proprietary UNIX had the same problems and the same mentality of blaming the user for all of them.


A lot of people are puzzled by this, but it only makes sense to me if there was heavy shilling involved.


My reply to a discussion on another list concerning shelloutput redirection:>> What's going on is that you're overflowing the *shell's*>> output buffer. When you do > you're asking>> the shell to capture all the output from and when>> it's done, stuff that into . As you've noticed,>> there's not much of a buffer there and when you've filled>> it up it goes kablooie....producing no error message or useful diagnostic, ofcourse. Such wasteful civilities are obviously far beyondthe ``small is beautiful'' design philosophy of which WeenixUnies are so fond. And you weren't actually expecting theshell to be designed to buffer its output correctly withoutsegfaulting, were you? As a user, keeping system programsfrom wetting their pants is, after all, YOUR responsibility.

Like a clockwork.

St cannot be daemonized, making it considerably heavier than urxvt when used in a tiling window manager setup.
Don't use either. X11 is bloated. Use Sway.

Pretty much this. People are like, "muh plan 9 tiny kernel", but they forget that Plan 9 has shit-tier hardware support, and if Plan 9 ever did get Linux's hardware support, it may or may not be 4.8 million lines, but it most certainly would be astronomically larger than it currently is, and would be far bigger than any suckless shill would allow.

HAHAHAHAHA
pic related. BSDfags actually treat their commercial bullshit as a SELLING POINT

And it's still way slower than what NVIDIA puts out. If you were trying to make a point here, you failed

For real though, if you guys really want better and more /minimal/ software, you should look to microkernels.

Attached: FuckBSD.png (895x429, 326.47K)

what am I supposed to be concluding from this shitcode? it's completely typical and has been for 30 years. the audience of codinghorror would only notice the first 2 points and some of the other minor syntax issues
I've been using mrxvt recently, is that bloated? Going from several other dog shit terminal emulators, the last I used was xfce4-terminal, which has unberable input lag and a bug where random strings of text become invisible while browsing man pages, and now I use mrxvt because it's decently fast (i.e actually opens within the first year of me hitting the hotkey to open it). However I don't think it supports unicode which has become impractical for me regardless of how shit unicode is

so give me a minimal memory-safe PL, like LISP (but not actually LISP lol)

Not the op, but doesn't st being way smaller than urxvt make this void 99% of the time? In any case, there are few situations where you're worried about the mem usage of the terminal, as opposed to, say, the browser. startup time does matter tho

only tards not knowing the cost of lack of memory-safety will promote writing the entire kernelspace+userspace in an unsafe language

GNU Guile?

Pascal. Not even joking.

yeah except when the daemon crashes and you get fucked in the ass, st all the way my nigger

Your reading comprehension has failed you.
If AMD can get increased performance by partially getting the driver out of the way and directly programming the hardware, then NVIDIA can as well. Why? Simply put, the current driver model is a cost-heavy software abstraction that limits the total performance you can get out of a piece of hardware. All GPU manufacturers will see a performance increase from directly programming the hardware.

Attached: 6756734gklhgfdk453.gif (346x244, 2.12M)

bounds checking is for pajeet XDDD
>>>/g/

Real white programmers launch another process in which they iterate over the array in a goto loop until it segfaults.

Maybe spanish programmers. Northern europeans unroll all their loops, no matter how many iterations, guaranteeing speed and security.

...

That's an interesting point, but the freedom to study the source code refers to the source code as it was used by the author. For example, if the author has his code split up neatly into various files, but then uses a tool to merge them all into one file with tens of thousands of lines of code, that would not qualify as source code. On the other hand, if the author is a turboauitst who can actually keep track of one file that several tens of thousands of lines long, then there is nothing to argue.

Bloat is not an issue of political or legal freedom, it's an issue of practical freedom. No normal person is going to audit the source code of an incomprehensive mess, let alone make changes to it, even if they are allowed to. At that point you might as well re-write it from scratch.

Of all the pro-suckless shilling in this thread, this is probably the only one that provides a solid supporting argument.

And if the author enjoys writing binaries by hand in a hex editor, then that counts as free software as well. Come to think of it, some of the microsoft tools are edited in hex editors...
If you're not already an anarchist, then why even live? The only issues that matter are practical issues. It just so happens that governments are very good at making political and legal issues into practical issues (and getting better at it).

kys licencecuck

Effectively zero if well-predicted? Like, one that goes one way all the time?

Branches are almost free only on very modern CISC uarchs. Also, speculative execution brought us some lovely problems, these last few months.

Buckle up then, since it's not going anywhere.

Just don't overuse it, like longjmp.

And superscalar machines can do useful work in parallel. Why waste silicon and power on useless checks if you can invest it in doing actual calculations instead?

That's not how it works. I can hand you the cleanest code in the world, if I don't give you permission to modify and redistribute it, I could sue the shit out of you for distributing a modified version. This is why practical freedom is built upon legal freedom.

Just think: If a rather "small" program like curl has a ton of vulnerabilities (curl.haxx.se/docs/security.html), how many other (networked) C applications have egregious vulnerabilities? Next time you pedos are shitting yourselves about Spectre/Meltdown/the IME just remember that most of the C code running on your machine is insecure. (Another point I have to make: why do you losers have a pathological desire to live in paranoia? Shoved into lockers one too many times?)

yes you are a pajeet

They're useful checks since without them you would get RCE vulns. I agree that there are use cases for unsafe assembly code, but anything in the chain of how you access your online bank is not one of them.

Literally not an argument. Practical freedom existed before "legal freedom" or "legal restrictions". Also I'm pretty sure in practice some small guy like you would be unable to enforce anything about your code other than maybe a harrasment lawsuit and earn yourself $5.

C isn't a good language in the first place. I don't want C with bounds checking. Ironically everyone here is too scared to open this PDF file literally because of C (which in fact is more prone to RCE vulns than assembly language). Even if C was memory-safe it would still be prone to causing security issues. A much better starting point is something like ML or even LISP.

Like clockwork. At least made a quality post.

Attached: 50251216b4af34995c957e582be7fea2a985d1736eb7f8d6d97f3318c4e1f465.gif (500x372, 62.26K)

Yes
No

What if I host it on behind tor? What if I'm some small fry torrent seeder not worth pursuing? What if I obfuscate the bins so you can't prove I copied from you? etc. Even though these aren't legal protections from copyright, they are practical protections, that various anons use every day. Doing something just because the government tells you to is the definition of cuckoldery.

Code artisanship and language wars are retarded. Waste of time when so much software is totally outdated and uninteresting.
Luckily academia is on top of things and is getting people to reconsider actual design instead of fagging around writing fib sequences in new innovative ways.

Yeah respecting free software licenses is retarded. You should just ignore the GPL and do whatever the fuck you want with it.

Academia is perennially masturbating over the new in vogue functional language (that essentially clones the functionality of an older functional language, while adding maybe ten unique features). At least they still use FORTRAN in places.

This is why you have different versions of the kernel on a per-uarch basis. This isn't as complex as you would make it out to be, either. You'd just have a modular microkernel that gets compiled into certain configurations.

well at least we can agree on that one
sel4.systems/
genode.org/

Attached: unhackable-kernel-sel4.jpg (982x552, 60.11K)

Daily reminder that despite all the math shit that went inte seL4 it's still vulnerable to spectre and meltdown without any mitigation.

...

What faggot has seen that their car uses GPLed software, and called them up to ask for the source? It's just a mildly annoying burden on them, and confers no benefit to you. Stallman's been jacking off to the distinction between free and open source software for 20 years, but I still have yet to hear of a situation where this has conferred any benefit to end users. The practical difference is that it fucks over large corporations, which I am all for, but why should I bother respecting this distinction?

Yes indeed checkmate math fags.

fuck off nigger i'm not defending sel4 i'm defending formal proofs

nobody looks at the code in their cars because it's hopeless. use feet or ride bike instead. why would you entrust your life to KLOCS-MLOCS of code made by an industry that never once had any oversight (aside from uConnect, which indeed proved ECU code to be a disaster). expect code worse than what you get in routers, smart TVs, and other "embedded" software

Well then bud instead of claiming things are "proven correct" how about you say "proven to match a specification that is likely wrong".

Your confusion is that you believe that users need to be computer experts with good programming skills. This is a false assumption, it is wrong to conflate freedom with technical aptitude. Users (who have freedom) who need technical help need to go ask a skilled helper to help them. The skilled helper will request the source code from the user and the user will request the source code from the distributor to give a copy to the skilled helper.

Open source exists to promote an open software development method. In this philosophy, freedom is not the purpose, the purpose is about producing the highest quality software through the open source method. The free software philosophy and open source philosophy is not the same ideal, do not conflate the two as you can have one without the other. It is also possible to have both philosophies working on the same project.

See how the Linksys router firmware was forced to be shared. Or see how "open source" allows faggots like Sony to just take FreeBSD and make their locked down computer called a console or Apple to avoid working for their turd of an OS.

fuck off nigger i'm not defending sel4 i'm defending formal proofs

Open source software is free software, except it grants one additional freedom, to disribute the software without providing source. As an end user, you have no reason to prefer free software over open source software. As a company who plans on selling the result, you will prefer OSS. The goal of free software, I say, is to screw over these latter companies, a job it does admirally. The goal is not to get companies to hand out their software for free, as the GPL requires them*, because no company would be stupid enough to fall for that. They will either use the free software in some way that doesn't make the rest of their code "derivative", or make/license a proprietary version of the software, even at great expense.
*fite me stallfags

Oh yay, you have the source for the firmware of a shitty router. No doubt you've already patched it a ton, and shared it with all your friends.
They weren't gonna release the source anyways, they would've picked some proprietary os instead if bsd wasn't around. That would've made the resulting product shittier and more expensive, so score 1 for open sores?

You believe that the purpose of free software is to screw over companies; this is wrong. The purpose of free software is to promote freedom for the users. The GPL works by preventing people to redistribute the GPL software as proprietary software, the only people this disturbs are the people (companies or individuals) who distribute proprietary software. You are confused to think that people cannot earn a profit selling free software; earning a profit does not conflict with the ideals of free software. The idea that conflicts with free software is the distribution of proprietary software in any form whether a profit is made or a loss is made.

The lispfag is right, also we could have had Smalltalk too. Running those on the bare metal would be easy these days and the systems are so much smaller, more flexible, and easily understood / modified.

It's all talk and no action. You guys have it good these days because you have access to affordable and super fast computing machines. Yet, people who complain about this spend none of their own time implementing such systems that will not take the amount of time it would take to write TempleOS. I suppose I could note the suckless team who do indeed walk the walk instead of only talking about should be done.

There is no "selling free software". You beg for donations, and some people will give them to you. In the old days, when software was distributed on tapes, you could sell the media. Nowadays, you can't hope to sell the download for more than a couple pennies, and even then github would undercut you.
Exactly. gpl screws over proprietary software distributors, mit doesn't. that is the one and only difference.

i thought summer ended already