An 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 base (modelbase) of the application.

A hybrid 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 programming paradigm is taken to a whole new dimention – coherent mutually dependent structuring of both information and code in an organic unity, based on their inherent links explicated.

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 functions/operations is also supported.

Explicit user-definable entity semantics that allows for entity attributes, functions/operations, relations/links and events themselves to be described in unlimited depth as arbitrarily complex inter-linked dynamic entities thus providing a basis for deep qualitative reasoning. For example, this provides for reasoning about entity 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.

Unique semantic virtual memory control with transparent co-ordination between in-memory and secondary storage operations.

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.

Logical 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 function/operation. 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 persistent 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, providing for universe of discource descriptions, close to 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 Conceptor^™ CML compiler loads the information, encoded in CML scripts, directly into the iConceptStore^™ modelbases. Executed either synchronously or asynchronously, the compiler accepts CML input from either static files or dynamic memory buffers at run-time. 

A 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 iConceptStore^™ overall architecture below). 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 dependencies.

A uniform client access (from within any programming language) to the EntityNet^™ run-time service is provided by the EntityNetAccess 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.

An independent modelling space is provided in memory for each of the simultaneous EntityNet^™ 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.

An extensible dynamic modelling system. There is nothing predefined at compile-time - any part of an information component (persistent and transient entities, attributes, variations, functions/operations, 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;

External 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 configurable ways.  

An information store with dynamic deductive capabilities, based on built-in coherent inference mechanisms: run-time inheritance along multiple taxonomy links on secondary storage; entity attribute implicit (i.e., implied) values, derived on demand from their dependencies through custom evaluation procedures; inference of implicit information by asynchronously propagating and handling dynamic constraints and event effects along relevant persistent attribute dependants and explicit entity links on secondary storage. Combined with the flexible conceptual representation of the iConceptStore^™ CML dynamic information structures and logical expressions in conjunction with the related built-in deductive mechanisms of its Inference, Rule and Event categories, this feature provides for dynamic non-numerical analytics.

Asynchronous custom notification call-backs provide for dynamic feedback during any client-initiated operations.

Designed and implemented to run in a separate process as a service on a local or remote machine, in effect EntityNet^™ serves as a kind of intelligent business logic middleware between the data- and presentation-tiers.

Native 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.

A smooth 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 anonymous instances, dynamically attached to corresponding entities with regular value variations of some of their attributes).

Clearly distinguished levels of knowledge representation and reasoning.

A 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 iConceptStore^™ fully customizable generalized Universal Conceptual Unification^™ mechanism.

Flexible, dynamic, yet straightforward and easy-to-use object-oriented (with regard to both information and functional components) environment.

A natural symbiosis between conventional and new generation tools for data and knowledge integration purposes.

Generation of information modelbase contents directly from static/dynamic CML scripts as well as programmatically by client- and server-side user programs.

Distributed client-server 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 sides.