• You can now set cells to be drawn as images. Defining the image a cell should use is as simple as making a rule of “draw <CELLTYPE> <URL>” (See Langton’s Ant for example.)
• The directions northeast, northwest, etc. have been added, as have fareast, farnorth, etc. The “far____” directions refer to cells two steps away.
• The special noun “neighbors” now includes the NULL cells at the border.
• New verbs “cellAt” and “neighborsOf” have been added. They both take a 2-by-1 array ([x,y]) of the cell in question as their right-parameter. The “cellAt” verb returns the type of the cell in question, while “neighborsOf” returns the set of neighbors.
• A new two-parameter verb “+” has been added. Right now it only operates on the 2-by-1 coordinate arrays discussed above. (Example: [1,-10] + [23,7] = [24,-3])
• In the same vein, a new special noun called “thisPos” has been added. It is the coordinates of the cell being evaluated.

That’s all!

For those interested in writing your own automata, here is a quick guide to the syntax:
An automaton is composed of rules. Each rule is designated by a new line. Double slash (//) or pound (#) designate a commented line.
Each rule looks something like BLACK->WHITE: 1 = 2
BLACK is the type of cell that the rule applies to, WHITE is the type of cell that it will become. After the colon is a statement that must resolve to a single value, or “noun”.
Nouns can be strings, numbers, true/false, JSON arrays, “neighbors”, or any of the cardinal directions (lower-case). The noun “neighbors” is a special noun which is a JSON array with values equal to the types of the surrounding tiles (in eight directions). The special nouns “west”, “north”, “south” and “east” are equal to the type in that direction, or “NULL” if at the edge.
Nouns can be acted upon by the following “verbs”:

• =, >, < — Basic comparison operators. They behave like their counterparts in javascript (except for =, which is comparison, not assignment). — example: “1 > 2 = false” (returns true)
• or, and — Low-priority logic operators. These behave like || and && in most languages. Low-priority means they are evaluated after other verbs. — example: “true and false or true” (returns true)
• not — Inverts the boolean value to the right. If the value to the right is non-boolean, it is cast to a boolean just like ! in javascript. — example: “not true” (returns false)
• contains, isIn — Check if a value is contained in an array. The two verbs are identical except in the order of their parameters (“value isIn array”, or “array contains value”). — example: “[1,2,3] contains 0″ (returns false)
• count — Changes the noun on the right from an array to an integer. — example: “count [0,1,2]” (returns 3)
• ofType — Filters an array on the left to only contain the value on the right. — example: “[0,0,0,1,2,3] ofType 0″ (returns [0,0,0])
• echo — Makes a popup containing the value on the right. Does not change the data. This verb isn’t very useful, and can flood your browser with popups if you aren’t careful.

Verbs are evaluated from left-to-right, but you can use parentheses to change the order of operations. More examples can be found by loading the prebuilt automata.

I know the interface is a bit hard to use, but if you make anything (even if it’s pretty trivial) please leave a comment! You can export boards as well, so feel free to share interesting formations in Conway’s Game of Life, Wireworld, or others.

On a related note, this talk by Wolfram is not to be missed:

Specifically, I began to notice how few links my notes contained, and the difficulty I might have in changing small details (like names) across many pages. Wouldn’t it be nice, I thought, if I were able to tell my computer about my world, and have the computer organize and maintain my notes in a way that let me quickly and easily extract and change the underlying facts. Essentially, I was thinking about automating the world-building process by reducing a world into a data and making code to manipulate and present that data.

Because I had heard good things about associative databases, I built one to handle the facts of the world and began entering items like
Kogámos is_child_of Sáríbá
(Yes, I know that’s a lot of accents). Associative databases (with exceptions, I’m sure) represent data ontologically (that is, as a collection of factual claims about entities), and in this way resemble the data structures of Good Old-Fashioned AI*. Now, before I started this project I was very skeptical about logic-based AGI, but I knew that in some domains, (such as Expert Systems) logic based narrow AI had become successful, so I set about exploring whether this was one such domain.

* – Really, this structure is common to all logic-based AI, even fuzzy-logic, modern approaches like NARS. Much of the criticism that follows can be applied to any sort of artificial reasoning system.

Before I go on, however, I’d like to share a documentary about the semantic web. It’s related, and I’ll be talking about it, but it’s 15 minutes and you could probably skip it if you’re familiar with the concept.

With the possible exception of being able to make meta-facts (that is, facts about facts), the eventual structure of the semantic web closely resembles that of an associative database. In fact, I’m sure that facebook has a piece of data saying
Max_Harms is_child_of Tracy_Harms
or something to that effect, right now. And like my project, the semantic web seeks to represent data about an entire world, not just a highly-restricted domain.

My project has some big advantages, though. The biggest is probably that all the information given might as well be coming from God. If the world-creator says that rivers run uphill, that’s just the way it works. Thus there is no need to model confidence in facts entered. Secondly, the system doesn’t actually have to act; it simply has to store and present the data in an intelligent way.

One of the early things I noticed in my exploration is just how fun it is to see the computer answer questions. Logic-based AI is very attractive because it takes hardly any work before you can ask it things like “Who is the child of Sáríbá?” and it will give you the right answer. I ended up spending lots of time asking questions that I already knew the answer to, just because it was fun whenever the computer was right.

One of the biggest hurdles in the transition from a Reductionist to a Holistic stance is that the Reductionist stance works so well for simple problems, and thus is very seductive to beginners.- Monica Anderson

The problem here is that answering simple questions based on simple rules from entered facts doesn’t mean squat. It’s about as useful as writing the information in a text file and using regex.

It gets worse than that, though. As mentioned before, worlds are messy and complicated. If the problem was as simple as generating a family tree, or making Venn diagrams, we’d be okay. But how do you represent something as nuanced as “Sally likes to spend time downtown, except on the weekend, when she finds it too crowded”? Such things are simple for us to remember because they tie into our experiences. To illustrate what I mean, imagine the similar phrase “Queue is angry about rowing in Vah, except when floating, when torque is standard.” This statement has no connection with our common experience, and because we do not understand it, we cannot store it easily. This is the same problem as that confronting the semantic web. We can pour in data until we die, and the system still wouldn’t “get it”.

If a programmer attempts to describe the world to a Logic based AI, for instance by creating ontologies, he’ll never finish the task. The world is too rich. The Cyc project – the largest and most famous AI project ever undertaken – has been trying to describe the world using predicate calculus for decades; it is the poster project for Reductionist approaches to AI. But Cyc will never approach anything worthy of the term “Intelligence”. It has been told many things and can recite many definitions but Understands nothing. This is the difference between “Instructionist” top down education and “Constructionist” bottom up learning – a distinction poorly understood even in human education.- Monica Anderson

Even in a task as basic as storing and retrieving information we still need the computer to understand what it’s doing beyond tasks of relative simplicity. This is because knowing about the world falls into a large class of problems that are fundamentally impossible without General Intelligence**. Other problems in this category include using natural language, navigating complex environments, and behaving in socially acceptable ways. As hard as we may try, until Strong AI is solved, a chatbot will always be a mimicking machine, a database will always fail in complex domains, and humans will be forced adapt to robots (instead of robots adapting to humans).

** – It may be possible for a vast enough intelligence to make a system so complex that it’d be able to handle one of these domains. I don’t think even large numbers of humans would be smart enough to make one, though.

Even with my increased dislike of logical systems, I’m quite happy with what I was able to make in the few days I spent building my database. You can check out the results yourself, or even add and delete facts. The database will be restored to a backup state twice a day (not sure what timezone my server is in), so don’t worry about making a mess.

Search commands:

• “describe X” = get all facts relating to X
• “list X is ?” = get all items that X is
• “list X is_child_of ?” = get the parents of X
• “list ? is|has X” = get everything that is or has X
• “list ? imports * ? is geographical_area” = gets geographical areas that import anything
• “infer” = list suggestions for facts, based on correlations

Source code is here. Everything I wrote (files in the root directory) is public domain. Attribution is appreciated.

(P.S. I’m a big supporter of the semantic web, and doubly so for open data. The criticisms expressed in this post are against the idea that it is possible to intelligently know lots about the world using ontological representations. Links are data, and that data is important, even if that data isn’t knowledge in itself.)

Yesterday I decided to play with some genetic programming. Though I found a neat GP resource, I decided to work from scratch and build a simulated tide-pool with algae/plants and animals of indeterminate form. Truth be told, I’m not even sure what I did really “counts” as genetic programming because the only evolved feature is the behavior for the animals. Regardless, I wrote the thing in a single day and got some neat emergent behavior and a screen-saver-wannabe. Green dots are “plants” and yellow/white/red/black are “animals”.

The code and runnable Jar are here. Everything is public domain, though I humbly request you don’t try to pass the work off as your own. The pulsing brightness is supposed to be day & night. The source code is really sloppy, so keep in mind that this was a quick, shoot-from-the-hip sort of project and please have forgiveness.

Controls:
Minus/Underline = Slower
Plus/Equals = Faster

Everything (code and images) is public domain. Credit is nice, but not necessary. Download code (and runnable jar) here. Created using Slick (Build #266) with LWJGL (2.0b1).

A Geocentric View of the Universe.

Another Geocentric Perspective.

View from Jupiter.

Oh, and I almost forgot! One of the other neat things I did with the simulation was “experimentally” measure the speeds of the planets (except Neptune). I looked up average orbital distances and the mass of the sun on Wikipedia and then tweaked the initial velocity of each planet until the orbit looked roughly circular. I did this mostly out of laziness, but I was shocked at how close I had gotten to the real values.

I’m releasing all the code into the public domain here. Everything is HTML5/javascript (view source to get it), and you’ll need a decent browser (not IE!) for it to work. There’s no user interface, so if you want to change variables or play with it yourself you’ll have to edit the source.

In my free time I set up a website which would let me play with that very question. It would serve as a set of polls, taking input from visitors on when they expected future technologies to arise. The whole thing is hardly scientific, but I think it’s interesting and fun.

Prescience was born, and after roughly a month in development, I’ve checked nearly everything on my feature list. My task now is to try and find as many people as possible who would be interested in the website, as the premise is based on large numbers of participants. Please, check it out and tell me what you think in the comments!

Most of the class was thinking of making an obscenely huge strategy game akin to Risk meets Monopoly, which just so happens to be the sort of design which I despise. Having spent many long years learning the hard way to design as small as possible, I helped my team brainstorm a small, grid-based, strategy game based on resource management and simple unit-movement. My hope was that the project would be basic enough that it could be running with an initial rule-set within the week and that the remainder of the term could be devoted to polishing the interface/graphics and working on the rules. (I was only vaguely aware of it at the time, but this sort of thinking would expand into rapid-prototyping, playtest-heavy, and iterative design philosophies in my own work.)

We decided on a zombie theme, with the twist that the zombies were actually corporate pawns, and the necromancers were CEOs. It’s kinda vanilla, but it was a 1-hour design within a group of relative strangers. We presented our designs for the class and they decided to work on Risk-Monopoly. That weekend, in about 8 hours*, I built a working alpha for the game:

EDIT: If the images aren’t working, you may need to view this post by itself.

Rules:
The player on the left (pink/green) goes first. And then blue player takes a turn, and so on.
To move an army, drag them to an adjacent square. (They move like kings in chess.)
Armies are composed of undead: zombies, lawyers, or both.

Each space is commercial, residential or corporate (Starbucks, house or building). At the beginning of each turn, you get cash to buy lawyers with and new interns to turn into zombies. The goal of the game it to capture your opponent’s skyscraper. The income is as follows:
Corporate Space: +$5,000 & +5 interns / turn
Commercial Space +$2,000 / turn
Residential Space +2 interns / turn

Each turn you get one action (upper-right), in addition to moving each unit. Select a board space then chose:
PROMOTE: Turn all interns into zombies at the selected space.
HIRE: Hire lawyers for $5,000 each at the selected space.
DEVELOP: Selected commercial or residential space now produces 2N+2, where N = current production. (Units are single interns or thousands of dollars.) Each space can only be developed twice.

If you move into a space that has an enemy army, you deal damage to them, killing a number of units. If you defeat all units in a space, you capture it. An army with both lawyers and zombies loses its zombies first. Lawyers deal roughly 5x
more damage to zombies (I forget the actual multiplier).

It’s really a very boring game, but the idea is that it’s playable and (mostly) bug free. Additional rules and features can easily be added onto the skeleton in an attempt to make it more engaging. At the end of the week you’ll have a game, though, and you’ll have a good impression of roughly how fun it is. This last part is vital, I think, to good game design.
Rapid-prototyping lets me play a game with very little time investment. This lets me determine whether it is worth making.

* This amount of time is actually quite excessive for such a simple game. At the time I wasn’t using Slick, and I didn’t have much experience with applets.

Disclaimer: I do not own any of the graphics used in the game, but I feel that they are used fairly. Unlike most of my work, this game is not open source, and I ask that you do not redistribute it without permission. Its sole intent is to showcase what I did one weekend, and maybe talk a little about game-programming.