Fundamental to most peoples complaints about desktop Linux applications is the lack of look and feel cohesion across all permutations of distro, desktop, and toolkit.

Wine applications using the Windows APIs look like complete garbage and fit in nowhere. The same would be true of OSX Cocoa apps - they wouldn't mesh well at all, and it would be practically impossible to skin them with toolkit theming.

That, and recent efforts by Gnome and KDE have been producing tons of good new applications with modern GUI. They just aren't all the applications yet.

That isn't true at all. I spend all day in a handful of applications and good aesthetics make my day much more enjoyable.

I don't think that's what the person was saying that I responded to or he wouldn't have made the condescending remark about people using a pro machine to use Outlook and Facebook.

In comparison, Mac apps will look and feel different from Linux or Windows apps, and QT and GTK+ apps will look and feel different from one another or the other two.

Switching between apps, even with heavily customized UI/UX, is consistent on a given platform, and that's what's important. Taking that away will just frustrate users and complicate things overmuch.

People find it easier to use apps that have a familiar look and feel. That means less training, less troubleshooting, lower operating costs.

Anyone capable of navigating their way in Outlook can probably navigate their way in Apple's Mail or Thunderbird or Evolution. Anyone familiar with LibreOffice can do the basic stuff in Numbers in minutes.

Now, if you want a Notepad user to become proficient in Vi, that's a whole different story. Gedit, OTOH, is pretty easy.

Mental context switching is just like high CPU system time, with the same results. I/O is slower, user time processing is slower and much less gets done.

Setting aside the purely utilitarian aspect of being required to use a piece of software to do a task or as part of a job, consistency increases efficiency by reducing the amount of time spent understanding the deviations from expectation in the user interface.

There's been a great deal written about how attractive things work better. It isn't crap and it does matter.

Now I need to find language to complement someone without it sounding like OO programming style.

HN, may I please have a simple +1 or upvote button? Needs to be usable on my smallish screen too.

When all software is designed to be consumed by other computers then we can ignore those emotional reactions, for as long as software is consumed by animals it is going to be a vitally important factor.

Would you marry an ugly woman? An ugly man?

I may think a terminal window is beautiful - if I do then I will choose a terminal.

What I won't do is purposefully use user-hostile/ugly software on principle - if there is a better choice I will choose the better choice.

Beautiful software, looks good, is intuitive, doesn't complain and complements the user. Hence software is different from art.

    The "professional" market doesn't care about visual cohesion.

[1] https://www.sketchapp.com

Unless your senior exec is carrying around his Mac Pro from his desk. That's a nice piece of hardware--without even needing USB-C and new dongles.

[1] http://openshot.org/

Like: the VSE viewer and the Image viewer are similar but distinct; that can be confusing. And OpenGL acceleration on a Scene strip shows a 3D model rendition that is not (in general) the same as the rendered output of the Scene.

If you want to get fancy with the compositor + VSE, again there are just a couple of quirks but the learning curve is merely steep, not long.

The open source alternatives are no where near as fast, they lag far behind supporting new cameras, their interfaces are ugly and difficult to use, etc.

There is a clearlooks theme that makes things quite a bit more bareable.

Ubuntu or a desktop that only uses Plasma apps may fit the bill. Plasma looks great but has a limited ecosystem. Ubuntu looks ok, but has a wider ecosystem.

What's most amusing to me is that I spend a considerable amount of time with Homebrew and others trying to make my MBP more Linux-like besides running Linux under Parallels. Getting Mac GUI binaries to run on [insert god-like desktop of your choice] would be very nice for the required closed course apps I must use. Developing for iOS (because I must) in Linux would be great. Otherwise, this feels like a step backwards.

-Mr. Fully Open Source Software

Unfortunately that seems to scare people away so everyone hacks GUIs together to keep them from running and that's how we got to where we are now.

Englebart? Sutherland? Kay? Idiots! Fifty years of academic and industrial research into Human Computer Interaction? Arrant nonsense. Let's blow it all off and do your thing. What could possibly go wrong? [0]

[0] http://gandre.ws/blog/blog/2015/04/07/why-the-command-line-i...

I like text interfaces as much as the next nerd, but most people want to interact with a computer intuitively: see a thing and interact with that thing.

