Bob was a simple amateur VB programmer up until a few years ago, when Microsoft decided to abandon VB6, and their VB programmers, in favour of their ".NET" version, which was not "Basic" at all any any real sense of the word. Bob now refuses to accompany Microsoft any longer either in VB or in Windows.

Also a few years ago, Bob first made contact with the Transcript programming language and was very impressed. Could this be a more advanced version of a plain-English programming system that he had been looking for?

Bob had worked with VB1 from the very beginning. He got a manual and a book with his purchase, which apart from a few natural difficulties that everyone suffers from time to time, were perfectly adequate for his general needs. The rest he found on the Internet or in bookshops. Bob never ever had to ask anyone a technical question about anything. He enjoyed finding things out for himself.

The manual Bob received was all about the VB instructions and IDE elements. Normally, about 1 page was devoted to each instruction. What Bob liked was the fact that a simple coded example was always given embedded in a mini-program, like this:

One of Bob's first projects was what you see above. it consisted of a "window", a "text box", and a "command button". The code he inserted in the mouseup routine attached to the command button was "Form1.Text1.Text = "Hello World!".

Bob knew he could make an executable version of this little program, but before doing it he was anxious to make sure the project ran OK. So he simply ran it using the START button:

Lo and behold, when he clicked on the project button Command1, "Hello World!" appeared in the text box, and Bob was very happy:

It wasn't difficult to stop the test: all he had to do was click on the STOP button, and after that is was just as easy to produce his executable. Of course, the window of the project returned to its original state, i.e. with no messages showing in the window at all. It never occurred to Bob that any other arrangement would be possible:

Once running, Bob clicked on the application button and hooray! The message appeared. Highly satisfied, Bob then tried to STOP the test. But this time he couldn't find the STOP button! He tried closing the window (as in VB), but it didn't help. So he tried fiddling about with the buttons again and found that the STOP button was in a fairly obvious place after all (it was next to the START button), but that this time it was called "Select Controls". A bit of a funny name for STOP, he thought, but it did allow him to select the controls when he clicked on them, and it DID stop his test running:

But just a moment! Why was the "Hello World!" message still there? So he ran the project again in the hope that the message would disappear. It didn't. It was there from the very beginning. This wasn't what Bob wanted at all. He wanted to start his program with a clean sheet. "Hello World!" should only appear when he clicked on the application button.

But anyway, there was a better version of Metacard around and Bob decided to give that a try. Who knows, he might be able to get his project testing to work better in "Runtime Revolution", and who knows, perhaps the buttons for starting and stopping the project test would be called something better than "Browse Tool" and "Select Controls".

So here it was, the famous "RunRev" he had heard a lot about:

The VB6 IDE that Bob eventually worked with was not radically different from the VB1 version. Here it is:

The manual, of course, would have made poor bedtime reading. No, Bob only used it when he wanted to look something up. And becuse the manual was well organised, he could always find what he was looking for very quickly.

But Bob was also very happy with the book he received telling him all about VB programming. Unlike the manual, it was full of lengthy explanations, examples, and pictures. He even read it in bed sometimes! This is what it looked like:

Much later, Bob was motivated to try the same thing in MetaCard. He drew a window which was now called a "stack", and then included a button and a "field" for his text. To display his text in the field, it wasn't difficult to find out how. The "handler" associated with the button was now:

on mouseUp
set the text of Field 1 to "Hello World!"
end mouseUp

No hassle. So then Bob looked for the START button to test the project before making an executable. He couldn't find it! Eventually, he found that the button was called the "browse tool". He couldn't quite work out why, but it seemed to do the job, so Bob was happy again:

Not too pretty, Bob thought, but he'd seen worse, so off he went to try to make and test his little "Hello World" program. Things didn't look too different to what they did in VB, and Bob was quite chuffed at setting up the program with no trouble:
Now for the great test! Bob tried all the buttons, but he couldn't find START anywhere. So then he tried the menus. No. What about right-clicking the mouse in a few places? Bob did that too, but didn't find START. Then he remembered. What did they call it in Metacard? Ah, yes. It was called "Browse Tool". So he looked for a browse tool. Nothing! Nada! So Bob went clicking and investigating all over the place. Eventually, he found a command that said "GO" which looked very promising, and Bob seemed to remember when he had played with RunRev a long time ago that this button seemed to do something useful. So he gave it a try:
No, nothing at all. After an awful lot of mucking about, Bob finally found the solution. They were now calling START by the name of "Modeless", and he found it by right-clicking on the window. It was tucked away in a popup sub-menu:
After choosing "Modeless" (whatever that was supposed to mean), Bob hoped his test might be running and gingerly tried clicking on the button of his application. Hooray!!!! "Hello World!" had appeared in the field. How about that then! Bob was deleriously happy:

