Relatrix.store([fromObject],[mapObject],[toObject]); // This stores a functional relationshipand a query for that set is as simple as:
StreamTo compose two relationships to an association:
stream = (Stream ) Relatrix.findStream("?", "?", "?");
stream.forEach(e -> Stream.of(e).forEach(g -> System.out.println("Element A:"+g)));
// This composes relationships
// This returns all range objects mapped to [fromObject1] through ANY map object, including the relationship stored above
stream = (Stream ) Relatrix.findStream([fromObject1],"*","?", true);
// This makes ready for consumption by stream all relationships as identity objects
stream = (Stream ) Relatrix.findStream(("*","*","*");
Neovolve is a Genetic Programming framework that uses unit tests as a fitness function to evolve programs. Using formal functional acceptance unit tests as fitness functions confronts programming from the purest set of criteria; that of specifying the 'proof' of the working program. As Alan Turing theorized, if you write the code that proves the program, you have after a fashion written the program itself. By specifying a complete enough set of unit tests and starting with the domain of possible operations, a genetic programming solution can be converged upon by statistical methods. As the complexity of our systems exceed the threshold of comprehensibility, such a framework would seem to be the future of programming. The name Extreme Genetic Programming borrows from the Extreme Programming paradigm by proposing a completely test-first design environment complete enough to allow the machine to devise the code.
Neovolve as an Extreme Genetic Programming Framework:
Neovolve is a modified version of the 'jgprog' Java Genetic Programming framework from SourceForge. Modifications include enrichment of the data types, function set, and addition of changes making it more amenable to developing solutions based on generic unit tests. The FIT testing framework was also integrated to vastly simplify unit test construction and provide a browser-based interface.
A major objective is for the unit tests to be transparent to the actual mechanics of the solution. We don't want the user to have to guess what might be necessary to solve the problem. In fact, we don't want the user to have to know anything about how to code the solution. We only want them to design unit tests and program as complete a test harness as possible. Neovolve will only ever know the values being tested and the type returned from the evolving code. As the code evolves, the results of running it with the values under test is checked against expected results. This process continues until all the tests are solved by the evolved code. Surprising , unexpected, emergent behaviour arises from the machine's attempt at optimal solving. Behaviour which often exceeds the parameters of the objective tests.
Click here to see an actual solutions evolved from unit tests.
A parallel computing framework written
in Java that allows multiple cluster nodes to assist in evolving genetic programming
solutions. Virtually any TCP/IP based network can function as a parallel computing
cluster using the PowerKernel and Neovolve has been parallelized using it.
The PowerKernel uses a "Tuple Space" paradigm to provide a simple retrieval mechanism based on class template matching and a simple set of
operations. By providing a global homogeneous memory buffer and implementing a set of cluster-based operations, parallel computing can be
achieved. Some notable features are barrier synchronization and cluster node provisioning through zero-time class loaders. A principal difference
from many clustering offerings is the ability to perform less-than-boulder-size granularity of computational operations.
The target use case became providing a content management framework with clustering built in rather than added as an afterthought. To that end a number of 'front ends' were developed to allow use of the cluster including SOAP based Web Services and dynamic forms submission supporting the classic MVC model.