Metafor: Translating Natural Language to Code

vivin writes "Computer programming is second nature to most of the Slashdot crowd. However, this is not true for the vast majority of people. Formal programming languages are not as expressive or flexible as natural languages. This becomes more evident when we try to translate user requirements into actual code. Researchers at MIT have come up with a program that bridges this gap. It's not so much a tool that turns English into code, as it is a program that translates requirements (in English) to code. When Metafor analyzes English, nouns phrases become objects, verbs become functions, and adjectives become object attributes (or properties). In addition to helping programmers visualize their program better, I think it also promotes writing concise (and therefore) requirements and descriptions. Metafor doesn't handle run-on sentences (or bad English) that well." Update For for the dupe. Not going well. Appreciate all the hate mail. Really encourages improvement.

Comments

Dupe

[tcopeland]

Of this, I think...

Re:Very Cute

[AKAImBatman]

My guess is that if you're having trouble wrapping your head around OOP, then you're going to have trouble wrapping your head around the ins and outs of a natural language interface.

For what it's worth, OOP is quite easy. The first thing you need to think is data encapsulation. Data encapsulation is simply the practice of bundling related data together. i.e. Color, make, year, and model are all attributes of a car. So you'd tend to put them together. You know, like structs. For example, a game sprite might have x, y, width, height, and direction variables.

class Sprite
{
int x;
int y;
int width;
int height;
int direction;
}

Of course, we want to know what the direction stands for, so we add static constants:

class Sprite
{
const RIGHT = 0;
const LEFT = 1;
const UP = 2;
const DOWN = 3;

int x;
int y;
int width;
int height;
int direction = RIGHT;
}

Now for the truly OOP part. We need a way of making the data operate on itself. For an example, I'll choose changing direction.

class Sprite
{
const RIGHT = 0;
const LEFT = 1;
const UP = 2;
const DOWN = 3;

int x;
int y;
int width;
int height;
int direction = RIGHT;

void changeDirection(int dir)
{
direction = dir;
}
}

Doesn't seem like much, but what if we want to ignore improper directions?

class Sprite
{
const RIGHT = 0;
const LEFT = 1;
const UP = 2;
const DOWN = 3;

int x;
int y;
int width;
int height;
int direction = RIGHT;

void changeDirection(int dir)
{
if(dir < 0 || dir > 3) return;

direction = dir;
}
}

In a real OOP program, we'd probably throw an exception, but you get the idea I hope. Now that we have our Sprite class, it can be treated as a complete data type of its own:

Sprite sprite = new Sprite();

sprite.changeDirection(Sprite.DOWN);

There you have it. A five minute introduction to OOP. Hopefully this will help unblock whatever mental issue is in your way. (Or badly written books as the case may be.) :-)

(Stupid lameness filter. Recognize code will you? No, that would be too difficult wouldn't it? Stupid lameness filter. Did I mention how stupid the lameness filter is? Recognize code will you? Stupid lameness filter. Recognize code will you? Stupid lameness filter. Recognize code will you? Stupid lameness filter. Recognize code will you? Stupid lameness filter. Recognize code will you? Stupid lameness filter. Recognize code will you? Stupid lameness filter. Recognize code will you? Stupid lameness filter. Recognize code will you?)