Hacker News new | past | comments | ask | show | jobs | submit login
We Need to Save What Made Linux and FOSS Possible (linuxjournal.com)
386 points by brewski on May 8, 2019 | hide | past | favorite | 252 comments

– We collaborate inside proprietary environments

Why is that? Why have users chosen those environments? Assume they are rational beings, and get at the heart of it. Ask: "How can we address the actual user needs while supporting our goals?"

– Many Linux and FOSS geeks today use Linux only professionally

Same answer as above.

– We're not modeling our values

WHY? (Hint: "the use of nonfree" is not, and has never been a primary human motivator even for many people who "get it".)


Finally, regarding the below... only one of these, the first, even tangentially touches on the user experience. There's an implied expectation of so much FOSS advocacy which reduces to "by writing and using our software, you will be wearing a hairshirt for the cause". This mindset is guaranteed to fail in front of users, who are by and large "non-believers".

     "Having real-time chat is absolutely essential to the advancement of free software."
    "We're the resistance now." "We need to create mass movement."
    "Volunteer to write free and open code, to participate in communities."
    "If you didn't live the history, learn from those who did."
    "If you did learn from history, teach those who need to know it. Respectfully."
    "Be patient. Remember that the tortoise won not only because it was patient, but because it ignored insult, ridicule and dismissal."
    "Model your values. Use free software and hardware."
    "Remember always how 'the rights to copy, share, modify, redistribute and improve software' are fundamental rights that matter to people."
    "Work to convince developers that their software freedom matters."

> Why have users chosen those environments?

Because they don't give a rat's ass about the freedom aspect of free software. If software A requires four clicks to do something, but B has a way to do it in 3, they are on B without a second thought.

But in this case, those users are not just any old end users; the are actually supposed to be FOSS developers, so there is a heavy irony there.

I think what is doing on is that large numbers of people are now "reluctant" FOSS developers. They do FOSS because someone told them to. They got a job somewhere and the job involves writing code that gets upstreamed somewhere and is redistributable. Well, they don't give a damn about that, it's just a job, no different from working on proprietary software. Or they work on some proprietary stuff, but it interacts with and depends on some FOSS pieces so they get in there and make changes out of necessity, and those changes are freely licensed only because they are derived from a work which requires that due to copyright doctrines about derived works.

It's partly a generational thing. Notice how Doc Searls looks about fifty-something. He remembers a grassroots free software movement which was about actually about displacing proprietary software and liberating the user, and not about about providing reliable commodity middleware for locked-down devices and cloud services.

If you were born after 1990, you don't know a world in which Linux and other FOSS wasn't used for making locked-down tech, and proprietary web sites that lock in millions of people and step on their privacy. So of course it's hard to understand someone like Doc Searls.

The free software ideology originated in a world in which you still installed applications locally and ran them on local data, on a machine where you were allowed to stick in a floppy disc with any piece of machine language in its boot sector that could easily take over the machine. The machine that was understood to be owned by you once you paid for it.

> Because they don't give a rat's ass about the freedom aspect of free software. If software A requires four clicks to do something, but B has a way to do it in 3, they are on B without a second thought.

Isn't this kind of the point, though? To compete with proprietary software, free software needs to actually be competitive. "It's not as good as this other (proprietary) software, but it's free" won't cut it.

> "It's not as good as this other (proprietary) software, but it's free" won't cut it.

Except that it has to cut it in order for a free software movement to exist, because otherwise free software is starved by a chicken-and-egg problem where developers don't use free software because it's inferior, and free software never improves because developers don't use it. In other words, being willing to use technically inferior software solely because of the superior freedoms it grants is the way to make the engine of free software run. GCC was not the best C compiler in the world when Linux started using it.

That argument is not holding any water.

First, free software doesn't improve "because developers use it". It improves because developers work on it. Blaming the users for that problem is not helping at all, except with a vague sense of moral superiority.

Second, people use tools (e.g. software) to achieve things. "Making the engine of free software run" is not on that list of things for the vast majority of people, so maybe we should try giving them reasons that actually matter to them.

Third, the reason that GCC was used for Linux was that it was the only one that was widely available, free, and had a 386 backend that produced useful code. Nobody involved gave a bit about "engines of free software" and "superior freedom", it was the only tool to get the job done.

It was certainly not technically inferior at the time.

Fourth, a large part of the reason for commercial software usage is the incredibly sanctimonious community around OSS.

If I can buy a piece of software that does exactly what I need, in a pleasant way, for a small amount of money, potentially even with support that cares about me? Why ON EARTH would I sink tons of time into a craptastic piece of software with horrible UI and an abusive community?

Like it or not, OSS is competing in a marketplace. It doesn't need to win on all axes, but it needs to win on some outside of "free"

The distinction between "developers use this" and "developers work on this" is irrelevant in this context, because to a first approximation no developer volunteers their time to software they do not themselves use or hope to use. If nobody wants to use your software, there is nobody who will take time out to contribute to it.

Secondly, nobody is suggesting that free software should not try to compete on non-philosophical terms. What people are suggesting is that a volunteer project cannot perpetually out-compete a well-funded proprietary competitor. If people care about the continued existence of free software, then they will at times have to console themselves with using software that, while hopefully fit for purpose, is quite possibly not best-in-class.

If you take care of your own interests in a more thoughtful way than "I want what works best and I want it now", Free Software looks much better. Short-term pragmatism can shoot you in the foot long-term. Lock-in and control are very real things.

And long-term zealotry can shoot you in the foot long-term, too.

There are trade-offs. OSS can shift trade-offs on some of the axes, but that's about a cultural change.

It means giving up on the ludicrous idea that GitHub is bad because it "runs proprietary JavaScript executed in our browsers". It means realizing that "writing code" is a tiny part of creating a useful product. It means giving up on the disdain for all things non-engineering. It means welcoming people into the community who "just" want to write documentation, or work on UX, or any number of other things. It means letting go of overblown rhetoric like "we're the resistance now".

Above all, it's about realizing that it's not about "choosing a fight", but creating a better community.

You are really making a lot of negative assumptions here. I happen to work (a little, I used to do more) on a F/OSS project that is all about user interface, and when I have no good idea for a UI, I ask an expert. Disdain for UX?? Please. Maybe you're thinking of that guy, I forget his name, that came up with git. He's very pragmatic about licensing, you'd like him.

(I actually think Linus is a positive figure overall, I just really can't stand git's UI)

I don't understand, though — there are so many cases in which free software dominates because it's better, despite proprietary alternatives from companies with deep pockets.

Most servers run Linux and Apache or nginx. The most popular CMS is WordPress. MySQL, PostgreSQL, SQLite, Redis, and MongoDB are the most popular databases.

On macOS, the most common shell is bash, and most of the commands are free. According to the 2019 Stack Overflow developer survey, two of the three most popular development environments are the open-source Visual Studio Code and Notepad++. The most popular web browser was Firefox for a while, but even Chrome is based on a ton of open-source technologies.

Most people aren't picking these tools because they have some principled stance on free software, they're picking them because they're just plain better.

How many of those products that you mentioned that are free are backed and for all intents and purposes controlled by commercial backers? Would the community maintain any of them to a re al degree if the backing company abandoned then?

Does it matter? If VSCode gets canned, or WordPress gets ruined, why should I, the user using the software to make a blog, give a damn? If VSCode goes there's another one I can switch to. If WordPress goes there's five million other blogging platforms I can switch to. The format that the content (i.e., the configuration, settings, presentation, etc) may all be proprietary, but so what? I have absolutely no allegiance to VSCode, MySQL, whatever. I just use the tool that made the most sense at the time, to accomplish what I wanted to at the time. Times change and if it means I switch tools then so be it. Who cares.


