What does HackerNews think of datascript?

Datascript is the open source analog for Clojure, ClojureScript and JS: https://github.com/tonsky/datascript

Minor correction, I don't think Datomic is used. I believe it uses a variation of DataScript and in turn DataLog for queries. Whereas Datomic is a DB which is also based on and uses DataLog queries.

Either way, super powerful.

Refs: https://en.m.wikipedia.org/wiki/Datalog https://github.com/tonsky/datascript https://www.datomic.com/

The work is funded by a Clojure community group (and a Clojure-using company), and Tonsky has written a bunch of awesome other Clojure (see DataScript[1]).

So it seems as though the decision to use Clojure was not made for technical reasons, but it's not exactly arbitrary.

[1] https://github.com/tonsky/datascript

Depends on your use case

I would suggest soufflé (https://souffle-lang.github.io/) if you're batching data through for static analysis.

DDLog (https://github.com/vmware/differential-datalog) if you want a rule-engine within your interactive application, to encode decision procedures and business rules.

If you actually want this to drive the views of a (web-)application, I don't think we're really there yet. We have to wait at least for the next generation of developments. But you can give it a try with datascript https://github.com/tonsky/datascript

Datomic: https://docs.datomic.com/cloud/query/query-data-reference.ht...

Datascript: https://github.com/tonsky/datascript

Crux: https://opencrux.com/main/index.html

Author here. I started it as a side project to have a local-first, org-mode outliner web app to use on my phone. I chose Clojure/Clojurescript because I'm more familiar with both compared to Javascript/Typescript. Several things I like a lot about Clojure/Clojurescript: Data-Oriented Programming, all three (logseq, roam, athens) use Datascript, which is an in-memory database and Datalog query engine. REPL (as other lisp languages) Clojure is very stable, I can run all my old projects without any issues. Also, I don't reverse engineering the Roam code(it'll cost more time for us), Logseq is hugely inspired by Roam Research, Org Mode, TiddlyWiki, Workflow.

- Datascript: https://github.com/tonsky/datascript

Maybe checkout one of these databases:

- https://www.datomic.com/

- https://opencrux.com/

- https://github.com/replikativ/datahike

- https://github.com/tonsky/datascript

Sounds like DataScript [0] could be a good fit for you. The Datalog query language is very powerful for writing recursive rules.

[0] https://github.com/tonsky/datascript

A lot of Clojure libraries will be described as Clojure(Script) libraries which means they run on both Java and JS usually with no interface changes here are some examples: https://github.com/tonsky/datascript https://github.com/Engelberg/instaparse https://github.com/wilkerlucio/pathom

Interop with hosts is a core feature of the language so it feels natural to reach for it when you need it and it's easy to write code that handles multiple runtimes but 95% of the time maybe more you don't need explicit runtime features

For Clojure, there is Datomic[0] (a DB with S-expression Datalog) and DataScript[1] (in memory Datalog for browser) which has a fair amount of usage. Also, there's a bitemporal database use Datalog name Crux[2] seems to be quite promising.

[0] https://www.datomic.com/ [1] https://github.com/tonsky/datascript [2] https://opencrux.com/

you can give https://github.com/tonsky/datascript and https://github.com/replikativ/datahike a spin

If you need to manage state and want to focus on functions instead of objects (classes), try ClojureScript - especially in combination with [DataScript](https://github.com/tonsky/datascript), an immutable database and Datalog query engine. Clojure/ClojureScript's persistent, immutable memory model makes it much nicer for reasoning about state.

Maybe I'm just a dinosaur, but I can't keep up with all the changes to JavaScript, whereas ClojureScript compiles to ECMAScript 3 and the syntax hasn't changed since its release 12 years ago.

Depending on the stack, you can use some open source libraries. Datascript is quite robust, and useable from javascript/clojurescript. https://github.com/tonsky/datascript

A more common solution includes using Datascript[1] as the client side DB and then using something like Posh[2] or Datsync[3] to handle query/pull subscription changes.

[1]: https://github.com/tonsky/datascript

[2]: https://github.com/mpdairy/posh

[3]: https://github.com/metasoarous/datsync

Totally not saying "you're holding it wrong", but maybe once you're more than a few couple levels deep into a nested map it's time to look at an in memory db like [Datascript](https://github.com/tonsky/datascript)? Actual Datalog queries can replace get-in vectors growing out of hand, and you also get better mutations with transactions.

> Unfortunately I just haven't been able to figure out how to do a left outer join (or if that's even the right approach in Prolog :-)

That is probably my main issue with SQL: That the names of some of the keywords are very table-ish and not very semantic; like LEFT OUTER JOIN. I mean, if we have some facts, like how old people are, and what they like to eat, then what does it even mean that any of those facts is to the left or on the inside of another? I can't fit that into my brain.

But let's take an example. We have these sets of facts (which, if they were in SQL, would be in two different tables):

    age(alice, 20).           
    age(beatrice, 30).        
    age(charlie, 90).                                   
    likes(alice, carrots).    
    likes(alice, chips).      
    likes(charlie, crumpets). 

Then an INNER JOIN would probably be like:

    age(Name,Age), likes(Name, Something).

This can be read as "What is the age of anyone, who like something?" (or more absurdly, "What does anyone, who has an age, like?", depending on what variable we focus on.)

I'm probably getting this wrong, but if we wanted LEFT OUTER JOIN it would be more like:

    age(Name,Age); likes(Name, Something).

Which is more like "What's all people's ages, and what does anyone like?"

In Prolog, the comma means 'and', and the semicolon means 'or', so in the second query anyone, who has an age but doesn't like anything, will still be included. In this query, that would be Beatrice. That's a bit like a LEFT OUTER JOIN, isn't it?

> I find the idea of a simple Prolog, like a Datalog, very intriguing as a potential simple query engine for apps in mainstream languages–not having to worry about the maps, filters, reduces, flatmaps, and all the other operations we have to do to coax data into the right shapes in line-of-business apps.

Seen DataScript?[0] I think MiniKanren has also been implemented in most languages. I like how Prolog "forces" a declarative style though.

[0]: https://github.com/tonsky/datascript

There is datascript, which has a foss implementation of datascript (with nice performance)

https://github.com/tonsky/datascript And this (deprecated) project, that translate datalog to SQL(lite) https://github.com/mozilla/mentat

"Datalog is a declarative logic programming language that syntactically is a subset of Prolog." [1]

"Datomic is a distributed database and implementation of Datalog.". Datomic seems to be quite succesful [2].

Related to datomic, I'm trying to learn Datascript these days ("An immutable in-memory database and Datalog query engine in Clojure and ClojureScript.") [3].

1: https://en.wikipedia.org/wiki/Datalog

2: https://www.datomic.com/customers.html

3: https://github.com/tonsky/datascript

Yes, Datomic is the killer app for Clojure [^1]. Have a look at Datascript[^2] and Mozilla's Mentat[^3], which is basically an embedded Datomic in Rust.

Hickey's Spec-ulation keynote is probably his most controversial talk, but it finally swayed me toward dynamic typing for growing large systems: https://www.youtube.com/watch?v=oyLBGkS5ICk

The Clojure build ecosystem is tough. Ten years ago, I could not have wrangled Clojure with my skillset - it's a stallion. We early adopters are masochists, but we endure the pain for early advantages, like a stable JavaScript target, immutable filesets and hot-reloading way before anyone else had it.

Is it worth it? Only if it pays off. I think ClojureScript and Datomic are starting to pay off, but it's not obvious for who - certainly not very ever organisation.

React Native? I tore my hair out having to `rm -rf ./node-modules` every 2 hours to deal with breaking dependency issues.

Whenever I try to use something else (like Swift), I crawl back to Clojure for the small, consistent language. I don't think Clojure is the end-game, but a Lisp with truly immutable namespaces and data structures is probably in the future.

[^1]: In 2014 I wrote down "Why Clojure?" - http://petrustheron.com/posts/why-clojure.html [^2]: https://github.com/tonsky/datascript [^3]: https://github.com/mozilla/mentat

What about:

https://github.com/mozilla/mentat https://github.com/tonsky/datascript

You can try a mostly Datomic-compatible Datascript: https://github.com/tonsky/datascript/

https://www.datomic.com/get-datomic.html starter version

https://github.com/tonsky/datascript Datascript is also neat, it's an in-browser DB with datalog query syntax. There's some neat stuff possible with om.next + datascript: https://github.com/omcljs/om/wiki/DataScript-Integration-Tut...

Depending on the definition of "it", someone has: https://github.com/tonsky/datascript

This would do the trick: https://github.com/tonsky/datascript

We use Datalog every day in a React-Native application, via the datascript db (https://github.com/tonsky/datascript). Has been a very positive experience so far.

Thinking in "facts" / binary relations is itself a refreshing approach.

There's a typo in your datascript url (s/k are switched). Here's the corrected one: https://github.com/tonsky/datascript