Skip to content

Home

Jump to bottom
Christopher Dumas edited this page Apr 21, 2019 · 3 revisions

Welcome

Welcome to the Atomic Database wiki! Atomic Database is (as stated in the description) an EAV-based deductive database using a backtracking logic programming language of my own design, and a natural language interface on top of that. Atomic Database is written entirely in Python and is currently under my active development. I have a roadmap in the README.

Inspiration

Atomic Database was inspired by the meeting of two ideas:

  1. That logic programming could be a very powerful paradigm for databases if it could be made practical and enticing
  2. That there is a severe lack of programs that present a smooth learning curve for a user looking to shape it to their needs

It's rare that one can find a program that is immediately intuitive and useful to the average user that is also flexible enough to allow changes for those people's needs and preferences. It is even rarer to find a program that has a smooth learning curve to access its power. Some programs (such as CADs) allow you to create plugins and scripts for them, but these immediately drop you into a full programming environment, with little intermediary states between using and extending. The vast majority of programs are even worse, because they don't even allow extensibility. This means they have a massive cliff in availability and learnability between passively using them, and creating a program of your own to do the job you need personally.

If you feel OK with reading a rant related to this, click here. This is a very large failing in most of the "Free Software" that the GNU Project and FSF provide/encourage. Even though they are amazing pieces of software (I use many of them), often incredibly powerful and extensible, they are not easy to use or control for most users. Even though the philosophy of Free Software is about providing the users of the software with the power to shape their environment and control it, and not feel controlled by it, they forget that making software free as in freedom does not automatically give all but the most computer-literate and astute users the actual control they desire. Most of the FSF philosophy seems to have forgotten about real users and focused on who owns the software, instead of remembering that sometimes, free software can be worse for users. I've chosen to take the core idea of the FSF, for Atomic Database, and apply it to something real beyond slogans. Users can, in a very real way, understand and feel control of Atomic Database.

Similar Things

The two influential types of programs that I know of that most often have a decent user-control curve are databases and spreadsheets. Everyone knows how to use a basic spreadsheet, and it's easy and immediate to go from using that spreadsheet and adding custom features and automation. Databases can be a similarly rewarding experience for a non-techy user, although its relatively rare, there are nice GUIs that allow adding to, deleting from, managing, and sometimes even querying databases that allow a nice learning curve (like SQL builders that let you use blocks).

Goals

Atomic Database aims to provide a learnable, accessible, and customizable interface with the smoothest learning curve that I can create, along with actually having some unique and useful features to give a reason for actually using it. In that interest, not only is there a simple graphical UI to edit and add things to the database, but there is a natural language (chatbot-like) query system to ask slightly more complex queries of the database. Once you're ready to customize Atomic Database, you'll find a mostly-graphical GUI for easily and intuitively adding Rules for your database to understand and follow. First, you can make simple rules with the same natural language that you can use in queries. when you're ready, however, you can test out S-expressions in the query box UI, and then write more complex rules (the language might be Turing-complete, although I haven't tried to test it yet) in the very same GUI-focused rules interface. I will be spending time extending the interactive and representational capabilities of the database (with columns that automatically update with values, an nicer GUI for adding information without doing queries, etc) and extending the ease of use and flexibility of the natural language interface (so that you don't have to use stiff, formal phrases) and, lastly, increase the power of the S-expression language.

A note on quoting. Strings are quoted with double quotes, like in Python or JavaScript. However, as in the Natural Language Query System, entity names should also be quoted! Although entity names are not necessarily strings, per se, they should be quoted to help the interpreter recognize them correctly. For entity names that would be a valid attribute or rule name, going without quotes should be fine. But for entity names that include special characters (beyond underscores), or entity names that would look like a variable name or include spaces please use quotes.

To read a code example, there are three things you need to know:

  1. Anything between angle brackets (< and >) is a placeholder. A placeholder means you can put a valid value in its place. Generally, the words between the angle brackets tell you what sort of thing goes there.
  2. Numbers between angle brackets mean that the thing the bracketed item stands in for is the nth argument. So <1> means the 1st argument, and so on.
  3. Ellipses (...) mean that you can put any number of things there. Sometimes, these are left out where the text explicitly says that multiple things can be put there.
Clone this wiki locally