In other words, "point and click". (Or just "point" if it's a touchscreen.)

My 2 year old doesn't know the first thing about computers, but he'll jab his finger at the screen when he sees something he likes.

'Open folder', 'show contents', 'see items', why does 'ls' make more sense? It certainly has nothing to do with literacy.

Not really. CLIs can be terribly inconsistent look and feel, even within the same tool (see git), which makes their lack of discoverability even more painful.

Most of "cocoa" came from the OPENSTEP specification, and GNUstep offers quite a complete implementation.

But now, it seems webified apps are king. The handful of native apps that people use are already satisfactorily implementable on Linux. In fact, a great number of native apps are being implemented on Linux in spite of the GUI bits not being source compatible with OS X or Windows. The major holdouts (MS Office, Adobe CS) likely have more to do with business reasons that factor much more than porting costs.

Now, if GNUstep were to become a compelling alternative to XCode for developing iOS apps, I could absolutely see that tide lifting the Linux fleet.

The web is the OSS GUI stack with the largest, most diverse, and most active developer community, and with it you get to ride on the coattails of multi-billion dollar companies like Facebook and Google that have significant investments in the web.

I got DDOSed and threatened. I got some of the most insane all-caps slobbering and frothing at the mouth feedback I have ever seen in all my years of interacting with any developer community. You'd think I went into a conservative church and gave a talk about evidence for abortion in the Bible or something.

The vast majority of this came after the article got posted to Reddit /r/linux. Most comments there amounted to "web sucks and JS coders are weenies and next year will be the year of the Linux desktop as soon as we finish the next rewrite of (insert favorite project)." Intelligent criticism is good but the vast majority of the comments I read responded to none of the core points of my post and amounted to not much more than developer community religious bias.

I ended up taking the post down for two reasons:

(1) I got sick of getting DDOSed and it wasn't worth it to me to fight just to get an off the cuff opinion out there. I am not deeply invested in this and have better things to do.

(2) This convinced me that the "desktop Linux" community is toxic in the extreme and should be avoided. This includes avoiding providing any input whatsoever to that community. Also caused me to become a lot less loyal to Linux in general, since it's a community full of people who respond to any opinion differing from their own with absurd amounts of hate and vitriol.

I personally wish we had a first class, broadly adopted Free *nix desktop option with native GUI and the like. I am not necessarily a fan of extending the web to all parts of my computing experience. However, what you described is very much what is happening with Chromebooks--so maybe your normative statements about the Linux desktop just required the implementation and backing by a Google.

That all said, I wouldn't write off desktop Linux along with the caustic communities you've found. I did a career switch to urban planning some years ago now, and what I've discovered is that every community has a majority group of mostly reasonable, mostly disengaged people along with a smaller group of really loud, difficult people. In that sense, Linux user communities feel normal to me.

End result is that they are operating inside an echo chamber of sorts, thinking they just need for sharpen the UX more to make "year of desktop Linux" happen while alienating existing desktop Linux users.

Damn it, Windows is not the leading OS because it has a sharp UX. Microsoft, besides their questionable behavior with OEMs and bundling, leaned over backwards to make sure Windows offered a stable usage environment.

Even with Windows 10 can you run a binary from the early days of Win32, as long as you use a 32-bit install. The reason it is not working on 64-bit is because the CPU modes needed are mutually exclusive.

But hey, that's why I'm in embedded development. That field is still safe for now.

A UI engine is a problem on par with creating a good game engine like Unity. If you don't have a loooooooong list of capabilities and polish your UI is a toy. By the time you extend and build it out enough to make it not a toy you will have re-implemented either Aqua/Cocoa, Microsoft's UI, or the web but yours will be new and nobody will know how to code for it.

Now make it flexible and programmable and extensible enough to be future-proof and battle hardened. Now make it work remotely over the wire with good performance. Now make it fast and efficient. Now make it secure.

The web isn't perfect by any stretch but it's IMHO the best combination of:

- Complete

- Modern

- Battle tested, including security

- Maintained by professionals

- Can be made to look good

- Has a yuuuuge developer community that isn't going anywhere

Qt is the closest other contender but its dev community is less than 1% of the web's. It's also starting to... ahem... look more and more like a web stack. It's still a little lighter and faster than the web but not much, and IMHO that gap is narrowing and will narrow even more. Look into Mozilla Quantum for an example of what's coming. We're going to have aggressively multithreaded GPU-assisted HTML+CSS renderers and web assembly soon.

JS is not my favorite language but it's not bad either for what it is (IMHO) and ES6+ features make it a lot better. It's a very acceptable "BASIC for the 21st century" and is perfectly fine for driving a presentation layer, schlepping data around, and controlling stuff. JS VMs are impressively fast given the difficulty of accelerating the language, and they are not overly heavy. WASM is going to break down this barrier as well by allowing CLANG to target the web as a native platform.

Web renderers are heavy but an OS that embraces the web as its presentation layer across the board could load one instance of all that bloat instead of one instance per app.

(A web browser on this imaginary platform would be a thin wrapper around an iframe.)

You'd have to pay a lot of attention to security. You might have to fork or implement a few added things into a good web engine to make it ready for such a use case, like better security models and resource management models around iframes. But that pales in comparison to the work it would take to re-invent a stack from scratch and reach this level of capability and then to build an entire ecosystem of this size and breadth around that stack. Forget about that unless you have a billion dollars to burn.

Regarding security, it seems like something like Servo on top of a capability system like seL4 or Robigalia could provide a lot of opportunity to enhance the client security of a web application.

Using wasm + WebGL (or whatever's in the pipeline for Vulkan) could make this easy to deploy creative applications.

Add IPFS into this mix, and we'll be able to deploy decentralized applications as easily as central-server applications.

I'd like to see better tooling for building UIs on the web before I could get fully behind this idea, but I agree that the web platform has been BY FAR the most successful GUI framework ever, and I say this as someone who works nearly exclusively on systems programming.

[1]: https://enlightenment.org

...but the embedded world is also being slowly infected with JS, java and people wanting to run interpreters on embedded devices for which they are totally inappropriate.

Oh well.

How is HTTPS even close to X11 protocol? That's like saying a car engine can function as a steering wheel.

BTW /r/linux is not all Linux users.

Qt, GTK, and other desktop techs are "weird" little tiny niche skills to acquire, and since desktop dev in general is lower priority these days they're going to be rare. HTML5+CSS+JS with a stack based on React or Ember will draw tons of dev talent.

For consistent look and feel the environment could standardize on a single set of CSS themes (maybe a fork of bootstrap) and a "recommended" UI toolkit (I'd recommend React). Use of other CSS or other UI toolkits is okay, but if you do you're strongly recommended to hold to the style guidelines.

Those style guidelines could in turn be informed by things like Atom, Visual Studio Code, Slack's desktop app, etc.

On mobile web tech based apps are the ugly step-children compared to native apps. They've had their chance I'm afraid. I understand why they should be ruling the word in theory, but it just never works out in practice.

I have been developing green field native applications in the last three years.

It has been a return to sanity after doing around 4 years web dev.

GTK3 yes, and it been constantly changing between minor versions so that most of the people that liked doing GTK2 themes abandoned doing GTK3 themes.

As for /r/linux, i get the impression that their permanent residents are a mix of gamers and "devops" these days.

Looking back over the decades and recalling my interaction with developers, I ask myself, when did we become an angry mob of anti-intellectual haters? Some of us are as cartoonishly awful as lords and ladies in French Revolution period dramas.

While i agree from a technical POV, i disagree that this can be seen as a good thing.

The Mozilla of recent years is a massive example of the whole "busybody" problem that FOSS is having these days. Too many people with some kind of "social" angle has gotten involved on the management end to tout their own horn.

This then is draining resources and taking focus away from writing good reliable code as they are chasing the latest "social problems" to solve so that said management can add another entry to their resume of causes championed.

I think that GNUstep has actually been around since the mid- or late-90s — but it was never a game changer. I don't know why really (was it 'fully-baked' and 'first-class'?), although for my part I just never found a reason to use it.

If it did, the GNUstep desktop could have gained users (WindowMaker was very popular, me included) and developers would have got interest in it.

That didn't happen.

I'd love to port my favorite OSX apps to linux (ITerm 2, I miss you so much ;_;) but that website makes it almost a point to be as useless as possible.

Also, reading through http://wiki.gnustep.org/index.php/User_Guides , why does it talk about FileSystem Layout. Is GNUStep an OS ? I thought it was just a library. The whole thing feels a bit messy :|.

Pretty much the first thing a desktop environment has to do is establish an abstraction layer for filesystems, so that desktop-enabled applications can have a consistent way to talk about files. Both Gnome and KDE have a VFS layer (GVFS and KIO, respectively).

A good portion of what KIO and GVFS do should be done at a lower level. Instead we get this weird situation where I can "see" a file in KWrite, but I can't see it the shell or in a non-KIO-enabled program.

Interesting, when I'm using Mac and I miss KDE's Konsole, which is superior IMHO.

Which features are you missing from ITerm2?

- Alert when current command finishes running.

- Download files with clics

- Drag-drop files to upload with scp.

- The tmux integration. Being able to use the "native" split instead of tmux splits is cool.

All those are important to me because I'm always ssh'd into a personal box, and they just make the whole terminal experience feel like I'm on my local machine.

Then there's the Marks feature, which is just friggin great, the fact that it supports a bunch of pretty useful escape codes (and they're even documented[0]), and lots of useful (but minor) features like the Caputred Output[2] that just make the whole experience pleasant.

Nowadays I'm just using i3 with urxvt. I'm hoping that one day, I'll have the time to write a tmux integration using i3's IPC, which would bring me 75% where I want.

[0]: https://www.iterm2.com/documentation-escape-codes.html

[1]: https://www.iterm2.com/documentation-shell-integration.html

[2]: https://www.iterm2.com/documentation-captured-output.html

It's kinda odd that the best terminal app is on OSX but not in linux :(. iterm is one reason I am postponing switching to linux from osx for my work laptop.

I predict this won't ever happen. Whether fairly or not, Qt has a reputation for not feeling native, and this is extremely difficult to shake. And with Swift becoming the language of choice for Mac development, the use of C++ (not even standard C++: C++ with the moc preprocessor) is becoming more and more of a liability.

http://www.linuxandubuntu.com/home/macbuntu-transform-ubuntu...

Is this a joke, referencing the new MBP releases?

Personally, I've been saying we're there already. I haven't bought a Mac in years. (employers keep giving them to me and I install Ubuntu on them.)