2008-05-10, by John Ringland
Before joining the conversation, please read and accept this Invitation to a Conversation.
SMN
can be thought of as a Universal System Integrator that can enter
into any computational space and integrate its various systems and processes
into higher level systems and processes that allow us to interact with the
low-level functionality in more intuitive and complex ways. Hence,
within any electronically controllable environment we could create an
SMN process that integrates that environments systems and processes
into higher-level systems and processes.
SMN can be introduced into any computational-space. The SMN
integrator has an interface through which the user can view and
interact with the virtual model, which consists of systems or
processes within the computational-space, which are reified within
the virtual space where they are integrated into higher-level systems
and processes.
The System
Oriented Modelling Paradigm project is in its first phase wherein
we apply SMN to Java
so this phase could be called "System Oriented Java". It
uses the Java programming environment as the computational-space and
a Netbeans
IDE plugin as the interface, which will provide an SMN view into a
virtual model that consists of Java objects.
This gives a high level systemic IDE for the Java programming
language that will allow for the development of complex robust
systems in Java. When deployed these will be pure Java programs, but
they will be implicitly structured according to the systemic logic of
SMN.
I could imagine an analogous situation with an interface
application that provides an SMN-view into a virtual model that
consists of POSIX
operating system objects and procedures. POSIX is an international
standard that many operating systems conform to such as UNIX, Linux,
Mac OS X and also Windows using the UWIN
extension. The OS objects and procedures are shell commands, shell
scripts, programs, directories, files, devices and so on. The POSIX
OS is the computational-space and the SMN-viewer application is the
interface.
In this scenario we introduce an SMN process into the OS
environment that integrates all the various systems and processes
into higher-level systems and processes. The programs could be used
as subsystems with which to construct complex robust computing
environments. The user could interact primarily with systemic virtual
models whilst behind the scenes the native programs are integrated by
SMN to implement the low-level functionality. This could be developed
into a high level systemic human/computer interface that can operate
within any POSIX OS.
If the computational space is web content on a web-server then SMN
could animate this in a similar manner to PHP
or JSP
but in a far more systematic manner allowing for more complex dynamic
web content.
If the computational space is a network of computers then SMN
could integrate their computational power into a single coherent SMN
process. In this context the computers can seamlessly interact within
a common virtual space and if we wish we can make a super-computer
out of many regular computers or transform a super-computer into many
virtual computers.
If the computational space is a set of concepts in a discourse
then SMN could systematically map these as concept maps (mind maps)
or ontologies and validate them, allowing for more complex conceptual
communication. This would use OWL
(Web Ontology Language) for clear and precise expression of ideas,
beliefs, opinions, conceptual models, plans, processes and so on. It
could lead to systemic methods for the integration of different
perspectives which would assist in conflict resolution and the
development of a unified understanding amidst a diversity of
perspectives.
If the computational space is raw computer hardware then SMN could
act as a complete operating system by reifying the various devices as
systems within a virtual space where they are integrated into a
unified systemic computing environment. The core SMN process can be
implemented on-chip (or in-silico) to produce a very fast pure-SMN
computer.
If the computational space is a modern industrial plant that is
electronically controllable, then SMN integrates all the components
of the plant and reifies the plant as a virtual system whose
behaviour can be closely monitored and controlled for greater safety
and efficiency.
SMN is a general systemic process that can be introduced into any
computational space. The project would seek to develop the general
principles whereby SMN can be applied to any electronically
controllable environment to integrate its various systems and
processes into higher-level systems and processes.
We initially implement these principles within the context of
Java. This serves as a useful tool as well as an example of how SMN
can be applied, which can help people apply SMN in other contexts.
Once the first "System Oriented Java" phase is well
underway we could then look to what other systemic context we could
apply SMN to next. Hopefully there will be others doing the same.
There would also be many other facets to the project such as,
documentation, networking, etc.
This will shortly be released as an open-source
project with some kind of a GPL
license so let me know if you want to get involved - there's a lot of
work to be done to fully define and develop this new technology and
it will be exciting to see it come together.
Best Wishes :) John Ringland www.anandavala.info
Before joining the conversation, please read and accept this Invitation to a Conversation.
|