
Open Source is not dead: On the recent demise of RethinkDB - EpicWaligora
https://www.deepstream.io/blog/open-source-is-not-dead/
======
mej10
I was surprised to hear that RethinkDB was shutting down, since everyone that
used it seemed to like it.

I looked into their business model a bit more... and it was like, super
difficult to figure out how to actually pay them for anything. Seems like
having a push-button managed DB option on AWS/Google Cloud/Generic would've
been awesome for them? The company just didn't seem like it was set up to make
money even though people liked the product.

I know, hindsight and everything... but without going to a page linked from a
random github issue that I found via Google I couldn't even find a page
talking about pricing. To build a business you have to not only make something
people love... you also have to let them pay you for it.

~~~
jrpt
Projects should reconsider the default decision of going open source. There's
just too much burnout and abandonware.

No pun intended, but I wrote a blog post about this a couple weeks ago called
Funding Open Source by Rethinking the Assumption at
[https://supportedsource.org/blog/funding-open-source-by-
reth...](https://supportedsource.org/blog/funding-open-source-by-rethinking-
the-assumption)

By rethinking the assumption (of a free price) we can keep a lot of the
benefits of open source, but also have a model that just might solve the
funding problem, by having end user companies pay. It's what I'm calling
Supported Source.

If you run a project and are interested, get in touch.

~~~
nickpsecurity
I was promoting something similar along with a guy named (Quinn?). About three
of us here before this thread haha. Anyway, proprietary software dominates in
terms of longevity and profit. FOSS has extra benefits plus lacks specific
risks. Seems obvious to me a hybrid is the answer. My first was where people
pay for product with source + perpetual license (copyright and patent) for
that release + GPL-like rights to fix or extend it for their own purposes.
Even distribute those to community of paying users. The final possibility of
lock-in or freezing that comes from lack of open distribution is the last
straw for open-source people. That needs effective solution.

The alternatives are two things: dual-licensing or just charging for the open-
source software. These are fully open-source where they have no risks of
proprietary software but risk loosing profit due to freeloaders or knockoffs.
The latter option, charging for OSS stuff, threw me as I thought it wasn't
allowed per some of the license but an OpenSUSE employee pointed out it's
basically what they do. Some others do, too, including one person whose
company does custom jobs for other firms plus GPL's anything they make. You
basically make it available for people to grab but just keep charging
corporations for it anyway. They don't know the difference as they're paying
for specific benefits.

What's your thoughts on these OSS options?

EDIT: Wait, yeah it was Quinn with Fair Source. I've been too busy to get back
to him but I see all of us having a more extended discussion on these things
in future when things stabilize for me. :)

~~~
chipotle_coyote
_My first was where people pay for product with source + perpetual license
(copyright and patent) for that release + GPL-like rights to fix or extend it
for their own purposes. Even distribute those to community of paying users._

Interestingly enough, similar models seemed to be more common back in the dark
ages of computing before terms like Open Source and Free Software were really
a thing, particularly on minicomputers and mainframes. It made its way to the
"microcomputer" world in more limited fashion, then sort of slowly died out.
But I think there may still be something to the notion of a license that,
while not remotely meeting the definition of "free software," still gives you
access to the source.

I'll be honest, though; I think FOSS advocates have a tendency to (perhaps
unconsciously) downplay how important "free as in beer" has been for the
adoption of a lot of major software projects. An internet in which Apache,
MySQL, PHP, and other major free software projects were released with
commercial "source included" licenses would probably look very different.

I have my own thoughts about RethinkDB's failure as a commercial entity, but
despite having actually been inside, I have pretty limited insider knowledge.
Perhaps we should have been trying to push an "enterprise edition" with
guaranteed support much earlier, following the "charging for OSS stuff" line
you mentioned; as others have said, maybe we just didn't have enough avenues
through which to give us money. (It's hard not to notice that MariaDB's .com
site is essentially _page after page_ of ways to give them money, for
instance.)

~~~
nickpsecurity
The Burroughs MCP came with source with users allowed to submit updates to
them for redistribution. So, the first, great mainframe for business operated
under shared-source license. It became a multi-billion dollar company. They
closed it off and pulled all kinds of schemes eventually. Now called Unisys.

