Progress on Behavior Manager

The behavior manager now takes correlated data and generates flocks and flock members using a statistical analysis of the distribution of the data items. Woo!

This was a tricky problem, but the solution is fairly simple. As I am generating the correlations between all of the data items I keep track of certain statistics about the correlations and generate a standard deviation for the set. Using this standard deviation I can group flock members with those most similar to themselves and generate related flocks.

Next step is to create an API and framework implementation for the various visual actions I will be supporting for the flock members, e.g. vibration, pulsing, colors, etc.

Data Correlation

Part of my capstones specification involves a data correlation engine. The idea is that Paradigm will take the pool of data garnered via local and remote service modules, and then assign every objects a “correlation” value for every other object. This correlation value gives the visual engine an idea of how related two objects are so that the flocking algorithms can bring related items closer together.

I mentioned in my proposal that I would likely fake this part of the application as data correlation is outside the scope of my prior studies. I do not have the necessary background in statistical analysis to create an effective engine. Instead I have created a system that assigns random correlation values when objects are added to the data pool. Later I will allow data service modules to define their own algorithms and attributes for data correlation and allow the correlation engine to use those.

Over the last few days I have been writing this fake correlation engine and the accompanying code in the flocking algorithms to use it’s results.

It works! 🙂

Quick update: module system actually works now

On Monday night I got the module loader system working. This means a user can now drop a module and module definition file into a predefined user services folder, launch the app, click through the title screen, and see the aforementioned module in the module selection screen. They can then choose any or all modules they wish to use as data sources and load them. Upon reaching the main application screen, clicking the retrieve data button will retrieve data from all chosen sources and populate the visual renderer.

The next step is to refine and document the module framework and API, create a mock data correlation engine (faked as per my capstone proposal), and refine the visual engine to properly process related objects.

On track!

Titles, settings, and modules oh my!

Last night I spent more time working with the module loader system. This time I finished up the commands to retrieve service module definitions (which I reported on in my last post). Once I had that working on the backend, I slapped together a title screen and a settings screen where the end user can choose which data sources ( as supplied by installed service modules ) they want paradigm to use.

Next step? Create a scheme for modules to collect their own settings.

File Access and Modules

Today I spent some time on fairly mundane issues. In order to manage modules (those little things other developers will create to provide Paradigm with services), Paradigm will need to be able to discover those modules and access them.

To that end, I spent time creating some utilities and commands to access the local file system, search out services modules, and then load them as proxies for my data.  Adobe’s AIR provides excellent facilities for interacting with the local filesystem, though I ended the night on a sour note of run time errors due to the directory access behaving oddly.


No news is good news right? Nope. The last three weeks have been a whirlwind of non capstone related stuff. Hopefully I will have something useful to post about later in the week after visiting family is gone and backlogged other stuff is taken care of.

Dynamic Modules and User-Created Services

Yet another part of my puzzle clicked into place tonight. I’ve implemented a system which will allow custom service developers to create “modules” for Paradigm which contain custom service classes. I will provide a limited set of classes necessary to create custom VO’s and service proxies. Using these classes, custom service developers will be able to create Flex modules and an XML file describing the module and any dependencies they have. Paradigm will search a specific folder for these xml files and modules, and can then dynamically load them into the app. Each module will contain a list of custom classes that Paradigm can use to access various services. These services could be local or remote, e.g. local filesystem, Flickr photos, Twitter feed, etc.

This was a major problem to overcome, but thanks to my work from two weeks ago on a dynamic settings manager and some extra research, it’s now built!

Video of application in progress

Video down temporarily.

Yay dynamicism!

So after a night out on the town I came home and decided to do more coding at 2 am. It’s now 3:29am. I managed to create a completely dynamic settings manager. This will allow me to define settings involving complex value objects in xml, and then load them into the application at run time. For now I am testing this with a simple value object containing the default settings for flocking ( alignment, cohesion, seperation, and anchor ). I’m using the programming concept of reflection to determine which type of object is stored in the XML and to then dynamically instanciate it and copy any values which match between the XML object and the fully typed object in Actionscript. This will impact the users of my framework in that it is crucial to allowing them to create their own data sources, value objects, etc. in Actionscript and to dynamically bind them into the application for end users.

This probably isn’t coherent to anyone who isn’t a programmer or awake at nearly 4am at the moment. I’ll explain better in my writeup and code comments.

P.S. Assuming this isn’t just my addled brain lying to me at a late hour, this may be just the sort of breakthrough I’ve been struggling for to help me actually start moving at a faster pace of development (when I have time to work on this at all).

Back on track

Woot! I fixed my stupid SVN problems. It turns out that when migrating from my old machine to my new, that my entire eclipse, flex builder, svn install was corrupted. So as of now my development environment is back to functioning properly, my entire codebase including libraries is check into version control, and I’m now going to do some actual honest work.