Can't we REALLY expect Linux to...

Carson Evans
Carson Evans

...at least throw up some damn GRAPHICAL errors when a program fucks up? Just display the same shit that shows up when you run a program in a command line - but in fucking dialog box. Is that so hard? But no, there's fucking nothing and off to the terminal you go.

Attached: linuxsucks.jpg (14.38 KB, 300x156)

Other urls found in this thread:

discord.gg/QQpNCUp
debian.org/women/
gcc.gnu.org/onlinedocs/libstdc /manual/license.html
gnu.org/licenses/gpl-faq.html#AllCompatibility
kernel.org/doc/html/latest/process/license-rules.html
pdf-archive.com/2014/10/02/ansi-iso-9899-1990-1/ansi-iso-9899-1990-1.pdf
port70.net/~nsz/c/c89/c89-draft.html
gnu.org/software/libc/manual/html_node/Program-Arguments.html
github.com/vivien/i3blocks/blob/9e8e313d252e5000d6bebb59fbaaff506bcb0408/json.c#L106
en.wikipedia.org/wiki/XML
cs.cmu.edu/Groups/AI/util/html/cltl/clm/node315.html
multicians.org/multics-vm.html

William Taylor
William Taylor

I got used to navigating through the operating system solely through keyboard after a while - it's faster and I don't need to frequently switch between the mouse and keyboard for the most basic tasks. Linux isn't a hackerman branded operating system with a Windows core underneath, so don't expect it to behave the same way.

Oh and also, kill yourself.

Angel Green
Angel Green

no you kill yourself, fanboy

Xavier Roberts
Xavier Roberts

Is that so hard?
Yes because Linux is a kernel. It would have to check which GUIshit is running (Wayland, Xshit or maybe even Android) and have a client for each of them.
When an error occurs and one of them is running it could output it over an own client window.
There is the issue. The solution is bullshit and that's what you get with thrown together shitpieces of different types of shit with independent shitvision.
Windows core
OS X and Haiku can do that too.
Oh and also, kill yourself.
Not OP but you first ;)

Parker Gray
Parker Gray

"WHERE'S MY BIG BUTTONS, BIG WARNING DIALOGS, BIG TEXT AND BIG WINDOWS AND BIG FUCKING COCK IN MY MOUTH"
GUIs are a mistake

Ethan Mitchell
Ethan Mitchell

Linux is just a kernel, so it couldn't.
But talking about GNU/Linux, which is actually an operating system, it depends on the type of an error. Would you like to have shitty Windows-like error code x1092378rDh120n rc21VO, "Something have happend, we're trying to fix it" which doesn't give any clues or what? If a program isn't working as it should I just run it in a terminal emulator, and search the program logs. I don't need error windows jumping on me.

Matthew Evans
Matthew Evans

No. This operating system was made for essentially electronic typewriters. Unfortunately you can't make a pop up on a typewriter so that feature is off limits.
<it's faster
We’ve done a cool $50 million of R & D on the Apple Human Interface. We discovered, among other things, two pertinent facts:
Test subjects consistently report that keyboarding is faster than mousing.
The stopwatch consistently proves mousing is faster than keyboarding.
AppleDirect, August, 1989

Aaron Cooper
Aaron Cooper

Salty Lincuck detected.
It's good to know whether your GUI application crashed or closed itself.
Especially on your unpolished OS.

Logan Garcia
Logan Garcia

OP here. I mean holy shit, I'm not expecting much. If a program can't find a library, is it so hard to display "File shitlib.so not found" ?

Adam Howard
Adam Howard

I remember fucking Windows 98 doing that already.

Juan Miller
Juan Miller

Yeah, sure. Good point, user.

Attached: 080.png (5.13 MB, 3840x1080)

Robert Perry
Robert Perry

As fun as it is to frame a potentially interesting technical discussion as a series of unproductive complaints, insults, and holy war rhetoric, I'm actually interested to know if such a feature could be implemented, and if not, what prevents that from being possible.

I'm not too familiar with the inner workings of D-Bus, but that would be my first guess for where to look. Surely D-Bus must know when one of the processes connected to it terminates. Does D-Bus have access to the standard output of connected processes?

Gavin Lee
Gavin Lee

<inb4 a UNIX weenie comes in and says that it's better for the program to just run and crash when it needs it

Camden Taylor
Camden Taylor

The way GUIs for linux are made, it's clear that nobody put any serious thought into them. This follows because linux is primarily for servers, so desktop linux will always take a back seat. Still, the number of different distributions for workstation linux would make you think it was mature, when in facts it's a hacked together PoS.

The way this would be solved on any other OS is quite simple: each application developer would be interested in making his program pass a bare minimum level of usability, so he would implement the dialogue himself using a standard interface meant for the purpose. You could create yet another hack that would sort of work half the time. But it would leave you even more confused the 10% of the time the hack didn't work.

I'm damn lucky I like server software, so I can manage fine with linux. But I feel very sorry for all the people who do graphical work, and have to suffer through their choice of hell.

James Martinez
James Martinez

linux errors are better than modern windows errors. linux gives useful information windows just some stupid something happened tier message that wont help at all.

Wyatt Murphy
Wyatt Murphy

linux errors are better than modern windows errors
So what? You are stooping pretty low if you have to compare yourself to Windows to say you have better error messages.

Jacob Wilson
Jacob Wilson

This is not a problem with Linux but a problem with specific projects that don't provide a graphical dialog box for errors.
You should probably stop using that program and instead look for a more graphical alternative.

Nicholas Harris
Nicholas Harris

This is not a problem with Linux but a problem with specific projects that don't provide a graphical dialog box for errors.
This deflection of responsibility and criticism is so common I can't tell if you truly believe this or if you're merely pretending to.

