innovative object-oriented paradigm and related method for application
development through building the explicit run-time conceptual model of the
corresponding application domain. Unlike other modelling methods, the resulting
model is directly used as the flexible run-time conceptual information and code
toolset for building the most important part of an application its back-end,
including all the essential information and functionality, independent of any
front-end user interface in a more natural and effective way. The classical structured
taken to a whole new dimention coherent mutually dependent structuring of both
information and code in an
Conceptual information store, maintaining on secondary storage
the actual run-time application information bases, structured conceptually as
sophisticated models of the application domain concrete and abstract entities
along with a multiplicity of explicit real and epistemological links (binary
relations) among them. Explicit dependency links may also exist among entity
attributes. Representation of higher-order n-ary relations and
is also supported.
Explicit user-definable entity
semantics that allows for entity attributes,
relations/links and events themselves to be described in unlimited depth as
dynamic entities thus providing a basis for deep qualitative reasoning. For
provides for reasoning about
attribute values not only within the context of
their particular primitive data types (being built-in iConceptStore concepts
themselves), but also about their relevant meaning within the much broader
semantic context of other related conceptual structures.
Coherent representation of entity
classes, sub-classes and their associated instances.
Coherent representation and
handling of both persistent and transient entities.
Coherent representation of attributes of
primitive and compound data and entity types with either explicit or implied,
whether single or multiple, values.
Note: implied (implicit) attribute
values are functionally dependent on values (whether
explicit or implicit)
of other entity attributes.
Coherent representation of
different kinds of (predominantly binary) links between entities (first tier) as
well as multiple dependencies between their attributes (second tier).
Built-in dynamic multiple inheritance
along entity net taxonomy links.
merger of the information and functional components of an application back-end
by explicitly relating code units to relevant information items on
secondary storage. These
declarative, pure descriptive, links reside on secondary storage as parts of the
conceptually structured information base and can be created or changed at
run-time. Each link reflects the inherent relation among an entity attribute
implicit (i.e., implied) value and its dependencies (values of other entity
attributes). Each link is inplemented in the form of corresponding dependency
Like the entity attribute explicit values, implicit attribute values, hence
execution of their dependency operations, can be transparently inherited at
run-time along their taxonomy links on
secondary storage thus allowing for consistent structuring of
both information and code. Thus the business logic inherent structure is modeled as a
network of only semantically connected multiple small information and code
components with no explicitly pre-defined (hard-coded) control flow or intended
usage (dynamic distributed usage-independent information and processing logical model).
Generic declarative conceptual modelling language (CML) for non-programmers,
universe of discource descriptions,
human conceptualization of an application domain. In order for encouraging wider
participation of business analysts and end-users in the application development
process, it allows them to concentrate on the application domain compexities rather than
computer-specific internal representations and operations. The incremental
compiler loads the information, encoded in CML scripts, directly into the
Executed either synchronously or asynchronously, the compiler accepts CML input
from either static files or dynamic memory buffers at run-time.
general-purpose application shell to be (possibly dynamically) loaded with
inter-related information and code components that function in co-ordination as
an application back-end (see the
architecture bellow). The application information bases are loaded either
programmatically or by means of the CML compiler, dynamically attaching custom
DLL routines and event handlers to related information items on
secondary storage thus bridging in
part the conceptual gap between data and code. Rather than hard-coded in
advance, the actual control flow is automatically derived on demand at run-time
from those inherent links among entity attributes and their
A uniform client
access (from within any
run-time service is provided by the
remote COM component, serving as means for creation and manipulation of entities
and their attributes/relationships as well as handling of any relevant events.
For easy of use, most functional parts of this interface component are
synchronous but they also have some asynchronous counterparts.
modelling space is provided in memory for each of the simultaneous
clients as they run in separate processes. However, all those client
applications, which refer to the same iConceptStore modelbase, share its common
image on secondary storage.
Dynamic fluctuations of model
components and characteristics.
extensible dynamic modelling system. There is nothing predefined at compile-time
- any part of an information component (persistent and transient entities,
relations/links and events) can be created, modified or destroyed incrementally
on-the-fly at run-time. Even related functional components (e.g., custom DLL
code), implementing particular operations (e.g., evaluation of dependant entity
attributes), are only attached on demand at run-time for the duration of the
actual operation (whether synchronous or asynchronous) performed. The system
also provides a unique built-in mechanism for collecting and using entity state
histories. And nearly everything in it is custom-extensible at run-time;
real-time events driven dynamic modelling environment. A flow of incoming events
can maintain the domain model in synch with the reality observed and make it
behave as an active information store, responding in a number of dynamically
information store with dynamic deductive capabilities, based on built-in
coherent inference mechanisms: run-time inheritance along multiple taxonomy links on
entity attribute implicit (i.e., implied) values, derived on demand from their
dependencies through custom evaluation procedures;
inference of implicit information by
dynamic constraints and event effects
and explicit entity links on
Combined with the flexible conceptual representation of
CML dynamic information structures and logical expressions in conjunction with the related
built-in deductive mechanisms of its
Rule and Event
categories, this feature provides for dynamic
notification call-backs provide for dynamic feedback during any
and implemented to run in a separate process as a service on a local or remote machine, in effect
serves as a kind of intelligent
middleware between the data- and presentation-tiers.
support for clastering conceptual information stores by attaching such remote
services to the server side with the ability to transparently resolve and
evaluate references to remote entity attributes as well as propagate event
effects to remote dependants.
and transparent integration under the new object-oriented paradigm of the widely
used relational database technology thus providing for use of
mixed modelling working paradigms (RDBMS's
role is restricted to only maintaining sets of explicit
instances, dynamically attached to corresponding entities with regular value
variations of some of their attributes).
distinguished levels of knowledge representation and reasoning.
special purpose interpretation programmatic interface for seemless
integration with higher level problem solving and reasoning tools and
applications, including first-order logic based ones, through auxiliary external
server-side variables, which have their values assigned and updated
transparently as a dynamic side-effect of the
fully customizable generalized
Flexible, dynamic, yet
straightforward and easy-to-use object-oriented (with regard to both information
and functional components) environment.
Transparent co-ordination between
in-memory and secondary storage operations.
Generation of information
modelbase contents directly from static/dynamic CML scripts as well as
programmatically by client- and server-side user programs.
infrastructure ready to use out of the box.
Server-side (in-process) C++ as well as client-side
(out-of-process) C++ and COM/.NET interfaces
(any programming language); alternative asynchronous event-based interfaces also exposed on both