« The plausibility corruption principle as an aporetic strategy | Main | Refining the Bravo Core »

Researching the "bravo core"

It's been a long, fine summer and autumn, and working on the Arete rule engine has been a lot of fun and a great challenge. Most nights it's all I can do to make dinner and try to get in a few hours of coding before sleep and preparations for the day job beckon. Weekends at the library, camped out somewhere with a WAN and power outlet and not too much noise is usually the only chance I have to get any serious work done. Much less blogging.

So, the result is that I have made more advancements in the Arete and CORM projects than I have shared with the public.

The first, and most significant advancement has been the purchase of $750 worth of server and network hardware, and the installation and hardening of the Solaris 10 OS on these machines. I had to teach myself Solaris administration, which was not trivial. Establishing the machines on the network in a secure manner was also not trivial. I registered a domain and set up port forwarding so that I could access these machines remotely, not without help and encouragement from Catharine.

Then, two weeks ago, I made the most important upgrade to the system to date. This was the purpose of the entire hardware and system setup.

I installed Subversion on my Solaris server.

Now Catharine and I can work on our three projects in truly collaborative terms.

As an aside, I have fought for a long time to get SVN at the University of Minnesota, but there is no funding at the University of Minnesota for Open Source research and development. They like to use the software, but don't have the organizational vision to foster a developer community here. At least not in the Office of Information Technology.

I hold out hope that the Institute of Technology could pick up the torch on this and move it forward. I know the students are interested, but I don't know whether the departments have any idea how to integrate the Open Source methods with their classroom instructional methods. I'm taking two computer science classes this autumn (nothing glorious, but rather reclaiming a bit of dignity on my transcript from early years when I was working to support myself as an undergrad and underperforming in college), and I can see how using standardized unit testing frameworks would really ease the lives of the TAs in the computer science departments. If there were a central directory for people to upload their packaged code, the TAs could effectively grade by running standard tests against student's homework assignment code, which would precisely mirror the method we use in Open Source: implement the test code. You're done when my tests run.

/end rant

The result of all this effort is a new sense of acceleration in R&D. In particular, CORM is getting a lot of my attention in the last three weeks. I've been absolutely amazed by the discovery of the JScience.org project, and immediately moved to integrate it into the CORM project, as it implements the entire quantity pattern much better than Arlow recommended, and does a decent first shot at the Money archetype pattern.

The most drastic changes I've made to my plans for the CORM project have been completely scrapping the Rules archetype pattern and moving to implement the rules in Arete. I think that Arlow's model fails to respect certain inversion of control principles that help us test and write good code. As such, we've inverted the paradigm and decided that CORM will remain a purely passive data storage model. All business logic will be implemented in a rule container, and the CORM objects will reside within that container and under its management.

But none of this is why I'm writing today. Today I'm writing to introduce the second official engine core of the Arete project. The first engine core was appropriately called "Alpha", and I'm calling the second logic core "Bravo". The Bravo Core implements the foundation for both a modal logic platform and for a real Aporetic analysis platform. The purpose of an aporetics platform is to analyze relationships between rules and find the subtle contradictions that arise in our short-sighted implementations, then to employ resolution strategies to isolate and resolve these apories.

The basis of such a system is a simple implementation of "K", Kripke's logic. In "K" I made the concept of Contradiction primary to that of boolean truth within the context of the Bravo Core, and by doing so managed to disconnect the imperative structure of Java from that of my rule assertions. In other words, truth and falsehood are no longer merely boolean values in the system, but are conditions for contradiction. The system will allow you to declare something to be true, and a second later to declare it to be false, but will throw a Contradiction to alert you to the discontinuity in your logic. This replaces the standard behavior of assignment operators in modern programming languages.

Anyway, I tagged a release today. Finally. It's at the Arete Download page.

Example code is limited to test classes right now, but the Bravo Core is fully tested and operational.