NeoCoreTechs - New Core Technologies
Applied Computational Sciences
The Definitive Source for Displacement Technology
Look for our repositories of open source contributions on GitHub
The Relatrix:

The Relatrix is a new data management system based on the branch of mathematics called 'Category Theory'. The Relatrix is a Java framework that manages unstructured data by the mapping of the functional relationships within the data sets. Relationships are defined as objects comprised of a ‘domain’ Java object, with a functional ‘mapping’ object, that relates the domain to a ‘range’ object. Data is retrieved using 'functors' that take categories to sets presented as standard Java Iterators. More plainly, imagine that rather than being able to map keys one-to-one like a relational database you can map them through a function that adds more relevance. We can then assign equivalence through isomorphism, or functional similarities between data. The relationships themselves are objects which can be composed into higher level relationships that harness the power of Category theory to perform analysis not possible with conventional databases.

Building relationships is as easy as saying:
Relatrix.store([fromObject],[mapObject],[toObject]); // This stores a functional relationship
and a query for that set is as simple as:
Iterator iterator = Relatrix.findSet("?",[mapObject],"?"); // This retrieves all domain objects and range objects mapped through [mapObject]
or to compose two relationships to an association:
Relatrix.store([fromObject1],[mapObject1],Relatrix.store([fromObject2],[mapObject2].[toObject2])); // This composes relationships
Iterator iterator = Relatrix.findSet([fromObject1],”*”,”?”); // This returns all range objects mapped to [fromObject1] through ANY map object including the relationship stored above
Iterator iterator = Relatrix.findSet(("*","*","*"); // This retrieves all relationships as identity objects
BigSack:

BigSack is a Java persistence mechanism that provides TreeSet and TreeMap functionality with a small footprint and exabyte object serialization capability. Just about any Java object can be stored backed by a BTree and multiple levels of pooled tuneable cache with durability through undo logging. The target use case is any where large unstructured heterogeneous collections must employ transparent durability and persistence, as in a robot that collects sensor data. The BigSack can be used in much the same way as the TreeMap and TreeSet from the Java collections classes.
Features:
  • Utilization of memory-mapped file IO or file system IO controllable by property file entry
  • Data consistency and integrity maintained by undo logging
  • Full 64 bit file pointers for exabyte storage levels
  • Multiple tablespaces for improved performance
  • B-Tree indexing of individual entries
  • Ability to use custom ClassLoaders for object resolution
For more information and to view/download source code go to GitHub
Neovolve:

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.

Click here for more details of the overall vision.

GOOeFloys:

They belong to the flocking Artificial Life creatures variety, sharing with them the social tendency to stick together, and the lifelike emergent behavior which is based on a few simple, local rules. They differ from most other flocking Alife animals by having the following properties:

  • Predation (they must survive against predatory GOOeFloys, or survive as one)
  • Ability to evolve (using the Genetic Algorithm).
  • Potential individualism (each can possess a different personality through evolutionary processes)
PowerKernel:

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.

Click here to learn more about the PowerKernel and PowerSpaces clients
Click here to learn more about the PowerKernel server
Click here to learn more about the Overall Architecture vision


NeoCoreTechs
Portland, OR 97217
Phone:(503)235-4284
Fax:(815)550-1014
info@neocoretechs.com
http://www.neocoretechs.com

Copyright © 2001,2013,2014 NeoCoreTechs