
DataScript: Immutable database and Datalog query engine in ClojureScript - jasim
https://github.com/tonsky/datascript/blob/master/README.md
======
robertstutt
We're using it in production, but then, the author is on our team. We've been
using Datomic in production since Jan 2013. It's as good as it says on the
tin.

I love living dangerously, if danger means using full-stack Clojure and
immutability -grin-

~~~
dwwoelfel
We're also using it in production, and it works really well when paired with
Datomic. Thanks to transaction queues on both ends, we can set up a meteor-
style sync that's pretty handy.

It's also well-suited for rapid-prototyping. I'm working on a small project
that will eventually need a backend, but for now I just store everything in a
datascript db and serialize that to localStorage. When I'm ready to add a
backend, I'll just subscribe to datascript's transaction queue and forward
them to be saved on the server.

~~~
NhanH
The syncing in meteor-style is something I've been interested in for a while.
Do you by any chance have any document on how it's done?

~~~
fnordsensei
Seconded.

~~~
jefffriesen
Thirded.

------
robertfw
This is a project I've kept a closer eye on, as I'm thoroughly fascinated with
Datomic, and the concept of using a similar system alongside functional
approaches like React seems a good match.

Would love to hear comments from anyone who has given DataScript a test drive
- I'm guessing from the alpha state that no one is using it in production but
hey, who knows... some people like to live dangerously.

~~~
Nekorosu
Wrong guess. The project's repository has a list of things people built with
DataScript. One of those is
[https://precursorapp.com](https://precursorapp.com) It's highly usable,
stable and fun app!

------
escherize
I've been thinking a lot about using a datascript database in place of a large
mutable deeply nested hash map, or other non-regular chunk of data, to keep
track of state using the amazing clojurescript library re-frame[1].

There are some times when having a novel way to query could lead to simpler
data.

[1] [https://github.com/Day8/re-frame/](https://github.com/Day8/re-frame/)

~~~
raju
I believe the author of DataScript also wrote Rum [1] which is a lightweight
wrapper around React.

[1] - [https://github.com/tonsky/rum](https://github.com/tonsky/rum)

------
dmix
> What if creating a database would be as cheap as creating a Hashmap?

I wanted something like this for Go recently, settled with SQLite :(

------
casperc
I wonder when we are going to see an open source implementation of Datomic's
main ideas in the database space.

~~~
robertfw
There looks to be a dormant attempt at the alpha stage here:
[https://github.com/runexec/PossibleDB](https://github.com/runexec/PossibleDB)

for bonus points, it uses rethink as the backing store

------
jwr
As a datapoint, I'm using DataScript in a project and I'm quite happy with it.
It wasn't quite the promised land, but it solved many hard problems for me.

------
amirouche
how do you compare datascript/datomic to neo4j?

------
wereHamster
Immutable database? That doesn't make sense. If you can't mutate it, how do
you write to it? How do you update records in it? If it's really immutable
then you can't. Such a database is a compile-time constant.

These days everybody seems to throw around terms like immutable, isomorphic,
pure etc. without actually knowing what they mean, or using them in contexts
whey they don't make any sense.

~~~
dragonwriter
> Immutable database? That doesn't make sense. If you can't mutate it, how do
> you write to it? How do you update records in it?

You don't write to the database, you perform an operation that takes a
database and a write request and returns a new database. Same with updates.
Essentially, the kind of things you think of as "mutating" operations have a
signature of, in Haskell-ish notation:

    
    
      db -> operation -> db

~~~
wereHamster
That's how every langauge with immutable data structures works. What makes
this one special?

~~~
dwwoelfel
With this one, the database is an immutable value, so you can hold on to old
versions of it. Here's an incomplete example of how you could implement
optimistic updates:

    
    
        tx_report = datascript.transact(db_conn, [{:key "value"}]);
        set_db_to_render_from(tx_report.db_after);
        send_report_to_server(tx_report, function(error) {
          set_db_to_render_from(tx.report.db_before);
        });