I'm speaking from the perspective of an upper 20something. I'm part of a generation that jumps jobs when the opportunity is better, or just because "it's been too long", not the one of years past where I'd be expected to work my way through the same company my entire life. With that said: if my new job says "we use Slack" then I use Slack, end of story. If they say "we use IRC" then I'd Google for how to use IRC because I have never ever used it in my entire life, never read up anything about it in my entire life, and I definitely don't hold IRC in high reverence like many posters here do. All I can see when I google IRC is that it looks ugly and honestly, that's what's most important to me these days because I have to look at, and interact with, the thing for 8+ hours a day so the least it could do is work out of the box, look modern, and doesn't need me to waste hours fussing with some dotfiles to get it to look the way I want, which is exactly how most modern chatting apps look (again: to me it's a waste of time, when I can just grab a off the shelf solution).

I appreciate that there is open source, and that there are free programs out there. I appreciate all the libraries that make my life easier. But the thing is, these are all tools I use to do a job. I don't care at all about the history of say gcc. All I care is that it works and compiles my programs, and if it does, then so be it. And if it doesn't? There are other options, icc, llvm, etc. My point is that at the end of the day, all I want is a tool to achieve a solution, and who makes that tool, or the history behind that tool, doesn't matter to me at all. It's not even part of the equation.

I, I, I, I, I, all I care, .... that's really the problem that we face.

> Who cares.

When the "new" tool is worse than the "old" tool, i care (and yes, the "new" tool can be worse - and often is - yet displace the "old" one, not because of its quality, but because of external reasons - like the developers of the "old" tool being unable to sustain its development).

> If WordPress goes there's five million other blogging platforms I can switch to.

Have you done a full migration of a grown Wordpress blog to another system, without breaking stuff? It's not something you do on a weekend or two. Changing away from a tool that holds lots of data and configuration is expensive.

Or, regarding his other remark, a migration of hundreds of thousands of lines of code from gcc to something else.

By the way, IRC doesn't look like anything. It's a protocol. It looks like your client software.

Yes it does, because someone has actually to do it and given how much FOSS developers get paid back from the community, we end up having lousy tooling, because it always gets implemented from scratch.

What if you're using a product and its community abandons it? This isn't a unique issue to products with commercial backers.

Free software without a community is a thing; it's perfectly fine, and in fact better off without all the flies buzzing around it.

Proprietary software that is years past its support date, from a company that has not existed in years, yet still in use, is also a thing.

The one kind of entity that dies instantly when its backing goes away is a proprietary website.

Until you want your data.

Turns out data roach motelling is a big thing. And it's even better for the corp interests if they can tie hardware and software to irreplaceable APIs that lock the user down to the whims of the owner.

It's time to take the fight back to "Owner"... If you purchased it, why can't you do what you want? Why are you prevented from doing arbitrary actions?

Case in point, it's surprisingly frustrating to get your photos off of Instagram on mobile.

>> Why have users chosen those environments?

> Because they don't give a rat's ass about the freedom aspect of free software. If software A requires four clicks to do something, but B has a way to do it in 3, they are on B without a second thought.

Convenience always wins. Always. Users do care about free (as in beer) and they care if the product or service will disappear without warning (hello Google!). But the definitions of FOSS are so strict that they harm developers, and thus products, and thus convenience for users.

OP is describing the symptoms of this phenomena.

Traditional free software developers do not use the most convenient program without caring about freedom.

Otherwise, for instance, nobody would be debugging with gdb, rather than Visual Studio or what have you.Nobody would be LaTeXing instead of using MS Word or Adobe Illustrator.

GIMP isn't as good as Photoshop (if I believe what people say), yet people still use it. (I've only ever used GIMP since 1996; I have no idea about Photoshop and don't care; it's not free, won't use it.)

People went through all sorts of inconveniences to use free software, like manually figuring out monitor clock timings to stick into their X configuration, building their own custom kernels and whatnot.

You can't say "convenience wins" with a straight face; that's like saying free software doesn't exist.

>Nobody would be LaTeXing instead of using MS Word or Adobe Illustrator.

Hahaha. Have you tried to write a piece of mathematics in MS Word? I did. It's a torture I wouldn't wish on anyone I know.

Mathematicians are all about convenience; so much so that proprietary LaTeX Editors were quite popular before FOSS caught up (remember WinEdt?).

But LaTeX itself - it's the most convenient tool to write and share mathematics that's ever been made. It's unsurpassed. It's required if you want to publish, because all the journals use LaTeX, and most math books are made with LaTeX.

It's so good that people will literally think you are an idiot if you are not using it[1] and won't believe your results.

And ArXiV, have you heard of ArXiV? No LaTeX, no ArXiV.

And trust me, most mathematicians don't care much about FOSS. But they care about not spending too much effort on making their results presentable and shareable. LaTeX -> PDF is the path of least resistance.


>Otherwise, for instance, nobody would be debugging with gdb, rather than Visual Studio or what have you.

If you're working with embedded Linux, Visual Studio isn't going to be much help for debugging on a target.

>Nobody would be LaTeXing instead of using MS Word or Adobe Illustrator.

LaTeX does some things much better than Word, and Illustrator is very expensive.

>GIMP isn't as good as Photoshop (if I believe what people say), yet people still use it.

GIMP is free. Photoshop is not.

You seem to be assuming the people have unlimited money to purchase software licenses. Many free software programs are used not because they're better, but just because they're free and good enough. If I just want to crop and rescale some photos or something, why on earth would I buy a Photoshop license when I can just download and use GIMP for free?

Many proprietary programs also get used because they are good enough. Not everyone wants to do a simple thing using some UI that has grown into a Boeing 747 cockpit.

Some Windows users use neither GIMP nor Photoshop to crop an image, but rather MS Paint, which is comes with the OS, so it is "no additional cost", and requires next to no training to use.

MS Paint has vastly diminished functionality compared to either GIMP or Photoshop.

Maybe cropping wasn't the best example for me to use, but there are many people who want to do more advanced photo editing than that (which is beyond the capabilities of MS Paint), but do not want to pay $$$ for Photoshop. Those people frequently use GIMP, simply because it's free and it works well enough.

> nobody would be debugging with gdb, rather than Visual Studio

If Visual Studio ran on Linux, would anybody bother with gdb? Currently, the second-highest voted UserVoice issue for Visual Studio is people asking for a Linux version (and rather hilariously not understanding what a colossal rewrite that would entail...)


> Nobody would be LaTeXing instead of using MS Word or Adobe Illustrator.

LaTeX might just be easier than trying to typeset something reliably in Word. I know I always wrote in plain-text and then did a final pass to paste and format it into Word immediately before printing.

> GIMP isn't as good as Photoshop (if I believe what people say), yet people still use it.

Photoshop is stupidly expensive still, and cracking software has fallen out of favor

> second-highest voted UserVoice issue for Visual Studio is people asking for a Linux version

How many of these users are long time free software developers, though, who did free software long before it could just be a reluctant aspect of a job you land into?

Interestingly enough Visual Studio now supports cross platform debugging ( you still need Visual Studio running on windows, but it can debug a linux based program )

A variant called Embedded Visual Studio already supported cross debugging of Windows CE targets twenty years ago. (I was there and used it). Maybe that's not quite cross-platform, but kind of half-way.

I don't think a few of us using Gimp (yes, I am an occassional user) will stand in the way of convenience winning. Hige majority of people do (and will) use Photoshop, simply because it meets their needs better.

GIMP certainly wins on convenience: you just download it, no credit cards or shady torrents.

> it meets their needs better.

That's hardly the case; they are not even aware of the existence of alternatives.

Most of people's occasional image fix-up needs could be met just by MS Paint, which they would find easier to use. Problem is, they don't even know that exists and that they have it pre-installed, let alone that GIMP exists.

A quick Google search for cheap/free Photoshop alternatives will usually get people to GIMP in a couple of clicks. Why are you saying that Photoshop users are unaware of any alternatives? It seems logical to me that anyone in the market for this kind of software would be interested in saving some money before shelling out for PS. Am I wrong?

> For instance, nobody would be debugging with gdb

I mean, I debug with lldb which is free and open. Sure, I do the debugging through the non-free(-as-in-freedom), non-open Xcode, but that's because Xcode lets me harness the power of lldb in a manner that suits me.

There's nothing stopping free and open software projects from being delivered in a user-friendly manner. I'm sure there are plenty of people using gdb and lldb with fully-free and fully-open editors and IDEs.

Sometimes it just takes a mindset adjustment to see that what is most often considered inconvenient, and that followers of free software doctrines must begrudgingly accept as their lot, can actually be delivered in a user-friendly manner that meets the proprietary-software-users' expectations.

It is not about "convenience". It is about "be done with it and get on with my life".

I don't want to use an IDE, I want to debug a Java program. I don't want to use video editor, I want to have a video. I don't want to use 3D redactor, I want a 3D print something.

I can go on forever. The problem with lots of free software folks and linux crowd is fetish of tools. Tools for the sake of tools. I couldn't care less about tools, I want to achieve something, I'll pick up whatever tool that allows me to achieve that quickly and effortlessly. And I'm telling you this as someone who's using linux and writing a bookmark manager for myself in Go right now to pair with menu because all other ways of doing bookmark management suck.

I agree with the sentiments you have expressed. But there is no way around it. People who develop for 'free' will write tools for the sake of tools but few of them will become numpy, latex, docker, Haskell etc.. You are interested in banyan tree, you'll get it if you find the way around the jungle or use a guide.

I just re-read it and I have no idea how I didn't notice my brain burping out Russian word instead of English one.


Separate question why would it do that

> Convenience always wins

Yes, but convenience also leads to greedy "algorithms" prone to getting stuck in local maxima. Convenience can make us lazy and choose the wrong long-term solutions.

This applies to more things than just tech ("convenience" may make us choose foods that are wrong for our health, for example).

> Convenience always wins. Always.

Not at all. There are million examples of human society choosing long term and social benefits over short term and personal rewards.

> Because they don't give a rat's ass about the freedom aspect of free software.

It's attitudes like this that make people really not care about FOSS. Yelling at people because they're not using IRC instead of slack isn't a good way to convince anyone.

When IRC looks like this https://quasseldroid.info/assets/images/phone.png or this https://blog.irccloud.com/static/2018-05-14-slack-integratio... and people still complain about IRC’s UI or usability, then what more can we IRC devs do?

For me the issue with IRC protocol (not that I know much about it outside my interaction with UIs built around it) was authentication, and connectivity.

So I had an android IRC app for a bit, some top paid one, and get booted from a bunch of my favorite channels because apparently it was just sat in my pocket cycling my connection and flooding the channel with join/unjoins.

That, plus the weird way to authenticate doing /msg Nickserv identify. That might be just how the server I was connecting to was implemented, but it felt fucky.

That's more an issue with your connection. Mobile devices have really bad connections. IRC was //never// designed with them in mind; they literally didn't exist and were not likely to exist for decades (which it has been).

IRC was designed, mostly, for two types of users: A) Large institution users who had a fixed link to the internet and ran in their shell on a mainframe. B) Dial-in users, who's devices mostly stayed connected, and when they disconnected, usually required manual intervention to get back on.

Anyone, and I mean ANYONE using a mobile phone SHOULD be using a 'bouncer' or other gateway to access a live communications environment. This would be more like use case A where someone has a small agent on a slice of a server they 'trust' and that maintains state (for their client) and stateful connection (for links to other servers and users).

IIRC, Quassel IRC has such a client/server model for the client, there are probably others too.

I guess that's the thing, though. Yes, mobile users should be using a bouncer — but who's going to set it up for them, who's going to host it for free and in a manner that it has guaranteed next-to-no-downtime?

It occurs to me that if IRC networks hosted their own bouncers, but that these bouncers were written efficiently to exchange data directly with the IRC servers' and their database rather than keep individual logs and so on, we might have something close to the "open-the-app-and-see-past-messages-without-needing-to-be-permanently-connected" quality that people have come to expect from instant messengers, Slack, Discord, etc.

(but then you might as well just write such functionality directly into the IRCd)

(but then you might as well just write such functionality directly into the IRCd)

Nah, such a thing would make most sense as a separate daemon that uses the server-server protocol to connect to the ircd (ie. it appears to the rest of the network as just another ircd).

It wouldn't be hard to build such a thing, the hard part would be convincing an existing IRC network to run it.

> That, plus the weird way to authenticate doing /msg Nickserv identify. That might be just how the server I was connecting to was implemented, but it felt fucky.

That's what SASL has been for for over a decade nowadays :)


Maybe consider the UX that Slack gives users instead of just cloning the UI on top of IRC and expect it to work out?

That's a major part of what I've done recently, trying to significantly reduce complexity, and contribute to clients to make them more discoverable and require less knowledge to fully utilize them.

The goal is to get rid of the historic interfaces which required a lot of RTFM, and instead to allow users to discover functionality through the UI easily.

If you have any suggestions on what to improve regarding UX of Quasseldroid (my main project), I'd love to hear suggestions, as I'm always interested in improving its UX and learning more about UX design. After all, I, as quasseldroid maintainer, am just one student, not a team of highly paid UX designers.

(And personally, I'm a huge fan of tools like Zulip, Mattermost and Matrix as well — we're all fighting on the same side, after all :)

IRC had its problems but I’d still rather be able to control my ui rather than have a bloated web browser running all day.

IRCCloud is okay, but the UX/UI isn't anywhere near as nice as Slack.

Why would you need to use Slack (or IRC) when there is


Probably because the few people who want to use alternatives to Slack are spread among these four alternatives instead of using one and sticking with it.

And honestly, of all the alternatives, IRC is by far the most popular one (and the other alternatives have IRC bridges) hence the most likely to stay around the longest.

Also the simplest to implement, which helps a lot too.

That may be true, but it's good enough that it should be easily usable by developers.

And I'm personally working on Quasseldroid, improving its UI to make it much more usable.

If you have suggestions on how to make Quasseldroid usable for the people that refuse to use IRC, I'd love to hear them :)

> it's good enough that it should be easily usable by developers.

Sure, but the reason all the developers at my workplace use Slack is because we have to communicate with a lot of people who aren't developers.

Slack's good UX extends beyond the basic chat interface to configuration, administration, and initial signup. It's significantly easier for someone nontechnical to toss money at Slack to get a new private space than it is with IRC. The first page of "IRC hosting" search results on Google for me are mostly shell accounts; nothing turnkey and professional looking that a business person could/would use.

I know plenty who use IRCCloud. There is nothing FOSS about it, though.

Neither of those look as good as Slack imho. Regardless, there's a bunch of stuff you can do with Slack that you can't with IRC. Emoji reactions, voice/video/screenshare, easily post files and images... Plus there's a unified experience for all users that's not client dependent, no burdensome technical or protocol jargon, no federated servers (or servers to think about at all)...

I've used IRC quite a bit but Slack is light years beyond in terms of the UX of even the nicest IRC clients. I think Discord is probably even better than Slack though.

"federated servers" is the only way to maintain a form of freedom while (out of necessity) operating software as a service.

If you think that you can't do free software development without relying on all the capabilities of Slack, then the honest thing to do is to quit and spend the rest of your days just working on proprietary stuff. You obviously prefer the solution which has features over any other concern, so why would you waste your time having anything to do with free software?

Richard Stallman obviously used proprietary software. But not past the point when he had replace it, even imperfectly: "I began work on GNU Emacs in September 1984, and in early 1985 it was beginning to be usable. This enabled me to begin using Unix systems to do editing; having no interest in learning to use vi or ed, I had done my editing on other kinds of machines until then." [https://www.gnu.org/philosophy/fsfs/rms-essays.pdf] This tells us that Stallman used Unix. Well, why wouldn't he have; what other practical way was there to code anything? (One supposes he could have started from the bootloader on up, like the Unix guys before him.)

Stallman wouldn't use Unix today, since it has been replaced by free software, and he wouldn't use arguments like, well, such and such proprietary Unix has better memory management or faster I/O, so I will still use that.

If you're using things like Slack or Github without the slightest intent of working toward replacing them, yet using them for free software activities, then that is a comically conflicted position.

Federation has been tried a lot and in the end it always fails, even if it's the best solution. XMMP is pretty much dead regarding free use, IRC for a lot of FOSS project is slowing dying, there were a lot of federated social media projects that simply failed because they couldn't attract anyone.

Being technically the best (or the best in 'freedom') doesn't seem relevant to anyone.

Centralization has never succeeded. Let's see how popular Slack is in 5 years. 10 years. There's no reason to believe it won't go the way of ICQ, AIM, Yahoo Messenger, etc.

IP, TCP, SMTP, HTTP, these are fundamentally technologies of federation. They succeeded and continue to succeed spectacularly. However, with the commercialization of the Internet there are much stronger countercurrents. I still expect federated solutions to succeed, but adoption will be slower and punctuated, and in the interim there'll be countless proprietary also rans.

I suppose you are right from a technology standpoint. I was aiming at the user-facing side of things. There is SMTP and email that is federated and usable by most people, so I suppose there are examples of user-success.

I would guess that he was editing source on ITS or a Lisp Machine before this point.

I think you can see some evidence of what people thought were development machines by the fact that Lisp Machines only seem to have been NFS servers, not NFS clients.

Yeah, I don't think so. I work on other OSS and happily use Slack because it's fun and easy (I used to use IRC). I'm not conflicted at all because I appreciate a good UX. I think it would be totally awesome if more open source developers realized that people will use whatever is better for them which often doesn't mean prioritizing openness over usability or features.

I totally get the value of a non-corporate, non-centralized solution. It just needs to have at least as good of a UX for me to switch back to using it.

You're only narrowly escape being conflicted because you identify as an "OSS" developer rather than a "free software" developer. The term "open source" and its identification was basically crafted to avoid being conflicted this way.


> A pure open source enthusiast, one that is not at all influenced by the ideals of free software, will say, “I am surprised you were able to make the program work so well without using our development model, but you did. How can I get a copy?” This attitude will reward schemes that take away our freedom, leading to its loss.

> The free software activist will say, “Your program is very attractive, but I value my freedom more. So I reject your program. I will get my work done some other way, and support a project to develop a free replacement.” If we value our freedom, we can act to maintain and defend it.

Relying on Slack, Github and what have you is clearly not to "get my work done some other way, and support a project to develop a free replacement.” It aligns with attitude exemplified by the "pure open source enthusiast".

This is correct. I care about user experience far more than any political statement. I love open source because I'm a developer and can work with the codebase but that doesn't hinder my enjoyment of closed source software at all if it provides an excellent user experience. There are way more buckets someone may fall into rather than closed source freedom killer and free software activist.

Emoji reactions are actually a thing nowadays thanks to IRCv3 :)