I think a combo of paid with source and closed-source extensions can still get
lots of success. We're already seeing it with enterprise editions for features
that basically only enterprises use. That keeps them from crippling the main,
OSS product which costs less. I also envision giving free licenses to people
that contribute lots of code, docs, testing, etc. One way is to simply not
charge businesses below a certain revenue amount or only to charge a support
fee tied to cost of delivering support. As they grow, so does the software
house like in the royalty model.

------
maxdemarzi
I hope RethinkDB going out of business does not become the justification to go
closed source. At Neo4j we open source both the community and enterprise
edition (
[https://github.com/neo4j/neo4j/tree/3.1/enterprise](https://github.com/neo4j/neo4j/tree/3.1/enterprise)
) but we ask you to pay for the enterprise edition with a commercial license.
Most of the non-employee contributions to Neo4j are not made directly to the
product but using extensions, and plugins.

We find people who start with community edition will eventually move to
enterprise once they establish the value it brings...and then eventually they
will pay for the enterprise license. Yes, we have tons of people using the
enterprise edition without paying... and that's ok. They'll come around too
eventually once they see the value.

If we can build a business going full open source, you can too. Don't let the
commercial failure of RethinkDB scare you otherwise.

------
johan_larson
We discussed this recently at Couchbase, where I work. Couchbase is mostly
open source. You can build most components of the database system, but the
installer and some of the more enterprisy bits of the codebase are closed-
source. You could, say, build the complete query engine and drop the very
latest code into an existing installation.

We don't have any users who contribute to the codebase. But there are a few
elite users out there who build their own components for debugging purposes.
This lets them send us very precise bug reports that get acted on quickly.

So, all in all, we get a little bit of benefit from being mostly open source.

~~~
wmccullough
I don't think your story at Couchbase is all that unique either. I'm finding
many open source projects without much contribution beyond the maintainers.

For me, the value in open source comes from being able to learn the depths of
a code base, or to see how a pattern was applied to solve a type of issue that
I may be trying to solve in an unrelated technology. If I find a bug I will
submit a PR where I can, if I understand the code base well enough.

That said, I think it's a Utopian ideal that going open source means that
people will flock to contribute to a project. Companies like Microsoft are
learning this the hard way I feel. Have a look at their .net core repos. The
vast majority of users are simply "throwing issues over the wall" without
trying to contribute any fixes or discussion.

I would love to live in a world where everyone attempted to produce more than
they consume, but we just aren't there.

EDIT: P.S. I love Couchbase!

~~~
Noseshine

      > a world where everyone attempted to produce more than they consume
    

Personally, the reason why I don't contribute but consume from many projects
is that I produce _other stuff_. All those projects are _input_ , they are
incidental and in the end replaceable. How would I do that anyway? I may use a
dozen projects regularly enough. Any one of them already is complicated
enough.

What I do is try to write easily reproducible bug reports. However, if I were
to even attempt to contribute any code I would have to make a _major_ effort.
There are few problems on a foreign code base that can be solved in an hour or
a few hours.

This is why I ended up using Intellij instead of an open source editor: I once
submitted an issue on Github and the response was basically "where is your
pull request". I understand the developer(s), but sorry, I am just not able to
do that. Imagine that a sizable number of OS projects only deal with your
reports if you are an actual contributor. Sounds like a good idea? But how
would any person even manage to be a contributor to even half the projects
that I am using? Anyway, back to the IDE, I pay Jetbrains and give them great
bug reports and they fix most issues.

I think it is completely normal, just from a statistics and system modeling
perspective, that only a tiny number of developers contribute to a project,
and that those mostly are people for whom that particular project is a _core
issue_. It is just not feasible any other way.

\--

Here is a crazy idea (only half serious, meant mostly to bring a new direction
into the debate - so no need to point out potential problems, it is not a
suggestion made to be implemented).

Imagine we had a worldwide organization that you pay a certain amount to.
Several levels, flat fee but with levels.

The organization watches what "free stuff" you use. Software, code, anything
that's bits and bytes, could easily be extended to 3D printer models photos
movies etc.

Then they distribute the money they got from the (semi)flat tax to the makers
of the various things.

The different payment levels indicate a) amount of use, someone using only a
little bit of free stuff vs. someone who uses tons of it, b) level of
sophistication, so use of the left-pad npm package and similar stuff is a
different level than someone using Blender, for example.

