An organizer for arbitrary knowledge, using an object model rather than text as the atomic unit of knowledge. See the web site http://www.onemodel.org for background.
Scala Shell Other
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
core
integration
web
.gitignore
CONTRIBUTING
Dockerfile
INSTALLING
LICENSE
README
docker-compose.yml
pom.xml
todo-om-dev-details.txt

README

This file is part of OneModel, a program to manage knowledge.
This file is copyrighted in each year of 2003, 2007, 2010, and 2012-2017 inclusive, Luke A Call; all rights reserved.
OneModel is free software, distributed under a license that includes honesty, the Golden Rule, guidelines around binary
distribution, and the GNU Affero General Public License as published by the Free Software Foundation;
see the file LICENSE for license version and details.
OneModel is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License along with OneModel.  If not, see <http://www.gnu.org/licenses/>
--------------------------------------------------------------------------------

About copyright year ranges: when a range of years (e.g., "2011-2013") is used
in a copyright statement in this project, it means that a change was made in
each year of the range inclusively (e.g., the previous example means 2011, 2012,
and 2013).  (The FSF's web site said if using ranges, to make the meaning
explicit.)

These files pertain to the OneModel (also known as "OM") project.

See the web site http://www.onemodel.org for a live demo, downloads, mailing
lists, and other general information.

See the file LICENSE for copyright, license & distribution information.  (The
file inside the onemodel*.jar file, called META-INF/LICENSE.txt, applies only
to any Apache Project artifacts (such as from commons-io) used inside OM, and
not to OM itself; similarly for any others like that.  The OM copyright is in
the file LICENSE).


SHORT OVERVIEW:

1) Theory: We have many systems (wikis, evernote, cyc, etc), but all are
crippled by relying on human language as a fundamental layer. To more
powerfully manage knowledge, we can approach it more like an object model
created on the fly by just using the system: what you know about a pen,
say, is best expressed as numbers, relationships, and code (mass, owner,
behavior ...); the human language words can change when the knowledge
doesn't.

2) Vision: Be effective on an individual level, then link OneModel
instances (find others' data, subscribe to changes, copy, link, etc),
to build large and comprehensive systems in wiki-like ways (with the
power of the network effect), but without the crippling human-language
limitations. Think wikipedia but all the data is effectively computable,
and locally controllable.

3) Today: The AGPL prototype is like emacs org-mode in being keyboard-
and desktop-oriented, and feeling like nested lists galore, but uses
postgresql, allows having the same data linked into multiple places,
is much easier to learn & use than emacs, and has a bigger long-term
vision. It's (for me) the best personal organizer ever: very fast to
navigate, and very flexible. The web site is generated from its data.

4) Next steps: Community-building and funding. I could really use
feedback. The current target audience might be note-takers who touch
type, like speed (and don't need mobile--cough), and need to be able
to put the same information in more than one place in their notes. And
anyone who wants to help move the big picture forward. Like, I hope to
add anki-like features, and ways to attach code to classes of objects
that were "modeled" on the fly as a side-effect of using the system (eg,
so you can change the date on tasks, in ways you specify, with simple
code, or eventually run simulations, etc).


PROJECT STATUS
    As of 2016-1-7:  Currently suitable for daily heavy use
for maintaining lists and notes.  Allows import/export & manipulation of
entities, attributes (including file storage with md5sums for integrity
verification), nested groups, and relationships with very efficient traversal.
At any given time, everything you need to know is on the screen (or nearly so),
and once you get used to the keystrokes, the most common operations are fast.
The structure and concepts will allow it to do much more, and it allows for
expressing rich info in well-modeled ways, though to do that and share it is
not efficient (yet!).
    Upcoming priorities include easier installation if interest warrants,
data sharing/cloud usage (making local postgres installation 
optional), mouse & mobile support, internal improvements and other features.

See the file INSTALLING for instructions on compiling, installing, and running.


CONCEPTUAL OVERVIEW (not yet fully implemented)
------------------
In brief: think of something like wikipedia, containing all knowledge that
anyone cares to collect, but computable (not based on text or words
fundamentally, but on an atomic model of knowledge, focused around numbers
and relationships).  Also personally or globally managed and maintained, and
highly efficient.  Then add trust networks between instances.

Perhaps the nature of knowledge, at an atomic level, isn't text, but an object
model.  Words are just a good useful way we express what we know, to each other,
but the words are not the knowledge.  If you look at a glass of water, you don't
fundamentally "know" about it in words; you can use different words, but you
know its weight, where it has been, who owns it, what would happen if you throw
it, etc.

Those things are numbers and relationships, and are captured in what we call an
object model.  Words are a layer on top of that, a way to describe what is in
the model, but words and text are not the model.

What if you could create an object model for everything you know, all internally
connected, and as we share, exchange and learn together (only what one wants to
share), our models become better and more effective, and we can share everything
we know.  If everyone did this, and shared the public parts, for everything they
wanted to keep track of, can you imagine the rich data we would have for, say,
economic, historical, medical or other kinds of research?  Or for personal or
family growth and mentoring, to become the best we can?

Of course, the human interfaces would have to be very convenient: easy to use like
a web browser or word processor, and not requiring specialized training in software
engineering.  The model can grow and mature on the fly, as a side-effect of working
within the system, learning, and editing; and it can be improved when
merging/sharing/comparing with that of others, or on shared efforts.

The idea is different from, say, wikipedia, or cyc, or mindpixels, or the semantic
web, because it is fundamentally computable: it is arbitrary knowledge with a
uniform structure, so we could do calculations, rich queries, and provide a variety
of representations or means of traversal, based on context or need, even if you & I
use different terms for the same thing, or speak different languages, if we have
shared and aligned (or shared with others who shared and aligned).  Those other
systems that rely on human words could be seen as ways of superficially
representing the knowledge contained in the object model.

This world has a lot of data now.  It is not well organized, when seen as a whole.
What if we made our individual data, or our big sets of data, highly organized and
related, so that it is all shareable (if/when/as desired), and distributed and
computable?  Let's try collecting everything we know, enabling a single, large,
extremely *computable* system.  The beginning could be a personal organizer that
relates everything to everything else, is easy to use, doesn't rely solely on
words (awkward messy human language) at the lowest level, and allows intentional,
useful, convenient sharing and exchange of any subset.  Of course it would
liberally show words, pictures and/or animations, based on the numbers and
relationships and context awareness it contains.  And of course there are good
problems to solve along the way, with  many good tools already available for use.

The ideas and their embodiment in software should be free and open, as far as practical.

What happens when everyone can know everything that matters?  (And what does it
mean for government of the people, by the people and for the people, if the
people can effectively know at least as much about their government and
everything else, as governments know about the people?  Consider the NSA, and
the historical observation that sunlight kills germs.  It is not supposed to be
"government by the big shots, for the big shots, of everyone else."  Changing
the one-way mirror of surveillance into a respectful well-lit view in all
directions seems necessary, as does pervasive honesty, the golden rule, and
obedience to or adherence to the rule of law for the benefit of everyone; rather
than laws being discretionary or only for other people, which leads toward
lawlessness and the rule of men.  But (ahem) we digress....)

More background info is at http://www.onemodel.org.

(By the way, "one model" can mean "one model of knowledge for each person,
organization, or use case", where desired, trending towards uniformity
where suitable -- as opposed to many applications with their own data models.)