What is Analytica.NET?
At present, Analytica.NET is only an idea. If realized, Analytica.NET would be a full-fledged .NET development environment, encompassing both the core ideas of Analytica and of Microsoft's .NET, allowing high interoperability among other .NET-enabled applications.
From Analytica.NET, you build models, much as you do in Analytica currently. As with Analytica currently, models are organized as hierarchical influence diagrams, function calls array abstract, computed values are cached and maintained by an automatic dependency maintenance mechanism, and evaluation can be carried out in multiple modes (Mid-mode, Prob-Mode, optimization mode). But, unlike Analytica currently, Analytica objects are full-fledged .NET objects, and can be used directly from other .NET languages and applications, and any .NET object instance, even if created in a different environment, can be treated as an Analytica atom. From within Analytica.NET, you can implement interfaces defined by other applications, call foreign methods, create new .NET class and interface definitions, and compile models to .NET assemblies.
Analytica.NET, therefore, is a full-fledged development environment, in the same way that C# and Visual Studio forms a development environment. You can literally create executable end-user applications from Analytica.NET, or you can create "modules" that are used within external applications.
There are three key parts to Analytica.NET:
- The core: The Analytica.NET core provides, class definitions, objects, language, evaluation, array abstraction, dependency maintenance, compilation to assemblies, and the other core .NET integration pieces.
- Application Environment: The application environment is the GUI foundation.
For Analytica.NET desktop, the application environment provides some key GUI functionality & components, such as window & menu management and diagram & table UI classes, threading, GUI event handing. It provides a framework for implementing, managing, and customizing the UI behavior. It defines and exposes various classes, interfaces and objects that can be manipulated to tailor the GUI. It is a layer on top of the .NET System.Windows.Forms, but is particularly designed for UI creation from Analytica.
- System Modules: The system modules are automatically loaded when Analytica is started. These modules define almost all of the built-in functions, define all the system menus, implement the menu actions, define some of the built-in classes and objects, etc. The system modules may actually be implemented in a popourri of .NET languages. Theoretically, they could all be implemented in the core Analytica language, but for efficiency, convenience, or other considerations, much of this will probably be implemented in C++/CLI or C#.
When you create a model, you can of course manipulate it interactively within the Analytica Environment, but you can also compile it into a .NET module (i.e., library) or .NET assembly (i.e., application). The compiled version can be used outside of Analytica.
We may institute multiple Application Environments. Perhaps the Desktop environment, the Embedded Excel environment, the web server/browser environment, etc.
- Rapid creation of stand-alone vertical applications, implemented in Analytica, but sold separately.
- Ability to deeply integrate Analytica or specific Analyica models with other .NET enabled applications.
- Possibility of extending existing product suites with Analytica functionality.
- Improved ability to extend and customize Analytica.NET. Can add new user-interface controls, new functions/methods implemented in a different language, each access of data, etc.
- Reduces the commmitment required to use Analytica. Becomes one development tool among many.
- Relevance for Enterprise Suites & Enterprise apps.
- Analytica.NET is a fully open architecture. Although the core code itself may be proprietary, the architecture is totally open and totally expandable, so the product itself can be arbitrarily extended by third parties.
- Analytica to .NET correspondences: Both Analytica and the .NET framework have their own concepts of classes, objects, functions, etc. A critical design step to realize the Analytica.NET vision is to identify these correspondences, and in some cases alter or add to Analytica's basic concepts to bring them into correspondence.
- Class and Interface Declarations: The method and mechanics by which classes and interfaces are declared in an Analytica model. Inheritance.
- Compiling classes & models to .NET: A key to the integration is the technical steps of compiling .NET modules and assemblies (i.e., libraries and applications) from Analytica.NET models, and of dynamically exposing Analytica classes & objects as .NET objects while they are still within the Application environment.
- Analytica.NET's built-in Class Hierarchy: Every Analytica.NET object is an instantiation of an Analytica class. Every Analytica.NET class is defined by an Analytica.NET Class object -- i.e., an object that is an instantiation of the built-in class "Class".
- Function/Method Invocation|Function Invocation|Function/Method Invocation: In addition to array abstraction issues, a number of other considerations occur with respect to function calling. Numeric coercion, function/method overloading, passing of evaluation context (prob/mid, optimized, cur slice), polymorphism, casts, etc.
- Values, Arrays, and Intelligent array abstraction: You can have an Intelligent array of objects - each object is an atom, occupying one cell of the array. In an Analytica.NET expression, an intelligent arrays can be passed to a function or method that expects something other than an Intelligent array as a parameter -- Analytica will array abstract as necessary to make the call. Intelligent arrays are not the same as C# arrays, for example, so new considerations come into play when passing/returning arrays to/from .NET methods.
- Desktop Application Environment: The design of the application environment presents some challenges to do it right. This idea is a bit different from creating an Application like Analytica. Here we are really looking for a flexible framework, very much Analogous to Visual Studio, but specifically tailored to Analytica. Functionality for the desktop, and built-in classes/interfaces specific to the GUI are specified.
- Other Application Environments: Perhaps Analytica.NET for Excel or Analytica.NET.Web require variant application environment designs.
- Considerations not necessarily unique to Analytica.NET, but whose design should be considered:
- Multi-language/multi-cultural support
- "Deep" Inference extensions
- Non-rectangular arrays
- Generalized "Dynamic"
- Alternative forms of inference: It would be nice if the core Analytica.NET framework has the flexibility to support other forms of inference, beyond just simple forward-propagation. The issue is not the implementation of inference -- it having the flexibility so that someone else could add the form of inference into Analytica.NET in the future. Examples of such inference would be MCMC algorithms, hyperclique propagation algorithms (e.g., Bayesian net propagation), or special optimization algorithms.