Home Up EntityNet


Decision-Making in Conceptual Design


Essentially, iConceptStore turns domain modelling from a preliminary phase of application development into its core activity through direct use of the resulting flexible conceptual model in capacity of application's actual run-time information and code base (modelbase). In order to make this natural paradigm possible, the iConceptStore object-oriented framework provides for dynamic conceptual modelling of any relatively self-contained world (environment) fragment as a discrete system (whether existing or hypothetical entity) with its inherent properties (with either explicit or derived, single or multiple, values), internal structure and functions/operations as well as external relations and behaviour. The special purpose Conceptual Modelling Language (CML) of the iConceptStore Conceptor knowledge engineering subsystem serves as means of describing any universe of discource in terms of those characteristics. Conceptor CML is a generic high-level declarative language for non-programmers, allowing such descriptions to be as close to human conceptualization of an application domain as appropriate. Intended to encourage 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. An 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.


Whether first described by means of CML scripts and then compiled or directly built programmatically at run-time, the contents of iConceptStore modelbases can be manipulated by any EntityNet client program and/or extension (see the iConceptStore overall architecture bellow). Multiple modelbases can be open simultaneously with multiple (possibly different) client programs accessing each of them at the same time. Standard COM (out-of-process, any programming language), .NET (out-of-process through the interoperability service) and C++ (both in-process and out-of-process) programmatic interfaces are provided, including input for asynchronous parameterized external events (built-in and custom-defined). Entities and attributes, explicitly designated as active, respond to external events by activating user-defined local event-handlers and/or asynchronously propagating event details and effects further along relevant attribute dependencies and/or explicit entity links.



Designed for the mainstream computing, with business analysts in mind, this original evolutionary product brings down to earth a selected set of innovative techniques with no exotic programming languages involved. In particular, it fits into Microsoft’s 3-tier general application software architecture (see the EntityNet example bellow as applicable to developing Internet applications), naturally filling the still empty slot of business logic (reflected by application domain models) manager – the intelligent middle-tier service and related SDK, crucial for building the sophisticated decision-support systems of the future.

iConceptStore's underlying technology provides means for a comprehensive representation of business logic facts (explicit well-structured information fragments) and rules (inference schemes/methods of drawing derivative/implied information items) as well as managing at run-time their dynamic persistent state on secondary storage.


It is a widely spread mainstream software development practice to incorporate directly into applications all sorts of specialised calculations, searches, selections, decision-making procedures, etc. The complexity of the methods involved could vary enormously but their main purpose usually is to determine the value(s) (in the broadest sense) of something depending on current values of some other things. The information processed is usually gathered from databases, user input and current internal states. One of the shortcomings of this approach is that it frequently results in large monolithic applications that are difficult to develop and maintain. Furthermore, the methods involved are artificially taken out of the logical context of their data dependencies with many hard-coded details absorbed. As a result, reuse of information and code components becomes problematic because of the substantial restructuring and alterations required.


Capitalising on the derivative nature of attributes with implicit values (depending on the values of other attributes), the iConceptStore framework offers an alternative application architecture that allows for spreading of evaluation methods across the persistent network of entity classes on secondary storage. Whatever the method complexity, the fact remains that from pure logical point of view it is nothing more than an evaluation – a procedure, embodying the relevant processing method, gets as an input the values of all the dependencies and produces a single or multiple value output. If the forms of those input and output are well standardised, then methods could be plugged in and out even at run-time. In this respect entity attributes with implicit values could serve as points of procedure attachment.


iConceptStore provides a set of such standard method invocation interfaces. Furthermore, it supports a generic mechanism for gathering the values of attribute dependencies – other attributes of the same or different entities. In the case of attribute evaluation, this process is initiated automatically by any client request for retrieving an implicit attribute value and is entirely based on the specification of dependency links, associated with every such attribute. EntityNet invokes the actual evaluation procedure, passing on to it the values gathered along with any other input parameters from the client application.


The iConceptStore framework automatically evaluates all dependency attributes prior to making the actual method call. In turn, such attribute evaluations might trigger other routine calls (if any of the dependency attributes evaluated have implicit values themselves) thus spawning chains of related execution processes. Ultimately, EntityNet collects and dispatches the resulting value(s). Conversely, while implicit attribute values are derived on demand from their dependencies, dynamic constraints and changes, affecting values of any active attributes, are asynchronously propagated back to their respective dependants and/or along explicit entity links, possibly handled and/or propagated further by corresponding event-handlers.


