Open source collaborative text editors - <AUTHOR> https://juretriglav.si/open-source-collaborative-text-editors/ <comment><USER2> A number of years back, I wrote an OT implementation in Clojure/ClojureScript as a hobby project [1] and learned a lot along the way. I even extracting out the core client/server implementations to their own package [2].

It's an incredibly fun topic, and one that's also really challenging. It also gave me first-hand experience with fuzz-testing where I could simulate all kinds of concurrent-edit conflicts and ensure both clients came out with the same end-result. While the end client/server implementations are working, it was a lot more effort than I anticipated building a full-fledged editor on top. I was too stubborn at the time to attempt to integrate with existing RTEs though, so the most notable part of the project was the core lib, not the end product.

For those interested in implementing it for themselves, I can't recommend this piece [3] by @djspiewak enough.

[1] [https://github.com/jahfer/ot](https://github.com/jahfer/ot) [2] [https://github.com/jahfer/othello](https://github.com/jahfer/othello) [3] [http://www.codecommit.com/blog/java/understanding-and- applyi...](http://www.codecommit.com/blog/java/understanding-and-applying- operational-transformation)

<comment><USER3> I'll recommend this link too. Saw it on HN a long time ago. It's quite long but very well explained.

[http://archagon.net/blog/2018/03/24/data-laced-with- history/](http://archagon.net/blog/2018/03/24/data-laced-with-history/)

</comment></comment><comment><USER4> I found this recent paper highly enlightening: _"Real Differences between OT and CRDT for Co-Editors"_ – Chengzheng Sun, David Sun, Agustina, Weiwei Cai, October 2018.

Arxiv meta: [https://arxiv.org/abs/1810.02137](https://arxiv.org/abs/1810.02137)

PDF: [https://arxiv.org/pdf/1810.02137.pdf](https://arxiv.org/pdf/1810.02137.pdf)

It's well written imo. The conclusions chapter is very good.

"In this work, we have critically reviewed and evaluated representative OT and CRDT solutions, with respect to correctness, time and space complexity, simplicity, applicability in real world co- editors, and suitability in peer- to-peer co-editing. The evidences and evaluation results from this work disprove superiority claims made by CRDT over OT on all accounts."

And it is also argued that OT is a more direct approach to the fundamental issues of realtime multiuser editing, and that that directness brings effectiveness.

HN discussion: [https://news.ycombinator.com/item?id=18191867](https://news.ycombinator.com/item?id=18191867)

<comment><USER5> Do you have any idea which would be better for a vector based drawing app? The data is mostly strokes (lists of points), and individual strokes generally don't change.

<comment><USER6> From the introduction:

"After over a decade, however, CRDT solutions are rarely found in working co- editors or industry co-editing products, but OT solutions remain the choice for building the vast majority of co-editors. In addition, the scope of nearly all CRDT solutions for co-editing are confined to resolving issues in plain- text editing, while the scope of OT has been extended from plain-text editing to rich text word processors, and 3D digital media designs, etc."

<comment><USER5> I'm not sure what to make of that, though, as there seem to be quite a few different JSON CRDT libraries, for example.

Just after that it says "The contradictions between these realities and CRDT's purported advantages have been the source of much debate and confusion in co- editing research and developer communities." That's kind of my question/confusion: people writing CRDTs really talk them up, and I can't tell what's true in practice. I have no way to judge the accuracy of this paper myself (I don't know enough to really understand it), so I'm hoping someone who knows this stuff in a practical way can shed some light on it.

<comment><USER4> I found that I could eventually power through the paper. I thought it was beyond me at first. Then I got angry and just shoved piece by piece into my head :) Not in linear fashion, and it didn't happen quickly. Actully not that slow either once I got going. I found I was maybe rather more of a paper- reader than I assumed I was. Probably you too!!

<comment><USER7> So, what is your conclusion after reading it?

<comment><USER4> I found the arguments convincing, and will be moving towards OT in general. From outside it feels like OT is generally closer to how I tend to think.

</comment></comment></comment></comment></comment></comment></comment><comment><USER8> Surprised the author didn't mention Quill.js, which works really well with ShareDB, and is fully open source. We've been doing a lot of fun stuff with it - here's a talk I gave recently as a job talk: [https://www.youtube.com/watch?v=gN37rJRmISQ](https://www.youtube.com/watch?v=gN37rJRmISQ). (It worked, I got hired :)). As a side project, I'm working on a ShareDB backed wiki, where we can use rich text for editing pages, but also other components, like spreadsheets or mindmaps, and everything supports live editing - I think it would be amazing for classrooms, hackathons, any kind of meeting etc. Would love to talk with anyone interested in collaborating. I have been waiting for a few features to complete to make a proper demo video, but this early one shows off some of the ideas: [https://www.youtube.com/watch?v=9-lU- in3ydc](https://www.youtube.com/watch?v=9-lU-in3ydc) ([https://github.com/chili-epfl/FROG](https://github.com/chili-epfl/FROG))

<comment><USER9> Thanks for the shoutout! We are actively developing on ShareDB ([https://github.com/share/sharedb](https://github.com/share/sharedb)) and if anyone is really interested in this, please reach out to me ([https://github.com/nateps](https://github.com/nateps)). Also, Lever is looking to hire someone to work full time on our internal + open source frameworks including ShareDB.

<comment><USER10> Thanks for ShareDB! Funny thing, I was looking for a self-hosted real-time collaborative editor myself just a week ago, and landed exactly on Quill.js backed by ShareDB. (I also considered SharedDB-backed Monaco, but it doesn't seem to support OT out of the box, whereas Quill is literally plug and play. Of course one can write a translation layer between Monaco's change events and OT.)

<comment><USER9> That's awesome! Let us know how it goes.

</comment></comment></comment></comment><comment><USER11> What many people not fully grasp, at first sight, is that offline support for a collaborative editor is at least an order of magnitude more complex than just building a collaborative editor. In online collaborative environments, solving conflicts is relatively simple, as the changes are supposed to be small. But when two (or more) people are working on the same document without synching it for hours or days, the merge strategy has to be extremely good to come up with anything remotely intended (assuming the authors had a common intention).

So just because your favorite editor can be used offline and it has an (online) collaboration feature, does not mean it is capable of being an offline-capable collaborative editor.

<comment><USER12> This is where differential synchronization shines (basically git). While OT/CRDT are really good for syncing small edits, they suck at being eventually consistent (with intentions preserved) on very large edits.

We make a powerful collaborative word processor for the browser (Zoho Writer [https://writer.zoho.com](https://writer.zoho.com)) with complete offline support. This is one problem we'd like to solve in the long term. One way to solve this is to fallback to differential sync when syncing huge offline edits - and present the changes as tracked-changes (underlined and striked-out) to the user. This way the user has the power to resolve the conflicts, instead of the app messing it up by itself.

I'd like to hear if there are better ways to sync large offline edits, with the intentions preserved.

<comment><USER7> > One way to solve this is to fallback to differential sync when syncing huge > offline edits

This is another question -- does automatic syncing make sense for huge differences in users' contents? The answer might be no.

OTOH, isn't this a rare scenario? How perfect it has to be?How much of a compromise can the users accept? These are interesting questions which shows that creating this kind of software isn't easy -- both from technical and UX point of view.

<comment><USER13> First of all when discussing about offline edits we should make effort to draw attention that "offline" could mean different thing to different people.

Offline editor from the point of view of the app's software developer might mean that editor can sometimes survive few minutes of lost connectivity, after which it will reconnect and possibly sync the team work.

Offline from the perspective of a team of scientists writing a joint paper means that some of them will take their work truly offline, to a secluded mountain hut, for an extended period (week or month) and will come back with a complete rewrite of the text to the point of being unrecognizable to the other authors. And then the coauthors will disagree with most of it, and will want to revert some of the pieces and keep some other pieces.

And scientists are not the only people needing joint collaborative environment. And not just for short papers. Few years ago, I was working in a larger team with a group of people doing revisions of a book, and there were so many revisions and revisions of revisions of revisions, and zillions of comments, that we had to split the book not in chapters, since Word got stuck even with 20-page chapters. We had to split the chapters in sub-chapters, of 5-10 pages in separate files, so that the processor would not get stuck with the myriad of comments and revisions.

These are all separate scenarios in collaborative writing, and there could be many other scenarios, so any solution should first explain for what type of scenario is it really targeting. Automated sync of collaborative work is not always the best thing to do.

<comment><USER14> Then there is the science fiction version where the editors are both online, but several light years apart with the resulting lag in updates.

</comment></comment></comment></comment></comment><comment><USER15> Indeed, the space is growing quickly. I run a company that provides a backend for real-time collaboration, so we necessarily stay on top of what's out there. There's a reason the server-side tech tends be paid: it is extraordinarily difficult to provide guaranteed eventual consistency of data at low latency. The CKEditor guys (and us, for that matter) have put YEARS of development effort into their solutions.

We're working on both offline mode and a generic rich-text data model with support for the major editors.

If anyone's interested, I'd happily do some Q and A here.

<comment><USER16> Are you working only with editors running inside web browsers or also native ones? What I would like to have is something that bridges two native editors, let's say emacs and VS Code, and let's a team share the editor (whatever each developer's preferred editor is) and not only the screen on Slack or similar. That would be great for remote pair programming. I guess there would be a protocol for selecting the buffer/tab and opening files (with local approval to prevent remote file reads/writes).

<comment><USER17> > What I would like to have is something that bridges two native editors

The big failing of co-editors is that currently they all silo into a single editor. THat's OK for e.g co-editing stuff on a web platform (e.g Google Docs) but it totally sucks for collaborating on code/documents you edit locally, forcing everyone to use the same editor/IDE, which ultimately fails because no one will use the same editor/IDE across a whole company/team/project, so although useful I've never seen one take hold for anything but a very short amount of time in any company.

We desperately need (a couple of) well-defined _protocols_ that get implemented across editors, and one to emerge as a widely supported winner, whatever its shortcomings.

<comment><USER18> For plain text, this is not so hard. The data model for plain text (e.g. a string) and the set of mutations on that model are pretty small. Also describing where a cursor is and what is selected is likewise fairly straight forward. Co-editing between plain text editors is completely doable, IMHO.

It's much harder for rich text editors (RTEs) because the various RTE's vary widely in the exact subset of rich text features they support. One will support tables, and another will not. One will support video and another will not. One will use a linear position to describe where the cursor is, and another will use a DOM Range. This makes it very hard to support co-editing between different rich text editors. It's not impossible, just hard enough where most of us are not tackling it.

</comment></comment></comment></comment><comment><USER19> I love your description of "the dive". I am happy to see I am not the only one experiencing these recurring devouring interests that bring me much much deeper than I would like to go until I am starting to fork a github repo at 2am wondering "what the hell am I doing?"

And that article is tangentially related to a recurring interest of mine (shared editable 3d universe in which you can code collaboratively). If you happened to have an article comparing the merit of several server architectures/algorithms for collaborative text edition, I think many things can be related. I am now reading about CRDT (What the hell am I doing?) and that's something I may use to edit a scene graph collaboratively!

<comment><AUTHOR> Hey thanks for that. :) Diving is super fun but also exceptionally exhausting. But often it's impossible to 'load' a complex problem in your head if you don't dive in for hours. Would be nice if there was a less stressful way.

In terms of editable 3d universes (whoah!), have you considered chucking together Three.js's JSON scene description ([https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene- fo...](https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4)) with [https://github.com/automerge/automerge](https://github.com/automerge/automerge), a CRDT for JSON? What could possibly go wrong?!

<comment><USER20> ShareJS has a JSON editor example [https://github.com/josephg/ShareJS/tree/master/examples/publ...](https://github.com/josephg/ShareJS/tree/master/examples/public)

<comment><USER19> Thanks! But a big part of my obsession is to be able to modify a 3d universe from within.

I won't claim it is practical or a good idea in any way, just an obsessive thing I want to try.

<comment><USER20> Right I understood that. I was replying to the other guy who suggested putting the scene in a JSON Three.js thing. So the idea was that the thing I suggested was just a possibly easy way to get a collaborative JSON editor into your program.

</comment></comment></comment></comment></comment><comment><USER21> I would be very appreciative if Google made a stripped down version of Google Docs for plaintext editing.

There are a bunch of basic integration features that would also be fantastic, but if the product was literally just Google Docs, minus the WYSIWYG bits, and all plaintext w/ maybe some syntax highlighting thrown in, I'd be super happy.

<comment><USER22> > Google Docs, minus the WYSIWYG bits, and all plaintext w/ maybe some syntax > highlighting thrown in

And the feature creep begins. Eventually you'll be asking for a full blown IDE.

<comment><USER23> Google has actually already has an internal cloud-based IDE.

<comment><USER24> Which doesn't do real-time collaboration, and due to the way it's backing store works, likely never will.

</comment></comment></comment></comment><comment><USER25> A few other CRDT / collaborative text editor links I've collected:

* [https://blog.datproject.org/2019/03/05/caracara-react-dat-au...](https://blog.datproject.org/2019/03/05/caracara-react-dat-automerge/)

* [https://conclave-team.github.io/conclave-site/](https://conclave-team.github.io/conclave-site/)

* [https://github.com/noffle/hyperpad](https://github.com/noffle/hyperpad)

* [https://xi-editor.io/xi-editor/docs/crdt.html](https://xi-editor.io/xi-editor/docs/crdt.html)

* [https://github.com/atom/teletype-crdt](https://github.com/atom/teletype-crdt)

* [https://github.com/atom/xray](https://github.com/atom/xray)

* [https://github.com/MicrosoftDocs/live-share](https://github.com/MicrosoftDocs/live-share)

<comment><USER25> Also: [https://github.com/gritzko/swarm](https://github.com/gritzko/swarm)

</comment></comment><comment><USER26> We went with CKEditor5 with a commonmark backend and I cannot recommend it more highly. commonmark data is converted upon initially opening and when closing the editor, allowing all native functionality to happen efficiently.

However I do note that we do not yet have a production ready backend for collaborative editing. I would suggest to use their service if possible, since we're developing an open source product it would not be an option for us.

There is a quite leaning curve when implementing new plugins due to the strict separation of model and data (commonmark in our case) and user-facing views.

<comment><AUTHOR> CKEditor 5 looks amazing (from tech to docs), but that lack of an available backend is a bummer. Do you know if there's anything out there that would work as an initial/hacky/example backend? How do you plan to tackle this?

</comment></comment><comment><USER27> All I want is org mode backed by a crdt or similar so I don't have to convert in and out every time I need to collaborate with someone.

</comment><comment><USER28> I was able to get real-time collaborative text editing to work on one of my side projects by combining quill.js[1], ot.js[2], and firebase[3]. This was a few years ago when there weren't any fully open-source options. I'm in the process of switching out firebase for an elixir/phoenix backend[4]. I'm really glad for this article because it captures the exact feelings that I have.

[1] [https://quilljs.com/](https://quilljs.com/) [2] [https://github.com/Operational- Transformation/ot.js/](https://github.com/Operational-Transformation/ot.js/) [3] [https://firebase.google.com/](https://firebase.google.com/) [4] [https://github.com/phoenixframework/phoenix](https://github.com/phoenixframework/phoenix)

<comment><USER20> That looks like a really cool project but.. there weren't any fully open source options? The original Etherpad came out 10 years ago. Etherpad Lite has been out for several years also and has had formatting plugins for quite awhile.

<comment><USER28> You're right, I completely forgot about Etherpad. But I don't consider Etherpad the same as Quilljs or ProseMirror. Etherpad is something you host (an app itself) while the other text editors are something you can build upon/integrate into your app. I didn't want to host an instance of Etherpad, I needed a library.

I wanted an editing experience similar to Medium.com text editor: consistent, well-formed html output and formatting. At the time, Quilljs was one of the best open-source editor that produced consistent output regardless of the browser.

Also I didn't want to store html, I wanted to store operations in the database.

I have an app similar to Figma[1] (basically real-time Sketch) and I needed just the real-time text editing feature.

[1] [https://www.figma.com/](https://www.figma.com/)

</comment></comment></comment><comment><USER29> What about Cryptpad? [https://cryptpad.fr/](https://cryptpad.fr/)

<comment><USER20> Its full copyleft AGPL which could be an issue for someone trying to use it in a commercial application.

But for other uses, it looks absolutely incredible.

[https://github.com/xwiki-labs/cryptpad](https://github.com/xwiki- labs/cryptpad)

<comment><USER30> From the Cryptpad README, gotta love the humor:

The server does have a certain power, it can send you evil javascript which does the wrong thing (leaks the key or the data back to the server or to someone else). This is however an active attack which makes it detectable. The NSA really hates doing these because they might get caught and laughed at and humiliated in front of the whole world (again). If you're making the NSA mad enough for them to use an active attack against you, Great Success Highfive, now take the battery out of your computer before it spawns Agent Smith.

</comment></comment></comment><comment><USER31> This was one of the project idea I made myself work on during this April. The motivation being, "how hard is it to make a real-time code editor". Long story short, it is far more complicated than I had imagine and to complete in less than a week. Implementing the CRDT itself, the logic itself is challenging and than putting it down to code is another story.

From my understanding, an implementation of logoot[1] is built to create the skeleton of a collaborative environment. From there on, you have the building block to make other things work with it, such as collaborative canvas.

I built one using Socket.io on Angular and used Ace Editor own implementation of CRDT

> [https://github.com/abdusamed91/realtime- > codeeditor](https://github.com/abdusamed91/realtime-codeeditor)

I used the following references to build it

1) [https://alligator.io/angular/socket- io/](https://alligator.io/angular/socket-io/)

2) [https://medium.com/@ofir3322/create-an-online-ide-with- angul...](https://medium.com/@ofir3322/create-an-online-ide-with- angular-6-nodejs-part-1-163a939a7929)

To get started with the theory CRDT low level algorithm, these two post go into great details

1) [https://conclave-team.github.io/conclave-site/](https://conclave- team.github.io/conclave-site/)

2) [http://digitalfreepen.com/2017/10/06/simple-real- time-](http://digitalfreepen.com/2017/10/06/simple-real-time-) collaborative- text-editor.html

[1][https://hal.inria.fr/inria-00432368/document](https://hal.inria.fr/inria-00432368/document)

I'd love to take it to another level if anyone here has mutual interest in this field of work.

</comment><comment><USER13> I wonder why would one make a headline "Open source collaborative text editors", and then write about online editors which are neither fully open- sourced, nor fully collaborative. And then stop with them, without even mentioning solutions that are both truly real-time collaborative and truly open source.

<comment><USER32> Such as?

<comment><USER13> Well some of the links that others have posted here before me are such examples - starting with Etherpad.

I realize that the OP is about something that works with structured text, but the headline (as is) is just click-bait.

<comment><AUTHOR> That certainly wasn't the intention, the title is a bit of a mix of: the initial intent to list _all_ open source collaborative text editors, and then realizing, as I state in the post, that it wouldn't add much value to have a long shallow list, then deciding to limit the scope significantly, but not wanting to redesign the headline illustration, as so much effort already went into the post (both content and the code behind it) that I just needed to stop working on it and ship it :) Hope that makes sense!

</comment></comment></comment></comment><comment><USER33> You should try [https://www.fiduswriter.org](https://www.fiduswriter.org). It does have realtime collaboration, export to ODT/DOCX/Epub/LaTeX, tracked changes, WYSIWYG interface, etc. and in the latest version even a document template editor. I think relatively speaking it's quite developed in comparison to some of the other word processors presented here. It does include both frontend and backend parts to make collaboration work. (I did a lot of the programming over the past 7 years.)

</comment><comment><USER34> This article from the NYT tech blog is a really good read on how they created a custom text editor for the newsroom: [https://open.nytimes.com/building-a- text-editor-for-a-digita...](https://open.nytimes.com/building-a-text-editor- for-a-digital-first-newsroom-f1cb8367fc21)

They built their custom app with the open source ProseMirror ([http://prosemirror.net/](http://prosemirror.net/)) toolkit.

</comment><comment><USER35> Emacs can connect to multiple screens.

<comment><USER29> Pointers?

<comment><USER36> Run and emacs server, and multiple simultaneous connections into it.

</comment></comment></comment><comment><USER37> So, lots of open-source UIs that use closed-source servers for collaborative editing?

This figures. This is one of the ways 'open source' companies can make money.

So, the author sets about making an open-source collaboration server that inter-operates with the existing open-source editor?

Kudos!

But now the company can retaliate by adding features or inconsistencies to the closed source server and its integration into the UI, making the open-source server forever out-of-date and playing catch-up.

Ouch.

</comment><comment><USER38> Another one missing: [https://en.wikipedia.org/wiki/SubEthaEdit](https://en.wikipedia.org/wiki/SubEthaEdit)

 _SubEthaEdit is a collaborative real-time editor designed for Mac OS X. The name comes from the Sub-Etha communication network in The Hitchhiker 's Guide to the Galaxy series._

From 2003.

<comment><USER39> Not sure why you got downvoted. SubEthaEdit was magical back when - here is the link to the github repo for the recently released source: [https://github.com/subethaedit/SubEthaEdit](https://github.com/subethaedit/SubEthaEdit)

</comment></comment><comment><USER20> Etherpad (etherpad lite) has plugins for formatting [https://static.etherpad.org/plugins.html](https://static.etherpad.org/plugins.html)

You can try a lot of them out in the demo online [https://etherpad.org/](https://etherpad.org/)

</comment><comment><USER40> [https://gobby.github.io/](https://gobby.github.io/) ?

Not web-based though.

<comment><USER41> That brings back memories. Used gobby all the way back in school.

</comment></comment><comment><USER8> One neat thing about live collaboration is that every single edit is stored. This enables some nice things, like seamless replay of the entire document editing history. We've been working for a while on trying to analyze edit histories, to see if we could predict which stage of editing a document is in, which writing strategy users use, how a small team is collaborating etc. (Main purpose is to support teachers using this with student groups). We have some code here that works with Etherpad and ShareDB ([https://github.com/chili- epfl/FROG-analytics](https://github.com/chili-epfl/FROG-analytics)), and happy to share preprints with anyone interested.

<comment><USER42> Hi Houshuang - very interested in this area. My company produces a web app for document-based collaboration in Higher Education (working with Universities in Australia and NZ over the last 10 years). We are also research-active and involved in collaborative research projects with a number of Unis. Please contact me via my profile. ~ Rodney

</comment></comment><comment><USER43> [https://github.com/psybernetics/synchrony](https://github.com/psybernetics/synchrony) does realtime collaborative WYSIWYG hyperdocument editing.

Imagine if Google Wave had a friends list similar to Telegram and each peer acted as a public cache for dead hypermedia.

</comment><comment><USER44> I'm new to the topic from a technical point of view. I was wondering if the conflict resolving issues are fundamentally different from online gaming scenarios. I.e., could the ways problems are solved in multiplayer games also be applied to collaborative editors and vice versa?

<comment><USER45> The quake3 netcode is eventually consistent and always reminded me of CRDTs. [https://fabiensanglard.net/quake3/network.php](https://fabiensanglard.net/quake3/network.php)

<comment><USER44> I was thinking exactly about q3a when I wrote the question!

</comment></comment></comment><comment><USER46> HackMD is a decent online Markdown editor.

</comment><comment><USER25> Another one for the list:

[https://github.com/ipfs-shipyard/peer-pad](https://github.com/ipfs- shipyard/peer-pad)

Demo here:

[http://dev.peerpad.net/](http://dev.peerpad.net/)

(this version will launch soon as soon as we complete the "pinning" / backup link to ipfs-cluster and make some UI tweaks)

Built with:

[https://github.com/peer-base/peer-base](https://github.com/peer-base/peer- base)

</comment><comment><USER47> Since it didn't make the list, nor has been mentioned in this thread, I want to recommend [https://firepad.io/](https://firepad.io/) \- we use it quite heavily at our company. It's uses Firebase behind the scenes so is essentially 'serverless' and we use it for editing our e-mail newsletters live as a team. It literally takes minutes to throw into an app.

<comment><USER48> It's in the headline image.

</comment></comment><comment><USER49> Until last year and for two years I kept an Etherpad Lite to do shared text editing and it was amazing. It was in use for three years. The only reason I stopped using it was Google Docs, who bought the company or IP for Etherpad, can do the same thing and therefore I don't have to do the Linux maintenance. I even had it use SQlite as the database and it could handle as many as 30 simultaneous users without a hitch.

<comment><USER50> Etherpad has been open source since 2009, when it was bought by Google and immediately re-licensed. It stayed open source ever since. It was written in a mix of Scala & JS.

Etherpad Lite ([https://github.com/ether/etherpad- lite](https://github.com/ether/etherpad-lite)) is a port to javascript, is backed by the Free Software Conservancy and is not owned by any corporation.

Yes, if you do not mind using Google's infrastructure, Google Docs is easier & more featureul. There are some cases in which running on premises may make a difference, and Etherpad strives to fill that palce.

</comment></comment><comment><USER51> Mediawiki's visual editor has a (unreleased) collaborative mode: [https://www.mediawiki.org/wiki/VisualEditor/Real- time_collab...](https://www.mediawiki.org/wiki/VisualEditor/Real- time_collaboration)

Hits all those open-source client and server notes, and has the advantage of supporting everything that mediawiki does.

</comment><comment><USER52> We (at brainioapp.com) are right now working on collaborative mind map app that works like notes that you can convert (based on mark-down) to mind map. It's like a combination of Evernote and XMind. Video here: [https://youtu.be/nJjFs7GmIBQ](https://youtu.be/nJjFs7GmIBQ).

</comment><comment><USER53> Can't see any link to collaborative demos for CKEditor 5 in the article but here it is: [https://ckeditor.com/collaboration/real-time- collaborative-e...](https://ckeditor.com/collaboration/real-time- collaborative-editing/demo/)

<comment><USER54> Anyone have any experience using the collaboration feature of CKEditor5 they can share?

</comment></comment><comment><USER55> VSCode is collaborative and Open Source. You install a plugin and send someone a link - you are then hacking on their document, in your VScode on your keyboard with your plugins installed.

Sorry I can't remember what the plugin is called, I used it every day at my last contract though. Made pairing super easy.

<comment><USER56> You are talking about LiveShare plugin for VSCode

<comment><USER55> That's it - thanks!

</comment></comment></comment><comment><USER57> I'm curious about the choice of PubSweet for the collaboration components. Can you summarise what functions PubSweet is performing in your example app, and are there alternatives to PubSweet that you looked at for this functionality?

<comment><AUTHOR> It mainly has to do with familiarity with the framework. The focus of the work was on the collaborative server bits, not learning a new framework/ecosystem and I feel very comfortable in PubSweet, being its lead dev. The project also served as an app-building exercise, as we're just now meeting in Cambridge to focus on that aspect and reusable components within PubSweet. And when all said and done, there weren't any friction points with this approach, it all just sort of worked, from data model migrations to React frontend, so yay :) Hope that clears it up!

</comment></comment><comment><USER58> Some colleagues at work started to use [https://hackmd.io/](https://hackmd.io/) for collaborative editing of markdown text. It works great.

</comment><comment><USER59> A CKEditor 5 team member here. Thanks a lot for such an in-depth analysis, the article is a great read and we truly appreciate being a contender there.

As for the existing implementations of CKEditor 5 with real-time collaboration, I'm afraid since the collaborative editor is usually a component of a larger platform (publishing, e-learning, CMS, intranet, documentation management system etc.) it'd be difficult to find something like a publicly available real-life use case demo of it. Without much effort, you can check out the real-time collaborative editing demos ([https://ckeditor.com/collaboration/real-time- collaborative-e...](https://ckeditor.com/collaboration/real-time- collaborative-editing/demo/?active-demo=collaboration)) that we have on our website.

A while ago we started building our own internal implementation of a collaborative document management system using CKEditor 5 and features such as real-time collaboration with track changes (something like Google Docs) for our own needs - hopefully, once we polish it a bit, we will be able to release it. We are working on publishing a few case studies with existing customers, too.

As for offline collaboration, our current solution switches the editor to read-only when you e.g. lose connectivity, and then the editing mode is back on when you reconnect, along with the changes that were done in the meantime by other users when you were offline. The platform is ready to fully support "offline" writing. We tested some more complex scenarios with one of the users being offline - and it works (however, no periods as long as days of being offline). We focused on delivering other collaborative editing features such as track changes or comments that were more required by our customers. Full support for writing while being offline is still on our roadmap, though.

As for the answer to why the collaboration component is not Open Source: we have currently 40 people in total working on CKEditor (CKEditor 4 & CKEditor 5). Developing such a complex application takes a lot of time and resources and we simply need money to cover the expenses. Without that, we'd not be able to spend so much time on fixing bugs or bringing new features. Also, unfortunately, we learned the hard way that some of the biggest IT companies don't want to help Open Source projects by spending even a single dollar on them, even if they use it in an application that brings them millions of dollars.

Regarding mobile support: CKEditor 5 works well on mobiles (with and without real-time collaboration). The comment you referred to was about the lack of an online demo of real-time collaboration on ckeditor.com for mobile devices. The reason behind this decision was that we are using the sidebar for displaying comments, which results in rather poor UX on mobiles. Fortunately, we are almost finishing the inline annotations plugin which will display comments inline, without using the sidebar. Feel free to assign a full Kiwi for mobile support :)

Thanks again for the article!

<comment><USER60> > The platform is ready to fully support "offline" writing

how did you solve the merge when somebody comes online again but creates a conflict with his changes?

<comment><USER7> I don't like "merge" word because it implies how the problem is solved. "Synchronise" would be better, as there is no merging, actually.

We use Operational Transformation, so all the changes are stored as operations (with their most important property being path - the position where the operation happened).

When a user comes online, they try to re-send all the operations that are buffered and not yet sent to the server. Then it is a matter of transforming these operations by the new operations that happened in the meantime (when the user was offline). Of course, the user also has to accept the new operations.

This is a bigger / more complex version of the basic problem of the real-time collaboration. During real-time collaboration with all users online you might need to transform your operation by maybe several other operations at most. When you go offline, it might be tens or hundreds of operations but the problem is basically the same, just bigger.

The quality of the transformation algorithms will make a huge role in how well the user intentions will be preserved.

"Platform is ready" means that the theory behind our solution is correct and that we checked some moderately complex scenarios.

Edit: still, the base scenario is that the users write "online" and "offline" kicks in when you lose a connection (for hours, even). If we are talking about "everyone writes offline and then they magically merge" then I think this might be a totally different feature (and maybe even outside of the editor and inside the CMS).

</comment></comment></comment><comment><USER61> i feel like overleaf/sharelatex should be somewhere in this article

<comment><AUTHOR> I know the folks at Overleaf and they're awesome! However, their editor is not open source. But yes, ShareLaTex probably needs a spot on there, though I haven't looked at it in a long while and it seems to be pretty dormant in terms of development: [https://github.com/sharelatex/sharelatex/graphs/contributors](https://github.com/sharelatex/sharelatex/graphs/contributors)

Had no idea it had real-time collaboration... Wonder how it's done. Digging in now... :)

If you're using it, it would be great to get your thoughts on it and what particular things you like about it.

Update: ShareLaTeX uses a string-based collaboration algorithm (i.e. LaTeX is plain text, not a structured document format), and seems to be limited to max 2 collaborators (though that could be old info), so that explains why it didn't appear on my radar. I'll take it for a spin anyway, thanks!

<comment><USER62> "seems to be pretty dormant in terms of development" \-- that's because Overleaf purchased ShareLaTeX. [https://www.overleaf.com/blog/518-exciting- news-sharelatex-i...](https://www.overleaf.com/blog/518-exciting-news- sharelatex-is-joining-overleaf)

Also, you might be unaware of CoCalc, which is open source [https://github.com/sagemathinc/cocalc](https://github.com/sagemathinc/cocalc). CoCalc supports collaborative editing of many structured documents, including Jupyter notebooks, but not rich text at present.

<comment><USER63> Hello, cofounder of Overleaf here.

Just to be clear, open source development of ShareLaTeX is ongoing and indeed has accelerated since Overleaf and ShareLaTeX joined forces. ShareLaTeX is split into many repos, and the one linked above is a 'coordinator' repo that doesn't get updated much. See [https://github.com/sharelatex/web- sharelatex](https://github.com/sharelatex/web-sharelatex) for one that is more active.

The free version of Overleaf/ShareLaTeX does have a restriction on the number of collaborators: you plus one other. Paid accounts support more collaborators [1], and you can also get more collaborators on the free account by referring others [2].

[1] [https://www.overleaf.com/user/subscription/plans](https://www.overleaf.com/user/subscription/plans)

[2] [https://www.overleaf.com/user/bonus](https://www.overleaf.com/user/bonus) (requires an account)

</comment></comment></comment></comment><comment><USER64> Collabora and onlyoffice are pretty good if you are looking for functionality similar to google docs.

</comment><comment><USER65> tmux + vim (akin to Windows Remote Assistance) can be good enough in some situations.

<comment><USER11> Not really. I use tmux + vim on a daily basis, but it starts with having just one cursor. Goes on with not being web-based and in the end, it has no offline collaboration support (that requires some kind of merge strategy).

So yes, there are some use-cases when it is sufficient for collaboration, but most certainly not for the use-cases described in the blog post.

<comment><USER65> My use-case isn't similar to the ones described in the blog post.

You could easily make tmux + vim web-based if you desire (I don't see why, I'd just use Mosh or SSH instead). For merging you could abstract the content to a Git repository. For multiple cursors you could try Wemux [1].

[1] [https://github.com/zolrath/wemux](https://github.com/zolrath/wemux)

</comment></comment></comment><comment><USER66> Any whiteboard products? Collaborative drawing would make remote work lovely.

<comment><USER67> I've just found that Cryptpad offers a whiteboard feature.[1] I know nothing more about them and was just checking them out after seeing the comment in this thread.

[1] [https://cryptpad.fr/whiteboard/](https://cryptpad.fr/whiteboard/)

</comment></comment><comment><USER68> The author didn't mention TinyMCE. Was that on purpose? Is it not good?

<comment><USER69> Does it support real time collaborative editing?

</comment></comment><comment><USER70> Is there a way to use one of them without hosting it yourself?

<comment><USER71> Also check out [https://codeshare.io](https://codeshare.io)

<comment><USER70> Ty!

</comment></comment></comment><comment><USER72> Awesome! Thanks for sharing :D

</comment><comment><USER73> For anyone who wants a quick primer on OT / CRDT text algorithms:

[https://gun.eco/explainers/school/class.html](https://gun.eco/explainers/school/class.html) ( Cartoon Explainer! )

For a detailed deep dive, including RGA:

[https://www.youtube.com/watch?v=yCcWpzY8dIA](https://www.youtube.com/watch?v=yCcWpzY8dIA)</comment>


Erlang Creator Joe Armstrong Wants to Ditch AJAX, Loves Chrome's New Web Sockets - <AUTHOR> http://groups.google.com/group/erlang-programming/browse_thread/thread/a73efebabf352d19# <comment><USER2> I've just completed implementing WebSocket support into our Mibbit webserver.

The interesting part is this:

Currently, we use XHR long polling, keep alive. Basically a raw socket with some HTTP header spam mixed in.

On the plus side, we can deflate/gzip the contents (unfortunately not across messages, but still does well). But on the negative, the HTTP headers are often about the same size or larger than the contents.

So, webSocket will improve the situation, in that there won't be HTTP header spam. Also we'll be able to use a single connection instead of two (One for sends, one for recvs). On the downside, there also won't be any deflate/gzip (Unless implemented in js etc).

The other big bonus with WebSocket is you can connect to a different port. Something that's not possible (For some idiotic reason) with XHR.

It'll be interesting to see which one wins :)

Pretty cool to see this in Chrome, I thought Firefox would be first to implement it.

<comment><USER3> _Pretty cool to see this in Chrome, I thought Firefox would be first to implement it._

If you wade through the thread, you'll see that someone posted that Firefox/Mozilla had it in trunk for nearly/over a year. Didn't check myself though.

</comment></comment><comment><USER4> Sometimes I'm glad I'm not famous enough to have everything I say scrutinized and re-broadcast.

<comment><USER5> <http://twitter.com/shawndrost/status/6547879113>

</comment></comment><comment><USER6> > Websockets let you use RHTTP. The client connects, sends a request to switch > to RHTTP, then becomes an HTTP server.

This isn't going to be another SIP, is it? 'Yes we've all agreed on this protocol, off you go and use it. NAT? What's NAT? Is it important?'

<comment><USER7> Well, the NAT issue is almost solved with STUN [<http://en.wikipedia.org/wiki/STUN>] and TURN [<http://en.wikipedia.org/wiki/Traversal_Using_Relay_NAT>] (in those cases where STUN is not enough). Together they make ICE [[http://en.wikipedia.org/wiki/Interactive_Connectivity_Establ...](http://en.wikipedia.org/wiki/Interactive_Connectivity_Establishment)].

But none of these is needed for websockets to work.

<comment><USER8> N.b. --- those solutions only work for UDP traffic, not TCP; if you want to use them and have a reliable stream protocol you'll end up reinventing TCP atop UDP.

<comment><USER9> "Reliable" and "stream" are different things. We often use (a variant of) RDP, reliable datagrams. We often want packets with guaranteed delivery, but not necessarily guaranteed order. We also use what we call USP (only partially intentionally to confuse everyone) which is an unreliable stream protocol. Packets aren't guaranteed to arrive, but if they do, they're in the right order.

Such variants have their places.

<comment><USER8> True indeed (and that's why I used both words), although for a general-purpose protocol intended for wide deployment, you probably want both properties.

</comment></comment></comment></comment></comment><comment><USER10> Am I the only one not excited by WebSockets? It seems like a nice layer over a new Comet method that's even more complex than the long-polling method that we're using today. The server still needs to handle tons of open long-running connections, but with WebSocket you have the added complexity of having to support a brand new protocol in your web server - whatever that may be - instead of one that your web server has supported since it was created.

Personally, I'd rather someone just write a minimal interface (i.e. not Bayeux) to long-running Comet connections using XMLHTTPRequest. It should be trivial after that to make it compatible with the nice API that WebSocket has exposed.

<comment><USER11> "It seems like a nice layer over a new Comet method that's even more complex than the long-polling method that we're using today."

Exactly backwards. Comet is a thick, ugly layer that is way more complex than sockets. It adds staggering resource overhead to the real abstraction you want; it will in the end be way _easier_ to support a ton of WebSockets than a ton of Comet connections. (That may not be true of pre-optimized implementations, but it will be true of final implementations.)

You don't add Socket support to your HTTP server... you have to add HTTP support to your (TCP) Socket server!

This _is_ the minimal interface; it's Comet that's the hacked up hideous ugly kludge that should never ever have been born because when that dude at Microsoft went to add XMLHttpRequest, if he'd had a clue what that bastard monstrosity would become, he would have created WebSockets right then instead. I don't blame him, it would have taken a lot of vision at the time to understand that. But _this_ is what we should have had from day one, and Comet should never have been.

We have spent a truly astonishing amount of time in the web world deep in the woods, failing to take advantage of simple things that have been known since the 1960s. We've been in the woods so long that people have come to mistake the hacks for the right answer. They're still hacks. Sockets are the not-a- hack. (Though personally I'd still have gone for real sockets.)

<comment><USER10> I can write maybe 10 lines of jQuery and hook into some of EventMachine's features using Thin as my web application server to use long-polling Comet. I agree that it's not the best solution, but I don't think WebSockets does a great job of fixing it. I also don't have a better idea though, so I suppose I shouldn't be complaining ;-)

<comment><USER11> But that's not what you were complaining about. You said that sockets were an additional layer over Comet. It's not. The fact that Comet is easy to use if you slather on another couple of layers of code doesn't change that.

Furthermore, you will find, eventually, that WebSockets perform better, both on the client and the server, and there is no amount of jQuery magic that can change that, because the suckiness is fundamental to the nature of Comet. Which again emphasizes the point that it is _Comet_ that is the layer of crap, not web sockets. There's also a lot less that can go wrong since there's a lot less code, and again, slathering on more code on top of Comet can't fix that.

<comment><USER10> My point is that long-running AJAX requests for Comet really isn't that complex or ugly of a solution. I definitely agree that it's not the most optimal (I believe it can sometimes cause problems once a large number of requests have been made, right?) A solid, native browser implementation is definitely the way to go going forward, but I'm saying that I'm not looking forward to implementing a server for a new protocol that has the same server- side problems as current Comet implementations.

</comment></comment></comment></comment></comment><comment><USER12> If the AJ in AJAX uses web sockets instead of XMLHttpRequest, isn't it _still_ AJAX?

Besides which, the X in AJAX is JSON often enough nowadays.

<comment><USER13> I guess it would be AJWS then. They're going to have to come up with a better acronym than "Adj-wuss" before this thing takes off.

</comment></comment><comment><AUTHOR> It will be great once web socket support becomes more pervasive. True 2-way communication would be a great boon in the complexity department for a bunch of different types of web apps.

<comment><USER14> Could I have a bittorent client running in Chrome?

<comment><USER15> they would need to provide a mechanism to allow connections to non origin domains, like crossdomain.xml

I understand there are security implications, but I wish browser would stop creating prohibitively strict restrictions on web applications and make a somewhat sensible way too elevate permissions

(same origin model, access to the clipboard, etc etc)

<comment><USER16> In addition, the NAT issues discussed elsewhere in this thread would also be a much bigger deal with P2P.

</comment></comment></comment></comment><comment><USER17> Something new to play with. Joe hits the sweet spot, regarding powerful & pragmatic, again.

Websockets + Erlang... nice.

</comment><comment><USER18> Ah. So _this_ is why Google built their own browser. I fully expect to see more goodies coming out of Mountain View in the future. Heck, even _I_ might finally decide to play with web technologies :p

</comment><comment><USER19> As they discuss, will proxies have to specifically enable Web Sockets to allow this to replace AJAX?

I thought this was the same problem Flash sockets had, traffic being blocked.

<comment><USER15> I think the biggest problem with flash sockets was the flash part :)

<comment><USER20> the biggest problem with flash sockets is the insane security policy file business.</comment></comment></comment>


Mossberg: The Trump effect - <AUTHOR> http://www.recode.net/2017/1/4/14162222/mossberg-trump-effect-policy <comment><USER2> TL;DR Bring back Corporate Research divisions tax free and everybody wins.

I've been a "research rat" all my life. I did research at Unimation, the first robot company. I worked at IBM Research. I've worked at Universities.

At IBM Research under Ralph Gomory, the company valued research. It measured itself against other companies like Bell Labs. I had the freedom to work on individual projects (e.g. rewritable paper and a Design-to-Build system that generated robot assembly plans from 3D CAD drawings). I worked on long term group projects, one of which was the Axiom computer algebra system.

IBM valued "wild ducks", the people who thought of new things regardless of their place in the organization. For instance, the "nipple mouse" that used to be in the center of keyboards was invented by Ted Selker who worked in the math department.

The key turning point seemed to be when Reagan shut down the Federal Labs. If you worked with someone outside of IBM Research your work was much more valued than inside efforts. The Federal Labs were a great partner in research. Once they were gone a lot of projects lost outside collaboration. The effect was widespread and deep. Axiom, for instance, was a multi-year pure research project in computer algebra. It was jointly funded by the company and the Federal labs. When the labs closed Axiom was sold, becoming a commercial competitor to Mathematica and Maple. (It is now open source and I'm doing unfunded research in program proofs for computational mathematics).

Companies don't seem to invest in "real research". Apple, Google, Microsoft, and Facebook are sitting on billions of dollars of cash. You would think that they would create a research lab equivalent to Bell Labs (where the Neural Network work was done in the 90s), or IBM Research (where the atomic microscope work was done). Gomory used to say you could employ 3 researchers per 1 million dollars. A billion dollars a year is 3000 researchers. Gomory pointed out that only 1 in 10 research projects ever produced anything that could be sold. That would be 100 new products a year, assuming 3 people per project. Gomory pointed out that "real research" took 10 years to become products. So start now.

There is a push to bring the "hidden dollars" kept overseas by Apple back into the U.S. at a lower tax rate. Instead, reduce the tax rate if the money is put into research. Let the big companies have tax breaks to run "corporate research", like Bell Labs and IBM Research. Then these company research efforts can work with universities to fund research graduate students and give them a career path worth their PhD. Tell Apple it can pump 1 Billion dollars a year tax free into a corporate research division and see how quickly the flowers bloom.</comment>


Facebook puts off IPO until late 2012 - <AUTHOR> http://www.ft.com/cms/s/2/2b842146-dec3-11e0-a228-00144feabdc0.html#axzz1XxCjKiPg

<comment><USER2> Groupon probably damaged software IPO sentiment, and people want to see how Google+ will play out. Also, they don't really need the cash and waiting will allow them to build a consistent revenue history (which will probably be disclosed, along SEC rules of 500+ investors). They can wait this one out.

<comment><USER3> I think Google+ already played out, the same way Buzz did. It's now just an echo chamber filled with Google employees and my computer programmer friends. It was nice for about two days.

<comment><USER4> Yeah, Google keeps making the same mistake by doing the closed invitation-only beta thing. My google plus is basically programmers and google employees posting shit from reddit and HN.

<comment><USER5> G+ is still in field trial, but it is far from "closed". I have 150 invites, as do all users to the best of my knowledge. The growth was limited for the first couple of weeks, but that is no longer the case.

I would disagree that controlled growth of a new product is a mistake for a company at Google's scale and brand recognition, and I would also disagree that it is still a "closed invitation-only beta thing".

<comment><USER4> Yeah? What's the male/female ratio on your google+?

<comment><USER6> I would say mine's somewhere between 1:1 and 2:1. Honestly, I don't see this as being the problem so much as the fact that it's just so quiet by comparison to Facebook.

</comment></comment></comment></comment></comment></comment><comment><USER7> With all the diffusion of their shares in the secondary markets they are on the way to reach 500 private shareholder limit and be forced by SEC to make the same kind of disclosures as a public company.

If anything the IPO timing is probably affected by their ability to stay under this magic 500 number.

<comment><USER7> Spoke too soon, looks like they have already reached 500 according to the article.

In that case hard to see how much value would be in staying "private" given the same disclosures and the liquidity in the secondary markets.

<comment><USER8> That's because the reason they've been giving to the press "that they want to keep employees hungry" is not really the real reason. With the Google+ launch, they probably think that the market will undervalue them now if they make it public.

</comment></comment></comment><comment><USER9> We've all seen rumored revenue numbers, but is there any indication that facebook is actually turning a profit?

If facebook really wanted to boost public image, a whiff of real profit would be the trick.

<comment><USER10> It is profitable: <http://www.google.com/search?q=is+facebook+profitable></comment></comment>


What Happened in the 2010s - <AUTHOR> https://avc.com/2019/12/what-happened-in-the-2010s/ <comment><USER2> [http://web.archive.org/web/20200101123154/https://avc.com/20...](http://web.archive.org/web/20200101123154/https://avc.com/2019/12/what- happened-in-the-2010s/)

<comment><USER3> May I ask why the Web Archive version is posted?

<comment><USER4> AVC.com was apparently being hammered by an avalanche of traffic. Not long after the articles about the 2010s and 2020s were upvoted to the HN front page, the site was persistently returning database connection errors. So archive links were posted in both threads.

</comment></comment></comment><comment><USER5> I very strongly disagree with #3. Machine learning has not yet proved its value outside of a handful of key areas (image recognition, voice recognition/synthesizing, etc). I think it's entirely possible we'll look back on today as a kind of machine learning mania. I certainly believe there is plenty of room to build sustainable businesses without a machine learning asset (and the associated data collection), and it's in no way "table stakes for every tech company, large and small".

<comment><USER6> You're wrong. Machine Learning is driving all of the ad placement on major ad platforms, personalization on all top social/media apps, search ranking for google, translation, speech recognition, finance, fraud detection.

In the next decade it will start taking over computer graphics, medicine, manufacturing, surveillance, hardware / software and every other aspect of our lives.

EDIT: for people who are downvoting me, here are some examples of how machine learning is and will transform our lives:

1\. 3D graphics: [https://www.youtube.com/watch?v=FlgLxSLsYWQ](https://www.youtube.com/watch?v=FlgLxSLsYWQ) Andrew Price doesn't have a technical background but does a decent job summarizing some of the ways deep learning will transform computer graphics. Soon all of the mocap, character design and animation will be driven by deep learning systems.

2\. Computer Architecture and Traditional Software: [https://www.youtube.com/watch?v=TTpKWOuzOxc](https://www.youtube.com/watch?v=TTpKWOuzOxc) There's a ton of recent research showing that you can use machine learning to beat human crafted heuristics in hardware, scheduling, compiler design and query planning.

<comment><USER7> ML is certainly valuable for speech recognition, translation, and fraud detection, but those are somewhat niche applications. It's a long way from "every tech company, large and small".

As for ad placement, social media, and search ranking: is that actually effective? The one constant with ads and social media and web search, IME, is that it just never gets any better. From the Lycos/AltaVista days to Google there was a huge jump in search result quality, and then it plateaued.

The ads I see online are still laughably bad. They're more professionally produced than 10 or 20 years ago, but they're still never for any category of product that I'd ever buy. Targeted and tracked advertising seems like a big scam.

<comment><USER6> > ML is certainly valuable for speech recognition, translation, and fraud > detection, but those are somewhat niche applications. It's a long way from > "every tech company, large and small".

Those were just some of the most visible examples. OCR, image recognition, NLP and speech recognition alone are enough to revolutionize most data entry jobs and we'll see a ton of startups using them to do just that for every industry.

There are countless other examples of machine learning applications, including drug discovery, radiology, production line quality assurance, etc.

> The ads I see online are still laughably bad.

Have ads ever been good? You see the ads that you're seeing because someone is paying a lot of money to put them there.

Bloomberg spent 120 million on ads last month, ad platforms had to find eyeballs for them.

<comment><USER8> IMO, you can get a pretty good ad experience by sticking to content-targeted ads.

If I'm looking at, for example, "how to programmatically control my model railway with a Raspberry Pi", there's a large number of easy to target, relevant products you can advertise against that. You don't need a gigabyte of creepy backstory on me to figure out "hey, show me ads for the products mentioned in the article, and there's a good chance I'll buy them because it's convenient."

Yeah, Mike Bloomberg might be willing to pay $1 to show his ugly mug next to that page, but the ad from a modeler's supply shop, who would only have paid 95 cents, would have felt much more appropriate to the consumer. I know some ad networks try to measure quality via clickthrough rate, but I'm not sure it was weighted in a way to nerf this issue.

Another problem is that a pure-content model doesn't extend to all types of site. There's no suitable product to advertise against "six die in New Year's party gone horribly wrong." and nobody wanted to run low-yield CPM branding ads, so they had to backfill wth retargeting and profile-based ads instead.

</comment></comment></comment></comment></comment><comment><USER9> In medicine, the 2010s may be remember as a period of explosive growth of engineered therapeutics. This is driven primarily by better understanding of diseases (and their molecular targets) and also by an expanding reach of bio- engineering platforms. Monoclonal antibody approvals especially have accelerated briskly for inflammatory conditions (there are 13 or more for the skin condition psoriasis alone) and perhaps more famously redefined many cancer treatment regimens with checkpoint inhibitors. Chimeric antigen receptor T cell (CAR T cells) are (very) expensive ex vivo gene-edited cell- based treatments, and other platforms for gene editing with are nearing or entering trials. This trend does not appear to be decelerating or plateauing.

</comment><comment><USER10> I think one of the big tech developments (hinted at in the article but not called out) is on demand video streaming and what that has done to how we consume media. It has changed the type of things we watch.

<comment><USER11> On demand music as well. It's ironically lead to a bit of a monoculture with music that's concerning. Streaming arguably caused the whole kerfuffle with this year's Billboard list: [https://www.stereogum.com/2068655/billboard-top- rock-songs-i...](https://www.stereogum.com/2068655/billboard-top-rock-songs- imagine-dragons/news/)

</comment></comment><comment><USER12> I was just thinking about the whole "what happened in the last decade". While the 90s ended with the rise of the web, and the 00s saw the rise of what we can do with the web, the 10s felt like an experiment of what NOT to do with the web.

</comment><comment><USER3> I am surprised with no mention of Smartphone. Which is arguably the most important innovation in modern history.

2010s, Smartphone ( iPhone 3GS at the time ) went from niche to 4B users ( iOS, Androids and KaiOS ), that is nearly every person on earth above age 14 in developed countries. I dont think there has ever been a product or technology innovation as important that spread faster than Smartphone. And it changes everyone's life. The post mentioned of Google, Facebook and Amazon empire, all partly grows to this point because of Smartphones. Technology companies together now worth close to 10 Trillions. The whole manufacturing supply chain exists and became huge in Shenzhen because of Smartphone. It was the reason why TSMC managed to catch up to Intel in both capacity and leading edge node. It was the reason why we went from 3G to 5G in mere 10 years because of all the investment kept pouring it. It was the reason why everyone went on to the Internet and had Internet economy. It brought a handheld PC _and_ Internet to a much wider audience.

I would even argue it was the Smartphone innovation that saved us from the post 2008 Financial Crisis doom as it created so much wealth, innovation and opportunities.

And the 2nd most important thing not mentioned in the article. ( May be it is not important to others... )

We lost the man who bought us the Smartphone era; Steve Jobs.

</comment><comment><USER13> > subscriptions better align the interests of the users and the developers of > mobile and web applications and avoid many of the negative aspects of the > free/ad supported business model

The most significant negative aspect that subscriptions avoid is ephemeral spambot accounts. If a user account costs money, there's way more disincentive for behavior that will get that account banned.

</comment><comment><USER14> It's sad, the point about the bay area. We could have done a lot more but nobody wants to make any sacrifices. I hope in the next decade the state will take a larger role and force local communities to drastically increase housing, density, and transit rights of way.

<comment><USER15> I've lived in the Bay Area for most of my life and I have zero confidence the situation will improve. It would have happened by now if it was going to.

The transit situation in particular will not improve because people prefer cars. People have little experience with public transit, and the experience they do have was bad, so they don't see themselves using it on a regular basis. They want to live in suburbs and drive cars, and they will try very hard to prevent anyone from increasing the density of housing or transit anywhere near their houses.

Those people vote, so a state government that tries to push for more public transit and housing density would not do well in the next election.

</comment></comment><comment><USER16> personal blogs are still crashing as if it's 2010. that must mean, not much happened

Edit: ok read the rest.

\- according to his admission, the subscription model did not scale

\- missing is the effect of planet-level monetary policy that massively benefited shares and their largest owners

<comment><USER11> Yeah he's so close to getting the idea that the World Bank and the neoliberal monetary policy caused this inequality.

<comment><USER17> What does the World Bank have to do with this?

</comment></comment></comment><comment><USER18> May as well give some thoughts on this:

> 1/ The emergence of the big four web/mobile monopolies; Apple, Google, > Amazon, and Facebook

I'm not sure you could class Apple alongside some of the others for monopoly power either. They're still less popular than Microsoft for desktop operating systems, Google for mobile ones and virtually every other major service in their other areas of business.

Apple is a very profitable business, but they're arguably more of a luxury goods maker than a monopoly right now, especially outside of tech circles.

> 2/ The massive experiment in using capital as a moat to build startups into > sustainable businesses has now played out and we can call it a failure for > the most part.

This is an interesting point, and I definitely wonder how it'll affect the tech industry in future.

> 4/ Subscriptions became the second scaled business model for web and mobile > businesses, following advertising which emerged at scale in the previous > decade.

Have they? They've done really well in some markets, but also done really poorly in others. People are definitely interested in them for music, films, TV, etc, and people + companies are interested in for them for certain products and services, but there are still many areas where they haven't done nearly as well as expected.

For instance, subscriptions still haven't worked in the media industry for news/journalism, as much as certain publications are hoping they would. They also haven't done too hot in the games industry either, if Google Stadia's performance is to be believed. Jury's still out for YouTube/Twitch creators too, with Patreon type services being the de facto monetisation method right now. Free with ads has usually beat out subscriptions when in competition with it.

> 7/ Technology inserted itself right in the middle of society this decade.

It sure did, though it's more like people took notice this decade, since the political tides went one way rather than the other.

> And the stagnation of earning power in the lower and middle class is > absolutely the result of technology automation, a trend that will only > accelerate in coming years.

It's effects on politics will accelerate too, as shown by this decade's move towards more extreme political parties and policies worldwide. This might not end well, especially with environmental issues caused by global warming/climate change at the same time.

<comment><USER19> > Have they? They've done really well in some markets, but also done really > poorly in others. People are definitely interested in them for music, films, > TV, etc, and people + companies are interested in for them for certain > products and services, but there are still many areas where they haven't > done nearly as well as expected.

A pattern I identified was that subscriptions work really well when property rights are strong and enforced strongly (TV shows, movies, music, books etc). It doesn't really work well when property rights can be bypassed easily or have a convenient alternative (you want to read NYT story without a subscription? read that story on some other outlet).

</comment></comment><comment><USER20> Very few new capabilities for mankind were discovered in the last 10Y mainly CRISPR and CAR-T therapy and two level neural networks (Google translate, alphago). Lithium-Ion batteries got 50% stronger and 6x cheaper (see photo in [https://drive.google.com/open?id=1FwCzOaig88r79FC7wM7RqtZ72c...](https://drive.google.com/open?id=1FwCzOaig88r79FC7wM7RqtZ72ct5hNM7)). Most scientists focused on confirming what was already there (gravity waves, higgs boson, water on moon, water on Mars, etc ). Carbon fiber increased passenger air travel efficiency and became commonplace in bicycle frame design. The 2010s were not a creative decade ...

</comment><comment><USER21> "...the fact that the tech sector has such a powerful role means that it will be highly regulated by society."

I think this reality will arrive hard and fast in the 2020's. The breadth and depth of regulation globally will depend on election outcomes. But it will happen either way. GDPR and CCPA are just a taste of what's to come. We'll see regulation in several key areas including:

\- Social media's goal of increased engagement vs mental health.

\- Cross border cybersecurity.

\- More jurisdictions adopting GDPR/CCPA-like privacy laws.

\- Cloud providers (consumer in particular) and vendor lock-in vs portability.

Some is already happening, but expect to see a ramp up. Don't interpret this as me being pro/anti regulation. Just a reality that's coming IMO.

<comment><USER22> OMG yes.

I find it funny that there're still so many CEOs that I speak to and they are constantly pushing the idea that tech should not be regulated.

Even if you're right, there's probably not a single politician out there who wouldn't use that as a way to build their career on.

</comment></comment><comment><USER23> In my opinion, machine learning is going to replace all of us, now or in the future. We don't know but it will eventually happen, not in this decade...

</comment><comment><USER24> >the US becomes increasingly internally focused and isolationist in its world view.

There is a lot of industry built around supplying the half a trillion a year military. They are well practiced in resisting reductions in funding. If the US becomes isolationist does that military might get turned inward.

Which option do you think is more likely

a) Stop buying so many toys

b) Overflow our sandpit into the rest of the yard

c) Play with our toys in other peoples' sandpits

Isolationism requires cutting out c as an option.

<comment><USER25> Looks like you commented on the wrong article. You're quoting the 2020s piece.</comment></comment>


Popular Myths about C++, Part 2 - <AUTHOR> http://isocpp.org/blog/2014/12/myths-2 <comment><USER2> Really, "For reliable software, you need Garbage Collection" is the straw man you're going to attack?

What comes to mind when you hear "reliable software"? Personally, I immediately think of critical embedded systems like rocket and spacecraft guidance and automotive control systems. And one thing I hear repeatedly is that many well-known coding standards for building such critical software prohibit _all_ dynamic memory allocation, because dynamic allocation is a potential failure point.

And of course, if you don't have dynamic allocation, you don't need garbage collection, because it would have nothing to do. So if the software that needs reliability the most often doesn't use dynamic allocation, only the most ignorant could think that you need garbage collection for reliable software.

<comment><USER3> All software can be reliable of course, even if it's not embedded software. Not leaking memory at every step, avoiding double freeing of pointers or other memory-related errors tends to make software more reliable...

Why so upset if I may ask? I think Apple declared GCs "bad" anyway.

<comment><USER2> I'm upset because a leading figure of the programming community who a _lot_ of people listen to is spouting nonsense, and lots of people are going to believe it.

Why do you think I'd care what Apple says about garbage collection...?

<comment><USER3> But it's not nonsense, realiability isn't all or nothing, and GC has the effect that it completely removes a class of problems that happen often in languages like C or C++ when doing manual memory management. It is making those programs more reliable, even if they aren't as bug-free as your typical spacecraft software.

That was just a joke with Apple. :)

<comment><USER2> I'm not arguing against GC or the reliability thereof. I'm merely arguing that "GC is required for reliability" is a ridiculous straw man of a myth. I am in fact a fan of GC, but I also recognize that when lives are on the line, GC and indeed dynamic memory management of any type is usually out of the picture.

<comment> mark-r The reason this isn't a straw man is that it's a true belief held by many people; most of us aren't exposed to the extremes of reliability that you're talking about. When lives _aren 't_ on the line, memory management is generally a necessity.

<comment><USER2> Who actually holds this belief, that garbage collection is a _requirement_ for reliable software? Most people don't work with such software but surely everyone who even thinks about programming is aware that it exists. I mean, you don't have to dive deep into computing to know that cars are full of computers and software these days.

<comment><USER4> Keep reading HN. You'll see articles and comments that state (or imply) that normal humans can't handle memory management, and therefore GC is the way to avoid bugs and memory leaks.

Sorry, I can't give you references off the top of my head, but I've seen that stated, here, in the last couple of months at least.

<comment><USER5> I get this feeling too, and I wonder if it is from a large vocal group of people who have never ever developed anything in C or C++, yet appear to know all about how "dangerous" it is and enjoy mocking the languages, whilst pointing to niche languages with much smaller development tool ecosystems and support libraries.

Is it just me?

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER6> Here's a good myth:

        "Only program in C++ if you absolutely have no other option."

I believe in this myth, I also am currently working on a project in C++ and reading one of Strousup's books. I think even Strousup shares this belief, but he would probably phrase it a bit differently. (My project is interfacing with the Unreal Engine by Epic that exposes a C++ API.)

Just putting this out there for the discussion's sake, perhaps someone could engage on it. I recently discovered to my horror that Apache Mesos is written in C++. They use the nice futuristic style Strousup would probably applaud though, still I think any other practical programming language would have been a better fit since it's just a sysadmin tool. Obviously they disagree.

<comment><USER7> Depends on how strongly you mean "no other option". For example, is Rust another option? I'm not sure how comfortable I am writing for a language with a version of "0.12.0". My understanding is that they make breaking changes fairly frequently (at least compared to the religious mania that is C++'s approach to backwards-compatibility). D seems like an option. Go, maybe, depending on what you're doing.

Here's my standard example for when I would happily choose C++: I am writing an image processing library that I want to be able to run on both the PC and embedded platforms (e.g. one of TI's DSPs). I also want to be able to write low-cost bindings in python, ruby, etc. There are other options, but I think C++ is the best one in this case.

<comment><USER8> > Depends on how strongly you mean "no other option". For example, is Rust > another option?

What _I_ tend to think people mean when they say that, is that you have some cycles to "waste" on a simpler - while also being high level - language.

> Here's my standard example for when I would happily choose C++:

I think the standard examples are certain application-level programs.

<comment><USER9> > What I tend to think people mean when they say that, is that you have some > cycles to "waste" on a simpler language.

Isn't C simpler than C++ and doesn't waste cycles?

The only "no other option" scenario I could imagine is, legacy code in C++ or using a framework that needs C++.

<comment><USER10> > Isn't C simpler than C++ and doesn't waste cycles?

I gave a couple of C++ books to a recent CS graduate. She assured me that C++ would be easy to pick up because it has a much smaller standard library than Java. I smiled but didn't say any anything.

Yes, C is simpler than C++. But that simplicity comes with a cost, mainly that the programmer has to keep track of more details. And the C standard library is smaller than the C++ standard library (and that would be true even if the C++ standard library didn't include the C standard library).

</comment></comment></comment></comment></comment><comment><USER11> I feel like it's a bit grasping if you need such a complex example to debunk a straw man.

Implicit garbage collection is about the ease of writing code, not reliability. You make the compiler work for you by not making what you want explicit. Yes, for bad programmers, this leads to better code, but that doesn't mean you don't benefit from implicit garbage collection if you are a good programmer.

<comment><USER12> >>garbage collection is about the ease of writing code, not reliability

No, it is about reliability. You are confusing not always necessary/perfect/optimal with average case reliability. On average, automatic memory management has less bugs because certain classes of mistakes can be entirely eliminated.

Also this argument of good programmers don't have to rely on X as a crutch is more about pride than productivity. In the real world, most teams have code touched by developers at a variety of skill sets and everyone's contributions affect quality of code so tools should be measured across levels of expertise.

If you look at the highly cited research on garbage collectors I believe you'll find most of it concurs as to the benefits, edge cases not withstanding.

<comment><USER13> > Also this argument of good programmers don't have to rely on X as a crutch > is more about pride than productivity. In the real world, most teams have > code touched by developers at a variety of skill sets and everyone's > contributions affect quality of code so tools should be measured across > levels of expertise.

Not to mention that sometimes even Homer nods.

If something needs to happen in a certain way and you have to manually ensure that it happens every time, sooner or later even the best of us will slip up. Now, the tradeoff in power and flexibility might be worth the risk of shooting ourselves in the foot, but it's still a tradeoff.

</comment></comment></comment><comment><USER14> The problem is not what C++ can or cannot do. Or if you can avoid its issues (which are many), or even how long you need to be to get competent at it.

The problem is that you spend most of the time dealing with issues that are created by the language, not from the problem domain.

Every minute you are debating which kind of smart pointer to use, interpreting error messages (which are quite verbose), writing copy constructors and assignment operators, or forgetting to add a virtual destructor, is a minute not working on your problem domain.

If it is performance you're after, then C++ is also bad in the sense that it's very difficult to reason about. Due to optimizing compilers, that's true to C, but the abstraction is way thinner.

</comment><comment><USER15> This article correctly observes that "many resources are not plain memory" and then goes on to advise users to close() a file in a destructor. However, one of the ways that files are not like memory is that while free() can never fail, fclose() can fail if writing is buffered and the final write fails. This is especially problematic in C++ since throwing from a destructor is dangerous. Whether you rely on RAII or GC to free files, you will not be able to catch this sort of error. It is precisely for this reason that GC is a mechanism for memory management, not resource management in general.

</comment><comment><USER4> So far, all the comments seem to be missing Stroustrup's biggest point: _garbage collection only works for memory._ Destructors work for everything - memory, file handles, semaphores/locks, database connections, everything.

Garbage collection handles 90% of the problem transparently to the programmer. That's wonderful (really - I'm not being sarcastic here). But the problem is, garbage collecting languages usually don't have destructors, and so you're left having to manage the other 10% of the problem yourself. You have to remember to close all your own files, clean up all your database connections, and so on. Garbage collection usually makes the 90% trivial, at the price of giving you no tool at all for dealing with the other 10% (non-memory portion) of resource management.

<comment><USER16> Many modern languages have a convenient solution for those cases as well: Python has the "with" statement combined with context managers; C# has the "using" block with the "IDisposable" interface that does essentially the same thing; even Java recently got its corresponding "try-with-resources".

Before those were introduced we had try/finally which works equally well but is slightly more verbose.

<comment><USER4> Yes, you can do this with try/finally. But if you have an object that has an open file as a member, then you open the file in the constructor, and then use the open file in the member methods, and then... what? You may have a scope that you are exiting where that object becomes irrelevant, but it may be several layers away. Having to close that object's handle in a finally in that scope seems likely to be forgotten at least some of the time.

<comment><USER16> That "scope that you are exiting ... several layers away" is where you put the try/finally.

If an object has resources to dispose of (such as an open file), it should implement (to use C# as an example – it looks similar in Python and Java) the IDisposable interface, which allows you to do either:

      MyFileWrapperObject obj = ...;
      try {
        foo();
        bar();
        ...
      }
      finally {
        obj.Dispose();
      }

or:

      using (MyFileWrapperObject obj = ...) {
        foo();
        bar();
        ...
      }

Or to take a Python example from what I'm working on right now:

      with open("something.json") as f:
        data = json.load(f)

The file will automatically be closed at the end of the "with" block. Just like in C#, this feature can be used for any kind of resource, not just files.

<comment><USER4> > That "scope that you are exiting ... several layers away" is where you put > the try/finally.

Yes, I know that it's where you're supposed to put the try/finally... if you remember. Each time. And if you move the action in the finally clause if the variable changes scope or lifetime.

Destructors are considerably cleaner than this approach. You just put the close in the destructor, and let it do its job.

</comment></comment></comment></comment></comment><comment><USER17> I've heard so much laid at C++ feet over the years, but I don't find it all that horrible to work with. It seems about on the same level as Python to get most things done, just without all the magic of the python standard library.

Are there some good stories of the bad of C++ that anyone can share?

<comment><USER18> Though not updated for C++11, a place to start would be the C++ FQA [1].

[1] [http://yosefk.com/c++fqa/defective.html](http://yosefk.com/c++fqa/defective.html)

<comment> expr- C++ FQA is rarely a good place to start for anything else than finding examples of biased writing.

<comment><USER19> I found that combining the C++ FAQ and the C++ FQA made me a much better C++ programmer when I was learning the language.

Sure, it's ranty and biased, but that's kind of the point.

</comment></comment></comment></comment><comment><USER20> "My precious language isn't broken! It's not! Not! Not!" Strostrup writes something like this about once a year. There's some denial there.

The basic problem with C++ is that it's hard to tell if something really bad is happening. Think of C++ from the view of the maintenance programmer assigned to figure out why a C++ program is crashing intermittently. Or worse, the security expert trying to figure out how a system was penetrated. C++ has hiding ("abstraction") without safety. This is a bad combination, one seen in few other major languages.

We make progress in programming partly by having the language eliminate some problem. High-level languages mean you don't have to worry about register allocation, saving and restoring registers, or calling sequence conventions. Assembler programmers have to obsess on those issues. C++ doesn't eliminate any problems from C. It helps with some of them, but not to the point that they're just gone.

The three big questions in C are "How big is it?", "Who owns it?", and "Who locks it?". C++ helps a lot with the first one, even though it doesn't have enough subscript checking to guarantee the absence of buffer overflows.

C++ has struggled with the second one, with three rounds of auto_ptr, unique_ptr, and now reference-counted smart pointers. But because these are an afterthought, implemented using templates, they're neither optimized nor airtight. The mold keeps seeping through the wallpaper, in the form of raw pointers. Rust has a designed-in solution to this problem. (Rust's borrow checker is perhaps where C++ should have gone, but C++ will never get there.)

C++ as a language has no clue about who locks what. The language totally ignores concurrency. That's said to be an operating system problem. This is now a very dated concept.

(As I say occasionally, I really hope the Rust crowd doesn't screw up. They address all three of those big questions in effective ways. But I see too much use of "unsafe" in Rust code, which indicates weaknesses in the language design. The use of Rust's "unsafe" for "performance" is a big problem. From a semantic standpoint, only "Vec" needs "unsafe", because somebody has to convert raw memory to an array of objects. Everything else can be built on top of "Vec". But there is unsafe code for "performance" in hash classes and such.)

<comment><USER5> How is abstraction unsafe?

Additionally, raw pointers are not dangerous. If you're passing them around as const pointers, the receiver can't do things like deleting them. If you are writing a container class (instead of using one of the existing myriad of containers in the STL) then you can use raw pointers. But typically you would not need to write your own container class; just use one of the STL's and the move semantics. You can then use references everywhere instead. Or const references. Everyone forgets about const correctness in their C++ bashing.

For concurrency, you may wish to see [http://en.cppreference.com/w/cpp/thread](http://en.cppreference.com/w/cpp/thread)

There's even mutexes in there.

<comment><USER21> Creating a dangling const pointer is pretty trivial. Hell, make it a const reference.

        #include <iostream>

        struct Foo {
            const int &dangling;

            Foo(const int &dangling): dangling(dangling) { }
        };

        Foo foo() {
            int dangling = 0;
            Foo foo(dangling);
            return foo;
        }

        int main() {
            std::cout << foo().dangling << std::endl;
            return 0;
        }

Neither g++ nor clang warn on this, either. I am not sure why you think const pointers are safe. They aren't. Flat out.

<comment><USER5> Well I was assuming for pointers that they'd be initialised to something sensible. That would be a coding standard problem if they're not.

The example you give is also a problem with coding standards, I'd argue. It isn't the languages fault that you're using a reference that's going out of scope - that's just bad coding. (A pointer going out of scope isn't so bad, no?)</comment></comment></comment></comment>


"Goofy Linux Book Sale".  DRM free Linux books on the cheap. - <AUTHOR> http://lunduke.com/2013/11/15/goofy-linux-book-sale/

<comment><AUTHOR> Side note from the author: Posting this here as I know some folks that read Hacker News wouldn't mind saving a few bucks on my books. Not meant as spam... just don't want anyone to miss out on saving a few bucks. Feel free to ignore if you don't like DRM free Linux books. :)</comment>


Ask HN: Trade design or writing for WP coding - <AUTHOR>

Hello! I'm a copywriter/blogger who also does graphic design, and I'm searching for someone who's kickass at coding for WP. I'll essentially need two separate sides coded up.
In exchange, I offer web or print copywriting, blogging, or graphic design (logos, headers, websites, etc.)
My portfolio (which will ultimately be part of the website you're coding!) can be found here: http://www.flickr.com/photos/lindsaygoldner/sets/72157626548226572/
For some of my writing, check out my blog at http://linzlovesyou.com <comment><USER2> Clickable:

[http://www.flickr.com/photos/lindsaygoldner/sets/72157626548...](http://www.flickr.com/photos/lindsaygoldner/sets/72157626548226572/)

<http://linzlovesyou.com></comment>


Ask HN: How do I find out what people will pay for my product? - <AUTHOR>

I have spent some time developing a feedback widget for startups to use on their own websites to entice their visitors to record their screens and submit their feedback. It is a free tool right now but that's largely because I have no idea what to charge for it.
I know user feedback is something people desire for their startups but finding an affordable solution can be a challenge. That's why I developed this screen recording widget.
You can see it here at http://betapunch.com. Any feedback you have for me in terms of pricing and if it's a worthwhile product is appreciated.
Thanks <comment><USER2> test it out and do some a/b split testing :)

A recurring model is optimal.</comment>


Ring – Decentralized, Free, Multi-Device Communication - <AUTHOR> https://ring.cx/en <comment><AUTHOR> There was a new release recently: [https://lists.gnu.org/archive/html/info- gnu/2016-11/msg00001...](https://lists.gnu.org/archive/html/info- gnu/2016-11/msg00001.html) Also they joined the GNU project: [https://blog.savoirfairelinux.com/en-ca/2016/ring- official-g...](https://blog.savoirfairelinux.com/en-ca/2016/ring-official-gnu- package/)

</comment><comment><USER2> Last time I checked, offline message (storage) was not implemented. Is there progress on this?</comment>