You should probably stop using that program and instead look for a more graphical alternative.
So, the system doesn't provide decent abstractions for much of anything, but that's everything else's fault? The Linux kernel doesn't even implement something such as fsync() in a way that database programmers expect, leading to issues. When every program needs to have loops to use system calls correctly, specialized code to sanitize filenames correctly, or its own abstractions just to report errors graphically, what's the point of the underlying "operating system"?

Camden Sullivan
Camden Sullivan

Terminal show graphical error when there's a problem
I want graphical error when there's a problem
?

Levi Bell
Levi Bell

When every program needs to have loops to use system calls correctly, specialized code to sanitize filenames correctly, or its own abstractions just to report errors graphically, what's the point of the underlying "operating system"?

yeah this is like programming a game engine all over again

Evan Roberts
Evan Roberts

Attached: Terry-Davis-Command-Line-pvjSNoGL1-g.webm (1.25 MB, 640x360)

Isaac Phillips
Isaac Phillips

Please tell me where you get those wallpapers.

Levi Miller
Levi Miller

Trying to use windows file explorer content search option
Searches for a while and then closes the window
Check event log
Error id 1000, file explorer has crashed.

Attached: 1a098bbe69da49109016f1c3e9e4066ad2096843f683422af486a202626bf5f8.png (411.08 KB, 1240x1686)

Jason Jenkins
Jason Jenkins

The stopwatch consistently proves mousing is faster than keyboarding.
This must be why the top Starcraft players use the mouse for everything instead of using hotkeys, or why people who are quick on photoshop click around instead of use hotkeys. A stopwatch would definitely prove that pressing right click, then pressing copy is faster than using ctrl+c.

Attached: twi.jpg (7.74 KB, 171x250)

William Lopez
William Lopez

Maybe I am too much of an autist but I hope this is sarcasm.

Brayden Howard
Brayden Howard

yeah let's blame the users for shit design
by the way I've seen more command line this month than you've in your whole life

Asher White
Asher White

There's no point in talking to keyboard zealots user. They are genuinely disabled.
I try to move my hand to the mouse but instead my arn overshoots the desk and I fall off my chair OMG this is so slow
my 'mouse' keeps moving when my fat palms rest on it damnit it is distracting so that's why I went full keyboard now I'm more productive than ever, 200 packages compiled today alone!

Mason Taylor
Mason Taylor

NO!
there's enough niggers and women using computers already

Parker Harris
Parker Harris

the point is the same you can put more information in the command line unless you want a window with a book worth of error text.

it's not that hard, but I refuse


void SHOW_ERROR_FOR_NIGGER( char* NIGGER_TEXT )
{

GtkWidget *nigger_dialog=gtk_message_dialog_new( GTK_WINDOW(parent_window),
flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s",
NIGGER_TEXT );

gtk_dialog_run(GTK_DIALOG(nigger_dialog));

gtk_widget_destroy(nigger_dialog);
}

SHOW_ERROR_FOR_NIGGER ( "YOU WILL NEVER BE WHITE" );

Jonathan Scott
Jonathan Scott

This deflection of responsibility and criticism is so common I can't tell if you truly believe this or if you're merely pretending to.
it's the operating systems fault that a program some random wrote doesn't provide graphical error messages

Christopher Lewis
Christopher Lewis

At least a missing library error could be enforced system-wide.

Austin Scott
Austin Scott

It took a decade of complaints for gnome to implement a graphical kill dialogue so users didn't have to open a virtual terminal and use ps -ax when a graphical application hangs.
The logic then follows, what would a retard who can't use a terminal want that output for anyway?
The concept of a 'desktop environment' where everything exists as a GUI purely exists for niggers, retards and women who have zero interest in fixing things and just want to call in the "nerd" (white man.)

Jacob Young
Jacob Young

try using windows file explorer
right click side pannel
crashes, no error

Owen Gomez
Owen Gomez

Debug is literally down to implementation
At least a missing library error could be enforced system-wide.
This is the job of the package manager, which is a part of distributions, not the kernel.

Thomas Wilson
Thomas Wilson

Be Linugger
Too autistic to understand ease of use or best practice design
F-fucking normalfags, th-they just don't get it!
Year of the Linux Desktop a-any day now!

Henry Green
Henry Green

lets get here fagots

discord.gg/QQpNCUp

Chase Clark
Chase Clark

Yes, it sucks
debian.org/women/

Dominic Smith
Dominic Smith

GRAPHICAL errors
dialog box
you're a nigger

Attached: whatmakescomputerwentwrong.webm (1.39 MB, 1280x720)

Benjamin Harris
Benjamin Harris

Not necessarily. Just normie users.

Aiden Murphy
Aiden Murphy

don't provide jack shit
be surprised when people opt to not reimplement everything in an ad hoc manner every single time
But at least it's not Linux's fault, dog bless.

Isaiah Cook
Isaiah Cook

Christian fundamentalism
Opinion dropped

Daniel Bailey
Daniel Bailey

I expected a retarded response but I didn't expect it to be that retarded.

Isaac Sullivan
Isaac Sullivan

the kernel is expected to provide an entire gui toolkit
kill yourself
you are the problem

Kevin Hughes
Kevin Hughes

shitty complaint thread
4chan

Alexander Butler
Alexander Butler

I have an idea!
Let's merge GTK into SystemD and then merge SystemD into the kernel!
Year of the linux desktop inevitable!

Ayden Flores
Ayden Flores

The operating system should, retard. That "Linux" is a kernel together with a bunch of ducttaped components lacking any design whatsoever is the problem, not an excuse. In that sense alone, systemd actually has the right idea, but of course it's done by Rathead and Poettering, so it's an abomination.
you can't blame the cardboard house for breaking down, it's cardboard after all
Maybe stop building shit out of cardboard then.

Jace Torres
Jace Torres

I'd just like to interject for moment. What you're refering to as Linux, is in fact, GNU/Linux, or as I've recently taken to calling it, GNU plus Linux. Linux is not an operating system unto itself, but rather another free component of a fully functioning GNU system made useful by the GNU corelibs, shell utilities and vital system components comprising a full OS as defined by POSIX.