In order for ensuring a complete context of method execution, EntityNet own reference as well as the current target and host entity references are also passed to the procedure executed thus providing indirect access to other relevant pieces of information, available either locally (within the scope of those two entities) or through further navigation along relevant context links to the rest of the entity network.


In a similar fashion, other types of methods, implementing certain kinds of synchronous or asynchronous operations in user-supplied server-side pluggable extension DLLs, can be loosely attached directly to either entities or individual attributes. The iConceptStore framework calls these routines by means of suitable well-defined C++ interfaces (see the iConceptStore overall architecture above) thus providing for user-defined actions in response to evaluation requests and/or application domain external events, possibly making use of standardised asynchronous notification call-backs as appropriate. Automatically loaded on demand, these routines provide a spread of processing power locally as their immediate visibility scope is restricted to just one of those information islands (others can be reached by navigating along existing persistent entity links on secondary storage).


In addition to asynchronous handling and propagation of external events, transparent run-time inheritance of both values and code along taxonomy entity links add further dynamics to the execution process. As a result, the actual control flow is formed as a logical consequence of dynamic inter-attribute dependencies and entity links, residing within the flexible iConceptStore modelbase, rather than by following any conventional predefined and hard-coded execution scheme. Essentially, any iConceptStore modelbase becomes a set of dispersed but inter-linked information islands with locally attached data and related intelligence.


In addition to the server-side attribute extensions, the iConceptStore framework also supports client-side extensions. They are also designed with standardized interfaces and implemented as ordinary custom DLL routines. While server-side extensions are executed within the EntityNet.exe process space and thus have controlled access to some of its internal structures, client-side extensions are loaded and executed within the client application process space on request of any server-side extension routine. Unlike server-side extensions, client-side extensions have indirect quasi-synchronous access to the client application through its asynchronous callbacks. Client-side extensions provide to server-side extensions a convenient universal mechanism for asynchronously executing code on the client-side as if it was part of the client application. Collectively, server- and client-side extensions provide for flexible CML based declarative style programming capabilities within the iConceptStore ResourceViewer event-driven visualization/execution environment and the underlying EntityNet dynamic run-time functionality.


iConceptStore is not just a development tool - its advanced distributed multi-tear architecture seamlessly becomes a run-time feature of any particular application developed. Along with their related entity attribute dependencies, the server-side extension procedures are the focal points of such an architectural embodiment, wrapping the relevant business logic in manageable chunks. The standard parts of their C++ source code and linker definitions can be automatically generated by the CML compiler, including processing of any input parameters, reflecting the related attribute dependencies data types as specified in the corresponding static CML script compiled.  Attribute dependencies and related functions/operations can be also contained within dynamic CML scripts, possibly generated and/or compiled at run-time. Alternatively, dependencies can be directly created programmatically by any EntityNet client program or extension.

Implemented exclusively by means of Microsoft’s tools and technologies, iConceptStore features a smooth integration with Visual Studio C/C++ 6.0 (iConceptStore Standard Edition and higher) as well as SQLServer 2000/2005/2008/2012/2014/2017 (iConceptStore SQL-Link and Enterprise Editions) and MS Office Excel/InfoPath (2003 and higher) - standard data management and data presentation tiers, respectively. In addition, specific iConceptStore COM add-ins allow for integrated use of the other MS Office components Word, Outlook and Project (2003 and higher). The iConceptStore Resource Collector dynamic interactive utility is also provided for use in conjunction with the MS Internet Explorer (all iConceptStore editions). Further integration with other Microsoft and third-party tools is also planned. Apart from the incremental CML compiler, several other interactive tools are useful for gathering of arbitrarily structured problem-solving and decision-making oriented information of any kind. Original multimedia utilities for viewing and modifying existing modelbases are provided as well.

Used in conjunction with selected Microsoft products, iConceptStore’s technology should be able to gain appreciation among software development professionals, especially users of Microsoft’s development and data management tools, which appear to be iConceptStore’s ideal prospective customers. Of course, iConceptStore’s unusual technology requires further research and development efforts in order to realise its full potential in the market place. In particular, suitable application projects should reveal its unique selling points and lead to essential enhancements and extensions. Additional layers of sophisticated dynamic knowledge representation and built-in problem-solving oriented reasoning mechanisms, which are currently being implemented with the next stages of their further extension planned, should help iConceptStore to evolve into an even more useful development environment.


Copyright © 2005-2020 Dr Vesselin I. Kirov