Now all he had to do was stop the thing and save his project. He had discovered where to get the thing started, so he unthinkingly right-clicked on the window to get back to the popup menu. Of course, it didn't work. So Bob tried lots of other things. Finally it dawned on him that he had to get back to the "TopLevel" and that he had seen this when he was trying out the "Go" command. Anyway, it was common sense that the "Application Browser" should probably have something to do with the control over the whole thing. Bob couldn't quite remember whether he had right-clicked on the name of the stack ("Untitled 1") or on the name of the card. As it turned out, it really didn't matter too much. Bob found out that either would do. Would "TopLevel" bring him back to the original level and STOP the project test?

Phew! Thank goodness! He had now managed to stop the thing.

But oh, what a disappointment! It had taken him much longer to get this far than it did in Metacard, and the damned "Hello World!" message was still showing in the window. What a shame!

Well, Bob didn't want to save the project or make a standalone like that! The field needed to be blank. So how could he remove it?

Bob began to think very carefully. Well, in VB the text would be defined as a "property", and if he could find the property he could remove it. So Bob went fishing again. After a while it occurred to him to try right-clicking on the field, and there is was - "PROPERTY INSPECTOR":

And this was the Property Inspector:
After looking at the various properties of the field, he discovered that "Contents" referred to the text the field contained, and slapped himself on the wrist:
There was the property his little program had acquired (the text message) when he test-ran it. So he removed it from the properties box:
Nothing happened immediately. Had he been working in VB, the text would also have disappeared from the field. So he tried closing the Property Inspector, and lo-and-behold, the result he had been hoping for. Back to square one. Finally, Bob had managed to return his program to the state it was in before the test-run:
He had done it, but by this time Bob was feeling a bit of a fool. After all, what he was trying to do was very simple in principle, and although Bob was by no means an expert programmer, he wasn't THAT stupid! He had to be missing something, but what, he didn't know. He wondered about the other programmers. Were they people who were different to him in that they had worked with this kind of IDE before? The RunRev IDE seemed to be based on principles that were very similar, except that in this respect it wasn't half as convenient as Metacard, for example. And had other VB programmers run into the same kind of trouble? Bob was very curious about this, but he was too embarassed to ask anyone else about such an elementary thing. They would all laugh at him! So he kept it to himself. But then Bob began to wonder. There had to be a "higher purpose" in such an arrangement. The "persisting properties" were a problem to him with the testing of the "Hello" program, but perhaps they were an advantage in other circumstances. Drawing perhaps? Bob had the idea of making an initial drawing in the window with the idea that his beautiful designs would not suddenly disappear, even if he did a test run:
Bob quite easily found the drawing tools and did some squiggles. He wasn't too impressed, because just like a thousand other so-called "drawing" routines, this one gave him the jaggies. There was no sign of antialiasing or vector graphics here, but that was too much to expect he supposed, even if RunRev was supposed to be a modern programming system. But while he was fiddling about with the "Tools" menu he made a fantastic discovery:
Hang on a sec! Wasn't "Browse Tool" what they called the RUN button in Metacard? And as he selected it in the menu Bob noticed that the top right-hand icon on the tool bar switched to the pointing finger on the left. And when Bob let the mouse stop over the button, the tooltip even told him what it was for:
How COULD he have been so blind? It even says "RUN scripts". Bob began to feel even more stupid, but he was happy with his discovery and of course he soon discovered that the STOP button was the pointing arrow icon at the side:

This tooltip even told him it was for EDITing mode! So in delight he spent a few minutes testing his program repeatedly, clicking on the Browse Tool for RUN, clicking on Button 1 to show the message, clicking on the POINTER Tool for STOP, and removing the Contents property of the field in his stack.

At this point, Bob wondered how he could easily remove the squiggles, but he was too emotionally exhausted to try. "No," he thought, "I'll just try and automate this thing and call it a day. So he thought a bit and then had an idea about how to solve the "persistent properties problem" as he then began to call it. What about clearing the property of the message when opening the stack?

And it worked! "A REAL beginner couldn't have done that in a million years", he thought, and he began to feel a tiny bit better. And then he wondered about the other programmers again. What did they do? What was he missing? Was there some higher purpose he didn't understand? But he was too tired to do any more, and he went to bed.

As he lay in bed, instead of counting sheep, he repeated to himself:



It really wasn't all that difficult....

Soon, he fell asleep, and began to dream (in images):

And in his dream he suddenly saw why it was he had so easily overlooked the RunRev test buttons: