Datomic Blog

While the author mentions that he just doesn't have the time to look at all the databases, none of the reviews of the last few years mention immutable and/or bi-temporal databases. Which looks more like a blind spot to me honestly. This category of databases is just fantastic for industries like fintech. Two candidates are sticking out. https://xtdb.com/blog/launching-xtdb-v2 (2025) https://blog.datomic.com/2023/04/datomic-is-free.html (2023)

> If you have 10s or 100s of app servers that has the exact same working set in memory, it's probably not worth it. The introduction of intelligent application-level partitioning [1] and routing schemes can help one balance cost and performance. [1] https://blog.datomic.com/2023/04/implicit-partitions.html

Do you have a specific example? Datomic is great for evolving in prod (https://blog.datomic.com/2017/01/the-ten-rules-of-schema-growth.html), and Clojure is a great language for generating data (or ETL) when you want to make radical changes in dev.

Wow, very cool indeed. We worked on an open-source community[1] tool using Datomic/Codeq[2], and the ops portion was/has been pretty unpleasant. I'd love to see Datomic-as-a-Service popup, even as a only-meant-for-starter-projects, just so that experimenting with it could be that much easier. That might be possible with the new license, depending on how the Cognitect team sees it. [1] The service is a frontend to Codeq, having imported many Clojure repos: http://www.jidaexplorer.com/ [2] http://blog.datomic.com/2012/10/codeq.html EDIT: Added links.

It is free now: https://blog.datomic.com/2023/04/datomic-is-free.html

https://blog.datomic.com/2012/10/codeq.html >codeq ( 'co-deck') is a little application that imports your Git repositories into a Datomic database, then performs language-aware analysis on them, extending the Git model down from the file to the code quantum (codeq) level, and up across repos. By doing so, codeq allows you to: >Track change at the program unit level (e.g. function and method definitions) >Query your programs and libraries declaratively, with the same cognitive units and names you use while programming >Query across repos

I really like the datomic guidelines for change, which negates a category of migration headaches: https://blog.datomic.com/2017/01/the-ten-rules-of-schema-growth.html

FWIW, Datomic still isn't open-source, but it is free: - https://blog.datomic.com/2023/04/datomic-is-free.html - https://blog.datomic.com/2023/06/datomic-cloud-is-free.html

> if you're ever introducing a new language, regardless of context, throw some code samples This is not a new language, it's a tool for Clojure. I really appreciate the contributions that Nubank is making (after making Datomic free, https://blog.datomic.com/2023/04/datomic-is-free.html). My only nitpick this time is that I would have liked some screenshots/screencasts of the this new tool in action.

http://blog.datomic.com/2012/10/codeq.html I think codeq 2 is being worked on

This is the mobile link, better link is http://blog.datomic.com/2018/01/datomic-cloud.html

This looks like it: http://blog.datomic.com/2013/07/datomic-musicbrainz-sample-database.ht…

If you take a language parser and pipe the resulting AST into Noms, you basically get something like codeq (http://blog.datomic.com/2012/10/codeq.html).

Sourcegraph folk, are you aware of Rich Hickey's codeq [0][1] for clojure: codeq allows you to track change at the program unit level (e.g. function and method definitions) and query your programs and libraries declaratively, with the same cognitive units and names you use while programming [0] http://blog.datomic.com/2012/10/codeq.html [1] https://github.com/Datomic/codeq#codeq

For joining vcs (git) plus db (datomic), there's an interesting library called codeq: http://blog.datomic.com/2012/10/codeq.html?m=1

Rich Hickey's (of Clojure fame) Datomic database uses Datalog as its query language. http://docs.datomic.com/query.html http://blog.datomic.com/2015/01/datalog-enhancements.html Nathan Marz's (of Twitter startup fame) Cascalog library (also implemented in Clojure) uses Datalog as its query engine to generate Hadoop jobs. http://alexrobbins.github.io/cascalog-intro/#/step-14 http://clojure.com/blog/2012/02/03/functional-relational-programming-w…

Excision removes the data. In other words, you can remember that you forgot, but you can't remember what you forgot. http://blog.datomic.com/2013/05/excision.html What you're describing is plain ol retraction. If you retract your credit card number, then someone can just surf back in time to grab it. That's why you'd excise it.

Relatedly, see Rich Hickey's http://blog.datomic.com/2012/10/codeq.html

Yeah, it kinda sucks -- mostly one learns to create new copies of definitions/code when doing substantial changes, which the notebook interface makes quite convenient. Or use a full blown editor like Eclipse. The holy grail as I see it would be storing the entire edit history of the document as a git-like tree of modifications, which is entirely possible because Mathematica notebooks are themselves built out of Mathematica expressions (see for example Cell http://reference.wolfram.com/mathematica/ref/Cell.html). This would be similar to Rich Hickey's work on language-aware version control (http://blog.datomic.com/2012/10/codeq.html)

In related news Riak was in fact added as supported storage today: http://blog.datomic.com/2012/11/riak-and-couchbase-support.html

> I'm curious to know what the actual data structure is. This tweet from Rich provides the missing puzzle pieces: "The log is not a btree - used for durability, not query. Separate indexes combine memory with batch-updated storage." https://twitter.com/richhickey/status/420910382538948608 Restating in my own words: The transaction log is essentially just a stream of asserts and retracts with metadata. That's used for durability first and echoed to clients/peers and the indexing engine. The indexing engine asynchronously batch updates indexes (which probably are b-trees, but have no need to be streaming append-only style in this context). The peers query a joined dataset of the latest consistent indexes plus the set of unindexed transactions. > As append-only B tree is persistent. You're right, it can be. However, the popular append-only b-tree systems (such as CouchDB) are actually append-only B+-tree systems. That "+" means the leaves of the tree are intrusively linked together, and so are not persistent. You can not "fork" such trees cheaply. > losing information is a specific feature that was added to git http://blog.datomic.com/2013/05/excision.html