Identification, abstracting, meaning

ABSTRACT

Growth of information volumes becomes one of main problems of contemporary computer world. This article considers the way in the past to this situation, but also proposes the solution. Key feature of this solution is to solve problems of identifying, abstracting, and meaning. The solution implies creation of new level of abstraction over user level, and of semantic protocol over HTTP. Such measures should hide computer-dependent information (file names, menu, dialogs, URLs) and converts such information into identifiers (natural language words, numbers, symbols, etc), which could be recognized by humans. Given approach is necessary, because an user should search for information (not for files), utilize application functions (not menus and dialogs), use words and clauses (not URLs).

INTRODUCTION

Internet is big information dump. Though, with constant attempts to sort and order it. But even the most successfull sorting machine for the simplest queries dumps million references (which, evidently should be considered as a sign of successfull sorting, as if a librarian would tell you "yes, we have million books on this topic, please search there..."). Well, we should rely on own abilities and additionally sort out what was proposed by a search engine. Quite naturally, usually we process of dozens, hundreds references, and if nothing found, a search is considered as failed. Of course, sorting machines are doing enormous job: calculations show that now there is about 1 trillion (10^12) unique pages, general query usually gives about 100 millions (10^8) pages, less general query gives dozen millions, etc. But, in real life similar queries should give not more than dozens, hundreds, or even only one reference. For example, "the host of Olympic games 2012" query has to result in only one answer, "cats" query has to give sites and pages, which dedicated to cats, but not all pages, where they mentioned somehow. No surprise that search engines try to guess what you want, to propose better filtering, to rely on human-enabled sorting, which assumes humans are the best in sorting of small information dumps.

The situation with personal computers is different. It contains from hundreds thousands up to several millions files, however, unlike Internet, where we can predict where content is located, searching through local files can be easily restricted: at least, it is not worthy to look for personal information in applications directories. Hereto, if information identification for somebody's else files is just meaningless, because it is more probable we won't use them again, then identification for our own files is more appropriate, because we use them often, therefore precise identification will find them quicker, than repetitive full search. But once identification is provided, abstracting (which involves approximated identification, ie comparing by similarity) should be granted too. But then also we should think about semantics (ie, relations between identified information). And if this will work locally, then we need single identification mechanism, which will allow to jointly use already classified information. Unfortunately, contemporary computers do not provide such possibilities.

In the beginning nobody even thought about such problems. The first computers were quite awkward, therefore information accumulated quite slow. Fortunately or not, but computer technologies gradually advanced more and more. Text interface, operating systems, high-level programming languages, data formats, graphical interface, Internet, at last. Each of these enhancements (even not considering hardware enhancements) facilitated input and processing of information, which lead to its volume and made searches more difficult. Internet made things even worse: when computers were not linked in one big net, rare bird took pleasure to dump own thoughts and emotions on hard drive, but emergence for thousands and even millions of readers became the trigger of exponential information growth.

Could we resolve the problem of overflowing information? Now we have a lot of promising technologies, which intend to tame information volumes: collaboration, social network services, Semantic Web, but also virtual reality, augmented reality, 3D interface, image and language recognition, etc. Some of them are not enough mature, some of them are quite effective esthetically, but not so useful in practice. Unfortunately, none proposed overall solution which would satisfy everyone. Could we understand what at least theoretically could cope with this problem? At first, we can browse through revolutions of the past and understand why this or that invention became breakthrough.

REVOLUTIONS OF THE PAST

