Dimitri Fontaine

I wish them well but fear this won't work out for them. This sounds like a smart move until you realize that they are just one of many players in a crowded market and that this actually decreases their value proposition for end users and external contributors. Having less of both is bad news for an OSS project, no matter how you spin it.

The way I see it this type of company has a short term value that derives from them being first (more or less) to market with whatever it is they do well. In this case, their thing is having a sharded/clustered db that can replicate across datacenters and with serialized transactions.

Awesome, that's a great thing to have and it will take other databases a while to get there. But they will eventually and that matters. This stuff commoditizes quite rapidly. It's based on published research by Google half a decade ago and people can look at the source code and algorithms. It's just a matter of time before somebody else figures out how to replicate what they do in some other product. Somebody like e.g. the postgresql developers: https://tapoueh.org/blog/2018/07/postgresql-concurrency-isolation-and-locking/ and https://pgdash.io/blog/postgres-11-sharding.html. It's probably not perfect yet but they are obviously heading the same direction and there's a notion of good enough and diminishing returns.

When it does catch up, it all reverts to which is the best product in the market. Part of that is features but another part of that is a robust…

The SQL can look a bit complex at first, and advanced queries can look complex, but MongoDB is quite limited what operations you can do with it, so the SQL queries that correspond to MongoDB operations are fairly simple.

Here's a documentation from MongoDB which could be used the other way as well:
http://docs.mongodb.org/manual/reference/sql-comparison/

For normal use you really need 4 operations:

SELECT - query data

INSERT - inserting data

UPDATE - modifying existing data

DELETE - remove data

Everything else is either used for database maintenance or DDL (Data Definition Language, defining how the data is stored) commands.

The DDL is the main reason why some organization are considering using MongoDB, they believe that by removing the schema (definition how data is stored) they will get more flexibility, the problem with it is that if you use MongoDB you still will have schema, the issue is that the schema will be enforced by your application. And if you don't enforce the structure you'll end up with quite a mess, and very complex code.

Also if you use Java (or JVM based language) there are many frameworks that supposed to help interacting with database each has their strengths and weaknesses. There's one called JOOQ[1] that allows you to write SQL queries in Java in a way very similar to MongoDB.

Edit: There's also article about MongoDB aggregate functions and equivalent PostgreSQL:…

I’m a bit surprised to hear that is the state of migrations in Rails. Being a Django developer I’m used to having most of the points you mention covered for a really long time already.

It’s timeless by looking at a captured schema, that doesn’t change with later code changes. Which means you can’t import / use methods of models and have to copy those over. So a different way than using the vcs for this, but still.

Not sure I’d name the second point “scalable”, but you can easily do data migrations as well.

It is really easy to use!

And you can certainly write tests for it, although it isn’t included in the framework [0]. But you can do that with just SQL too [1].

What I find much harder with (somewhat) larger dbs, is is a) determining whether it will lock up too much and b) whether it backwards compatible (so that you can roll back). Which is splitting in these pre- and post-migration steps as the article mentions. We currently use a linter for that but it is still a bit basic [2].

[0] https://www.caktusgroup.com/blog/2016/02/02/writing-unit-tests-django-migrations/

[1] https://tapoueh.org/blog/2017/08/sql-regression-tests/

[2] https://github.com/3YOURMIND/django-migration-linter

I'm also very curious for hear from expert lispers. I've tried to find the sweat spot where lisp would fit better than what I already know: shell for glue and file ops, R for data munging and vis, python to not reinvent things, perl/core-utils for one liners. But before I can find the niche, I get turned off by the amount of ceremony -- or maybe just how different the state and edit/evaluate loop is.

I'm holding onto some things that make common lisp look exciting and useful (static typing[0], APL DSL[1], speed [2,3,4]) and really want to get familiar with structural editing [5]

[0] https://github.com/phantomics/april
[1] https://github.com/coalton-lang/coalton/
[2] https://renato.athaydes.com/posts/revisiting-prechelt-paper-comparing-languages.html
[3] https://github.com/fukamachi/woo/blob/master/benchmark.md
[4] https://tapoueh.org/blog/2014/05/why-is-pgloader-so-much-faster/
[5] https://github.com/drym-org/symex.el

This is more related to a mindset than a list of features. By the way, "modern" and "new" have different meanings[0]. Even if a good deal of features from Lisp are incorporated in newer languages, what makes Lisp interesting is how everything is designed to bring a cohesive dynamic environment. Trace, debug, macroexpand, change the readtable, change the pretty-printer, change evaluation rules, types, conditions and restarts, special variables, around/before/after CLOS methods, the MOP, etc. all those little things contribute in making programs that can evolve, not in a hacky way but as part of the language philosophy.
I also like the idea that programs should strive to be correct first and fast second, while effectively providing ways to profile and optimize code, tune or deactivate the GC, etc.

[0] I switched from Python to Lisp because I wanted a modern language (http://tapoueh.org/confs/2014/05/05-ELS-2014)

My own point of view is biased, admittedly, but I couldn't stop thinking that Common Lisp was relevant for each item in your list.

Of course, much isn't built-in, but this is not as bad as it sounds: concurrent channels are not part of the language specification, but you can install the "calispel" or "cl-actors" libraries that gives you what looks like primitive constructs.

Regarding "modern" languages, I like this quote from the author of pgloader:
"I switched from Python to Lisp because I wanted a modern language" (also transcribed as: "[...] in searching for a modern programming language the best candidate I found was actually Common Lisp."; see http://tapoueh.org/blog/2014/05/14-pgloader-got-faster.html)