And personally I consider the slack UI, especially due to the different workspaces, relatively unintuitive.

> there's a bunch of stuff you can do with Slack that you can't with IRC. Emoji reactions

I don't see a big difference between sending the message :rose: in Slack and having the client display it as a picture of a rose, vs sending the message :rose: in IRC and having the client display it as a picture of a rose. Emoji don't enter into it.

Reactions, maybe.

Forget IRC. You can do everything with Matrix :)


Matrix is an incredibly centralized service masquerading as an easily self-hosted distributed service. The moment you try to get a non-technical user connected to a homeserver other than matrix.org, all hell starts to break loose.

It's bad enough that both France (tchap) and Purism have created their own client forks to make on-boarding somewhat tolerable at the expense of really painful rebases against upstream Riot, while Riot tries to get it's shit together on the non-matrix.org user story.

Mattermost has a slightly less painful situation -- they provide a relatively easy to brand/preconfigure client (and fantastic docs on how to do so: https://docs.mattermost.com/mobile/mobile-compile-yourself.h... ), but you lose out on federation and self-service sign-up, leaving your community isolated (sometimes a pro, sometimes a con).

This is pretty disingenuous - we have spent loads of time making Riot work well with self-hosted servers (c.f. the current login & registration flows, which explicitly prompt you to select a server), and around 50% of the network are running their own servers. Our intention is to turn off the original matrix.org server once we have decentralised accounts and the network is healthy enough.

Please share a useful workflow for getting a non-technical user onto a non matrix.org homeserver.

I've personally run 3 homeservers for communities formerly centered around Facebook, only one of which was technical. For the non-technical communities the workflow was the one provided by riot-web when a mobile user visits the homeserver.

Neither of the non-technical communities saw more than 5% adoption in the org. The technical community constantly complained about the login flow.

When I deployed Mattermost with a custom app for the first non-technical community I saw 40% adoption within a week, and 80 within the month. The second community has looked at the first as an example, and I can expect 80%+ adoption within a week or two of deployment.

I've asked repeatedly in both #ios:matrix.org and #android:matrix.org about assistance in putting together docs similar to mattermost's and was completely ignored.

I've asked if the Riot folks would be open to deep-links providing the homeserver to mobile apps, and was shut down by somebody who insisted deferred deep links were the only kind of deep links, and that they would only ever be supported by a Google Play on-boarding flow.

I really want to love Matrix, but y'all make it fucking difficult sometimes.

so, you should be able to enter an mxid (e.g. @matthew:wherever.com) on Riot/iOS & Android and log straight in.

Meanwhile, if you go to Riot/Web on mobile for a custom deployment, you should see a page like this https://webchat.kde.org/mobile_guide/ which guides you through the process.

Deeplinking from web into the app is hard, as the only way to do so vaguely reliably is by fingerprinting the browser using something like branch.io, which is distasteful from a privacy perspective. Meanwhile, affiliate links in google play seem to only work about 30% of the time, given the planets have to be in precisely the right orientation for the association to not get lost.

Mattermost might be doing something smarter (perhaps letting you install the app generically, and then getting you to click a custom URI handler link from the web to provision the correct config on the client?) - but would be useful to know which of these failure modes people were falling into?

> Deeplinking from web into the app is hard

This is exactly whay I was getting at before. Please stop fixating on the deferred form of deep links. The play store need not even be involved for deep linking to an already installed app.

The mobile_guide instructions are where most people bail out.

"Yeah, no. This is too complicated." is the response when they see

"Install an app, then click on a check box that changes the UI, then enter https://foo.bar:8448, then register".

That's a massive turn off before your app is even installed. A flow of "Install this app, then return to this web page" is significantly easier. Or if/when branded builds of Riot are possible, it becomes "Install this app."

> If software A requires four clicks to do something, but B has a way to do it in 3

The difference is usually more like "software A requires an hour of setup and constant maintenance on a dedicated VM or container due to dozens of dependencies, and software B requires 3 clicks"

And also the difference between "the code is inelegant and sucks and I'll remove it, damn the users" and "the code may be ugly but the feature users want is ugly so let's do it".

Case in point, I recently upgraded the computer of a non-technical person from Ubuntu 18.10 to 19.04. And now desktop icons are completely broken. It's been reimplemented in JS, with horrible performance, and doesn't even support features like dragging an icon to a folder. Their reason for removal? A bunch of technobabble no user would understand. https://gitlab.gnome.org/GNOME/nautilus/issues/158

Stuff gets removed from proprietary software all the damn time. To pick a notorious example: have you tried to use Google Reader lately? :-P Others I've personally noticed in the last couple of years include features of Dropbox; of Gmail; of Facebook; of Google Search; and various startups acquired and shut down -- including a mobile app with no backend of its own.

When stuff gets removed or shut down, the basic reason is that it takes work to keep it going, and someone decides to stop allocating any work to that. Even with client-side software with no service to run (like that mobile app), the platforms they run on change, and it takes work to keep up.

And that's exactly what I see in that GNOME issue you link to. There's a bunch of technical detail about why it's so much work -- but the point they're making is it's been a lot of work to keep that feature going the way it was, and it'd be even more work to continue doing so as the rest of the software on the desktop changes around it in the ways that are planned. And so they decide to drop the existing thing and build a new one in a much easier way.

The only difference from proprietary software is that everyone has the option to step in and say, no, I'm going to go pick up that work, and everyone's welcome to use my version instead. In fact, GNOME makes a great example, because there have been a bunch of popular projects precisely about doing that with previous decisions they've made: https://en.wikipedia.org/wiki/Cinnamon_(software) is one of the bigger ones.

If people had that option with Google Reader, it'd be alive today. (I'm told it was a very small amount of work to keep running, and when the ax fell on it many Googlers pleaded to be allowed to just keep it running on their own time.) Ditto for many of the other proprietary things I've missed after they went away.

On the other hand, there is proprietary software still running whose company has been gone for decades.

Stuff does not get removed from proprietary software installations spontaneously, unless there are automatic updates (which can be turned off).

Stuff spontaneously disappears from a proprietary website, and the users can't do anything about it.

Proprietary websites are a whole new form of social harm that makes plain old proprietary software look virtuous in comparison.

> On the other hand, there is proprietary software still running whose company has been gone for decades.

True, I'm sure!

Equally true of free software... and indeed when that situation does happen, you're in rather better shape if it's free software than proprietary.

I think there are good reasons for people to keep their software installations generally up to date, though -- certainly anything that's exposed to today's Internet. And for a given version of $component, the OS versions that shipped it will only continue getting updates for so many years. Because of that, in the example I was replying to I don't think it's unreasonable to see an announcement that, strictly, just says "this feature will be dropped from future versions of this software", and think of it for practical purposes as "this feature will be going away".

Its more like if it takes 12 clicks to do it but I was shown how to do so at school/work, or it was preinstalled I will keep on clicking.

good point on the "reluctant" FOSS developers. i see this a lot. big companies have teams that work on FOSS projects, but most of the people in those teams don't understand what the fuss is about. they come to FOSS events to promote their products and treat them no different than their proprietary ones.

the thing is, their leaders may actually understand FOSS and believe in it because they can see the benefits, but they don't understand that for the developers below them it is just another job.

i have argued that exact point in a company where i worked, telling the leaders that if they want to get the developers to make actual voluntary contributions and participate in the FOSS community the leaders need to set an example and actively motivate the developers to do so.

just assigning someone to work on a FOSS project is not enough to help that person to join the FOSS community. there are exceptions of course, where someone interacting with the community realizes that there is more to it and becomes drawn into it, but that's not the norm.

>about about providing reliable commodity middleware for locked-down devices and cloud services.

Free software made cheap, network centric computing feasible. This led from a model where the user ran their applications (open or closed) on their machines to one which turned the user's machine into a dumb terminal to access the network. This resulted in defacto loss of user privacy and control.

In a world where Windows was dominant and you had to pay a per cpu licensing fee, would companies be trying to put everything on the web, or would they create more apps that ran locally with some network based syncing? It would have been a smart computer, dumb network world instead of the dumb computer, smart network world we have now.

One of the great ironies of computing is how free software in its quest to enable user freedom actually enabled a world with less defacto user freedom than before.

> Free software made cheap, network centric computing feasible.

Anybody remember the dot-com boom? Sun Microsystem's silly "The Network Is The Computer." ads? No? Linux wasn't even a blip on the radar back then at the enterprise level.

> In a world where Windows was dominant and you had to pay a per cpu licensing fee, would companies be trying to put everything on the web, or would they create more apps that ran locally with some network based syncing?

Um, obviously yes? The fact that Sun and the other UNIX server vendors and Oracle other server software vendors were charging various fees for their OS and software, on a per server or per CPU basis, did nothing to put the brakes on the dotcom boom. Network-centric computing took off well before free software became the buzzword of the mid to late '00s.

Linux itself might not have been (although I'd challenge that if I could remember dates a bit better); Apache and Perl certainly was.

In 2000 we were delivering UNIX software into production on Aix, Solaris and HP-UX boxes, my employer at the time did not consider either GNU/Linux or BSD fit for the quality standards we expected from a standard UNIX, although we did use them on some internal servers, including our builds.

Free software gave much greater freedom to those who want it. Turns out, though, that the large majority of users don't actually want it.

And that's why everything is continue to go downhill in the Free Software world

Because of the mentality that UX problems are just "the user being lazy"

IRC stopped in time. Linux desktop is a mess and have very weird ideas about UX (especially Gnome, they love making things "simple" by shipping a car with no gearbox but only one speed)

"Freedom" is a "cost/quality" like any other, some people might value it the most, some people might value it the least, but it is less important than other factors.

An excellent point. FOSS has long been great at underlying tech, freedom, and openness, and terrible at UI/UX and ease-of-use. That's been true for a long time and still seems to be true today. The reasons for this are much-debated and well-known, yet the underlying challenge persists.

Writing good UI/UX and having your software have a vibrant set of open source contributors are usually opposing goals, similar to how you don't see a lot of microservice devops architectures sold as on-prem products. It's certainly possible, but it has to be a fundamental decision and makes a lot of things harder.

Someone might contribute a nice screen layout, but actual design of a user experience involves design, which is usually a process of intelligently deciding on limitations.

Slack and iTunes often get smacked around for their designs because they are kitchen sinks of features, which makes them bulky and non-intuitive.

Open Source communities tend toward this sort of kitchen sink by default. This is because people are contributing the features they want and need, not the ones which fit into your product plan. So you typically see the most success for software that is under an open source license but has limited or banned the ability for people to contribute.

Rather what is considered good UI and ease of use is sub-optimal for people who understand tech, and those are the people who write free software for themselves and others like them. (Why would you spend months making some UI that in the end requires a minute of manual labor to do what some piece of syntax in a config file achieves in seconds, and which can be diffed to the previous version and so on.)

There are good examples of UI in free software. There are also terrible examples of UI in proprietary software. A lot of the peculiar user experience in GNU/Linux is that way because it was cloned quite exactly from a proprietary system called Unix. A lot of that bad user experience is standardized with an IEEE standard called POSIX, which isn't free.

> Rather what is considered good UI and ease of use is sub-optimal for people who understand tech

The widespread love of the Mac and OS X among techies on HN says otherwise.

It says nothing about whether it's optimal or not. You can't easily evaluate how good a UI is for expert users until you're an expert yourself, and once you've made that effort, will you really want to abandon all that hard-won skill to learn another system? I think many people use sub-optimal UIs because the short-term cost of learning a different one, which might not even be better, is too high.

True, and that includes me. My favorite thing to say about bad UI is "those designers should spend two weeks using a Mac from 1985". :)

