Fault tolerant and combinatorial software environment system, method and medium

Abstract

A fault tolerant software environment, in which various program components (e.g., portions of computer programs, applications, etc) are objectized into entities represented by “codons.” This allows for improper syntax to occur, enabling, for example, combinatorial operations such as genetic programming. The present invention also contemplates such features as the ability to probabilistically execute individual codons, to switch between treating information as executable code or as data (or passing over it), provides that the individual codons can be tagged so that additional information can be associated with them, and provides for tagging of the stack.

Description

CROSS-REFERENCE TO RELATED APPLICATION [0001] This application is a continuation of U.S. application Ser. No. 09 / 570,605 which issued on Dec. 6, 2005 as U.S. Pat. No. 6,973,560, which claims priority under 35 U.S.C. § 119(e)(1) of provisional application Ser. Nos. 60 / 144,078 (filed Jul. 16, 1999, entitled “System, Method and Medium For Enabling Solutions To Problems”), now abandoned, 60 / 144,204 (filed Jul. 19, 1999, entitled “system, Method and Medium For Enabling Solutions To Problems”), now abandoned, and 60 / 196,084 (filed Apr. 11, 2000, entitled “Fault Tolerant and Combinatorial Software Environment System, Method and Medium”), now abandoned, all of which are hereby incorporated by reference in their entireties.BACKGROUND OF THE INVENTION [0002] 1. Field of the Invention [0003] The present invention relates to a fault tolerant and combinatorial software environment. More specifically, the present invention relates to a system, method and medium for providing and facilitating a vi...

AI Technical Summary

Benefits of technology

"The present invention provides a fault-tolerant software environment that allows for the separation and splicing of various portions of a computer program, creating new and potentially different functional portions. This allows for combinatorial operations such as genetic programming, which can facilitate various types of modeling and self-analysis, modification, and creation of other programs. The individual codons can also be tagged with additional information, making them read-writable, and stack tagging capabilities facilitate analysis of functional portions of a program."

Problems solved by technology

Although many computer systems / languages are increasingly compared to DNA and genetics, they do not include many desirable attributes of biological “computation” systems and therefore are deficient for implementing robust, evolvable, life-like computer programs.

Instructions cannot be arbitrarily recombined to form new programs.

Superfluous, “junk”, instructions are not allowed within programs.

Although algorithms and programming methods have been specifically developed to emulate the evolutionary process (e.g. “Genetic Algorithms”, “Genetic Programming”), these also fail to provide the facilities of natural systems, are often cumbersome to deploy, and are not inherently designed to facilitate evolution.

Automatically created programs cannot themselves create, inspect, test, and terminate other automatic programs.

Implementations do not provide for multi-tasking, e.g. the simultaneous evaluation of two or more evolvable programs.

A fundamental problem in using genetic programming to evolve solutions to problems is that programs cannot be arbitrarily recombined without producing software with invalid syntax, nonsense logic, overflow errors, etc.

Termination is an unrecoverable error that stops the entire computing process in the middle of execution and typically requires human interaction in order to resume.

Traditional computing environments are therefore unsuitable for automatically evolving solutions to problems or designing a robust life-like computing system.

As noted above, existing virtual and silicon machines (computers) are not designed to process random code, and will halt execution on unhandled errors.

This restriction may hinder the achievement of an optimal solution as all paths must be syntactically correct, thereby prohibiting “short cuts” or “trespasses” through the space of “illegal programs.”

In addition to syntactical errors, the arbitrary recombination of programs frequently produces programs containing circular logic and infinite loops that cannot be readily terminated by existing genetic programming systems without human intervention.

Existing computer architectures do no allow for the inclusion of junk instructions which have the potential of later being executed (silent instructions).

Although the role of introns is not fully understood, no software system presently allows for their inclusion.

However, this real-time extensibility is not a feature of existing software languages.

Although it may be possible to detach and update object libraries that a program uses through operating system commands, existing computer languages do not provide functions to programmatically edit and update the elements of the libraries, i.e. prior art languages do not provide features for programs written in such languages to modify themselves at run-time.

The above-noted shortcoming limits the speed that programs can be evolved, as the process must continually be terminated and then restarted at each generation.

It also does not enable online adaptation or cooperative computing in which one personal computer is in production while another one is evolving improvements to the library.

For example, prior art computer systems are highly deterministic.

Were such deactivation of portions of code allowed to occur in current software environments, the program may become syntactically incorrect, thus generating an error.

Another deficiency of the prior art is the lack of ability to dynamically switch between treating information as executable code and treating it as data.

Programming languages such as LISP have a limited ability to switch between data and executable code mode in that it can manipulate text-based items rather than processing them.

However, LISP does not assign numerical designations to all of its instructions.

Thus, it does not manipulate the items on a numerical level, and would be deficient in implementing the concepts mentioned above.

The inability to individualize each instruction in current environments thus limits the possibility to analyze, study, research, modify, and price programs.

From the above, it can be appreciated that “prior art” computers (virtual and silicon) and software languages are deficient in emulating many of the characteristics that make up the evolutionary process and do not allow the deliberate or arbitrary recombination of software instructions.

Existing computers terminate execution on unhandled errors and are therefore not fault tolerant.

Code cannot be arbitrarily reassociated.

Unused code (analogous to introns) cannot reside embedded in software programs as the code itself lacks the facility to determine which sections to execute or ignore.

Software languages cannot be compiled or interpreted if syntax errors exist.

Extant languages do not permit real-time extensibility, the ability to add new functionality without stopping execution of the program and recompiling.

Existing machine instructions which make up software languages and are processed by the computer are uni-dimensional and do not provide for individualization (e.g., tagging).

Images