Actually, such organizations do exist. In Germany there is one that collects
fees from copy shops and distributes it to right holders of printed works ("VG
WORT"), and there is another one collecting fees for music and film ("Gema").
Lots of problems, of course, just saying that the idea itself is not all that
outlandish and attempts at partial implementation for specific countries and
sectors already exist.

Again, just to show another option compared to no solution and continuing what
we do, lots of problems of course, like how do you prevent someone from
inflating their usage count, privacy, etc.

How about a limited implementation of something like this? We need _some_ way
for contributors of "free stuff" to be able to live a life. I think it is bad
to a) accept and b) rely on such people making a living somewhere else. It is
too random.

I am _not_ a "socialist". It is entirely "capitalistic" to expect that there
should be a reward system for actually useful contributions (as measured by
usage). I just think our 19th century system is very badly suited to handle
the new digital world, from copyrights to open source.

The problem of individual payments also is that the per-payment cost is too
high - and I also mean the psychological cost. Imagine you had to buy a car
screw by screw instead of as a whole package, being asked for every single
tiny piece "how much are you willing to pay or contribute?"

It could also be a potential solution for this problem also on the frontpage
right now, because those people could go from the official job market where
they are noz wanted into the system I describe:
[https://news.ycombinator.com/item?id=12724104](https://news.ycombinator.com/item?id=12724104)

\---

I also want to make a connection to the Universal Basic Income discussion. I
am skeptical of the "pure" idea, I think we are still far away from allowing
universal leisure and I don't believe that most people will voluntarily do
something useful. But how about the above idea can be connected? If you do
_something_ useful that's all that's needed, but you have much more freedom to
decide what that is. Mostly, "distributing free stuff" now works as a business
idea!

~~~
witty_username
What is the problem with money as the reward system as it currently is?

~~~
jrpt
The problem is that open source is given away for free, and companies are
exploiting that. It's estimated that open source was worth at least $143M of
Instagram's $1B acquisition. But the open source developers got nothing.

The solution as I see it is Supported Source
([https://supportedsource.org/](https://supportedsource.org/))

~~~
nickpsecurity
The estimate on Linux was at least a billion. That's what IBM alone was
willing to commit to defending it against Microsoft/SCO suits if I interpreted
the reporting correctly. I'd love to see how much money people saved on IIS,
etc. thanks to Apache deployments. We'd first need to know what percentage
would've paid for a server in the first place as many will only set up if it's
free. Then, convert that to even half IIS + Windows Server licensing I bet
it's a fortune.

~~~
pjmlp
I bet many of them would just go back to pirating stuff.

This is what FOSS actually made in the last decade, moved many that would
never pay for software from pirating it to just downloading whatever they can
find in open source repositories.

But the developers still don't get anything back.

~~~
nickpsecurity
I didnt think about that. Good point. Counter would be BSA. They tip employees
to reveal stuff like that. They could visit each Global 2000 to pay employees
for info on what software was used and how often. Plus network fingerprinting.
Just collecting first years fees as payment would cover cost of BSA and
payouts.

~~~
pjmlp
That would only work in countries where organizations like BSA do exist and
are actually effective.

Which isn't the case in many countries.

~~~
nickpsecurity
Another good point. I might have to think further on it.

------
jratkevic
Launched these guys and many other OSS cos and I never thought of them as a
true DB. Rethink was evangelizing an approach and how DBs of the future should
operate. Ultimately no one knew if they were an DB or a load balancing engine
of some kind that sped up DB transactions for say mobile apps that would only
send DB changes to the client vs entire DB data. They got stuck in this no-
mans land of no one knew what they were - let alone they had no way to sell
it.

Open source or not didn't even come into play, They had great _interest_ ,
devs liked them and they figured out how to do meetups without much budget.
Devs I knew said they liked them team but shortly into it it was clear they
were hoping a revenue stream would stick and went forward on that would just
happen. Strange one really.

------
SadWebDeveloper
From my POV: Open Source should be about transparency, 3rd party code reviews
and occasionally contribution from your own fanbase/community or well niche
players. It was never about allowing (unpaid) developers help you built your
project, unfortunately most people think the later is why you go OSS.

~~~
pjmlp
Many comercial products always had the source available.

For example, usually with the professional version of compilers the source
code was also there, just not on the student/hobby versions.

Just recently I got hold of an old Turbo Pascal 5.5. brochure where Borland
explicitly referred the availability of the source code on it.

~~~
TimJYoung
Yes, and later on the entire Delphi ecosystem frowned on not making the source
code to third party components available in at least some form, so most did.
Borland originally set the stage for this by including the source code to the
entire RTL/VCL in Delphi, which continues to this day.

------
ernestbro
I think what is dead is open source as a novelty that gets you noticed (e.g.
Ipso facto having an open source product means the market you're after notices
you over your competitors).

Yes, open source brings commercial benefits to a company over closed source
but it's not as big of a differentiator because it's quite pervasive now
(which is good!)

------
stemuk
I think it is pretty interesting to see that the authors (Wolfram Hempel)
company, deepstreamhub, does have a businessmodel not far away from
RethinkDBs.

Both are based on paid consulting/support and try to monetize their open
source software (RethinkDB and Horizon on one hand, deepstream.io on the
other) through hosted versions, the Horizon Cloud (beta) and the yet to be
released deepstreamhub.com. I really hope this works out for deepstream.io,
maybe the focus on PaaS makes the difference.

------
mkesper
If by "open source" he means open core, I sincerely hope it's dead.

~~~
pluma
Why are you against open core in general assuming the open source part isn't
crippled as part of the strategy?

As long as the open core is still a quality product with good support and
documentation I don't see the problem. Nearly every other open source database
seems to be built this way and it seems to be working fairly well for GitLab
(who are also pretty open about their development of the EE although the EE
itself is not open source).

~~~
mperham
I use the same open core model with Sidekiq
[http://sidekiq.org](http://sidekiq.org) and it's working incredibly well.
Casual users get lots of value from the free OSS version, heavy and corporate
users get additional APIs and support from the paid version. Open Core isn't
the only way to make OSS work but it's worked really well for me.

~~~
protomikron
Ok, I looked up your project and it seems to be a job scheduling system for
Ruby. Kudos to you, but I had a look at the feature table, and the "multi-
process" feature is only available in the paid edition.

IMHO this is the main problem with open-core and it is a really tough decision
you have to make - is multi-process a standard feature or not? Because
ultimately I would have guessed it is a fundamental feature of a job
scheduling system (assuming long-running tasks) and one could say it is even
at the _core_ of a scheduling system.

Don't take this the wrong way, I applaud everybody who finds a way to develop
meaningful FOSS (and a reliable working background job scheduling system is
not a walk in the park) and getting paid for it, so good luck with it!

~~~
mperham
Good questions. Couple of things to note:

1\. My paid features are all built on the core APIs that are open source.
Almost every feature I sell has an OSS variant that someone has written. If
you want to plug in a dozen different OSS libraries, integrate and test them
together, you can get most of what I sell for $0. You will get varying levels
of support and yearly upgrades of that stack will take days or weeks to
validate. My customers recognize that building __and maintaining __any system
like Sidekiq is non-trivial. You can spend a week or more annually maintaining
your own Sidekiq "distro" or you can pay me to do it. So far, many hundreds of
companies have opted for the latter.

2\. Regarding multi-process specifically, each Sidekiq process is multi-
threaded and will execute (by default) 25 jobs concurrently. Multi-threading
is the OSS feature and delivers a huge jump in efficiently versus the old
single-threaded Ruby job processors (Resque, DJ). multi-process makes it
easier to spread work across many cores with a single command but nothing is
stopping users from running multiple Sidekiq processes, they just won't share
memory and must be managed separately.

~~~
protomikron
Ok, thanks for your answers, that sounds reasonable. So if I have a multi-core
machine with 8 cores I can utilize all of them if I have 8 CPU intensive jobs
(considering they fit into memory)?

~~~
mperham
Not with MRI. The standard Ruby interpreter, like Python, uses a global lock
to prevent threads from executing in parallel. You'd need to spin up 8 Sidekiq
processes by hand or use the multi-process feature to automate that manual
process.

That said, your scenario is unusual. Most server-side jobs have plenty of I/O
(think DB queries, memcached/redis calls, file I/O, etc), which allow the
threads to context-switch; lots of I/O concurrency means lots of jobs get done
quickly, even with one core.

------
colin_mccabe
It is sad to see the RethinkDB company fold. However, there are many healthy
open source NoSQL databases out there. For example, HBase, Mongo, and
Cassandra are all open source.

Why were these projects able to build communities around their codebases, when
RethinkDB was not? Part of it might have been large companies making
investments that other companies could build off of. I think choosing an
appropriate open source license, and Apache governance model was another big
part.

Certainly, not all databases or data stores need to be open source. But there
are still many successful ones out there.

------
pluma
My feeling is that there are really just three forms of open source beyond the
small-scale "single developer hobby project":

1\. Standalone open source companies like RethinkDB. These typically rely on
secondary sources of income (e.g. support contracts, SaaS, etc) or eventually
adopt an open core model (deriving a commercial product from the free open
source project).

2\. Major software companies that open source part of their work to push their
commercial services (e.g. Microsoft, Apple and Google), or as an elaborate
recruitment tool (e.g. Facebook).

3\. "Independent" open source projects where maintainers are directly
sponsored by outside companies or indirectly via foundations (e.g. Linux,
Apache, Mozilla).

I think #2 is only workable at a certain scale (because open source work
basically becomes a major marketing expense) and #3 typically requires several
significant backers to guarantee long-term survival.

So looking at startups the only workable solution for open source seems to be
#1 but because open source lies at the core of what the business does it's
vital to generate a source of income other than the open source work itself
(unless the open source work is de facto unusable for most users without a
commercial license, e.g. Sencha ExtJS and Touch).

RethinkDB seems to have failed at becoming profitable. My understanding is
that they tried very hard to maintain a "pure" open source ideology and
therefore fully relied on support and training contracts -- which is directly
at odds with their primary goal of making RethinkDB easy to learn and use.

I think RethinkDB's biggest failure was that as a product it didn't really
find a market where it could become profitable. Based on their marketing, the
main audience seems to have been startups. They were likely hoping that
startups would give them a reputation and that reputation would translate to
traction which in turn would translate into paid support, training and
commercial licenses.

But even though they could have made it a lot easier to give them money (the
support and training is hidden behind the "Services" section on their website
and I only heard about the availability of a commercial license from RethinkDB
users) I think that alone wouldn't have helped them because there just isn't
much money they could have extracted from that particular market.

RethinkDB is unattractive to most companies outside the startup sphere that
aren't tracking the new hotness. Streaming is a great selling point but there
are very few companies who would be willing to trade for that benefit when it
means a ton of drawbacks in other aspects. Horizon was acting as a
competitor/successor to Firebase but even Firebase doesn't have much of a
market.

People repeatedly point out SaaS as a possible source of income but creating
and maintaining a SaaS product is an entirely separate can of worms from
"merely" working on an open source database. Plus it brings with it a large
set of financial risks and overhead that can be a major drag on resources --
all the while hinging directly on the success of the open source main product.

And SaaS also suffers from the same problem as offering support and training:
SaaS is most useful when deploying and maintaining the same services on your
own hardware (or cloud) would be hard or troublesome, but RethinkDB tried to
position itself as easy to use and easy to learn.

For databases the only plan that seems to work for #1 is the open core model.
True, it's not ideologically "pure" open source but as long as the community
edition is a decent product on its own, there's no harm in providing
enterprise services on top of it at a premium.

------
baybal2
What is RethinkDB?

~~~
gokaygurcan
You know, there's this thing called "Google".

~~~
baybal2
I know, but I don't have it here

------
pgaddict
> Granted, it’s possible to shoehorn similar functionality on top of CouchDB,
> Mongo or PostGres - but RethinkDB ...

PostGres does not exist. Correct spellings are Postgres and PostgreSQL.

~~~
stemuk
Doge be like: Much Grumpy. Such spelling. Wow.

