| Previous | Table of Contents | Next |
Languages, on the whole, represent information in a fairly similar way. A document invariably consists of a set of concepts,
each of which consists of a number of other concepts, and so on until the concepts are nothing but simple pieces of atomic
data. This can be seen in both procedural and object-oriented programming languages, as well as in natural English. For example,
an English essay could be said to consist of a series of paragraphs, each of which contains a series of sentences, which contain
a series of words. A piece of source code for the Java programming language [Java] could consist of a series of import statements,
package statements, and class definitions, which contain variables and methods, which contain sets of parameters and statements.
At different levels of depth on this ‘concept tree,’ the representation of the containing concept changes. One common change
is for concepts higher on this tree to be introduced in some way. For example the essay with its paragraphs might first have
a title, or chapters within a thesis might have chapter numbers and titles. A method declaration in a Java class definition
has a visibility value, a method name, and a return type. By contrast, where an element is the only possible element in its
position, it may go without an introduction, such as sentences within a paragraph, or statements within a Java method definition.
However, to be effective this requires some language familiarity on the part of the user, something that cannot be assumed
for the HUTN languages.
Particularly in structured notations such as programming languages, it is often necessary to separate the contained concepts
using some form of punctuation. Java, for example, uses braces to delimit method bodies, commas to separate method parameters,
and semicolons to terminate statements. Written English uses full stops to terminate sentences, and commas or parentheses
to delimit phrases. The choice of symbols for separating punctuation can also be dependent on the depth of the concept on
the tree. For example, braces are often associated in programming languages with high-level or major concepts such as procedure
declarations, while commas are often associated with low-level or minor ones, such as a list of method parameters.
The MOF modeling concepts underlying the HUTN languages also conform to this ‘concept tree’ paradigm. Package instances contain
Class instances, Class instances contain Attribute values, and so on. Accordingly, the HUTN language core has been based around
these ideas of concept containment, introduction, and delimitation.