* Text (console, command-line) interface. Appeared because of necessity to communicate with computer with human-recognizable language. Conditions which required for that: (1) possibility to identify computer entities (eg, a disk or a copying operation), (2) possibility of abstracting (ie, expressing of a set of objects or actions with one identifier, eg usage of copying operation as an abstraction of copying bytes from one place of hard drive to another). Side-effect: (3) possibility of reusing of identifiers. There were a lot of attempts to use natural language for the same goal, but they failed not only because full analysis of syntax and grammar is quite complex operation (though simplified analysis is quite possible), but also because special language is more suitable for operating with computer entities. In fact, any human activity uses own slang or specific abstract language (as mathematics), which abstract entities of the activity area better than natural language.
* High-level programming languages, programming interfaces, data formats. The same situation as with text interface, but with richer possibilities, because of available additional abstractions, which could compose more complex solutions. Data formats are, in fact, abstract languages (which is not so evident as binary, but more evident as text) for ordering and restricting information.
* Operating system. Environment, which helps software and an user to use hardware. It provides an abstraction layer which hides low-level entities of hardware, also allows software to build own abstraction layer which provides a set of entities, which could be recognized by an user.
* File system. It provides atomic element of information storage (file) and directory hierarchy to order files. File contents theoretically should abstract into its names and a restricted set of attributes. File lists theoretically should abstract into a directory name. But, in fact, abstracting principles often violated, because file names transforms into a meaningless set of letters, and a directory chosen arbitrarily. Moreover, information on directory (which theoretically should classify a file) is lost when a file is copied. File contents often is hidden by a processing application, therefore information inside file could not be reused (unless provided by the processing application).
* Applications. They are abstract layer between operating system and an user. Provide determinated set of actions for predefined user reactions. Encode original meaning (how an user sees a domain) as abstractions (by architects, then by developers), to decode eventually these abstractions into meaning, which could be understood by an user in UI. Naturally, in many cases, meaning becomes distorted just because passed through several transformations.
* Graphical interface. Its advantages come not only from the fact a human absorbs visual information better (a human mind processes space abstractions quicker than logic or language ones, possibly the very abstracting originates namely in visual perception). But it also represents and restrict information (eg, you see all commands at once, but not recall them; possible values are represented as a list, etc), and links it (one element correspond to another elements, like in the case when there is a linke between some objects and actions, provided by a menu). However, big amount of elements makes us again to use natural language (with manuals, instructions, etc). Moreover, some elements needed to be hidden with ordering them into hierarchies (menu, trees, nested dialogs, etc). This restricts context (which is better for understanding a separate area, but many nested levels hide application features, which results in these features are rarely used and difficult to be found. At last, one more problem is GUI elements and data are linked implicitly (for an user), which disallows to reuse such interface (ie, to refer to GUI elements). Graphical interface, even though considered better than text one, is always supported by natural language. The root of the problem is the fact visual elements are not always could be easily understood, but humans learn natural language during many years. You should notice that icons do not differ from letters (which are icons too), but when composing of complex actions is required, this could be done easier either with natural language (eg, as an instruction), or with abstract language of scripting, but not using graphical interface. In general, though GUI is very efficient, it could not represent any information (eg, sound or complex abstraction), therefore only symbol interface could be universal.
* Internet. Its benefits come from the indivisible joint of two unions: of computers into global net and of information inside hypertext (which represents a container with text and other medias). Both factors taken separately could not make a revolution: you can just realize Internet without hypertext (with only ftp) or you can imagine existence of only some advanced format, which allows links texts, but only at your hard drive. Naturally, one comes from another, and appearance of global net led to appearance of all Internet technologies.
* Hypertext, Web, Web 2.0, domain system. In own turn, they represent a symbiosis of following factors: resource linking, data formatting, and resource dynamics (both client with JavaScript, plugins, and server with forms, GUI elements). Later, formatting and dynamics were considered more attentively, than linking. Therefore, many still miss its shortcomings: hypertext linking allows a link only one-to-one, which makes sense, when you refer to an unique resource or to a part of the whole (like inside boundaries of one site). But if we refer to arbitrary resource of arbitrary site (eg, to news which duplicated at many other resources), then such reference is restricted and subjective. Web 2.0 advances dynamics of resources, adding more features for client side (but here we again face shortcomings of GUI in general). Domain system is an analogue of Internet "file system", where domain and its components theoretically should identify an information provider and meaning. Practically, domain names often misused (intentionally or not) like file names, which encourages corruption around domain names.
* Personal pages, email, chat, instant messaging, blogs, microblogs, social networks, commenting, collaboration sites. Internet became a trigger for information accumulating. In pre-Internent time, personal information usually distributed only as a curriculum vitae. After we see again symbiosis of two factors: information publishing and distributing. "Personal page" was the first buzzword. Blogs make personal pages obsolete, because they provide almost the same features with less efforts for design and support, adding embedded ability of message exchanging (which could be saved and which exposed globally). Microblogs is simplified development of the same tendency. Additionally, today many sites provide commenting, which for many visitors is a sort of microblogs (because their comments often could drift away of the a site topic). The same concerns social networks. Collaboration sites (unlike social networks of subjective information exchange) deal with objective information (where a role of person ideally should be minimal). Though having many shortcomings, Wikipedia became de-facto a standard of reference on different subjects.
* Portals, search engines. Initiallly, portals considered as a solution for ordering Internet. But they have certain shortcomings: (a) any hierarchy is partially subjective, therefore it is not always evident where concerned subject is located inside it, (b) any hierarchy though orders information with branching but also hides information this way, (c) they used manual update of references, though many portals could be updated by everyone, which makes them similar to collaboration sites. Though portals have also searching, but standalone search engines eventually made portals obsolete. Search line (like command line of OS) is the entry point for any information in Internet, with constant updating. Of course, search engines as any artificial thing made by humans have own shortcomings. The main one is their benefit too: representing of all information in Internet as one big "flat" database. We can consider the world in similar way, then continents, cities, humans, animals could be represented as "flat" database of atoms. Naturally, such representation is partially absurd (because it matters which structures formed by atoms). Creators of search engines understand this quite well, therefore they provide additional tools: relevancy/ranking of words/queries, collaboration tools to increase relevancy, etc. Search engine has the best result only when a word or a group of words completely corresponds to a meaning behind them.
* XML, Semantic Web. The idea of linking everything and representing in one universal format was the base of HTML, looking further, but even of SGML (though if look even more further, this idea was discussed by many thinkers many centuries ago). XML came to the solution closer, because it had the consensus on universal format. But it missed meaning. Semantic Web is going to add meaning (and is a potential candidate for new revolution) but it has certain shortcomings. The main is it is oriented for processing by automated agents, not by ordinary users. And this processing concerns mainly data, which already ordered. Moreover, there are doubts if ubiquitous usage of "subject-predicate-object" triple is expedient for abstracting everything with it. Of course, there is no doubts you could represent everything with this format, but is it expedient? This triple is similar to natural language constructs, where such triples symbolizes dualism of space-time and the fact, that any action occurs between two things. But triple is not obligatory in natural language (object could be missed), and it is complemented with adverbial modifiers, etc. Of course, adverbial modifiers could be represented as triples too, but it could be expedient only if subject, predicate, and object are roles, but not meaning. For example, in this case, verb-action and verb-relation could have a role of predicate, both noun and adjective could have a role of an object (but an adjective rarely is an object, but usually is an attribute of an object). Favorite example of Semantic Web: "sky is blue", where subject is "sky", predicate is "has color", and object is "blue". We see there is no action by meaning, but only relation (or attribute). Given example shows that original dualism of space-time (like in "I go") represented in an abstract form, where a predicate and an object are only roles (that is, abstractions isolated from reality). Moreover, evident shortcoming of obligatory ternary representation is the most of data is organized as N-ary (this is especially evident in computer world, where data could be linked by many arbitrary references, but it is true for natural language too). Ontologies of Semantic Web introduces new level of complexity and are the continuation of data formats and XML schemas, which allow to represent metadata. In general, we see that Semantic Web (at least, now) is oriented of experts, which restricts collaboration on the base of it. There is no doubts that Semantic Web is useful for certain tasks, but as any tool it is restricted which is even fixed in its specification which states that "Much of this meaning will be inaccessible to machine processing and is mentioned here only to emphasize that the formal semantics described in this document is not intended to provide a full analysis of 'meaning' in this broad sense; that would be a large research topic." [RDF Semantics, Patrick Hayes, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210]

IDENTIFYING, ABSTRACTING, MEANING (SINE QUA NON)

Thus, a work with computer is the work with abstractions, which expressed with abstract, graphical, and natural languages, formats, protocols, representations. Which, in own turn, are sets of identifiers, linked between each other with rules and relations (in particular, with separators expressed either by specific symbol or by empty identifier of boundary or linking relation). Before Internet, all revolutions were intended to build higher levels of abstractions over hardware and machine code. The highest peak of it is graphical interace (which theoretically should be closer to an user). Internet revolution gave linking between computers and of information inside hypertexts. All other innovations are either consequences of these causes (social networks as one more way for communicating), or shortcomings of original standards (as dynamics of hypertext), or ways for overcoming of certain problems (search engines and Semantic Web). In general, we see that each step related to three main aspects: identifying, abstracting, and meaning.

* Identifying
Identifying problem is ideally solved in programming. No surprise, because this is condition sine qua non of the process (because everything should be identified to be reused later). For the rest of the world, identifying problem is still actual (though this problem exists in programming too, when we need identifying of objects which is not included into an application directly). Text interface made identifying more difficult by introducing thousands of abbreviations to be remembered or to be found. Graphical interface alleviated the problem by showing some identifiers explicitly, but which are not available for reusage anyway (for example, to refer to some GUI element or change its state). File system introduces one more level of identifying, because it is necessary to remember file names and pathes. Domain system forces us to remember domain names and URLs. In general, any remembering is good memory traning, but in the result we have a big dump of million meaningless identifiers. Such situation is explainable when using identifiers of other people, but even our own identifiers lose meaning with the course of time.

* Abstracting
Abstracting problem is more or less solved in programming. No surprise, because it is sufficient condition of the process (because programming constantly deals with abstractions which corresponds to other abstractions or real world objects). There is small problem: when passed through several stages of abstracting (eg, "user-architect-developer-user" chain) abstraction does not always correspond to original abstraction. Discarded information either implied (by architect, developer, etc) or just ignored. The problem looks different outside of programming world: there is abstracting is absent at all. Why? Mainly, because there is no formal algorithm of abstracting. However, abstracting is available partially with identifying (contents corresponds to an identifier, which abstracts; it is especially evident when identifier uses natural language). No surprise here, because identifying is "ideal" abstracting, when similarity of a source and a result of abstracting is full.

* Meaning
Meaning problem is partially solved in programming. What is meaning? The simplest definition is: a set of identifiers are similar by meaning, if corresponding objects, actions, and relations are similar too. For example, a set of identifiers could include: (1) a picture of reality where grass is green and the sun is shining, (2) a prose about this part of reality, (3) just "grass is green, the sun is shining" sentence, (4) "spring comes, plants revived, warm and dry again" sentence. Of course, there is no full equivalency between these sets, because (1) is the result of camera abstracting (or by a human eye), (2), (3), and (4) are results of a human mind abstracting, and (3), (4) could be an abstraction of (2). Full identical abstracting of various abstracting tools (human mind, eye, camera, etc) is achievable only in ideal conditions. Therefore, we should set boundaries, inside of which such sets considered as similar. In our case, meaning is abstracted in objects of grass and sun, which are green and shining correspondingly (actions, relations). Abstracting allows us to ignore that the grass is not fully green, and the sun is not shining always. Such restrictions allow eventually considering sets as similar. In programming, each object of real world corresponds to either a variable, or an object, or a set of objects, etc. What is missed in programming is: (a) classification of meaning elements (objects, actions, relations, etc), (b) linking with real world objects. The same concerns Semantic Web, which tries to order information with new standards, but does not solve neither the problem of classification (though tries with ontologies, etc), nor the problem of linking with real world (though tries with URI/URN).

It is necessary to underline that identifying, abstracting and meaning problems are resolved in natural language. It refers to things, actions, and conceptions with simple (words) and complex identifiers (sentences, paragraphs, texts). A reference could concrete (the simplest case when we have 1:1 relation, eg "Everest") and abstract (when we have N:M relation, eg "favorite activity"). However, all identifiers balanced (with the help of abstracting) between concrete and abstract, thus, "Everest" could refer to an organization or a metaphor of big achievement, and "favorite activity", already pronounced by a person and linked with his or her favorite activity, becomes more concrete. Meaning, in this case, is what we referred to.

CHALLENGES OF THE PRESENT

These three aspects are conditions sine qua non of solving of big volumes of information. Identifying allows to accelerate sorting, abstracting decreases volume of needed sorting, whereas meaning can make sorting more precise. But except of that, we have many other challenges, which needed to be solved too (some of them were already mentioned above):

* Numerous computer identifiers (file and directory names, site and domain names, long instructions for opening GUI elements) which impossible to remember.
* Computer identifiers is not natural (words of natural language often represented as not recognizable abbreviations, separators are either missed or replaced by other separators) and difficult to remember (URL). For example, equalsIgnoreCase is used for comparing equality ingoring letter case, it is equivalent to "equals ingoring case" in natural language, or to computer identifier "equals(boolean ignoreCase)". As we see, computer identifiers changed mainly because of ignoring separators of natural language (which is used for other purposes), and because a part of meaning becomes statis not dynamic (as a parameter).
* Usual identifiers (eg, of natural language) used for GUI elements, but are unseparable from these elements (ie, unavailable for reuse).
* Elements of interface, file, document, application and site are unseparable from each other, which makes reuse more difficult.
* Contents and a list of contents of an archive or a file is hidden by managing application (therefore, sometimes it is impossible understand what is inside of file without opening it).
* Hypertext fixedly integrates information, which leads to "content hell", which means (a) not clear boundary between content and non-content, (b) content is only sequences of symbols/words, but not meaning, (c) subjective and objective are mixed, etc.
* Hypertext link refers a word (abstract) to a resource (concrete)
* It is impossible to create and classify information without mediator between information and an user (eg, to create a note, which relates to some aspect of a project, you should either to create a separate document or to use a separate application for creating notes)
* It is impossible to markup information with identifiers or meaning, without intrusion into file contents or application
* It is impossible to use jointly classification of files (eg, an author classifies a file as "document of project A" and this classification automatically available for everyone), use jointly information without mediator (eg, to transfer files to a friend, you should use either email application, or browser, etc), to request information without mediator (eg, to ask some project document without asking this in message exchange, searching the documents, and explicit transferring).
* There is almost no possiblity to save "snapshots" of information, which you worked with (eg, the last query to a database or a site) and be able to update it later.
* It is impossible to receive precise answer for search (instead, you receive millions references)
* It is almost impossible to guide application by goals (though we represent them when working), but only by instructions (eg, instead of setting "send documents to Mr. N" as a goal, we should divide our goal into separate commands, which includes selection of documents, searching for Mr. N in address book, and sending with the help of some application)
* Some actions should be done manually (eg, to change files after installation, or change some options) only because there is no method of information identification inside containers and for GUI elements, but methods of identification inside programming interface is too difficult (therefore not implemented)
* It is almost no time relations (possibility, necessity, etc) but they often implied
* There is principal restriction of any graphical interface. It is better suited for conditions, when a human could remember the whole set of necessary action to automatically reproduce it later. Unfortunately, it badly represents complex actions, because a human "optimized" for graphical system of natural language and it is difficult for him or her to remember all details of graphical systems, provided by applications and operating systems. To build simple GUI is possible for simple tasks (it is the good example that everything should be simple but not simpler than necessary), many interfaces intentionally simplified to achieve esthetical effect but deteriorating their possibilities.
* Problems of unordered interface or content shifted to an user ("read the manual" or "search in Internet"), which partially relates to the problem of any hierarchy (by filtering it hides a part of information), eg, to look for information in several levels of menu and dialogs or in several levels of site map is the task which requires not so much skills as time, but sometimes even just luck.
* Associations (keywords, tags, etc) often replace abtractions (reduced or generalized information). Though, in general, information can have many associations, but only one abstraction.
* Applications are determinated and could not work with unforeseen situations.
* While there is no filtering, which could restrict a searching area.
* Abstracting during application or content development usually implies or ignores a part of meaning, which leads to not corresponding of desirable and real.
* Semantic Web proposes to use URI for identifying any objects, but there is no way to separate identifiers of real world objects from ones of http objects.
* Semantic Web proposes to define semantics as ontologies, without linking ontologies between each other.
* Already created taxonomies and ontologies use numerous relations for defining own elements, which makes difficult their usage (and often could be understood only by semantics experts). But any definition is only one of answers for the question "what is x?", identifying of an object is more important (which could be done by a human which is domain not semantics expert).
* This is paradox but computer world is not ready to recognize natural language, ie even if such recognition would work tomorrow, then recognition of separate words could accelerate information input, but not revolutionize a work with computer. There is no general scheme how to link natural language phrases to GUI, therefore contemporary applications are not ready to work even with simple phrases. Meaning recognition is even impossible, because there is no general understand what it is.

SOLUTION

What approach could confront all these challenges? Today, there is a lot of partial solutions for each of them, but if general approach is possible? Ideally such approach should solve problems of image and language recognition, abstracting, storing, processing, and retrieving of information, undeterminated behavior (like intellect). Unfortunately, such ideal is unreachable technically (by these or those reasons). But could we at least be prepared for the moment when such approach starts to work? At this moment, we have no even possibility to define approximately meaning of phrases or abstraction of some information. Considering it in more general aspect, we have no abstraction level, at which we could operate only with terms which used in real life, but not with files, menus, dialogs, browsers, addresses, etc. Of course, usage of computer terms is explainable, because any domain uses own dictionary (because any new term saves time for explaining some additional meaning comparing with full explanation, eg "browser" instead "application, which allows to work in Web", etc). But if computer terms are necessary to work with information? Is it possible to make an user to be unaware about low-level computer abilities (like today we unaware about sectors of hard drive)? Should we know which button or menu allows to launch necessary function?

In general, we work with computer with following steps:
1. We have some representation on some thing or conception.
2. Transformation into computer form is transformation into identifiers of natural language (words) or into data, using application identifiers. That is, we encode information.
3. When necessary, we transform identifiers of natural language or data back into some representation. That is, we decode information.
4. When searching, we should guess which identifiers were used on encoding.

Problems:
* Each encoding and decoding changes information.
* We should guess which identifiers were used.

Possible solution is new level of abstraction which can hide computer related details. This can alleviate side effect of encoding-decoding, because information integrity will be supported at this new level, and integration violation can be easily traced, prevented, or avoided as soon as possible. This new level should be a link between usage of computer and real-world identifiers. Unfortunately, natural language could not be used fully today. But we can use its identifiers. This tendency is evident in GUI (its elements uses natural language words as labels), but it does not use own potential fully. Let's consider the whole solution in details:

* General approach: loose integration
- Minimum intrusion in status quo. We should use a form, which will obey to data (not to the contrary). Using "wrappers" for files, which will provide additional information (identifiers, abstracting, meaning) on files, this additional markup will be visible for all applications and globally (eg, information which is marked as "project document" goes to this project context at other machines too). Also such "wrapper" could be used as container, which can unite files and some other elements (like hypertext, but without formatting). It is required to have composite union of identifiers, abstracting, and meaning.
- Define new semantic protocol (possibly with usage of URN) over http, which uses computer identifiers for resources; instead of that, semantic protocol should make correspondences between information and identifiers (of natural language, of database, of URL, etc), eg, any word in html could be a semantic link which refers to multiple corresponding resources; in fact, such protocol already used verbally, maybe you have heard a phrase "type in search engine ..."?
- Information space should be "transparent" for an user, ie, information could be requested from both global and local sources (see delegation below).
- Soft concretization, ie, possibility to set not fully detailed relations, because an user has no expert knowledge and because full detailization is not always required (eg, a car engine is a car attribute or should be a subobject inside a car? instead, we can simply define that engine is inside of car, that's all), also we could not use a system of base relations for other relations (because there is no consensus if we can define them in principle).
- Possiblity to work with identifiers, linked in arbitrary graphs (as the alternative to triples, ontologies, etc of Semantib Web), which will make semantics accessible for non-experts and will be closer to natural language.

* Identifying
- Identifying of all meaning elements and translation of identifiers (eg, "plane" and "avion" should have one language-independent identifier in general case; in particular "plane" could be translate to both specific plane and plane as conception), such identifier could translate to local identifier of database for specifying vehicles, or to GUI element, which used for editing vehicles (it could allow user-defined application compatibility).
- Identification should be done preferrably on information creating (it is assumed a information creator is acquaint with related domain, and contexts are used, which can facilitate identification). Once identified, there is no need in complex calculations required for recognition (which done today by applications, whose results are not always correct).
- Identification of application elements should include not all elements, but only meaningful ones (otherwise, we can confront "identifiers hell").
- Translation of identifiers and abstractions (with similarity criteria), eg, a car model could be different in other country, with some modifications, in this case, identifier translation is impossible, therefore identifier can be only "approximately" translated into other. Opposite to keywords, tags, associations, "related" topics, such translation implies evident definition of similarity (abstracting) criteria, ie, typization.
- Translation of identifiers into resources (hypertext links, files, etc), unlike hypertext reference which links a word and a resource, such translation should link a word with an identifier(s) which would have links to resources.
- Translation of identifiers can lead to calls of actions/services/methods (with parameters), like natural language sentences (eg, "I write a letter to my friend by pen" implies a call of "write" with "a letter", "my fried", and "pen" parameters, or of "writeLetter" with two parameters, or "writeByPen"). Such translation allows (1) to refer to different identifiers, resources, depending on parameters, (2) to link actions more flexible (eg, a page can have "write a letter" identifier, without linkin with specific service or application), (3) to use identifiers for help (eg, an instruction like "go to menu, check radio button, press OK" can be represented as executable identifiers), etc.
- Translation of identifiers should be delegated implicitly of explicitly (eg, at first to an user computer, then to higher network levels: project, departament, company, city, country, globally; or to higher application levels: library, application, suite, OS, etc; or to higher context levels, ie using abstracting). Thus, (1) translation is done at the level which able to do this, (2) translation can provide different understanding from various levels, (3) server networks could be used for specific identifier sets (eg, only of biology or sports, etc), (4) it can simplify information exchange (eg, you send "project document" identifier to your colleague, he or she try to open it, because a document is not available locally, corresponding level process a request and provides a document).

* Abstracting
- Explicit representation of abstracting results (eg, an article about production of model A of car B should be abstracted to "productin of model A or car B" phrase, which consists of "production", "model A", and "car B" identifiers, which linked into one phrase, where "model A" is a part of "car B"). Typical example of "identifier + abstraction" representation is "ID + name" pair which used in many applications, where ID is computer identifier, and name is identifier in natural language.
- Abstraction of language forms (some of them are historical or used for join different forms in a sentence), eg "sun rises" or "rising sun" could be represented with two the same identifiers, because "rising" is used only when we need to use one more verb like "rising sun shines".
- Any search should use at first abstraction (eg, if "model A" word occurs in "production of model A of car B" phrase, it is more important, than if such word occurs in an article about all products of a company, in own turn, this is more important if this word occurs in a book on cars, but only if a book not about "model A").
- Any search should abstract results, grouping them based on abstract comparing (eg, searching by "model A" should result in "problems with model A" and "shops selling model A" groups), which is done already by some search engines but not always regularly. Such grouping is similar to hierarchy, but is more arbitrary which is more natural. Similar grouping used in texts, when we group text into chapters, paragraphs, lists, etc, which underlines that meaning of such groups is different, also it allows to concentrate similar meaning in one place.
- Any search should use importance criteria, which based on the way of information abstracting and filtering (contemporary GUI uses sorting and filtering for this purpose; bold text is another example of importance usage).

* Meaning
- Semantics should be explicit and compatible for different applications (which is supported by identifier compatibility and translation). Information can be ordered into structures like lists, tables, graphs, hierarchies. It can use different relations 1:1, 1:N, M:1, M:N (which corresponds to different structures). It can use objects, actions, and relations (space ones, time ones, possibility, planning, goals, etc), which used in natural language, but not always explicitly in computer world.
- Association of information with attributes, categories, etc (today it is done with tags and keywords) should be replaced by linking with identifiers which behind curtains could be linked with other identifiers (eg, if you link a picture with "vacation" identifier, you should not link it with "rest" identifier, because it will be done implicitly). Such link implies only itself (eg, "vacation picture" relates only to vacation pictures, but to documents which mention vacation and/or pictures).
- Any identifier is the result of abstracting, an abstract identifier uses similarity and usually corresponds to a type (eg, "car" relates to multiple things), a concrete one uses identity and usually corresponds to a variable or a value (eg, "my machine" is an unique identifier). That is, unlike in programming, there is no strict boundary between a type and a variable, we can consider only a balance between abstract and concrete (usually, the more identifiers used the more conrete is contents).
- Any exception should use either additional identifiers ("car but with two wheels"), or more abstract identifier ("this is not car, but just transportation"). Such additional definitions and even redefinitions express a balance between determined and possible, which could occur to any information.
- Any thing is static and dynamic simultaneously, only abstraction can change a balance to one of two sides. This could be explicitly defined for any identifier (eg, "model A prices" could be a request to dealer site, which returns current prices, or a fixed data, which were received in some moment of time; both forms could be linked between each other, to update information or receive notifications on updates; for documents such dualism could be expressed in a composite form, which developed through time, and versions, which fix "snapshots" of a document; version should be one of base property of "wrapper" described above).
- Any information is both subjective and objective. Objective character is a criterion of bigger abstracting (ie, the more subjective consensus, the more objectivity; even more precise criterion of objectivity is verifiability, but it can't be applied always, especially to information which relates to not precise areas or pure abstractions). A subject (a person or a site) considers own opinion as "objective", therefore it is important not only to separate objective and subjective (eg, an article and comments), but also to indicate who's author of opinion (then objective information could be classified as subjective, when it goes out of boundaries of a subject).
- Any information can be atomic (eg, separation by files) or closed (eg, all necessary values are available inside an application or a site), but also consistent with other information. More important, that information should be ready to break own links, when going outside of closed system, and be ready to be a part of the whole and acquire links when being a part of other closed system.

* Interface
- Any interface is an abstraction which hides implementation (actions, data, etc). Therefore, everything said about abstraction could be applied to it too. It is necessary to use mixed approach, which will unite advantages of both text and graphical interfaces, and will add something new, which will unite advantages of hierarchies (like in GUI and portals) and one entry point (like in command line and search engines).
- Identification is one of the most imporant element of interface, which should provide identifiers not globally (eg, contemporary search engines provides all identifiers availalbe), but restricted with contexts. Context for information filtering, which defined by a set of identifiers, will restrict information visibility (eg, graphical context will show only graphical applications and files). Similar restrictions now done by file types, and by applications and sites themselves, which implicitly restricts visibility. Contexts should replace contemporary desktop, providing multiple entry points to a system. Contexts should be provide ability to increase/decrease visibility, to intersect them, etc.
- Information should be available with meaningful identifiers (eg, instead of 124.sub file, information should be vislble as "subtitles of movie A", where "subtitles" and "movie A" are separate identifiers, which could be reused for further searching/filtering).
- Application elements should be linked in one entity (files, settings, etc). This would facilitate recognition of file application ownership and manipulating with application (eg, saving settings to move them to another computer).
- Access to interface with meaningful identifiers (eg, access to "car model" field could be done with "car model" identifier, which could be reused; you could save a form of all car fields, fill it outside of an aplication, and then load it when an application will be available; we can create "shortcuts" for some dialogs are used multiple times with the same values, such "shortcuts" are similar to "macros", but they will be available in all applications; also, this could help with remote and virtual machines, when operating with GUI will be operating with identifiers, which is quicker in such cases).
- Options/parameters should be linked with functionality (eg, on activation of this function, we can see which options affect it).
- Any interface element can be represented in following aspects: (1) declarative (identifiers), (2) imperative (related to actions or changes), (3) referring, (4) interrogative. These aspects can help how given element can (1) be used and reused, (2) change and be changed, (3) linked with other elements, (4) can be linked with other elements (necessary when information is incomplete).
- A sort of command line (but not for OS, but for applications and sites) with meaning restrictions, hints, linking, etc. (eg, if a product list can be defined only after an order created, then on typing of "add product", such command line should show that an action is possible only when an order is defined, therefore it should propose either "add to order" or "create order"). Possibility to operate with interface not only with fixed forms (like in contemporary GUI) but also with dynamic forms (an action is represented as an identifire with relating parameters as placeholders, which marked as necessary or not, restricted with visibility, etc).
- Context filtering can be a security tool, restricting application visibility and declaring what is could be affected by an application (which is simpler than when it is done by users, because application visibility declared once by an application creator).
- Possibility to manipulate with non-linear text (which additionally to linear text, has references to other information). Non-linear text is a further development of hypertext idea (which has no simple way to create text, add links or comments, without formatting). Such task could be done today with text editors, but they do not use identifiers, relations, etc.

EXAMPLES

Thus, how this will work together? Of course, not only identification, abstracting, and meaning which matter, but also interface, which facilitate the solution.

Example 1. Pictures from vacation

1. Open picture context (where only graphical applications and picture files available).
2. Load pictures from camera. Classification inside this context is proposed on load. You type "vacation", but you already have "vacation 2009 seashore" identifier, therefore new identifier is proposed (because file attributes belong to 2010 year, and geotags is far away from seashore), proposed name is "vacation 2010 Paris" (because you use only year for specifying time, and geotags are abstracted into the largest geographical entity, ie into Paris, if you have more geotags for Versailles, then they are abstracted into Ile-de-France). Further classification could use "I" and "wife" identifiers (which means specific persons at this computer), "best" (which applied only for certain pcitures).
3. Classification is ready. "Best pcitures from Paris" now imply only best pictures, not all documents which has these words. "me at pictures" returns all my pictures, including pictures from Paris.
4. You need to send best pictures from Paris to your friend. For that you need just apply "send" to "best pictures from Paris", also you may (or may not) choose a type of transfer. Further actions depends on different factors: (a) if your friend is available, then he or she should confirm transferring (if it is not always allowed), your computers establish available connection (email, http, ftp, IM, p2p, etc) and copy pictures. (b) if you friend is not available, then he or she is just notified about transfer, which should be confirmed, your computer receives confirmation when your computer is turned on, after that files transferred to some relaying server, and when your friend will turn on computer again, relaying server will copy files. After that, files available in the same context (which you defined) at your friend computer (though it could be changed).

How it differs from today situation? (1) Identifiers mean what they should mean, seashore is not just word but can include coordinates, "Paris" is France capital, 2009 is not just a number but an year (because you defined it). (2) Identifiers available not only for the application which created them (like EXIF information), but globally (including file transferring). (3) You haven't to know where pictures stored at your hard drive, usage of contexts, classifying, and abstracting guarantee you can find them (file libraries are restricted, because they are only a list of files without identifying and meaning, which means they could not be created automatically). (4) You work with computer with goals (send), not with instructrions (open application, find pictures, attach them, send). (5) Identifiers translated into each other, therefore "I" means you for you, and it would "my friend" for your friend, therefore you can use different identifiers for the same person. (6) Identifiers are abstracted, therefore "Louvre" is inside "Paris", which can be calculated (not necessary at your machine, which could not have all facts).

Example 2. Screen locking
You want to disable screen locking. Today, you have to find an answer in Internet and modify registry. Could such task be simplified? It is also interesting what percentage of users know screen can be locked manually? How many know it could be done with keyboard shortcut? How many know this locking can be disabled? And why such knowledge is not available for all?

Usage of locking can be described by following items: (1) locking is necessary to prevent access to computer, when an user is absent, (2) locking is turned on after inactivity period, (3) locking can be turned on manually, (4) locking can be used to set not available status in IM. To describe such facts in meaningful way we need necessary relations: (a) goal (to prevent access..., to set status....), (b) possibility (can be turned on manually or after inactivity period; or disabled at all), (c) cause-result (turned on after inactivity period), (d) after (in this case "after" coincides with "cause-result", but generally "after" does not mean "because of").

Why an user does not know screen can be locked manually? Screen locking dialog should notify about it. The same concerns keyboard shortcut. Goal relation can be used in security notification, to inform that screen can be locked to prevent access. Also IM can inform about relation with screen locking. Possibility relation can be used when locking was turned on automatically, but an user should be also informed about ability to turn on manually and about disabling. Cause-result relation can be used after inactivity period, which did not result in locking, to inform such locking is possible. All listed cases do not mean additional implementation, but only linkage between GUI elements and meaning.

The situation with disabling is a little more difficult: manual modifying of registry does not warn that screen locking disabling is not quite secure. But how an user can use such ability even ignoring warnings? Today, he or she has to follow instructions or modify registry manually, or launch .reg file (which without understanding the contents is unsafe operation), or to use some utility (but which should be installed, and where you need to find concerned item in dump of settings and menus). But there is an alternative way: for example, OS could provide a service with "add registry key", "change value" identifiers, etc. "Wrapper" which links disabling/enabling of screen locking with such identifiers should be loaded to some certified site. You can find it directly from screen locking dialog, because here context is restricted with screen locking. Also, you should link "disable" namely with "screen locking", which prevents from finding pages, which have "screen locking", but "disable" relates to control panel.

Comparing with the current situation, we significantly decrease time, required for developers to implement some features, which are not included into regular utilities, and which does not require complex design and implementation.

Example 3. Orders
You work with orders (which have some identifiers inside registring application, which unfortunately has no web access). During work you need to discuss orders with colleagues, and sometimes with clients. In communication, you usually refer to identifier of an order, or copy-paste its contents, etc.

Similar routine can be and should be improved with the help of more flexible operations with identifiers and order forms. Order identifier should be available for reference which means: (1) you can directly access an order data (ie, referring to an identifier can open corresponding application, and follow to informatin which corresponds to an identifier), (2) you can receive data "snapshot" for an order and store it locally (though data is outdated, but you know "version" or date of fixing), which could be updated when necessary, (3) an order components are available for referring, ie, you can add back-references and markup which entities refer to an order (eg, discussion of availability of products, included into an order, can refer to this order), (4) if an order has not some field/attribute in the system (eg, you need own classification by custom attribute), you can create your own, referring to orders by an identifier (which will guarantee data integrity).

You can notice that similar tasks can be solved with programming even now. But they require addtional effort, resources, and time. Identification, support of static and dynamic forms, and other features can make them a routine with additional effort at user-side.

Example 4. Application
You develop an application which sums numbers.

1. An user sets the task in simple phrase: "sum numbers" (which consists of two separable identifiers).
2. An architect specify the task more precisely: numbers are restricted with two 2-byte integers, which is input, sum operation process them, and there is one 2-byte integer as output. An user can check that such model corresponds to his or her expectations (that is, checks for correspondence between "number" and "integer", etc).
3. A developer builds an user interface and links "integer" identifiers with two text fields, and "sum" with "+" button, and "result" with the third text field (also he or she links identifiers with code). An architect can check correspondence with own model, and an user with own understanding.

Of course, this is simplified example, but which shows that semantic links are not broken, meaning integrity is supported when information transferred between different persons, in the case of problem you can check correspondence, an user comments can be instantly available in corresponding places of model, specification, code and interface.

Example 5. Discussion
Everyone are familiar with the situation when a dicussion accumulates details, quotes, sub-topics, sometimes generates parallel topics. Management of such discussions is quite difficult. How proposed solution can cope with it?

Let's consider an example with orders:
- What's happened with order #12345? (this question refers to indicated order, possibly, an order linked with this discussion too; as soon as discussion starts we can automatically switch to this order context)
- I've talked with Mr. N and see no problem (this answer refers to discussion with Mr. N)
- Well, what with #12346? (this question refers to different order; so context can switch automatically to other order context, which even hide previous questions as unrelated)
- I will request company C (this answer at once can have linked TODO note, or unfilled request, which will launch corresponding application and will process it)
- I've looked at your discussion with Mr. N and see we have problems (this statement can refere to a part of the discussion with Mr. N where problems found)
- You know him, he asks for impossible, but after rolls back everything, if explained. Do you need a reference to his whims of the past?
- No, thanks, this cannot be attached to an order. Which means, discuss with him again, prove him everything needed.
- Yep. Have you seen pictures of the last corporate event?
- No, not yet.
...

As we see we can refer to everything: (1) questions-answers inside this discussion (this is evident and made in almost all communication applications), (2) other discussion (this is done in email, but usually absent in other communicating or available with web reference), (3) data inside applications (available today only with web-access, which should be created), (4) from data inside applications, (5) application interface. The very discussion flows from one subtopic to another, but parts of discussion remain linked with specific contexts, therefore context of order #12345 include two parts of discussion (in the beginning and in the middle). Subjective opinion on Mr. N is not included into an order context (but theoretically, a company can have context of clients to be available for new employees or which worked with other clients). Today, all such references are present in discussion too, but not available for reuse.

Example 6. Search
There is one example of Semantic Web critics (which given to show Semantic Web cannot cope with such query): "Is the Pope Catholic?" (question is rhetoric, but taken literally the only answer is "yes")

Proposed solution on typing "Is the Pope Catholic?" can solve this way:
a. "Pope" can be identified as either the Catholic Pope or a part of name (eg, Alexander Pope) or other meanings.
b. Adding of "catholic" already could resolve the ambiguity and concentrate on the first meaning. Though it could happen even automatically, being in context of church or theology, etc.
c. Further, a link between "Pope" and "Catholic" should be found (by delegating this query), which should return "yes".

Contemporary search engines on "pope" query dump pages with possible definitions of the word (but which are unorderd and duplicates themselves several times), "pope catholic" naturally gives pages on the Catholic Pope, but slightly different "church pope" gives "Lake Tahoe's Santa Claus slams Catholic Church..." as the fourth result, "pope catholic rome" gives "The World Seen From Rome" as the fourth result. Of course, "is the pope catholic" gives exact matches for pages on this phrase though not answers to the question. Which proves that contemporary search engines give correct answers only when natural language identifiers coincide with meaning. A little different query and results are already far from correct, which shows that identification of words and relation identification is required.

Example 7. Semantics
This example is considered in Semantic Web OWL specification): wine agent. This example shows how Semantic Web works, when choosing wines and meals.

What do we need if using the proposed solution? We can use already available information and markup it with identifiers, recognizing specific wine or meal. We don't need to specify full set of relations. It could be done by applications or specialized sites, which would return delegated answers for wine details or matching with meal.

Semantic Web makes the task more complext (no surprise, because it is assumed it would be solved by experts). For that, we need to define ontology, which will be used by a reasoner. In the process, ontology:
- uses computer identifiers like "pasta-with-spicy-sauce", which meaningless for natural language and make reuse of its parts impossible (unless parsed);
- uses fixed hierarchy, which assumes, for example, that "wine" is "potted liquid", but wine could classified in hundreds ways ;
- defines which fields and restrictions wine should have (which is good, because it does the same what GUI does when disallow input of meaningless values); however, a field set is determined and concrete, though, in particular cases, fields can be undetermined and abstract;
- queries to reasoner do not look as easily recognizable by a human;
- etc.

That is, in general, Semantic Web has similar shortcomings as contemporary applications have.

CONCLUSION

What we have in result? This is a sort of a compromise between areas of "ordinary user" and areas which usually belongs to experts only (they were just unavailable for users, and detached from reality for professionals). Could such compromise cope with information garbage? At least, identification, abstracting, and meaning can alleviate sorting significantly. Quite naturally, we can confront with another problem of huge number of references. But this problem of not sorting, but rather of performance. This requires possible different approaches to computer architecture, a sort of cloud-computers (do not confuse with cloud-calculations). Could proposed solution be implemented? In particular, similar approaches are implemented long ago. But also we need global consensus on semantic protocol and globally available identifiers. Is it possible? Hopefully yes, because proposed approach can save efforts, time, and resources both globally and locally.