OpenEuphoria

Re: Howdy!

• Posted by Travis Beaty <travisbeaty at arn.net> Apr 19, 2001
• 406 views

Howdy!

Jonas Temple wrote:

> Sorry to have to point out this mistake but:
> * grammar is still a viable means of communication and there are plenty
> of jobs out there where you can still use grammar.
> * grammar++ is a better way of communication although it's much harder
> to learn grammar++ rather than grammar.  With grammar++ you can reuse a
> lot of the words you already have rather than re-inventing the word all
> over again.  Some argue that grammar++ is slower and makes communication
> harder but those who are used to grammar++ will argue the opposite.
> 
> Jonas

I'm sorry, Mr. Temple, but I must vehemently disagree when it comes to
using such legacy systems as grammar.  This is, after all, a new era,
and we, as speakers, must eventually crawl out of the darkness imposed
by our own paradigms and learn to accept that grammar++ is the wave of
the future, and grammar, bless its soul, has been tossed into the
roadside garbage barrel of human evolution.

My first point would be the fact that there are so many "dialects" of
the grammar language.  First of all, grammar offers no standardization
between the different standard library files which make up the
incredible numbers of platforms which grammar can support.  Consider the
word "cat."  (Be sure you cast this word from the noun type first.)  As
it stands in grammar, the value of "cat" can vary widely from platform
to platform:

(word)cat = "cat"	        /* English grammar */
(word)cat = "gato"              /* Spanish grammar */
(word)cat = "kittie-cat"        /* tiny-English grammar */
(word)cat = "putty-tat"         /* Tweety Compiler v1.0 */
(word)cat = "Kat"		/* Alabama Compiler */  

This is only a very small listing of different platforms which support
cat.  Without standardization, cross-compiling and porting from one
platform to the other is a horrendous undertaking.  Moreover, there have
been very few attempts at a compile-once run-everywhere implementation
of grammar, as most grammarians look at the learning curve associated
with the ANSI 2001 Grammar Standard [ANSI2G] unfavorably.

Now let's contrast this with the more advanced paradigm proposed by
grammar++, especially the new SGTL (Standard Grammar Template Library). 
Using this library, things become much clearer:

class word {...};
class noun : public word {...};
class cat : public noun {...};

As you see, Mr. Temple, typecasting is no longer needed to work with cat
as a word, because due to the rules of polymorphism (which, I stress to
remind you grammar does *not* have), cat is a noun is a word. 
Furthermore, consider sheer amount of documentation needed for
typecasting using English grammar.  If the speaker is not extremely
careful, mis-casting the present tense verb "think" could cause the
speaker to inadvertently use the value "thunk" later in conversation. 
Or, one could be left with a null pointer, which can be even more
irritating.  

Speaking of null pointers, grammar++'s use of exceptions shows its glory
here.  A thorough look at the ANSI2G specifications states that "the
return value of speak(const word*), when its parameter is NULL, is
undefined."  Depending upon where said speak() points, a different value
could be returned.  If the null pointer points to an unused area of the
speaker's cerebellum, the value will typically be "uh."  If it points to
the California jump table, it is typically "like."  And, most
dangerously, if this pointer points to an area without any null
terminators, one may get a large chain of unintelligible speech.  (This
is the key to the Seinfeld virus, which causes speakers to become
permanently locked into outputting the value "yadda".)

(In fact, in the BlondOS, if the returned value hits an interrupt
vector, the system can bob its head side to side, giggle, then lock up. 
That's what happens in systems which aren't multithreaded.  But, I
digress ...)

Grammar, imo, produces poor speaking style, and the lack of exception
technology, especially as it pertains to teen-age systems, produces such
atrocious output as ...

"I, uh, was like, uh, going to the store, and, uh, like, uh, I said,
like, what-e-ver!  Yadda, yadda ..."

Since speak() in grammar++ is a method of the class word, no pointer is
needed.  And thanks to polymorphism, any classes descended from word may
also use this method via overloading.  In addition, with exception
handling, one can catch any errors at run time, instead of speak time.

try {
    cat.speak();
} catch(forgotword) {
    "fluffy thing with claws that hisses".speak();
}

And finally, since SGTL is actually a *standard,* it can be used on any
platform, as the platform is determined dynamically by the library at
mouth-run time.

But, there are some dangers in grammar++ as well.  For one, multiple
inheritance can be very bad in the wrong hands.  Consider an object that
inherits both the dog class and the cat class.  If this is not done
correctly, the object can run itself up a tree.  But all in all,
inheritance, I believe, is a good thing for the progression of our
species.  When speaking about a female, and wishing to be politically
correct, one needs only to use the the speak() method in the superclass
Human.  This could potentially spell world peace.

So please consider my point of view before you, uh, like, start
thrashing grammar++.

Have a nice day.

-- Travis --