Communing with beta 1

Talking to Reveal (ie. creating and developing an interface with the reveal engine) is meant to be a natural process. Now, "natural" is a rather relative term, so consider (for example) playing with toy blocks. Building a tower of blocks is easy, even though we're dealing with complex concepts like gravity, mass and friction in order to do so. The secret is that we're familiar (to the point that we're not even aware of it most of the time) of the underlying logic of how things work in this universe.

Knowing the concepts of how things  work (or more appropriately, objects  act, or even nouns verb :) is essential in order to live, work or play in any environment. Reveal is no different.

The aim is that working in reveal will be just as intuitive and logical as any other condition. The key is that you've got to be familiar with the ground rules of the "reveal realm" as it were. Once you are, the idea is that (hopefully :) you won't have to necessarily "learn" by example many inherent capabilities and intricacies of the reveal engine... they'll just come "naturally".

Whether or not Reveal succeeds in this is important. However, it is also (to a degree) irrelevant to the rest of this article, because understanding the basic tenets of reveal is an essential first step - whether you like to learn things by example, or just leap off and play. So that's what we're going to be starting today: outlining the "laws of physics", as it were, of Reveal.


First of all, it's important to understand how fundamental the concept of objects is to Reveal. Just like language and just like the physical world, if you want anything to happen (or describe something happening), you have to have something for it to happen to, and/or with. In Reveal, every thing is treated as such: a separate thing, or to use Reveal terminology, an object.

For instance, you might use one object to change the condition of another object, just like you'd use a hammer object to move a nail object, or a fire object to burn a toast object (hey, I'm a student, okay?). Also, in actual Reveal script (just like spoken and written languages), sometimes we might explicitly declare the influencing object, but sometimes it'll just be implied. The reason? Well, it's just logical.

You'll notice that in all of these (most profound) examples that it's really the relation of the two objects that gives the happening (or situation) it's meaning. Keep this in mind, because we'll get to it later.

Before getting into the three classes of objects in Reveal, we should establish some idea of the role of properties. Basically, every object needs properties to define itself. Like anything in the "real" world, we recognise, and thus, know how to relate to something (or someone) by their unique properties (whether they're colour, size, shape, or emotional properties).

For example, in Reveal, every object has a common "type" property. This is a special property that basically says what kind of object the object is; basically, whether it's an image, hotspot, integer, string or any other reveal object. You can see from just this example that objects are very much the sum of their parts - they exist only as long as properties define them. As a further example of other, more "run-of-the-mill" properties, we might consider an image object. Some of its properties include the image file itself, the x position of the image, the layer, whether it's transparent, it's width, and the page it's "on".

At this stage, you might be thinking, "gee, that Judge Judy is really hot." In which case, you really need to get outside and meet people. However, you might instead be thinking that all of these properties sound like they should be objects too. Well, you'd be right. And on that rather insightful note, it's time to look at the first class of objects: simple objects.

Simple objects are just what their name implies: they're simple. They've only got one property (apart from their inherent "object type"). These five object are arguably the atomic level of Reveal, as most properties of other objects (with some notable exceptions) are one of these types. So what are they? Well, as they stride down the catwalk (in no particular order) I'll introduce them as: Int (integer), Float (floating point number), Char (character), String, and Bool (boolean).

You can see a list of all the other object types over in the blueprint section to go along with that. I'm determined to keep these workshop things as chunks, so we'll stop there and continue with complex and special objects in three (fingers crossed :) days.

Let me know what you thought of this,
syndrome




headline | blueprints | fumes | designs
workshop | storeroom | what is it? | architects | rev.web