Many computer users run a modified version of the GNU system every day, without realizing it. Through a peculiar turn of events, the version of GNU which is widely used today is often called Linux, and many of its users are not aware that it is basically the GNU system, developed by the GNU Project.

There really is a Linux, and these people are using it, but it is just a part of the system they use. Linux is the kernel: the program in the system that allocates the machine's resources to the other programs that you run. The kernel is an essential part of an operating system, but useless by itself; it can only function in the context of a complete operating system. Linux is normally used in combination with the GNU operating system: the whole system is basically GNU with Linux added, or GNU/Linux. All the so-called Linux distributions are really distributions of GNU/Linux.

<The "operating system" does retard, via GNU GTK.

William Green
William Green

no it's fine, just use this ducttaped component
or that other one
or this niche one that's popular on Zig Forums
oh the one I recommended has breaking changes every six months btw lol
Consider understanding what you read, rather than just matching patterns blindly.

Julian Ortiz
Julian Ortiz

Let's merge GTK into SystemD and then merge SystemD into the kernel!
<that's not good enough
LET'S MERGE ALL OF GNU INTO THE KERNEL, THAT WILL FIX THE PROBLEM

Lucas Anderson
Lucas Anderson

LET'S MERGE ALL OF GNU INTO THE KERNEL
Who are you quoting?

Xavier Gray
Xavier Gray

consider the ramifactions of your suggestions instead of just spewing complaints blindly

Aiden Cook
Aiden Cook

The operating system should, retard. That "Linux" is a kernel together with a bunch of ducttaped components lacking any design whatsoever is the problem, not an excuse. In that sense alone, systemd actually has the right idea, but of course it's done by Rathead and Poettering, so it's an abomination.

the logical conclusion to your worthless blabbering is that linux should include the entire GNU operating system under one umbrella

Dominic Campbell
Dominic Campbell

I see no rational objections have been raised, just freetard sperging...

Ryder Scott
Ryder Scott

Oh no, the operating system would have an actual design instead of providing ten million crevices for vermin and ten million easily accessible opportunities to fix some minor fault. What will Zig Forums circlejerk about now?

But not in the KERNEL you illiterate mongoloid.

Asher Richardson
Asher Richardson

fortunately it can't, because the majority of GNU is now under the GPLv3, and linux cannot include it unless it switches to the GPLv3, which would displease linus's cianigger and jew overlords.

Kevin Brooks
Kevin Brooks

But not in the KERNEL you illiterate mongoloid.
<Instead of including the entire GNU operating system into the KERNEL, let's include the KERNEL into the entire GNU operating system.
can't because
linux and stallmann aren't fans of eachother.

Joseph Reyes
Joseph Reyes

Admittedly I'm not too deep into license bullshit, but I doubt that. Wouldn't BSD (not ideal but much closer to a designed system than Linux is) have run into the same problem with GCC? They seem to be doing fine.

Alexander Rivera
Alexander Rivera

The fact that all of these components are separate is a core principal. A thing should do one thing and do it well, else it will become a bloated monstrosity and do nothing well, and then you get windows 10, where disgruntled microsoft employees say the source code is such a garbage fire nobody knows what's going on anymore.

GCC is under a separate license specific to GCC
The source code is distributed under the GNU General Public License version 3, with the addition under section 7 of an exception described in the “GCC Runtime Library Exception, version 3.1” as follows (or see the file COPYING.RUNTIME):
gcc.gnu.org/onlinedocs/libstdc /manual/license.html

Alexander Murphy
Alexander Murphy

luckily GNU has a convenient table to answer these questions
gnu.org/licenses/gpl-faq.html#AllCompatibility

The kernel is GPLv2, not LGPL
It can be mixed with only with GPLv2 and LGPLv2, not GPLv3 or LGPLv3.

Hunter Jones
Hunter Jones

consequently the other way around, if GNU wanted to include the kernel in a wider umbrella project, instead of the kernel including GNU

A derivitive work licensed under the GPLv3 cannot include works licensed under the GPLv2 "ONLY" ( this is a thing ).

The kernel is NOT GPLv2 or later, it's GPLv2 ONLY.
kernel.org/doc/html/latest/process/license-rules.html
The Linux Kernel is provided under the terms of the GNU General Public License version 2 only (GPL-2.0)

which means it cannot be included in any GPLv3 derivative work.

Angel James
Angel James

They can be separate entities and still follow the same design. As a very small example that already shows how deep the mismatches run, look at how every goddamn program STILL handles command line arguments differently, even the common ones for stuff like version display and help messages. A more useful example would be a set of common data formats that ALL programs of the OS can understand and exchange, though that might already get first conflicts with the Unix nature of it all because muh files.

GCC is under a separate license specific to GCC
Ah right, I forgot about that. It still seems kinda strange though; how can Linux distros exist if userland and kernel cannot be combined? Clearly there is some way though to be honest I'm not keen on GNU and Linux consolidating nowadays, the damage is done already.

Aiden Bell
Aiden Bell

how can Linux distros exist if userland and kernel cannot be combined
there's no restrictions on them being distributed together, distribution is different from a program actually "using" a library, which is why these distros can combine all this shit together.

it's an interesting point though, is an install script "using" a library? how can an install script install and configure both GPLv2 "only" code and GPLv3 code?
It's obviously not because all distributions do exactly this. Probably because the script isn't actually using any of the software directly, it's only installing it, it never actually runs it, the user does.

Matthew Bennett
Matthew Bennett

A more useful example would be a set of common data formats that ALL programs of the OS can understand and exchange
that's what the glib bloat is trying to do at the code level.

how every goddamn program STILL handles command line arguments differently
i don't know what your talking about every program I run has the same format of positional and optional command line arguments

./program positional_1 positional_2 --optional_1 --optional_2 --optional_3 optional_3_value --optional_4

Ayden Carter
Ayden Carter

What does -v do for all of these? Print the version? Verbose mode? Nothing? Something completely different?
How do you print the help message? --help? -h? -help? What happens when you use the wrong one?
How many of your programs support --? Can they deal with files that start with dashes?
And these are just two extremely common cases.
inb4 just read the manual
I know memorization makes you feel smart, it's what's so appealing about systems like these. But what you are memorizing is how to work with other people's design mistakes, not anything sensible.

Kevin Cooper
Kevin Cooper

they do whatever the fuck the developer wanted them to do?
what are you some kind of argument fascist?

Isaac Garcia
Isaac Garcia

they are all standardized

<ANSI/ISO 9899-1990
5.1.2.2.1 Program startup
A hosted environment need not be provided, but shall conform to the following specifications if present.

"Program startup"

The function called at program startup is named main . The implementation declares no prototype for this function. It can be defined with no parameters:

int main(void) { /*...*/ }

or with two parameters (referred to here as argc and argv , though any names may be used, as they are local to the function in which they are declared):

int main(int argc, char *argv[]) { /*...*/ }

If they are defined, the parameters to the main function shall obey the following constraints:

* The value of argc shall be nonnegative.

* argv[argc] shall be a null pointer.

* If the value of argc is greater than zero, the array members argv[0] through argv[argc-1] inclusive shall contain pointers to strings, which are given implementation-defined values by the host environment prior to program startup. The intent is to supply to the program information determined prior to program startup from elsewhere in the hosted environment. If the host environment is not capable of supplying strings with letters in both upper-case and lower-case, the implementation shall ensure that the strings are received in lower-case.

* If the value of argc is greater than zero, the string pointed to by argv[0] represents the program name ;argv[0][0] shall be the null character if the program name is not available from the host environment. If the value of argc is greater than one, the strings pointed to by argv[1] through argv[argc-1] represent the program parameters .

* The parameters argc and argv and the strings pointed to by the argv array shall be modifiable by the program, and retain their last-stored values between program startup and program termination.

pdf-archive.com/2014/10/02/ansi-iso-9899-1990-1/ansi-iso-9899-1990-1.pdf

are you suggesting they create another standard around your narrow vision of what -v should mean?

Robert Hill
Robert Hill

html version
port70.net/~nsz/c/c89/c89-draft.html

GNU libc
gnu.org/software/libc/manual/html_node/Program-Arguments.html

Michael Rivera
Michael Rivera

(You)

Gavin Young
Gavin Young

Please tell me where you get those wallpapers.
the internet

Hudson Morgan
Hudson Morgan

informing the user of errors in an interactive system is a bad thing
Absolute brainlet

Robert Howard
Robert Howard

If the fact that Linux is merely a kernel and not a comprehensive system really bothers you that much then just use one of the BSDs (this is one of their own arguments for why you should use their OS). You have all the same software, just look at FreshPorts or pkgsrc.
If having to decide whether to use -h or --help (vast majority programs allow you to use both btw) is your biggest problem, then you should use an operating system that comes configured with a nice Fisher Price user interface so it's easier for that peanut you call a brain to handle. -h and --help exist so you know whether or not -v is for version or verbose; additionally, there are these things call man pages that would give you that answer immediately without any trial and error.
Very helpful. Thank you for your contribution.

Colton White
Colton White

Did you just have to vent at someone or why are you telling me things I brought up myself?

Andrew Ross
Andrew Ross

He wants an input-blocking pop-up window to appear in front of whatever he's doing whenever something breaks

How many times have you seen a normalfag using a computer hover their mouse pointer around a button and then move it very slowly onto that button before clicking it?

Let's just merge KDE and LibreOffice into the kernel and be done with it
Maybe macOS is more your speed, if you care so much about muh unified user experience.

Nolan Rogers
Nolan Rogers

into the kernel
I swear to god analphabetism runs rampant on Zig Forums.

Cooper Gutierrez
Cooper Gutierrez

Forget normalfags I've seen keyboard memers who don't know about search in graphical file explorers.

Camden Morgan
Camden Morgan

You know what I mean.

Julian Martinez
Julian Martinez

retarded quote of something nobody said
hurr durr go to apple then
I legitimately don't.

Kayden Long
Kayden Long

If you're looking for an environment where a central committee decides that there should be one accepted way for the operating system to function with a level of control to the point that they dictate a GUI system and all software developers for that environment must comply to that design, you have two choices:
try to start your own
go to apple/microsoft

Jack Green
Jack Green

It could be an option you turn on or off. Stop the excuses.

Charles Martinez
Charles Martinez

There is an option, make it yourself. If you can't I'm sure one of the thousands of distros out there have implemented exactly what you want.
muh repositories

William Myers
William Myers

That is pathetic. This is not even a Linux or UNIX issue, it's a matter of designing according to different models of liberty. OS intervention in some issues diminishes programs potential flexibility, and many people when designing their program will prefer to have to work an extra mile to implement some things, should their program need it, than be limited so that something that is not relevant for them can be applied universally. Other people won't, and that is why we have different OSes out there, and some of them are open source so you can adjust them to your needs if you want.
Your point is simply like saying, why should a citizen be able to do X and Y, of the government can do it for them?
And, well, we have a bunch of people who freak out if the government intervenes too strongly on their lives, while others think a lax, liberal society is flawed, undisciplined and decadent. That is why we have different ideologies and different countries on earth where you can move to so they will fit your necessities better.
So the point is quite simply, if you want to work amd get stuff done, you have many tools around you, choose what works best for you. If you prefer to just spend eternity in a loop of trying to prove your preferences are objectively better than everyone else's because it helps you kill time, or feeds your vanity, then, sure, you can do that as well.

Ryder Clark
Ryder Clark

<b-b-b-b-but what if people want their operating system to be shit
<checkmate UNIX haters

Zachary Scott
Zachary Scott

That is not an UNIX issue, as I stated. Those are simply design choices, and there is no objective beter or worse, sonce good arguments can be made for both choices, freedom or top-down control are both valuable, depensing on use-case. Just make your choice and stop winning.

Jacob Gonzalez
Jacob Gonzalez

Judging from the responses in this thread Linux fanboys actually do seem to like their OS being a mess.

Tyler Hernandez
Tyler Hernandez

Cry moar winfag. How about you run you try and run your software from the terminal and monitor errors that way?

Jaxon Murphy
Jaxon Murphy

OP here. I do use Linux and haven't Windows for 12 years except on other people's computers. Doesn't mean I can't notice the flaws because I'm not a damn fanboy / freetard. Sure I can run everything from the terminal - doesn't mean that it's optimal!

Leo Cruz
Leo Cruz

You probably don't want to dump standard error (not standard output like every unix illiterate keeps saying) to dialog boxes - they are verbose debugging messages, and would essentially be graphical spam if you had to okay each one.

You probably want a concise single description of why the software failed - the vast majority of the time, that falls on the developer of the software to do and there are different ways to do it. Textmode software shouldn't be linked with GUI libraries and should give textmode errors. GUI software could give dialog boxes , and sometimes does, or could write some kind of log. Right now, many applications, across EVERY SINGLE PLATFORM, don't have good error handling. A huge portion of my job in IT is figuring out why windows apps crash without leaving any kind of user visible error. Unfortunately, Windows Applications generally don't have verbose standard error like linux apps, and there error messages are far more cryptic - often only undocumented numbers for most proprietary software.

When it isn't the applications fault, (IE. wrong binary format, missing libraries , ...) you could have graphical launcher your using provide error messages.

If these are features you want, you can implement them, or request them. Go file bug reports or review and add the code yourself.

Error handling sucks everywhere unfortunately, but I use linux for the freedom, not error handling superiority - which I'd still say it has anyway.

Hunter Flores
Hunter Flores

Yeah, dumping the whole terminal inside a dialog box obviously isn't smart. But SOMETHING has to be fucking done.

Bentley Jenkins
Bentley Jenkins

Trying to use windows file explorer content search option

Searches for a while and then closes the window

Check event log

Error id 1000, file explorer has crashed.

Final solution to Downdowsers and NPClosers who literally believe the quality of GUI programs is any better than laughably bad.

John Rogers
John Rogers

If you think there is a problem, write an application monitor for your launcher - for bash its as simple as returning keeping the exit code of the program in the prompt. For a graphical environment you could write a complex loader that uses waitpid(), and monitors stderror, and dmesg. Or, use software that doesn't suck. If the error handling on your program is unacceptable fix it , or file a bug report with the project. Unlike quickbooks, you have a voice in the development of open source software.

From my perspective, it hasn't been worth it. I am normally not intrested in debug output of my graphical programs, and if I am, I will run in terminal. 99.9.. % of the time they just work. The one time they don't I will open terminal and observe the problem. If its worth it to you , things can be done.

As a heads up , some linux distributions like Fedora do have mechanisms to detect and report segfaults graphically (were an application would be unable to do its own error handling) - I emphatically do not want this "SEND | DONT SEND" functionality on my computer.

Joseph Moore
Joseph Moore

top fedora

this.
OP is a lazy and a faggot at that.

but aren't most *BSD people fans of LLVM/Clang because of the license?

Samuel Foster
Samuel Foster

From my perspective, it hasn't been worth it. I am normally not intrested in debug output of my graphical programs, and if I am, I will run in terminal. 99.9.. % of the time they just work. The one time they don't I will open terminal and observe the problem. If its worth it to you , things can be done.

Also, let me mention that terminal output often isn't very useful. In fact sometimes it can misdirect you. So dialog boxes with actual information would be great.

If the error handling on your program is unacceptable fix it , or file a bug report with the project. Unlike quickbooks, you have a voice in the development of open source software.

If I tried to do that for all the software I use I'd have no time to take a shit. Devs should take care of their own turf.

Camden Long
Camden Long

They still used (or still use?) GCC for a long time.

Parker Morgan
Parker Morgan

Well fuck the world i guess man. Your not willing to file a bug report or fix yourself, your not willing to use better software. Everyone sucks as a dev, but your better, you just don't want to do anything about it. You'd rather complain about it on 8ch. Got it.

Anthony Gray
Anthony Gray

Hey, it's a discussion thread. I do file bug reports sometimes but I'm not the world police. And I don't dev so I get that it's hard work. But they can be criticized! Especially if Linux aspires to be a Windows replacement.

Christian Nelson
Christian Nelson

OP, Linux will never be good because it's based on the Unix philosophy, a retarded way to think of modern end-user computing.

Focus your energy on Haiku, ReactOS or any other alternative OS. At least those have the potential of becoming good some day.

Adrian Ward
Adrian Ward

Set up a terminal in the corner of your screen and pipe STDERR there. Problem solved, faggot.

Leo Green
Leo Green

The fundamental problem is in how UNIX handles errors. In UNIX, an error message is dumped onto stderr as text. There are huge problems with this approach. The first one is that there is no way to correct the error, so the program usually terminates or does something you don't want. The second one (which is pervasive throughout UNIX) is that error messages are not allowed to change because idiots "grep" for text instead of checking for error codes (usually because there aren't any). That leads to other problems like not being allowed to improve (or localize) error messages, so UNIX says bullshit like "not a typewriter" instead of something that actually makes sense. This mentality of having programs parse and interpret text meant for humans is one of the core reasons UNIX and pipes suck.

Instead of this brain damaged bullshit, some languages like PL/I and Common Lisp have a error handling mechanism called conditions. Instead of unwinding the stack (or worse, killing the program), the handler gives you the opportunity to fix the problem and try again. This works for out of memory and end of file too, and it's mostly transparent to the program. When there is an unhandled condition, it runs an outermost handler set up by the OS or language runtime while keeping the original context that caused the error, which can display an error message, log the error, enter a debugger, or signal it to the user in the most appropriate way for the user's UI. What makes this powerful is that Lisps and some mainframe operating systems use this same system for all errors, including compiler errors and warnings and I/O errors.

The programmers at BBN were generally the exception. Most Unix pro-
grammers don’t fix bugs: most don’t have source code. Those with the
code know that fixing bugs won’t help. That’s why when most Unix pro-
grammers encounter a bug, they simply program around it.

It’s a sad state of affairs: if one is going to solve a problem, why not solve
it once and for all instead of for a single case that will have to repeated for
each new program ad infinitum? Perhaps early Unix programmers were
closet metaphysicians that believed in Nietzche’s doctrine of Eternal
Recurrence.

There are two schools of debugging thought. One is the “debugger as phy-
sician” school, which was popularized in early ITS and Lisp systems. In
these environments, the debugger is always present in the running program
and when the program crashes, the debugger/physician can diagnose the
problem and make the program well again.

Unix follows the older “debugging as autopsy” model. In Unix, a broken
program dies, leaving a core file, that is like a dead body in more ways than
one. A Unix debugger then comes along and determines the cause of death.
Interestingly enough, Unix programs tend to die from curable diseases,
accidents, and negligence, just as people do.

Jaxson Edwards
Jaxson Edwards

Fun fact: You can actually make your DE print GUI messages when an app fails. Just make its launcher launch every app in a way that it pipes its stderr to zenity. That's all. And you can do it in a single line of bash.

Isaac Thompson
Isaac Thompson

Why the fuck do you want that you retard? I bet you use Reddit and Facebook.

David Johnson
David Johnson

OP asks why Unix programs don't display graphical errors by default
The fundamental problem is...
proceed to ramble about unrelated error handling shit and forget OP's question entirely
Someone's getting senile.

Ryder Sullivan
Ryder Sullivan

how error handling is done on the OS is unrelated to how error handling is done by programmers
Someone's getting senile alright.

Isaiah Rivera
Isaiah Rivera

OP asked why Unix doesn't display error messages in dialogue boxes, which it can (see ). This has nothing to do with the Unix hater's bitching about Unix not using error codes or conditions, which aren't inherently friendlier to dialogue boxes than the current solution.
Personally, like says I prefer having verbose debugging messages in the terminal to short popups or questionably helpful error codes. Conditions sound neat so I guess that's another excuse to fuck around with Common Lisp.

Jaxson Cox
Jaxson Cox

The Windows way of doing it is really fucked. I prefer semi-verbose terminal error messages instead of the usual "error codes". I get why they might exist, but having that as the sole output is one of the worse things that's happened to design. I'm with on this one. It doesn't promote troubleshooting or provide any advice, even in a brief form. It just promotes the "Jewgle the error code" mentality, where you're solely reliant on big daddy microsoft to solve your problem. No free thought, just copypaste the pretty numbers, goy!

Carson Evans
Carson Evans

conditions, which aren't inherently friendlier to dialogue boxes than the current solution.
Conditions sound neat
They are neat, but more importantly, why are you declaring shit about things you admittedly haven't used?

David Robinson
David Robinson

Part of 's rationale for error codes is that you can can swap them out for better error messages. Why not spit out that better error message in the first place? Because Unix's plaintext fetish sucks™.
read someone's post
respond to it
how dare you talk about something you've never used
So if someone describes a fetish or sex act to me, I can't call it shit unless I try it myself?

Attached: 1437029873422.jpg (39.06 KB, 540x801)

Samuel Gonzalez
Samuel Gonzalez

what's wrong with authoritatively speaking on things you admit you have no idea about
I realize I'm on Zig Forums, but holy fucking shit this has to be a troll question.

Bentley Lopez
Bentley Lopez

Though I suppose compared to the other idiots on this board you are at least honest about it.

Jose Scott
Jose Scott

(nice Hitler digits)
what's wrong with authoritatively speaking on things you admit you have no idea about
I can make an educated guess based off his description, faggot. The rest of his post wasn't relevant to OP's specific complaint and neither was his description of conditions, so it was a fairly safe assumption.
Could you have error dialogue boxes with conditions? From what he's described, sure, but the same goes for every other technique he mentioned in his soapbox post, including the ones he doesn't like.

Leo Morales
Leo Morales

Attached: youmad.gif (981.2 KB, 290x218)

Connor Bailey
Connor Bailey

This. When you have a programmer at your terminal, and an interpreted language, dumping the user to terminal to fix the problem is possible. When you have a real systems language and a normal user at the terminal, debugging isn't a benefit - a error message explaining what library is missing, or etc is far more helpful than dumping the user at a debugger because open returned ENOENT. As far as error handling for a user goes, dumping to a debugger is actually far more confusing than no error message or CLI only error messages.

Grayson Reyes
Grayson Reyes

Plain text is actually a cool idea and everything as a flat file was a revolution idea, and when taken further in 9P resulted in being able to create VPNs with standard unix tools like ln . Everything as a file is actually an interested idea that has real world trade offs including machine parseability and standardized interfaces vs human readability , debuging, and composability

People have suggested using XML, or JSON as replacements to plain text but so far XML has sucked.

Obviously in the real world there are trade offs. But everything as a file and plaintext have resulted in a usable, flexible, and interesting operating system. I am open to alternatives. So far The Unix Way has been awesome and incredibly productive.

Colton Lopez
Colton Lopez

The Unix Way is good. It's a shame it doesn't typically get applied to the kernel though. Perhaps something like >>1041246 will change that.

Jackson Collins
Jackson Collins

This is actually a good point. Usually I've always thought debugging was only after programs had shitted out, since when a program fucks up its naturally assumed you terminate afterwards. How do you fix problems in an already running program? Especially when that program is compiled?

Jayden Morris
Jayden Morris

everything is a file
lol
the unix way
lmao

Michael Nelson
Michael Nelson

Linux is a kernel.
When will you learn?

Bentley Robinson
Bentley Robinson

You redefine the offending parts at runtime and retry the failed section. From what point you can reasonably retry depends on the program, obviously.
Especially when that program is compiled?
Think of compilation as a cache. Alternatively/Additionally, you can have the compiler available at runtime. The latter is extremely common in Lisps because despite the initial barf reflex (which likely comes from the utter uselessness of (this construction in) other languages) the compiler is very useful to have around.

Adam Evans
Adam Evans

error codes or conditions, which aren't inherently friendlier to dialogue boxes than the current solution
Of course they're friendlier to dialog boxes because the OS knows what the error is, how to present it, and can actually give the user a chance to control what happens. The UNIX way dumps some text on stderr, if you're lucky. Conditions produce a standard mechanism for error handling and recovery. Common Lisp gives you a list of actions you can take (restarts) and the OS could show that graphically and if it's a file name it could open a file chooser dialog box, or if it's a wrong string it could give a text box to edit it. The nice thing is that this separates the cause of the error from handling it, so anyone can do this. You don't have to wait for the OS. It's like the difference between a debugger and UNIX's printf "debugging" (which was never good because even in the 60s you could set breakpoints and print the values of variables).

Plain text is actually a cool idea and everything as a flat file was a revolution idea
Computers had plain text and flat files long before UNIX and used text for configuration too. Even the so-called "revolutionary" idea of UNIX, getting rid of any files that weren't sequences of bytes, was just a limitation of some other minicomputer operating systems of the era. The only difference is that the shills claimed that the OS not doing as much and making everyone reinvent wheels was a good thing, just like they did with the lack of dynamic linking and the other huge flaws. Most of the "genius" of UNIX was being able to shill an inferior version of what computers already did to people who never used computers (or only used DOS or CP/M and believed it when weenies blamed UNIX flaws on multitasking, multiuser, or virtual memory).

People have suggested using XML, or JSON as replacements to plain text but so far XML has sucked.
This is your brain on UNIX. XML and JSON are plain text.

I am open to alternatives. So far The Unix Way has been awesome and incredibly productive.
UNIX wastes an enormous amount of time on parsing and piping text from one program to another. On a better OS, none of that would even exist. Your idea of productive is wasting time on bullshit that shouldn't be necessary.

No, no, no, you don't understand the elegant simplicity
of Unix error mes- sages. Remember: The map is not the
territory. No translation is ever completely accurate.
The text doesn't MEAN anything, it simply IS.

A truely elegant Unix would eschew the use of
English-like phrases in its error messages - they just
confuse the issue. If your error message had been
just, say, "+2C)", you would have been equally
enlightened, and could have grep'ed just as easily -
but much more quickly.

Gee, I thought the politically correct error message was
just the same as the success message: null. Think of the
advantages. No pesky man page to update, or have users
complain about. When it gets piped into the middle of you
text file, your file no longer has "%%swap space exhaused"
spliced into it. It does make it a tad more difficult to
grep for the error in the sources, but hey, that's a small
price to pay for making the elegant pipe mechanisms robust
and bullet-proof.

Lincoln Watson
Lincoln Watson

Attached: b91afe13fc7e1b79898b1f65a12b4d23a25d5083ec0410185ff563fdf8ce8a87.jpeg (157.34 KB, 625x625)
Attached: index.png (6.46 KB, 225x225)

Noah Bailey
Noah Bailey

This is your brain on UNIX. XML and JSON are plain text.
This is your brain on Lisp/Multics. XML and JSON are not plain text. See pic related.
"XML combines the efficiency of text files with the readability of binary files"

Attached: xml-ascent.png (11.65 KB, 836x574)

Cooper King
Cooper King

Of course they're friendlier to dialog boxes because the OS knows what the error is, how to present it, and can actually give the user a chance to control what happens
But does the OS need to know what the error is? Does it really have to check an error code against some internal list of known errors just to display a fucking dialogue box? It's not like the application can directly spit out text to a standard location or anything.
Conditions make some sense if you can send the user to a debugger. Error codes, on the other hand, are "here's a file picker!" babby mode at best and outright inferior to stderror plaintext at worst.
He's talking about the character encoding, not the markup language.

Henry Reed
Henry Reed

Except literally nobody was talking about character encodings here. He's the one that brought it up and intentionally misread the conversation in order to get his big 'Unixtards BTFO' moment, despite the fact that it doesn't actually hold up when you think about it for 2 seconds.

Jose Howard
Jose Howard

XML and JSON are not plain text
They are text though, which is the point he was trying to hammer. The problem is that if you are working with XML or JSON you have to constantly serialize and deserialize your data when communicating with other programs. Instead you should be able to just pass the data directly skipping this double serialization phase.

Joshua Richardson
Joshua Richardson

So if someone describes a fetish or sex act to me, I can't call it shit unless I try it myself?
Don't knock it till you try it.

John Smith
John Smith

What do you expect to do with plaintext... not parse it? not spit it out in a consistent format?

Deserializing is just reading it, serialization is just putting it out. Do you really believe that wc -l | grep | process.sh is just directly moving the data..? How do you think each program manages to spit out different formats?

There's no such thing as "passing the data directly"; all program interop requires some kind of de/serialization format; plaintext is just one of those (and it's only notable aspects are that its not well-defined, and it's sometimes more readable). UNIX tooling is only special in that, since the format is extremely underspecified, it comes with a lot of tools for massaging the data into a more manageable format (and the core tooling tend to be more maleable/less dependent on specific format requirements, eg grep and wc are only reliant on newlines/EOF).

The issue with XML is that your data transmission ends up being 10X the size of the data itself, and JSON is more resource-friendly... but has a weak specification (eg lacking many useful types, and even has ambiguities), and only enforces the syntax but nothing for the schema.

Evan Murphy
Evan Murphy

What do you expect to do with plaintext... not parse it?
Duh. Consider this broken JSON parser from i3blocks:
void json_parse(const char *json, const char *name, int *start, int *len){
char *here = strstr(json, name);
*start = *len = 0;
if (!here) return;
here += strlen(name) + 2;
*start = here - json;
if (*here == '"') { /* string */
here++;
while (*here++ != '"')
*len += 1;
} else /* number */
while (isdigit(*here++)) *len += 1;
}

github.com/vivien/i3blocks/blob/9e8e313d252e5000d6bebb59fbaaff506bcb0408/json.c#L106
it's better now, don't worry
For plaintext parsing, something to this effect would be perfectly valid. For JSON it's fucking retarded.

Leo Allen
Leo Allen

The entire point of the unix way etc. being a joke is that you would never ever write a program where each function parsed text, turned it into some data structure and then turned that back into text for the next function.
Can you even imagine how dumb that would be?

Dylan Cooper
Dylan Cooper

:( Something Happened

John Carter
John Carter

XML literally is plain text designed to be written with an ordinary keyboard. Saying it's not easy to read doesn't make it not plain text. It was actually meant to be a format for documents in the vein of SGML, but UNIX weenies promoted it as a replacement for binary data storage because they want everything to be plain text.

en.wikipedia.org/wiki/XML
Extensible Markup Language (XML) is a markup language that defines a set of rules for encoding documents in a format that is both human-readable and machine-readable. The W3C's XML 1.0 Specification[2] and several other related specifications[3]—all of them free open standards—define XML.[4]

But does the OS need to know what the error is? Does it really have to check an error code against some internal list of known errors just to display a fucking dialogue box?
It gets that information from restarts provided by the program. This explains how it works.

cs.cmu.edu/Groups/AI/util/html/cltl/clm/node315.html

It's not like the application can directly spit out text to a standard location or anything.
You can do that in Lisp too, but that's the "debugging as autopsy" mindset. Many times an error can be corrected by a caller and is never even seen by the user. That's the whole point of having scoped condition handlers. Printing text doesn't do the same thing at all. If you used assembly and interrupt handlers, you would understand conditions right away, but the new generation of UNIX weenies is being taught C as the "low level" language and have trouble understanding them. UNIX brain damage not only leads to vastly inferior software, it also makes fundamental computing principles harder to understand.

Error codes, on the other hand, are "here's a file picker!" babby mode at best and outright inferior to stderror plaintext at worst.
How is the ability to correct an error and continue "outright inferior" to dumping text on a virtual printer or tape drive? Dumping text doesn't fix anything.

What do you expect to do with plaintext... not parse it? not spit it out in a consistent format?
Why are you so focused on parsing text. Text is for people to read. If GUIs worked the same way as text on UNIX, you would be OCRing screenshots so you can control a program that moves the mouse with a virtual mouse driver.

Do you really believe that wc -l | grep | process.sh is just directly moving the data..? How do you think each program manages to spit out different formats?
Pipes are UNIX brain damage and a shitty and tremendously inefficient way to do IPC. What really sucks is that shell scripts probably have 1000% overhead or more in context switching, forking (a really slow and stupid way to start processes), and parsing and printing text, but weenies refuse to check array bounds because it's "too slow." Shell scripts make Python and Perl look fast.

There's no such thing as "passing the data directly"; all program interop requires some kind of de/serialization format;
That's factually wrong. Again, UNIX wastes an enormous amount of time on parsing and piping text from one program to another. On a better OS, none of that would even exist.

multicians.org/multics-vm.html
The fundamental advantage of direct addressability is that information copying is no longer mandatory. Since all instructions and data items in the system are processor-addressable, duplication of procedures and data is unnecessary. This means, for example, that core images of programs need not be prepared by loading and binding together copies of procedures before execution; instead, the original procedures may be used directly in a computation. Also, partial copies of data files need not be read, via requests to an I/O system, into core buffers for subsequent use and then returned, by means of another I/O request, to their original locations; instead the central processor executing a computation can directly address just those required data items in the original version of the file. This kind of access to information promises a very attractive reduction in program complexity for the programmer.

UNIX tooling is only special in that, since the format is extremely underspecified
That used to be considered a bad thing. When you use "ls" the computer has no way of knowing what a file name is or that these characters are a number that makes up a file size.

That's the essence of why UNIX sucks.

> Yep, Unix can sure handle text. It can also handle
> text. Oh, by the way, did I mention that Unix is good at
> handling text.


Text ... text ... oh yeah ... you mean VI, right?

David Hall
David Hall

How is the ability to correct an error and continue "outright inferior" to dumping text on a virtual printer or tape drive? Dumping text doesn't fix anything.
missing the "at worst" part
Take a look at Windows' absolutely brain-dead, worst of both worlds approach to error codes sometime. The faggots thought sending error codes not to the OS, but to the user was a brilliant idea, so instead of getting what could be a stderror-style message you have to search a random jumble of letters and numbers on the internet and hope there's some decent documentation on this shit. When you bring up error codes, most people will assume you're talking about this faggotry (which you'll no doubt blame on Unix too) and dismiss your post altogether.

Christopher Morris
Christopher Morris

Why?

That IS what happens on Linux.

Brandon Powell
Brandon Powell

GUI on Linux is mostly a hack, not really meant to be there

Justin Wright
Justin Wright

Tell that to all the *buntu users...

Cooper Roberts
Cooper Roberts

GUI on DOS is mostly a hack and not meant to be there
GUI on *BSD is mostly a hack and not meant to be there
GUI on NT is mostly a hack and not meant to be there

Xavier Jackson
Xavier Jackson

1. Use strace
2. Find GitHub of your software package, and berrate them for not including error messages, and include your strace log
3. Kill yourself

Christian Barnes
Christian Barnes

windows did X badly so X is shit
Literally half of this thread. Are you people really this retarded or are you merely pretending?

Jack Anderson
Jack Anderson

<eyes on animals are mostly a hack, not really meant to be there

Jordan Hall
Jordan Hall

HAPAS ARE SUPERIOR TO WHITES