-
Notifications
You must be signed in to change notification settings - Fork 11
Glossary of Concepts
Querki is a fairly big and complex tool -- there's no getting around that. Here are the main concepts in the system. (Most of which still need better explanations and examples: this is a very rough first draft.)
Note that we're intentionally avoiding programming jargon, almost to a fault. That's partly in order to use the most intuitive terms for end users, and partly to avoid incorrect assumptions. For instance, while a Thing is fairly similar to the usual programming idea of an Object, it doesn't work quite like any Object in any programming language you've seen.
As a user, I own any number of Spaces -- each one is a collection of related information. A Space might be a Cookbook, or a Blog, or a Project, or any other bunch of data that makes some sense together.
Each Space is a collection of Things, and the Properties that define what those Things can describe.
A Thing describes a particular item in the Space. For instance, if my Space is a Cookbook, my Things would include Recipes and Ingredients. In a Contact List Space, I would have Things for Person, Organization, Activity and so on.
A Property is a name that describes a specific sort of information that you want to use. In a Cookbook, you would have Properties like "Recipe Name", "Number Served", "Ingredient List", "Preparation", "Notes", and like that. Once you've defined a Property, you can use it on any Thing you like.
(Programmers should note that last: Properties are scoped by the Space, not by the Thing. That's wierd but deliberate -- it makes it much easier to search around the Space arbitrarily, without sweating the details too much.)
When you use a Property on a Thing, you give it a Value. The sort of Value depends on the Type of the Property -- Recipe Name would be a short name (like it sounds), Number Served would contain a Number, and so on.
A Model is a particular sort of Thing, that describes how to create other Things. For instance, my Cookbook would have a Thing named Recipe, which is used to create actual Recipes.
(Object-oriented programmers are saying here, "So it's a class, right?" Close, although not quite. Models behave much more like Javascript prototypes than Java classes -- similar concept, but different details. Every Thing can be used as a Model, and every Model can be treated like an ordinary Thing.)
Every Property has a particular Type, that says what sort of values you can put in it. Types include basic Text (for any free-form text you want), Tags, Numbers, Links to other Things, Address, Photo, and lots more. When you create the Property, you say what Type can be put into it.
This is a fine detail, that you don't have to worry about most of the time, but Properties always contain a Collection of a Type. That basically says how many Values you can put into it. To start with, there will be three kinds of Collection, and you say which one you want when you define the Property:
- ExactlyOne -- The simplest collection, this Property must always contain one Value.
- Optional -- This Property may contain a Value, but can be left empty.
- List -- This Property contains an ordered list of as many Values of the given Type as you would like.
Which sort of Collection you choose affects the way you enter stuff into this Property, and how it displays.
Querki isn't just a database, it's a social environment that helps you share what you build. Once you have built a Space, you may choose to share it as an App. This basically pulls out all of the Models and Properties, in a way that lets other people do the same thing even more easily. So if I build my Cookbook from scratch, I can then quickly create a Cookbook App from that, and other folks can just say that they want a Cookbook, too!
Most folks will mostly start with an App, rather than building something from scratch. Once you've taken an App, you can start adding your own Things into it. And when you find changes that you want to make, you simply start tweaking it to make it work the way you want.