I don't mean to say there is direct cause and effect, but I am pretty sure there is very, very strong correlation: Open Source software generally does not ever really stand out when it comes to Usability or User Experience. If there isn't an already existing commercial thing which has had competition honing it's user interface for the OS folks to copy, then we end up with monstrosities like the original GIMP, or anything related to KDE, or GNOME, or, to wit this evening for me, anything related to trying to stitch up a panoramic photo. (And even when there is something to copy, somehow things get mucked around with enough to make it overall worse, it often seems.)

Of course, whenever anybody attempts to point out all the suck there is some really disturbingly clueless vehement reaction from fan-types claiming that everything is perfectly correct, that everybody should actually want the equivalent of bloody internal guts to vomit out of their computers onto their laps every time they try to Just Get Something Done.

As an erstwhile programmer, I do love me some Open Source! I prefer to run Linux. I pretty much don't trust or really much like the nefariousness or usability of Windows or Mac OS X for use at home, unless it is what I need to get a job done. Not being able to figure out WTF when something is fubar because there's no docs and the thing is closed source is the worst hole to try to dig oneself out of. But my love of FLOSS does not mean I cannot bear witness to the general abomination of i.e. the so-called linux desktops, whichever they are.

Now, I don't want to just complain. I want to know what it is that we as software people can do to make UI and UX something more easy to wrangle. I think fundamentally it is all really hard and so only the people with enough time, which generally means enough money, can ever get around to evolving something that doesn't bare-faced suck. Most of commercial stuff is crap, too! I guess because UI and UX is really bloody hard.

What are the essential complexities of it? Then what are the accidental complexities? I feel like the essential complexities are things like: How much subjectivity there is in usability; The inherent variance in people; The bad training people got using other bad UI memes, getting brainwashed in the process. I feel like the accidental complexities are everything related to software, no matter how wonderful it is purported to be (random e.g. Interface Builder).

Since I am the 2nd type of person, I do not know what the solutions are. I can only point out that we have problems. (The 1st kind of person doesn't see or admit there are problems. The 3rd kind of person can come up with actual possible solutions to experiment with.) So I am doomed to suffer. Ignorance would be blissier.

(The real kicker that tells me humans are frankly idiots when it comes to UI and UX is that even with the much trumpeted and ballyhoo'd touch interface, things! still! suck! C'est de soupirer. Gun in mouth blues.)

I realize I am talking about "first world" problems here...

...but I have to say that I am fundamentally unimpressed with most everything Google does other than maybe Search. Today it is Google Photos / Picasa that is doing its best to create a completely unintelligible, terrible, lame, broken, confusing, slow, uninformative, misleading, random, and all 'round BAD user experience. I literally do not know how somebody could even come up with a plan to actively execute to make things this bad. Nor could simulated annealing find these grossly global minimums in the UX state space. There truly are genius alien PhD's working tirelessly there to invent this pure and utter drivel. BUT HEY, IT'S FREE. (Errr, not! It is called your SOUL, people!)

/venting.

Textbook definition of, "bimodal distribution"? Weird stuff. I guess it is like random psychological conditioning, they want to keep you off guard?! Sorta always giving the monkeys hope their order will be the blessed one.

Godwin's Law #2: "Godwin's rule of Donald Trump analogies."

Software is hard. Really, really hard. You just won't believe how vastly, hugely, mind-bogglingly hard it is. I mean, you may think it's a long way down the road to the chemist -- er, ok, but you know, software is hard.

Unfortunately, part of the reason software is hard is that we, the majority of us, even in software development, do not know how to do it right, or even well. Especially when it comes to the software engineering things that go around the actual core code itself.

Pretty much every software project I have ever worked on or used has been obviously terrible in terms of basic usability, user experience, quality, sanity, cleanliness, etc., pretty much all immediately obvious within the first 10 minutes of using it. (That doesn't mean they are all useless projects. Hopefully far from it. They've paid my bills at least. But that doesn't mean they were great, to me, if they had these other issues. So probably there has never been a great project ever, according to me. Like I said: it is hard.)

And I really do indict myself here, not just everybody else in software. :-) By putting this off-the-cuff list up I hope some folks can think about what tools or processes could be invented or refined in order to nullify them. (On which I have my own thoughts, but you can try doing your own 5 Whys on them.)

• Not having anything better than a somewhat mediocre if not downright bad installation experience (e.g. anything written in C or C++ that I have to try to get to build on my machine).
• Purporting to be 'cross platform' but then instead of actually really solving it or at least admitting where it isn't being solved well, just sort of either rationalizing it or maybe really being unable to even see the suck?
• Not spending enough time to get good quality on The Naming of Things. 
• Not having progress bars or verbose modes or any of the things people need when they are trying to figure out WTF.
• Not doing continuous integration.
• Not having 'sufficient' unit tests.
• Not having somebody dedicated to devops on the project.
• Having a checksum for file downloads, but not saying precisely what kind of checksum it is.
• Not managing versions properly (e.g. ending up with a flood of warnings when people run the build, and then you apparently can't do anything about it until some future release because of some versioning nightmare constraint).
• Using some kind of overly fancy web fu on the documentation, such that it even breaks the freaking back button navigation. Let alone looks and behaves kinda crappy.
• Not presenting a unified one-throat-to-choke front to users who just wanna get their work done, not learn the inner byzantine component architecture of your system.
• Not having great documentation. Like, maybe you have a lot of documentation, but I still can't find the answer to my question, or even know how to find if the answer isn't in the docs.
• Letting documentation drift out of date just to screw the newbies.
• Trying to reinvent something yourself as a component in your system (e.g. event bus) when you could maybe have used something that already exists and has miles on the tires and mindshare and S.O. answers and documentation and etc.
• Trying to use communication mediums that turn up less in web search results, because I guess you want people to ask the same thing ever over instead of just finding the answer via e.g. Google+StackOverflow?
• Not using or passing static checks, for example IntelliJ's"inspections".
• (Using any tool that itself kinda sucks. At least try to pick the one that sucks least. (That is, of course, impossible.))
• (Personal bent: using a language that isn't amenable to static type checking.)

Oh. My. God. Apparently by default out of the box the IntelliJ based AndroidStudio helpfully suggests it can remove curly braces around a one-line-block. "Remove braces from 'for' statement."

"When I work on old code, I spend the most time on lifetime analysis when trying to make changes, followed closely by dataflow propagation which informs the lifetime analysis."