Because companies that build consumer product spend tons of money on usability testing and people to work on the ui who are not developers. There just are not that many of these people working on oss projects. What ends up happening is features are just jammed in wherever a developer thinks they are convenient and you end up with an image editor that’s about as fun to use as the software your company has you filling out your timesheets on.

FOSS does not appear to value user accessibility as a priority. Non-IRC, non-XMPP chat systems continue to implement features that users enjoy and appreciate, while IRC/XMPP clients argue that those features are irrelevant because the ideals of IRC/XMPP should take precedence.

IRC has, in the past ten years, fallen behind on:

- Scrollback syncing (client-to-client) and persistence (server-to-client)

- Everyday user interface (mIRC ships a UI from 1995)

- Setup and configuration (I can't get SASL right on the first try and I helped upgrade an IRC network to support it)

- Authenticity at a network level (not just Anope setting a umode)

- Protocol resilience (netsplits should not be visible to users)

- Defense against attackers (pitting the idealism of anonymity against the safety of identity)

Why has FOSS allowed itself to be eclipsed by closed-source chat providers in these regards? I believe it's because the ideals of FOSS are now in direct conflict with the needs of modern users, including FOSS people themselves. For example:

- Anonymity is an ideal to be held up above all others, so defending against spam attacks is impossible, because anonymous users are granted equal rights as my friends.

- Accuracy is an ideal to be held up above all others, so preventing netsplits is impossible, because the clients must know when they don't have a realtime immediate connection to each other.

- Maximally-capable UX is an ideal to be held up above all others, so building a less-capable UX that is more widely easier to understand is impossible, because otherwise we might not be able to view our chat at the maximum information density possible.

- Local-only data is an ideal to be held up above all others, so scrollback syncing must be outright prohibited and campaigned against, because otherwise the clients would expect the server to help them exchange data that the server must never permit itself to hold.

If FOSS realigns its ideals with those of modern users such as ourselves, then it could easily retake the gap covered in the past decade by closed-source software. I hope with all my heart that it does so someday, but I'm not holding my breath.

Footnote: Apologies for all the whitespace but, ironically, HN doesn't support formatted text such as bulleted lists, nor does IRC. This would take up half as much vertical space on your screen on Slack :)

Chat (and communications in general) is a tricky field to evaluate for this sort of thing, due to Metcalfe's law and related effects. I also don't think it would be easy for the gap to be retaken (for the same reason).

I use Slack, Facebook, Twitter etc. because I want to communicate with other people who use those services for communication. If I only use IRC and email, I would miss out on some of that communication.

I don't know the various reasons why each of those people use them, and I agree that it is, in part because of some of the things you mention. However, it is also probably also down to marketing. Many people use XMPP via Whatsapp without knowing it, they are just using Whatsapp.

The user accessibility problem is not universal to all FOSS. In my opinion, LibreOffice (MPL) is a superior office suite in terms of usability to MS Office. Audacity (GPL) has a simpler UX than many proprietary audio editing suites.

> Assume they are rational beings, and get at the heart of it.

Except: They aren't, so you won't get at the heart of it if you make that assumption.

People simply are extremely short-sighted. People choose the "convenient" proprietary solution for the same reason that they elect the "convenient" dictator or for the same reason that they choose the "convenient" SUV ... what all of those choices (and countless others) have in common is that long-term costs are simply ignored when making the decision.

It's actually just a lie that proprietary software is more convenient. What is true is that it (oftentimes) is more short-term-convenient, i.e., you will save some time/effort right now. But the pretty much universal goal of the proprietors of proprietary software, and in particular of proprietary platforms, is to use that short-term convenience (which they optimize for) to establish themselves in a position of power, which they then use in the long term to maximize the profit while inconveniencing those they have managed to gain power over in any way that promises profits.

The most pernicious form of that long-term inconvenience is the "invisible inconvenience", namely the inconvenience that results from hindering innovation by hindering competition: It's inconvenience that you never notice because the more convenient alternative simply never gets developed, so you never get to experience the difference between what you do have and what you could have.

We don't have an internet that functions as intended. IPSs conspired to prevent residential users from running servers. The result is that everything free either needs a patron to cover expenses or be monetizable.

>Assume they are rational beings, and get at the heart of it.

Why? Why import the concept of homo oeconomicus into this discussion?

> Many Linux and FOSS geeks today use Linux only professionally

As a long time FOSS and Linux user I can tell you that usability of FOSS GUI systems has repaidely degraded in comparison to professional systems (Mac OS or Windows). If half of my hardware is defunct under Linux I will not use the FOSS. It's like buying anew car and being unable to switch to fourth and fifth gear or use the built-in entertainment system.

The Wayland fork hasn't contributed to this situation.

> We collaborate inside proprietary environments, such as Slack and Google Hangouts. Most of the chat and messaging systems in use today are also proprietary and closed. So are most video-conferencing systems and the codecs they use.

This one in particular worries me. Having access mailing list conversations and IRC logs provides such a rich history of open source development. I worry about every open source project moving to github / slack, where we may not have nearly as good a record of conversations that formed the software in 20 - 30 years.

On the other hand you won't see any argument from me that these services provide an easier workflow than what existed before, and maybe that easier workflow opening development up to a wider community is more important.

For what it's worth, there are workalikes for both Github and Slack which are at least tolerable -- Gitlab has most of Github's core features, and there are multiple slack-alikes (the one I've got experience with is Zulip, which I, at least, find to be a whole lot better than Slack). BUT...

Just having open-source (or free software) alternatives doesn't necessarily solve the problem. Gitlab and Zulip still leave your data scattered around back-end DBs which may not be terribly accessible in 20 years' time if the software itself doesn't still run.

Zulip lead developer here.

For chat apps, I don't think the problem of "data scattered around backend-DBs" is a real concern. E.g. Zulip has a well-defined data export format that's easily parsable JSON and contains all non-transient data (i.e. the status of who's typing right now isn't included): https://zulip.readthedocs.io/en/latest/production/export-and.... And so do most of the other popular chat systems.

I'd be surprised if Zulip doesn't still run in 20 years, but in any case, we have data import tools for the export formats of Slack, Mattermost, Gitter, and HipChat, and ultimately it wasn't that much work (The most recent few we've added were each a few person-weeks' work). So I think we can safely assume that at least for chat, it'll be possible to import the history.

But even if they don't, there are already scripts to export the public history of a Zulip organization and turn it into a webpage that can be hosted wherever (see for example: https://leanprover-community.github.io/archive/).

The https://zulipchat.com homepage and https://zulipchat.com/for/open-source are relevant reading for folks considering Zulip for their open source project.

Can non-admins export data? Mailing lists often allow downloading archives in mbox format and people also have local archives.

In cases of catastrophic failure or why-style "digital suicide", it seems like modern tools could easily leave a community with no records at all.

Yes, via the Zulip API, which is how the Lean Prover tool works. Zulip's "full organization data" export tool is only available to administrators, and we haven't heard any complaints about that model.

This one really freaks me out. Especially since many of the TOS are downright abusive. Discord, for example, reserves the right to read through and listen to all your communications and monetize that in any way and you agree to let them sell all that to anyone, forever.

The fact that we're just sort of expecting everyone to slave away on github every night and weekend to remain employable is pretty disgusting too. That's not sustainable.

Friendly reminder that Mozilla has decided to abandon IRC and the Rust community has therefore moved to Discord, a platform that is abusive regarding data and requires you to use a closed source javascript application to access the service.

Mozilla is a bad example because their leadership is simply pathetic, but you get the point. This trend is very, very dangerous. But well the writing was on the wall when many open source projects started moving to github.

While Mozilla seems to be a large open source/web advocate, I always have a hard time with the fact that, as an organization, most of their revenue comes directly from Google buying the top spot in default search engines.

And yet, they have one of the few FOSS products that can compete with any of its rivals on quality alone (the only one I can think of actually).

Don't forget about VLC.

Also 7zip, Calibre, some torrent clients.

7zip from both a UX and feature perspective is awful compared to something like WinRAR, it is popular mainly because it provides good compression and is free, but beyond that it is eclipsed by WinRAR in almost every other front (outside of compression, the only other thing that i find 7zip good at is archive support - it supports a ton of formats including even disk images with support for various filesystems, although only for reading).

Even PeaZip has a (slightly) better UI than 7zip (and that one is also crossplatform, if you care about that stuff).

Whats wrong with the UI in 7zip? Its basic but it works absolutely fine.

The reason I use it is because it's open source and there are no terrible nag screens.

There is nothing wrong with 7zip's UI (and a program cannot be only "perfect" or "garbage", there are in-between, e.g. "mediocre" or "good enough" or other things) but WinRAR's UX is simply better.

One example, which for me is one of the most annoying aspects of using 7zip, is double clicking on an .exe file or .html file or anything in an archive that relies on other files in the archive (dlls, images, data files, whatever): 7zip extracts only the file i double clicked on, ignoring everything else whereas WinRAR extracts all files since chances are if an executable is part of an archive, it'll need the other files in the archive to work too. This means that with 7zip i have to manually unzip the archive somewhere first, usually drag and dropping the top folder in the archive (assuming it has one, many donts) in the desktop or a temp folder, then open that temp folder, run it and then delete the folder. With WinRAR i just double click the executable and WinRAR does the rest. This is very useful when i want to run some game from a gamejam, run an installer which for whatever reason isn't part of an executable, test an archived build of a project that is made up of exe+data, check an archived webpage that is made up of several html and image files, etc.

As a sidenote (and another source of frustration), 7zip also has the annoying behavior of deleting that temp file almost right after it extracts it (i'm not sure exactly how it decides that) which means that unless the associated program is fast enough to open it, it'll get deleted under its feet, creating a race condition between the associated program and 7zip.

There are other issues with 7zip as well as a lack of features (practically zero features in the self-extracting archive generator, as an example). The main reason i have it installed is because it can open more formats than WinRAR, especially useful when dealing with disk images from VirtualBox since i can simply open it with 7zip and extract files from there directly without booting the VM. But when it comes to working with zip, rar and even 7z archives, i stick with WinRAR.

BTW, the "terrible nag screens" go away from WinRAR once you buy it. It has been a while since i saw any of those.

Calling people "pathetic" is generally a very bad way of convincing people of your argument.

You misunderstand, I'm not trying to convince anybody of anything, I'm merely conveying information.

The leadership of the Mozilla corporation is pathetic, toothless, and either useless or ill-intentioned. This is a comment and I'm not trying to convince you of these things, I'm stating my opinion. Readers of this comment should feel free to look at the decisions taken by those people these past years and agree or disagree with me.

>requires you to use a closed source javascript application to access the service

Closed source in the legal sense, I guess, but there's nothing stopping you from popping a devtools inspector inside of Discord and reading through everything. It is an Electron app after all.

Why couldn't they use Matrix instead of Discord?

According to them, because they have special needs regarding moderation, because "muh harassment".

fwiw Matrix provides pretty comprehensive moderation tools as per https://matrix.org/docs/guides/moderation, hopefully exceeding Mozilla’s requirements


«While we still use it heavily, IRC is an ongoing source of abuse and harassment for many of our colleagues and getting connected to this now-obscure forum is an unnecessary technical barrier for anyone finding their way to Mozilla via the web. Available interfaces really haven’t kept up with modern expectations, spambots and harassment are endemic to the platform, and in light of that it’s no coincidence that people trying to get in touch with us from inside schools, colleges or corporate networks are finding that often as not IRC traffic isn’t allowed past institutional firewalls at all.»



Where's the part about Matrix?

Oh, I thought you just needed a source on the harassment claims. I do not believe there was an explicit rejection, however at the bottom of the blog post, we have...

* We are not rolling our own. Whether we host it ourselves or pay for a service, we’re getting something off the shelf that best meets our needs.

* We are evaluating products, not protocols.

* We aren’t picking an outlier; whatever stack we choose needs to be a modern, proven service that seems to have a solid provenance and a good life ahead of it. We’re not moving from one idiosyncratic outlier stack to another idiosyncratic outlier stack.

Given other language such as "modern expectations" in regard to interfaces and being "spoiled for good options" as well as Rust's move to Discord possibly setting a precedent within Mozilla, the posters in the HN thread above don't have a lot of hope Matrix will be selected even via Riot.

Use Matrix. It's been a slow and bumpy few years, but it's there now. Idealism aside I genuinely prefer it to other messaging services.

You don't need to host your own server or anything special (unless you want to). You can just sign up here: https://riot.im/app/

Another website with ferociously irritating password restrictions... sigh.

Just use Riot. I actively seek to contribute to projects nowadays that actively use Matrix as its communication platform. Rust was mentioned in another comment - Mozilla might move to a proprietary data-insecure privacy violating walled garden of Discord, but the Rocket web framework, Tokio, and several other Rust projects have official Matrix discussion rooms as some of their primary points of contact.

I’m probably bad but I honestly can’t get slack to work with all the different communities I’ve been invited to. Discord basically works like IRC, except almost every channel I’m in is by invitation only, making it almost impossible for new people to join.

In my opinion IRC is still the best tool out there and I really, really wonder why we stopped using it.

I think by a wide margin the biggest problem is that IRC doesn't have any offline features. In a world where people swap devices all the time, it really sucks to have to drop your connection on every device change, and lose any chat that occurred while you were offline and be unreachable while you're offline.

Maybe IRC should have a standard way to send an email to a user wherein the irc client knows the users email but don't reveal the users email. It could also use its intermediary status to filter obvious spam, individual channels/users could also set policy as to who is allowed to mail users for example registered accounts only.

Well that sounds like a feature I would absolutely hate and never enable. Offline messages need to live in the same place as online messages.

So use IRCCloud or selfhosted Quasseldroid+Quassel? Or maybe even Matrix with Riot and the IRC bridge?

IRCCloud is really neat. Great UI IMHO. However, I must admit I’m too cheap to pay $50 USD/year for something that I use even less than once a month. So I go with irssi+screen instead.

In that case you may want to try quassel + quassel-webserver + quasseldroid, which gets you something very close to IRCCloud, entirely selfhosted

Cool. Looks really useful!

So the initial letter hits upon something that the article itself ignores, namely that the FOSS community requires more than just developers. I see this attitude all the time in certain circles that only the developers contribute any value to a project, and prospective contributors should either learn to code or get f--ked. It's not terribly welcoming to the larger community (of whom the majority are not developers), and the fact that many of these projects lack adequate documentation, wide availability, or a centralized support forum only reinforces that understanding.

It's a problem that can be remedied, provided the projects stop pretending that the packagers, technical writers, GUI/UX artists, and community managers are expendable.

Not to mention users! I can't count how many times I've seen bug reports responded to with a dismissive "you're welcome to file a PR", which is just a thinly veiled expression of the same attitude: you're not valuable, your domain expertise is not valuable, and the time you're taking to engage in the development cycle is not valuable; only your code is valuable. It's really not a big mystery why more average users don't flock to that sort of treatment.

Even when that attitude isn't so explicitly directed at users, you're right about it being visibly directed at other community members. It all sends a clear message, such that the average prospective user will move on, thinking "that application is meant for someone else."

I wholeheartedly agree.

In addition, responses like that do more to specifically push people towards commercial software than anything else (not specifically proprietary, just commercial). Why use a piece of software where the developers have no incentive to care about your concerns when you could instead use a piece of software where you're a paying customer and the production company has a financial incentive to keep their paying customers happy?

Since the launch of Windows 10, Microsoft has been surprisingly responsive to customer requests. They have a ticketing system where customers can submit new feature requests, and if it's both reasonable and popular enough, they'll implement it. Here's a reasonable example: a while back, they decided to eliminate the split mode from the virtual keyboard because they thought nobody would miss it, as they added a swipe keyboard to replace it. Well, it turns out they were wrong, because lots of people opened tickets with Microsoft asking for it to be put back. They put it back in the next update. They listened to paying customers. Compare this to GNOME, on the other hand, which regularly removes popular features and ignores all user complaints.

>Compare this to GNOME, on the other hand, which regularly removes popular features and ignores all user complaints.

The fact that GNOME is the dominant DE for Linux, despite this fact you cite, really is confounding considering that the whole point of FOSS is supposed to be that it empowers the users. It almost feels like the entire existence and adoption of GNOME by many prominent distros was a conspiracy to prevent FOSS desktops from succeeding.

My guess is that it wasn't really a conspiracy but that most distro developers do not give a rats ass about good desktop experience, thus they simply package whatever those who do work on desktop stuff and get done with it. "Those who work on desktop stuff" are basically Canonical and Red Hat and both of them decided, for various reasons to stick with GNOME, partly because GNOME at some point (2.x days) was a good enough desktop and partly because everyone had settled on Gtk+ as the defacto Linux toolkit (itself mainly thanks to it being usable from C, written in a way that allowed other languages to interface with it almost automatically and of course having a license usable by everyone from the beginning) and GNOME was the defacto desktop environment for Gtk.

Of course all that was on the Gtk2/Gnome2 days and Gtk3/Gnome3 broke a lot of bridges, still the complexity of the desktop and the fact that GNOME has actual paid people working on it ended up with the project having a lot of inertia and they are the projects that do most of the work no matter how misguided that work might be.

After all, those who do the work are those who decide how that work will look like. Anyone else, regardless of them being right, wrong, having better or worse opinion on that work, is irrelevant.

If you want to take control of the Linux desktop away from GNOME you need to replace the GNOME stack - not just the desktop, but also the toolkit, the inter-application communication, sound libraries, etc - with something that is objectively better (for a definition of better that a majority agrees with it) and convince other developers to use it.

>After all, those who do the work are those who decide how that work will look like. Anyone else, regardless of them being right, wrong, having better or worse opinion on that work, is irrelevant.

Yes, but it's not just GNOME who does such work. KDE has been around even longer than Gnome, and has a very different philosophy for their DE (one which, IMO, is much more aligned with the hacker philosophy of being able to customize things to your heart's content and having lots of features), yet most Linux distros stick with Gnome.

>If you want to take control of the Linux desktop away from GNOME you need to replace the GNOME stack - not just the desktop, but also the toolkit, the inter-application communication, sound libraries, etc - with something that is objectively better (for a definition of better that a majority agrees with it) and convince other developers to use it.

Yeah, we already have that; it's called KDE. We also have other DEs based on both Qt and Gtk: LxQt, Cinnamon, MATE, Xfce.

Basically, your post seems to imply that Gnome is the only full-featured DE available for Linux, and this simply isn't the case at all.

KDE is nice and all and certainly better than GNOME from a UX perspective (at least according to my preferences) but it always suffered from Qt:

1. Initially Qt1's license made a lot of developers to shun it (if that was warranted or not is a matter of opinion, but that is what happened).

2. Being written in C++ makes it very hard to not break ABI and Qt broke it several times - either because of itself or because of C++ libraries.

3. C++ also makes it harder to interface with other languages, meaning that for most languages interfaces either do not exist or they do but are of inferior quality. In comparison Gtk+'s gobject was designed to be easy to interface with.

4. Even if you buy into C++, for a long time you had to wrap your build system around Qt with moc and all.

5. Qt was always controlled by a 3rd party company whose interests did not align with KDE's: Trolltech/TQTC wants to provide middleware to developers for developing desktop applications, KDE uses it to provide a platform API. These two overlap a bit, but they also are incompatible in other areas (such as API/ABI stability).

Some of these (e.g. license, moc) are not valid any more, but others (TQTC goals) are and even without them, GNOME has already a lot of inertia.

> Cinnamon, MATE, Xfce.

These desktop environments rely on technology developed primarily for GNOME by GNOME and/or RedHat (and to a lesser extent Canonical) developers, like Gtk+, Clutter, etc.

The original post was about why everyone uses GNOME if other environments are available: if there is anything that my answer implies is that if you rely on GNOME tech and/or tech made primarily with GNOME in mind (even under the disguise of a neutral tech) then GNOME will be where things will work better and first show up.

The only neutral tech that there is on desktop is X11/Xorg and of course the GNOME people want to tear that down and replace it with their own tech.

I think your comment really does hit the point home. The developer working on a piece of software without any incentive to actually work on that software, doesn't and shouldn't care for the user.

To solve that, one needs to find a way to incentivise the developer so they are actually able to work on requests not just features they deem important.

Some projects have adopted donation systems with different grades of success. However this really requires having a combination of factors to work out, such as people actually needing the product, developers not being toxic in communication, the project and developers actually being around for some time to gather a dedicated following.





Having lived through the entire history of free software (well, Free Software with capital letters, anyway) it always comes back to this: Software freedom is fundamentally valuable only for developers, because only developers can use the freedom it gives. (That's pretty much the definition of "developer"—someone who can modify software.) Users get value only as a side effect of this developer freedom, because a developer builds a product for them.

Free Software originated in the hacker community—which is a community of developers developing for developers. It's always struggled to extend those values in a way compatible with the rest of the world. Notice that developer tools like GCC or Linux are the big success stories of Free Software, whereas end-user tools like OpenOffice or GIMP have always been kind of…meh.

> Software freedom is fundamentally valuable only for developers, because only developers can use the freedom it gives.

That is akin to saying that democracy is fundamentally valuable only for politicians, because only politicians can use the freedom it gives.

That is simply completely wrong. You don't have to be a developer yourself in order to benefit from not being dependent on a monopoly. The fact that you can buy development work on the free market benefits every user of Free Software. The fact that the code of Free Software is easier to inspect benefits every user of Free Software.

There is no need for everyone to be a politician for democracy to be generally valuable, there is no need for everyone to be a car mechanic for freedom to repair cars to be generally valuable, and there is no need for everyone to be a developer for freedom to inspect and change software to be generally vaulable. Those freedoms are what enable free markets instead of monopolies.

I said fundamentally for a reason. All of those things are of course user benefits, but they are indirect side effects. Users get none of those benefits without enlisting a developer to take advantage of them. So the most powerful evolutionary pressure is to make free software that is valuable for developers. The closer it gets to a “pure” user problem, the less incentive there is for developers to work on it, and the worse it gets. (As a general rule.)

> All of those things are of course user benefits, but they are indirect side effects. Users get none of those benefits without enlisting a developer to take advantage of them.

That is not really true.

For one, even users of purely proprietary software do benefit from the work that developers of Free Software do, because the market pressure exerted by their presence in the market does affect the pricing and quality of proprietary offerings. While that is an indirect effect, it does not in any way require "enlisting a developer".

Also, in order to have a free market choice in who you hire to do development work for you, you don't need to enlist a developer. That freedom of choice is every user's immediate freedom.

> The closer it gets to a “pure” user problem, the less incentive there is for developers to work on it, and the worse it gets.

But that has nothing to do with whether it's a "user problem", but only with whether it's a problem of people who value their freedom. If a user values freedom and thus invests in it, such as by paying a developer for doing some work for them, then they will get just as much freedom as developers who value their freedom and for their reason invest in it. The problem is not that they are users, the problem is that they are unwilling to invest in their freedom, and instead expect others to invest for them.

The problem is the expectation that developers invest in the freedom of users. Developers will invest in their own freedom first and foremost, obviously. If you expect developers to invest effort into solving problems of non-developers, you should also expect non-developers to invest in developers solving their own problems. Like, you should expect users to pay developers so they can work on stuff that is of no importance to the user.

> Software freedom is fundamentally valuable only for developers, because only developers can use the freedom it gives.

Substitute software freedom with open source and I'd agree. But software freedom is a whole other thing that is valuable to non-developers. Proprietary software can cost money, require subscription fees, make older versions no longer available, add all sorts of licensing costs like per CPU licenses, restrict features to "pro" versions, etc. Those are issues that affect people (and large companies) that will never read the source code.

Free software is about user freedom, OSS is just a means to that end.

Searls says that the fight for general purpose computing is the one most worth having: but I think he's using a definition of "general purpose computing" that most non-developers won't even understand, much less agree with.

The problem is that development is an extremely special purpose--one that most people don't do and don't understand the needs of. As a developer, I want a level of control over every aspect of my computer that most people don't want, need, or even think of. To most people, "general purpose computing" just means their computer (or more likely their phone, these days) can run any app they want it to run. It doesn't mean what Searls (and the people whose articles he references, like Doctorow) takes it to mean.

And to the ordinary person, the idea that it is essential to society that developers have the freedom to configure their computers however they want, regardless of what the government or some corporation says, doesn't sound like something worth fighting for; it sounds like something scary. They don't think of Stallman developing Gnu or Linus Torvalds developing Linux; they think of computer viruses and worms running rampant.

Maybe we can at least make sure that the next generation of children get it, or at least the kids that we are close to. This is on my mind because I have five nieces and one nephew, all of whom are less than five years old. I gave three of them Amazon tablets the Christmas before last, and have come to regret it. I will do what I can to make sure that their next computers will be general-purpose as we developers understand it.

It may be worthwhile to reflect on my own early experience with computers. In 1988, when I was almost 8, my family's first computer was an Apple IIGS. As I explained in my personal retrospective on that machine a few years ago [1], that machine had kind of a split personality, because it combined compatibility with the earlier 8-bit Apple II models with a more or less Mac-like, native 16-bit environment. The legacy 8-bit environment included BASIC in ROM, whereas the native 16-bit environment could only be programmed with a dedicated development environment that wasn't included with the computer. Of course, even many 8-bit Apple II programs were written in assembly language and were locked down to varying degrees (e.g. copy protection, no easy way to break into the BASIC interpreter). But at least that BASIC interpreter was available in the 8-bit environment. So the 16-bit environment represented another step in the direction of separating users from developers.

I remember one experience that, I think, helped spark my interest in programming. One day when I was about 8, my uncle Eric was over at our house, and he brought with him a disk full of 8-bit Apple II games. One of those games was written in BASIC and somehow involved shapes crudely rendered in text mode (I don't remember anything else about the game). He had modified those shapes to bear the names of his kids. That was interesting all by itself. But then, if I remember correctly, he went in and modified the game to show the names of my siblings and me instead. These days, we call this live coding. And with most off-the-shelf software now, it's impossible. If we can fix this for free software, I think more people will be enthusiastic about it. Of course, the specific example I recounted here is pretty trivial, but the lesson is clear: we need to make it practical for people to modify the software they use every day, on the fly, with low friction. Then, the freedom to modify software will matter to more people.

[1]: https://mwcampbell.us/blog/apple-iigs.html

Its more abjectly a moral failing of society that institutions have not aligned to enable free software proliferation.

Software, and information in general, have been a prisoners dilemma for time immemorial. The optimization of utility is total freedom of information - but such a state of affairs means benefactors reap the labors of others and have no obligation to give anything in return.

Copyright was fabricated to solve 18th century problems with an 18th century bureaucratic solution. The whole free software movement in general emerged as a counterculture to how intensely harmful to society that policy influenced the natural state of affairs to become.

If anything, the fact free software enthusiasts have lost sight of what the ultimate goal has to be - the abolition of copyright and institution of basic standards of living for all citizens derived from the productive gains of the extraordinary multiplicative effects technology, itself derived substantially from free software, produces - is what really needs to shift. Anything less keeps the movement in an atrophying limbo where fresh minds join, put in their best effort, and fall out from the captured value innovation produces in our society.

We need to move towards a state of affairs where enthusiasts can produce freedom respecting code because they want to, that don't go hungry or homeless for their efforts, and where all of society can reap the benefits of theirs (and billions others) generosity and compounding efficiency produced through technological innovation. And where everyone has access to the fruits of those labors regardless of means as a way to improve the collective knowledge of mankind for all the rest of us.

Just think for a moment of the bizarre world where the brightest need not toil to manipulate tired and depressed minds psychologically to siphon scarce money from them to line the pockets of robber barons masquerading as productive members of society, but instead could comfortably collaborate towards actually making the world a better place.

Yes, and it'll take collective action, i.e. politics, to fix those institutions. Positive example: https://fsfe.org/campaigns/publiccode/

Free Software enthusiasts can't advocate against copyright, because it's the only thing that gives the GPL any meaning at all. In a copyright-free world, any company could make a proprietary GCC fork, lock its code up behind many layers of physical and digital security, make all its developers/employees sign NDAs and other legal agreements ensuring they don't leak any of the new code, et voila. Hardly sounds like a Free Software utopia.

> Free Software enthusiasts can't advocate against copyright

You're right that we can't advocate for just eliminating copyright, without shooting ourselves in the foot. However, eliminating copyright, combined with, say, an obligation of software companies to disclose the source code of their "products" to their customers, or, less intrusively, with making the type of NDAs you describe illegal, would work.

More generally it comes back to the right to repair. We operate in this perverse economy where we lack a meaningful right to repair in the digital age because understanding on the subject is so scarce, but I personally believe in a strong consumer right to repair, and in a post-IP world that would include a requirement to disclose source of software - in practical terms, so the owner of the tractor can fix bugs in the tractors computer, but in general so anyone purchasing software - or just goods of any kind - should have the right to understand what it is and how it works.

Its one of the defined software freedoms of the FSF, after all, and its fundamentally why software freedom is advocated for, but it absolutely doesn't need copyright to be enshrined in law.

On the other hand, in a copyright-free world once a leak happens (and they inevitably do), everybody in the world would be legally free to use that code. There would be some liability for the developer breaking the NDA or for the hacker stealing that code, but in the absence of copyright the buck stops there and all the other seven billion people in the world would not be bound by these legal issues.

My personal take on it is that in practice software liberation is more akin to the right to repair than to a need for intellectual property.

We currently have both a draconian IP regime and woefully inadequate right to repair, but fixing the latter does absolve free software from needing the former to function.

The way I see it free Software enthusiasts who advocate against copyright believes that without the ability to derive rent from copyright, companies will just release the code in hope for contributions. Rent seeking is thus seen by this group as the biggest reason why companies keep software strict proprietary, and it is a fair trade to give up on GPL if we could remove the rent seeking. In this scenario, EULA and other contract-like mechanics to replicate copyright would equally not be allowed, and right to repair addresses most issue around DRM in this context.

It is a very different strategy than GPL, and doesn't look very likely to happen given the trend in both EU and US, but I see it as a valid long shot strategy. It would be a terrible strategy however if we gave up GPL without anything in return.

I still cannot believe that we live in a world were:

- A website with a silly name like 'Facebook' is worth half a trillion dollars and is extremely profitable.

- A website with a silly name like 'Twitter' which only lets you post 140 characters at a time is worth 30 billion dollars.

- An app with a silly name like 'Snapchat' which loses billions of dollars per year is worth almost $15 billion.

- An international taxi service with a silly name like 'Uber' which is losing billions of dollars per year is worth almost $100 billion.

- That software developers don't see anything wrong with building apps on top of proprietary cloud APIs (e.g. Amazon Lambda) - The closest real-world analogy that I can think of is that it's like building a house with your own bare hands for years and then, once you finally finish it, you start paying a corporation rent (at whatever rate they ask for) so that you can live in your own house! Meanwhile, the whole time, there was an even better plot of land right next door which was 100% free but you ignored it because the signposts on the corporate land were flashing with bright neon lights.

The economy makes so little sense that there is no incentive left to create value. The best you can do is just look for the next financial scheme to take advantage of. I bet it will be something completely random and useless.

Names are hard, and all of those except Uber are extremely apt and descriptive.

In the lambda case, it's very much closer to "build and maintain a house, doing all the trades work yourself" versus just renting somewhere. The latter has a much shorter lead time and upfront cost. If you're just doing a job for 18 months somewhere to see if it works out, would you spend a decade building a house there first?

Re Lambda, I think the closest analogy is renting unfurnished office.

When our company moved into next office, it had bare walls with old ugly wallpaper. We paid for the new wallpaper, carpet, interior walls, wiring, etc... And we also kept paying the rent to the building owner, and were at their mercy when they eventually decided to stop renting out that space.

Even then, this made perfect sense for business. All-new construction would have been way longer and more expensive, even taking limited lease time in the account. Why would software equivalent of this (Lambda) be different?

>> bare walls with old ugly wallpaper

With Lambda, it's more like no walls at all... The land just comes with a concrete foundation but you have to build the walls and roof yourself.

Running your own servers doesn't require you to bid for sparse plots of land, like constructing your own office space does.

Of all the “lock in” of AWS, lambda functions are the easiest to convert. Not only that, you can write a standard Node/Express C#/Web API, Python/Django service, throw a proxy on top of it and deploy it either to lambda or a standard server just by slightly tweaking your build pipeline.

A lambda function is nothing more than a standard app with an entry point with two arguments. Your handler function should be “skinny” just like a Controller action in a typical MVC framework.

A bug in GPL is that it allows SAAS Software as a service built on Open source software which means Software as a service can leech on open source software without contributing back.


Using AGPL instead of GPL closes the Saas loop hole.

Also due to close to zero bank interest rates the general availability of venture capital is to some extent stopping new open source software. Instead of giving away your software for free as Open source software you start a venture capital funded Software as a service instead.

> Using AGPL instead of GPL closes the Saas loop hole.

In spirit maybe, but not in practice because of its loopholes. That was the reason MongoDB changed their license.

True, but that is what has driven most business to ignore most GPL libraries and drive back to glory days of PD/Freeware/Shareware, just with the source code for basic funcionality as the modern demo version, instead of the old time limited one.

I love the way commenters here equate FLOSS development with unpaid hobbyist developers.

Fact: most of the contributors to the Linux kernel are highly-paid professionals who do that work full time.

The same goes for many, if not most, of the popular and successful FLOSS projects.

It is an error to assume that free (as in speech) software is only made by free (as in beer) development.

Fact based on what? I don't doubt the kernel claim. There are regular LWN summaries, about what companies contributed to whatever release.

But I have no clue what you're basing your second claim on. There's huge amount of FLOSS programs that work fine, are useful, but don't get much contributions. And I don't know about any studies/overviews on what number of programs say in a Debian distro is a work of passion, and what is created by paid devs.

Here's a thought - can we trace this back to the point at which everyone moved from Slashdot to Hacker News? All of a sudden the dominant social incentive changed from open software to startups and profit.


But if you do that, it would also be interesting to trace free software back to the point where the GPL became popular. (GPL was published in 1983, but in my recollection it wasn't until the early/mid-90s that it surged into general usage.) Before that, 'free' software generally meant public domain: no licenses, no limitation on use -- at all. We had two or three decades of free software of that type, mostly distributed over Usenet, BBSes, FTP/Gopher, etc.

I'm probably being too oblique, but I believe it's short-sighted to believe free software must only be ideologically free. There was, in fact, an earlier period, where developers release software for free because, well, why not?

Okay, time for this retired grumpy programmer to retreat back to his hut in the forest now...

My memory of that period (mid-90s-299ish) is that in a majority of cases the widely used 'public domain' software was distributed without restrictions but also without source code, and thus did not really enable modification and redistribution of improved versions even if the licence (or lack of it) didn't prohibit me to do so; so back then the 'ideologically free' movement towards open source software did result in an actual increase of practical freedoms.

Ah, I did not explain clearly. My mistake. I wasn't talking about binary-only shareware distribution, but rather source code (primarily Unix/C-based on comp.sources.*). I'm thinking about the Usenet software itself (B News, C News, rn, tin, vnews), sendmail/bind, early Pine/Mutt/procmail (?), scripting languages like Perl/Python/Ruby, and so on. And a pile of early microcomputer code for Z80/8080/6500/6800/etc.

Most people engage with FOSS for practical reasons, not ideological reasons. Given that developers of proprietary software have made a lot more money on the whole than developers of FOSS, I don't see that changing anytime soon.

The ideological reasons are practical reasons. We don't want to give you software freedom because we believe in some abstract ideology. We want to give you free software because we believe this is the way that you will eventually get the best software that will let you do the most.

Indeed, for software of good quality, free software wins. GNU R has completely dominated most areas of statistical computing, for example. The ideology is there not because we think you're "impure" or "evil" or something if you use non-free software, but because we think you'll be happier if you do, because you deserve it, because we all deserve free software.

> Indeed, for software of good quality, free software wins.

What is good quality differs between people. Personally i consider good quality to be desktop software with a good and simple (but not patronizing) UX and responsive UI that does not abuse my system's resources.

The vast majority of FLOSS fails hard there, at best you get a single aspect of the application to be very good at what it does (e.g. some 3D renderer might provide a very accurate light model) but suffer at everything else (e.g. be usable only through the command line, using only a custom format, no support for the 3D authoring tools that everyone else uses, etc).

There are very few FLOSS applications of good quality and of course that is what i consider good quality (someone might consider the command line part i mentioned above as a sign of quality because it would be easier to drive via scripts, e.g. for setting a render farm).

>The ideological reasons are practical reasons. We don't want to give you software freedom because we believe in some abstract ideology. We want to give you free software because we believe this is the way that you will eventually get the best software that will let you do the most.

While I wholeheartedly agree with this particular stance--doing away with ideology and sticking with ethics and pragmatism--, I am not sure that everyone in the FOSS community, if such thing exists, adheres to that same premise.

In fact, that's only the ideology of Open Source software.

Free/libre software (e.g. GNU and the FSF) believe in "free as in speech" for ideological reasons, not for tech quality reasons. In fact -- they argue -- one should sacrifice convenience and sometimes even short-term quality in favor of freedom. I certainly see the merit of that line of thought, though it's also a very hard road, and harder still to convince people.

Ideology is not a bad word :)

I'm not saying the quality of the software is the most important thing. I'm saying that software freedom is a pragmatic goal. Being able to fix your own software or bring it to anyone competent who can repair it is a practical thing. Giving the software to your friends is a practical thing. Being able to modify the software is a practical thing. Knowing that your software won't spy on you is a practical thing.

Software freedom is not some abstract ideology with no relation to pragmatics.

Everyone could stand to learn the lessons of gcc.

Back in the '90s, when gcc really took off, it got a lot of attention for being faster and optimizing code better than anything else out there. It wasn't just free: it was _better_. Of course, the 'free' part helped too, but the only 'free' people cared about was as in beer, not speech. This was when Sun was charging $$$$ for C compiler licenses on top of the operating system. So you could buy Sun's cc for massive amounts of money... or get a _better_ product without having to shell out. No wonder gcc won.

And if you look down the road to the 2010s, when LLVM/clang is eating gcc's lunch, you have to wonder what went wrong. What went wrong was that gcc fell behind for ideological reasons. RMS categorically refused to allow gcc's frontends to output the AST on the grounds that proprietary tools could make use gcc's output. The developers of LLVM and clang, on the other hand, had no such qualms. Being able to get an AST out of clang meant you could have IDEs compiler-assisted syntax highlighting and real-time error checking, things that gcc will never have for ideological reasons.

gcc succeeded when it was better than the competition and faltered when it was worse, and freedom had nothing to do with it.

That's the commonly accepted narrative about LLVM, but in retrospect it's even more clear that it was always about the GPL and, in particular, GPL3. Fast forward to today and LLVM's interfaces are no more stable than GCC's, and GCC is the only project with useable dynamically pluggable modules.

RMS was wrong to have pushed back on module support for so long, but it was irrelevant. Apple wanted to be in the driver's seat, and Apple's legal department was and remains violently opposed to GPL3. And it turns out that when you're in the driver's seat you don't really need stable interfaces and you definitely don't need modules.

The competition has been good, though. I like using both compilers.

That's a great example.

The concept seems obvious, but often times free software activists forget or are unaware of lessons like this. Because free software activists are willing to make sacrifices to preserve their freedoms, they sometimes forget that others are not willing to make those same sacrifices.

Getting end users and often developers interested in your project isn't easy. The vendor lock in proprietary software companies use makes it even more difficult to get users even if a free solution is better. The goal of a project should be to grow the community outside of just the free software community by improving the software until it's eventually better than proprietary alternatives.

That's why I'm particularly excited about projects like GNUnet, Guix, and Librem 5. I think they have the potential to blow the competition out of water and move the free software community closer to it's goal. https://gnunet.org/en/ https://www.gnu.org/software/guix/ https://puri.sm/products/librem-5/

This. The problem with FOSS are incentives which are not aligned.

Sure, some developers will give their best for free... for some time. But sooner or later the going gets tough and maintaining (let alone developing further) your pet project becomes a chore. Will you still do it? For how long? And if you try to monetize the project to at least somehow offset the lost energy and time, and maybe even pay someone else to help you, then you figure out you can't. Because free / open / libre means that anyone can take what you did and run with it.

This is the reason why FOSS projects don't reach the maturity and polish of closed variants. The only exception I can think of is Firefox, because it is able to capitalize on its unique position where it threatens (a bit) Google Search. With Google also making its biggest rival.

And the end result is that while the FOSS software is free (as in freedom), its quality leaves much to be desired, so the users are not flocking to it. Far from it.

Until FOSS movement rethinks what "freedom" is, nothing is going to change for better. Maybe giving Commons Clause and other hybrid licenses a chance could be a way out? I don't know, but it makes me sad that I'm typing this on a closed phone without (realistic) choice.

Android especially the google variants are pretty open and unlocked. The librem phone is due in Q3 of this year.

If you crowd fund development instead of try to sell consulting or a premium version then Amazon can't pull the rug out from under you by offering hosting and support because you aren't in that business. You may never have an IPO or make a <doctor evil>billion dollars</doctor evil> but if as the song says we "Try just a little bit harder" We may be able to offer sustainable income from making free software.

The common clause licenses isn't a "hybrid" its a proprietary software license. Calling it a hybrid is like saying a BLT without the bacon, lettuce, or tomato is a sandwich. It's not a solution its giving up.

> The common clause licenses isn't a "hybrid" its a proprietary software license. Calling it a hybrid is like saying a BLT without the bacon, lettuce, or tomato is a sandwich. It's not a solution its giving up.

Well, it's more like tiramisu with chocolate instead of coffee. In the end, as a user, I would prefer a convenient and polished product (that I can't sell) to worse product that respects some other people's definition of supposedly my freedoms.

Agree that crowd funding is another way, yes. Probably works for very few projects (font awesome comes to mind) though.

Why would a license that discourages any community participation result in a more polished experience?

Got any examples?

Why do you think it discourages any community participation?

It does put some restrictions regarding the license for modifications (it must be permissive, or CLA needs to be signed), but anyone can fork, maintain or share their copy. They just can't make money by selling it, without also paying to original authors. Which seems fair to me.

Should contributors also be somehow compensated? Bigger ones, absolutely. How? I have no idea, but there's at least some chance of that happening with Commons Clause, while with FOSS there is none.

As for examples... From Commons Clause? No. But since Redis Labs changed the license for their modules I'm not aware of any projects using it. Unfortunately.

There are plenty examples in closed source space though... Windows, MacOS, Photoshop, Illustrator, Trello, GitHub.

There is interest in contributing to open source projects fake open source not so much.

This is such a close minded view of the world that the only way to monetize software is to violate software freedoms to do so.

The valuable good in exchange is the developers time, not the code itself - nation states have constructed a goliath IP apparatus to impair the natural capacity to instantly and infinitely replicate information. But its wholly fictional and fabricated - its just an outdated paradigm from the era of the commoditization of the printing press where there were still marginal costs that could endanger businesses to overspend on.

There are many ways to monetize your time while creating liberated code in the process, but that is where the focus must be in the free software ecosystem.

> This is such a close minded view of the world that the only way to monetize software is to violate software freedoms to do so.

Ok, I don't even agree with your definition of freedoms, but I'll bite anyway. Do you have an example of a different approach? RedHat? Selling services, FOSS is just a by-product. Mozilla? Yes, though its position is very unique, and they are the only ones who really have incentives aligned with their users'. Redis? Mongo? MariaDB? Their change of license tells everything.

If it didn't work for myriad of projects in the past, maybe there's a problem with the approach?

As for other things... You must be living in a very different world from mine. (edit: this was not meant in a bad way... just an observation)

Many popular programs are now seeing continuous paid development by patronage including Godot, Krita, Blender, GIMP, and OBS.

It is unsettling that they all get this success on a proprietary middle man that siphons a portion of the money in the form of Patreon, but the principle is absolutely applicable to development in general. Right now its regular people paying to have software they want to use developed - game engines, art tools, etc - but nothing should stop a culture shift from getting both corporations and private developers to start paying in a similar way for libraries and infrastructure given the means to correlate the added value in doing so.

> Many popular programs are now seeing continuous paid development by patronage including Godot, Krita, Blender, GIMP, and OBS.

Godot=$10k/month (patreon) Krita=$2k/month (their donation page) Blender=€31k/month (their fund page) GIMP=individual donations only for two developers, $1k/month and $595/month each OBS=$3.5k/month from opencollective, $1.5k/month for the lead developer for patreon

Now, i do not know what sort of standards you have, but to me considering the amount of effort needed to create the software you mentioned these sound like pittance with the exception of OBS (and even then the developer would get a lot more money if he worked as a developer on a regular company... in some places even as a junior).

$10k/month for a game engine of the complexity of Godot? For Unity that would be absolute failure even back when the editor was available only on Mac OS X.

$2k/month for an advanced complex image editor and painting application? Even in the 80s (and ignoring inflation) that would be a cause to close shop for any software development company.

Blender needs to reach €50k/month to hire 10 developers full time? I'm curious what part of that €5k/month actually goes to the developer.

I'm not going to comment on GIMP, it should be obvious how ridiculous those numbers are.

Look, these numbers are actually the proof of how bad the economic side of FLOSS development is. These are jokes compared to even a small startup, let alone projects that exist years for software used by hundreds of thousands (if not millions, for some).

Developers who work on those aren't doing it for the money, they are doing it because they love the work. If you want to monetize your work, FLOSS is not the way to go, especially as an independent individual.

True. It's funny when those who rave against the licenses that might actually help change these problems, also publish their donations' summaries. Funny in a sad way, that is.

That's absolutely not true for people who make it in the first place.

Maybe for GNU project contributors, but look at some of the most currently popular FOSS projects. They all came from companies that rely heavily on proprietary software for their core business. They're certainly not contributing to FOSS because they're ideologues who believe all software should be FOSS.

Kubernetes (Google), Angular (Google), TensorFlow (Google), VSCode (Microsoft), TypeScript (Microsoft), React (Facebook), PyTorch (Facebook), just to name a few.

What made Linux and FOSS possible is a specific time and context and that is not happening again. There is no job security, everything is about building a resume, getting a job and hanging on or a startup, everything is related to money or status.

There is also an ahistorical perspective of tech, as if things just are or happen with no deliberate effort and its an open question whether there is any real commitment or concern for the principles which drove the open source movement.

In many ways Slashdot defined the original generation and Hackernews defines this one. And even paying lip service to principles would be quaint here. Defending building surveillance systems and stalking people 24/7 while referring to general users as idiots are often the top voted comments. This is a huge shift.

from the article's comments:

Dave Taht • 44 minutes ago We really, really, really need a return to our core values I remember how fired up I was in 1999, when I wrote this - https://www.youtube.com/watch?v=KxLbNCB-YKI and how fired up I am now to try and get our internet back. Still it is hard to be a revolutionary with two kids and a mortgage, and we've lost most of the next generation of coders to javascript and student debt.

> referring to general users as idiots are often the top voted comments

I seem to recall this being true on Slashdot also.

Sure, we need naive wish lists, but for open source to be more than a curios historical blip and not fall into a Venezuelan disaster, the least we can demand of FSF and OSI is to give us a proper open source license so those who want to _do_ open source work can also succeed commercially. They need to understand and address problems faced by MongoDB, Redis, Elastic et. al. and support their needs with a new license (something better than AGPL). Not flat out dismiss the problems and swipe it under the rug.

No, they need to make clear that VC funding isn't entitled to returns on bad business models. That is the real problem.

Yeah, I'm often puzzled by some FOSS developers not using open communication tools and not running Linux on their actual day to day work computers.

I've seen (and also not understood) the use of Slack/Gitter/etc. but the "not running Linux" part is a surprise to me, personally.

I've used Linux or BSD on all of my personal machines for a long time, and assumed, wrongly I guess, that most other people were in the same boat. I'm not sure it's a problem, but it's interesting.

Agreed, I've been using desktop Linux on my home laptop for more than a decade now. Every piece of software I want, wireless printers, videogames (many AAA!), everything just works.

I'm puzzled. I think it was just the unfortunate rise of mobile.

In my experience, using Linux until even recently had some rough edges, which I personally was ready to deal with. I suppose some don't want to do it. But I've always seen not doing it as not modeling our values, same way the article suggests, so it was an obvious choice for me, despite the learning curve.

That's partly because Linux is so hard to run. I bought an xps 13 because it is supposed to have official Ubuntu support and I still get weird errors on start-up, and crashes sometimes when I plug 2 external monitors in.

In 2019, it's far easier to run Ubuntu than Windows 10.

I would argue that the GPL is so restrictive to violate the principles of FOSS. BSD or public domain is better and more free.

That doesn't fit reality. For example, Apple are avoiding and even banning GPL, preferring BSD. And they are one of the worst anti-FOSS values examples (due to extreme lock-in, patent aggression and so on).

Apple anti-FOSS, given the scale of their involvement in eg LLVM? They are at most anti-GPL.

Freedom isn't about people doing things you like. It's about allowing people to do things you don't like.

GPL is about user freedom. You're talking about someone else's freedom; not user freedom. GPL doesn't say 'you can't make money on this software' or even 'you can't do evil things with this software'. It just says you can't take away other people's freedom to use the software under the same terms.

So Apple are pretty much anti-freedom, since they for example don't like competing browsers (which are FOSS) and they don't allow them in their store. They also don't like people installing something they don't control, so they try to forbid it with DRM and other junk. The whole idea of lock-in is anti-freedom, since it reduces choice.

Preventing others from reducing choice is the epitome of anti-freedom. With freedom, you have to take the bad with the good, and trust in humanity that the good will outweigh the bad.

> Preventing others from reducing choice is the epitome of anti-freedom.

That's a fallacy of the same sort as party slogans from Nineteen Eighty-Four, just reversed. There they said "Freedom is slavery". What you are saying is "Tyranny is freedom" (since tyrants should be free to oppress). That's simply bunk. Tyranny is not freedom.

You'd be wrong.

We also need to donate more to FOSS. And find more ways to monetize FOSS. It's tough for many FOSS projects to succeed on a volunteer basis.

The opinions in this article are simply fear-mongering and divisive of the programmer community as whole.

They are formulated on an irrational fear of FOSS being extinguished by the greed of the corporations.

So long as there is at least one programmer left with the will to post their source to the world FOSS will not die.

Let's also not be so one-eyed as forget to value equally the contribution of all programmers who write great software whether free or not, open or closed-source - we can still admire the fruits of their labours if not their algorithms.

FOSS community, please stop wringing your hands in fear, go write some code with them!

This! Like much else, these kind of movements (FOSS etc.) depends on having good “institutions” that work. In this case e.g. the documentation project and similar. They are fundamental building blocks ...

I don't think the problem is that FOSS (as a movement) can't accomplish what proprietary software does. For a while, some FOSS software did address certain user needs better than proprietary software.

But the world of proprietary software (including permissively licensed open source software) just moved faster, because its associated business models gave it the money, incentives, and the early signals needed to attack problem spaces in human-computer-interaction and secure, managed application platforms, among other things, that FOSS didn't have the resources to address, and so it just fell behind in key areas relevant to users.

We just don't know what the FOSS movement could have achieved given similar resources (or how it would have gotten those resources in the first place without a business model), or a lot more time.

I have several things to say here.

I see we are still debating the same points as many years ago (GIMP vs Photoshop, Visual Studio, paid vs unpaid labor, chicken and egg, convenience...). It’s like we haven’t learned anything.

About the end of general computing, I don’t see it as a bad thing. In some way it has always existed. Right now we have server computers, desktop computers, smart phones, mainframe, cloud... even on a single class of computer we have some segmentation. It just means we’ll have even more specialization. And FOSS still can have a place there.

Speaking about that, I believe FOSS is stronger at the foundational layers.

Maybe the future is kind of and hybrid model in which we have lots of new computer classes with FOSS as their foundation. Not very different from what we have now, just much more diverse and, I hope, more open.

There's a great deal of irony in a publication promoting FOSS, but their own website is closed source.

Is Linux Journal's website closed source? Looks like it's running Drupal to me, a quick scan of the HTML reveals <meta name="Generator" content="Drupal 8 (https://www.drupal.org)" />. Drupal is GPLv2+, seems fine.

Would be nice if they replaced Disqus with e.g. https://commento.io/ though.

.. along with the usage of Disqus, some third-party analytics and Google Apps.

Convenience seems to be the only value of things in the real world, so bad even that people en masse are prepared to submit to slavery to get it.

I suggest that the FOSS community now finally starts building something convenient for themselfs instead of making things hard and massochist.

Bit of hypocrisy on the part of the author for publishing on this platform....

The comment section of this article: "Our discussions are powered by Disqus, which require JavaScript. "

Wonder how many free software would be in china inside e-great wall?

What wonder what we use if majority of computer is intel based and they have a parallel computer controlled your cpu?

Strangely arm is sort of open what can you pay to develop your own total open env and ...

Any further, wonder what is open source movement is all about if not asking for a mixed environment ? It is the dying middle that might be the problem or is there no problem. Wonder.

Linux was built in an era of fierce resistance from the corporate world, so what is there to save today when everything runs or touches OSS in one way or another and most decent developers will make an OSS contribution, to claim on their CVs?

> Our discussions are powered by Disqus

Abandon all hope.

That's what happens when you are bogged down in Donglegate-like discussions.

Don't listen to the Copyleftists. FOSS is bigger than ever because non-copyleft free software is what professionals can build on.

For the most part, Copyleftists are stuck in Hobbyland and it really shows when you look at the software they produce. Their business models - if they even have one - largely don't work. Given that software is very expensive to produce, copyleft software eventually runs out of suckers to support it after the "fun factor" wears off and the "real work" starts.

The Linux kernel is the major exception, but only because the particular exceptions that the GPL grants to it do not encumber the enterprises that develop Linux. Wherever it does, enterprises will choose non-copyleft alternatives (e.g. Sony and Nintendo building on FreeBSD).

People choose proprietary software because proprietary software doesn't make you memorize and type things like "systemctl suspend" for the most basic of tasks such as putting your computer to sleep.

They don't want to find, audit, install, and evaluate dozens of obscure third-party extensions to make their OS usable.

They want options for setting their background image besides Fit to screen.

And they want to be able to use their friend's computer without having to learn how to use all their friend's customizations.

> People choose proprietary software because proprietary software doesn't make you memorize and type things like "systemctl suspend" for the most basic of tasks such as putting your computer to sleep.

Nothing says that all free software will be good or user-friendly (systemd is an excellent case-in-point). But you can choose a better alternative.

Proprietary software sometimes has short-term convenience benefits, but even thinking slightly-longer-term quickly shows that it's never worth it.

Even with less-than-ideal software like systemd, it's still miles better than proprietary alternatives. Yes, you may have to run "systemctl suspend"* to put your computer to sleep, but you don't end up with Candy Crush embedded in your program launcher, or over-12-years-outdated bash, etc.

[*] It's pretty easy to wrap 'systemctl suspend' in something friendlier, such as a shortcut.

Yes, Windows Home is awful, but I believe I got a Windows 10 Pro key for ten dollars. I think I used the same key on two different computers. No Candy Crush, slightly better control over the system.

It would be nice to have an OS that's actually fun and intuitive for normal people (nevermind me), not stripped down and sanitized, and also doesn't have corporate bloat and massive data collection by default.

> an OS that's actually fun and intuitive for normal people (nevermind me)

That's no version of Windows, in my experience. I suffered through Windows 3.1x to XP to Vista to Window 7 (and tried out Windows 10), and none of these were fun or intuitive, certainly not compared to what I used immediately before (Atari ST) or immediately after (Ubuntu Feisty Fawn).

In 2019, Ubuntu is far more intuitive and manageable for an ordinary person. No going to the internet to download dubious software (or getting malware through the Windows Store, as per my Windows 10 experience), no weird Candy Crush and 'telemetry' (data siphoning) or any of that Microsoft sort of goodness.

Driver issues alone disqualify Ubuntu versus Windows (where are all the three-monitor setups and touchscreen laptops?). So does the complete lack of desktop background options. And having to hold down `Alt` to make the Suspend button appear (which doesn't say Suspend on it by the way). Even the word suspend is so serious like you're punishing your computer, not putting it to bed.

Ubuntu is all business all the time. A five year old would get bored of it within five minutes. iPads are probably crack cocaine in comparison.

Settings doesn't even have an appearance and personalization section. Ubuntu is more stripped down than a Holocaust victim. And there's nothing fun about the Holocaust.

This is just....such a bizarre example. What Linux desktop environment are you using that provides no more user-friendly method to sleep the system than the `systemctl` command? Or are you suggesting command-line-only installs should have a better interface for this? What would the precedent be for that use-case?

Ubuntu is indeed bizarre (tried 18.10 and 19.04). It's either lock, restart, or shut down. Otherwise I get to have fun at the command line.

And multiple monitors hasn't been anything but a pain either.

I was told that Ubuntu is about as friendly as Linux gets. Sure, it's more usable than say Devuan or OpenBSD, but that's nothing to brag about. It's nowhere near ready for primetime.

Well, I don't use Ubuntu, but it seems like they have hidden the suspend button behind a modifier key[1]. How inane. FWIW, personally I don't think Ubuntu is as friendly as Linux gets. You might want to check out something like Elementary OS. Though pretty much any other desktop environment won't have weird unintuitive stuff like this going on.

1. https://help.ubuntu.com/stable/ubuntu-help/shell-exit.html.e...

All of those are design choices. None of that has anything to do with open source.

I am generally a fan of Linux and FOSS on my personal gear. However, I'm still not sure where this article is coming from, or who it addresses.

The author seems to be mixing the use of FOSS in the professional world with the use of FOSS in their personal world.

In a professional environment, there is no room for "modeling your values". It sounds harsh, but that is the way it is. You use what works. Yes, Linux OSs do some things better than Windows OSs, and vice versa.

I think part of what the author is addressing is the ignorance exhibited in your comment. I don't mean to be rude; it's easy not to see the big picture when you're busy just making a living.

To me, Searls' point is that an overwhelming pressure to monetize everything has corrupted the health of the open source community. This is not just holier-than-thou moralizing; there will be real financial consequences if the creators of open source products don't start eating a lot more of their own dogfood.

Exactly. It's about solidarity, I think. If you make FOSS and you want people to use it, you need to make an effort to use other FOSS projects. Otherwise, don't be surprised if the community is gone someday, you don't get help developing and promoting your FOSS project, and everyone abandons your software for some better-funded proprietary cloud startup that gets bought out by Facebook.

> To me, Searls' point is that an overwhelming pressure to monetize everything has corrupted the health of the open source community.

I agree, and perhaps my parent comment itself was harsh and looking at this from the wrong point of view.

I think I perceived this article written in a more romanticized way than necessary. If there is a concrete, financial detriment to FOSS developers, then I would advise to make that point upfront.

If the problem is "There is too much monetization within the open source community", then many of the points in this article sound like symptoms or variants of the problem, rather than isolated problems themselves.

Are you sure he's the ignorant one?

As a young adult who had a roof over their head by default, I was 100% FOSS and installed Gentoo on anything I owned that could even limp its way along that path (and discarded devices that couldn't), I refused to use proprietary messaging tools and social networks, and I accepted that I had limited myself to the social and economic opportunities that these things allowed me, as a sort of altruistic techno-hippie.

Now I am on LinkedIn, Slack, on a Mac and an iPhone, backing up to a proprietary NAS, operating most things in Amazon's or Microsoft's clouds using managed services that lock me and my clients in to their ecosystems, running default OS on most of everything. The technology choices in my day job are made by whoever has the power to make them, for whatever reasons those people may have -- and "freedom" or even "sustainability" for that matter are pretty low on their list of priorities. The technology decision in my home life come down to "what do I have time and energy to put up with?" and "is there a risk that I'll have to fuss with this in order to make sure it's operational when my wife wants to use it, late at night on some weekend when I'd rather be relaxing?".

Maybe when and if I return to a survival-by-default - when the mortgage is paid and health risks are (well enough) accounted for I'll be able to "model my values", but probably not before then. Even that might require a divorce, in adult life one's motivations and their consequences are not solely one's own to keep.

Aside from that, given the experience I've had with FOSS, at this point I doubt even if I were 100% financially independent and early retired if I'd go back to participating except to go to low effort to upstream fixes to my own problems (here's a patch/pull request, if you don't like how it's indented or documented, that's your problem to solve, not mine). The incentives are all awful with so many volunteers trying to create software for users or use cases that are fantasies, bike shed arguments, corporate interests trying to get their way and take advantage of free labor, corporate leech organizations saving millions in license fees for proprietary software and contributing nothing but sassy bug reports, the folks who are militant and awful to each other about inclusion/exclusion topics, well-meaning but ignorant people who refuse to understand their behaviors and words cause others grief, projects with lack of vision, leaders who are reluctant to lead.

Further aside still, there's a reason normal human beings don't use free software or decentralized whatever and it's because the developers of those things don't have the resources or vision to build software for normal human beings: people who won't edit a config file, won't author content in Markdown, don't want to read a man page of flags to understand the permissions in their chat channel, don't want to have to have a tower PC whirring and heating up a corner somewhere in order to solve what seem to them like simple problems, etc. etc. etc.

I don't disagree. You point out that there are no incentives for FOSS developers to cater to the muggles. Fine, so how do we fix that? I really want to know. I have to believe it's possible.

I do believe it is possible, but it is a compromise. Let go of one of the freedoms so that other freedoms (like "right to repair") have a chance. In other words: Commons Clause.

Compromise sounds nice but when the "compromise" is a one-sided capitulation it's not really compromise.

Do read the license, it's really short and to the point. At least for me I don't think I'm giving up much (as a user) by using Commons Clause software. I just can't sell the app or services without obtaining permission from authors. Which seems fair to me - if I earn money, they should get a piece of the value.

I'm also a huge FOSS nerd and it makes my personal AND professional life a lot easier, and I totally agree with you.

If the problem is that the ruthless winner-take-all nature of professional environments is destroying open source, then you need to fix both problems, not one of them. Trying to fix only one won't help.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact