{"id":329,"date":"2007-03-02T11:15:21","date_gmt":"2007-03-02T11:15:21","guid":{"rendered":"http:\/\/scientopia.org\/blogs\/goodmath\/2007\/03\/02\/clear-object-oriented-programming-not-in-glass\/"},"modified":"2007-03-02T11:15:21","modified_gmt":"2007-03-02T11:15:21","slug":"clear-object-oriented-programming-not-in-glass","status":"publish","type":"post","link":"http:\/\/www.goodmath.org\/blog\/2007\/03\/02\/clear-object-oriented-programming-not-in-glass\/","title":{"rendered":"Clear Object-Oriented Programming? Not in Glass"},"content":{"rendered":"

Todays bit of programming insanity is a bit of a novelty: it’s an object-oriented programming language called Glass<\/a>, with an interpreter available here<\/a>. So far in all of my Friday Pathological Programming columns, I haven’t written about a single object-oriented language. But Glass is something
\nspecial. It’s actually sort of a warped cross between Smalltalk and Forth – two things that should never<\/em> have gotten together; in the words of the language designer, Gregor Richards<\/a>, “No other language is implemented like this, because it would be idiotic to do so.”<\/p>\n

<\/p>\n

In general, Glass using single character identifiers and commands. To use any multiple character identifier, you need to wrap it in parens. So, for example, “a” is an identifer; “abc” is three identifiers – a, b, and c; “(abc)” is a single identifier. This has the interesting effect of making the language considerably harder to read, for absolutely no good reason.<\/p>\n

A program in Glass, like in most other object-oriented languages is a series of class definitions. A class declaration is enclosed in curly braces, and consists of a class name followed by a list of methods. Each method is enclosed in square brackets, and consists of a method name followed by a sequence of cmmands. So, for example, the “main program” in Glass is the method M of the class M; so a minimal Glass program is:{M[m]}<\/code>: that’s a declaration of class “M”, which has one method, named “m”, which does nothing.<\/p>\n

Within Glass code, there are four different kind of variable:<\/p>\n

    \n
  1. Global variables: generally used for class names, global variables have names that start with an upper-case letter.<\/li>\n
  2. Instance variables: variables local to a particular object. Instance
    \nvariables have names starting with a lower-case letter.<\/li>\n
  3. Class variables: variables shared between all instances of a class. Class variables start with a lower-case letter. They look exactly like instance variables,
    \nbut they’re accessed using a different operator.<\/li>\n
  4. Local variables: variables local to a particular invocation of a method. Local variable names start with an “_”; since identifiers more than one character long must
    \nbe enclosed in parens, all<\/em> references to local variables must be enclosed in parens.<\/li>\n<\/ol>\n

    The basic operators in Glass fall into three groups: object-oriented operators,
    \nstack operators, and control-flow operators. I’ll use Forth notation for stack effects: (v1 v2 – v3 v4) means that the top of the stack before the operation consisted of the values v1 and v2 (with v2 on top); and after, the top values were v3 and v4.<\/p>\n

    The object-oriented operators are:<\/p>\n

    \n
    Create object: !<\/code> (varname global –)”<\/dt>\n
    Assumes that there are two identifiers on the stack – a global variable
    \nreferring to a class, and any other kind of variable. An instance of the
    \nclass named by the global is created, its constructor method (the method named “c__”) is called, and the result is assigned to the target variable.<\/dd>\n
    Retrieve method: .<\/code> (object name — method)<\/dt>\n
    Retrieve the method named “name” for the object “object”, and push
    \nit onto the stack.<\/dd>\n
    Assign self: $<\/code> (name — )<\/dt>\n
    Assign the value of self to the variable whose name is on top of the stack.<\/dd>\n<\/dl>\n

    The stack operators are:<\/p>\n

    \n
    Push variable name: (name)<\/code> ( — name )<\/dt>\n
    Push a variable name onto the stack. The parens are only required if “name” is more than one character long.<\/dd>\n
    Copy stack value: (number)<\/code> (sn<\/sub> sn-1<\/sub>…s0<\/sub> — sn<\/sub> sn-1<\/sub>…s0<\/sub> sn<\/sub>)<\/dt>\n
    Copy a value from the specified depth onto the top of the stack. The parens are only required in the number is more than one digit.<\/dd>\n
    Push a string: \"string\"<\/code> ( — “string” )<\/dt>\n
    Push a string value onto the stack.<\/dd>\n
    Push a number: <number><\/code> ( — number)<\/dt>\n
    Push a numeric value onto the stack.<\/dt>\n

    as a stack copy command.<\/dd>\n

    Drop: ,<\/code> (v — )<\/dt>\n
    Discard the top value from the stack.<\/dd>\n
    Retrieve variable value: *<\/code>. (name — value)<\/dt>\n
    Retrieve the value of the variable whose name is on top of the stack.<\/dd>\n<\/dl>\n

    And finally, the control flow operators are:<\/p>\n

    \n
    Return: ^<\/code><\/dt>\n
    Return from the current method call.<\/dd>\n
    Execute method: ?<\/code><\/dt>\n
    Pop the method on top of the stack, and execute it.<\/dd>\n
    Loop: \/(name)commands<\/code><\/dt>\n
    While the variable named “name” has a non-zero or non-empty string value,
    \nexecute the commands in the loop body.<\/dd>\n<\/dl>\n

    There are also a set of built-in classes which contain basic operations:<\/p>\n

      \n
    • Class “A” contain arithmetic operations: A.a (add), A.s (subtract), A.m (multiply), A.d (divide), A.mod (modulo), A.f (floor), A.e (equality test), A.ne, A.lt, A.le, A.gt. A.ge (comparions).<\/li>\n
    • Class “S” contains string operators: S.l (length), S.i (character at index),
      \nS.a (concatenate), S.d (divide string at a position), S.e (equality test),
      \nS.ns (number to character conversion), S.sn (character to number conversion).<\/li>\n
    • Class “O” contains output operators: O.o (output string), O.on (output number).<\/li>\n
    • Class “I” contains input operators: I.l (input a line of text), I.c (input a character), I.e (check for end of file).<\/li>\n<\/ul>\n

      So… Finally some sample programs. As usual, we start with Hello world:
      \n
      \n{M[m(_o)O!\"Hello world\"(_o)o.?]}
      \n<\/code><\/p>\n

      It looks awful, but it’s actually pretty easy. It instantiations class “O”, storing the instance in local variable (_o); then it pushes the string “Hello world” onto the stack; then it pushes the “o” method of our instance of “O” onto the stack and executes it.<\/p>\n

      Now for something much more interesting; the Glass version of a Fibonacci sequence generator.<\/p>\n

      \n{F\n[f\n(_a)A!\n(_o)O!\n(_t)$\n(_n)1=,\n(_isle)(_n)*<2>\n(_a)(le).?=\n\/(_isle)\n<1>^\n\n(_n)\n*<1>(_a)s.?\n(_t)f.?\n(_n)*\n<2>(_a)s.?\n(_t)f.?\n(_a)a.?\n]\n}\n{M\n[m\n(_a)A!\n(_f)F!\n(_o)O!\n(_n)<1>=\n(_nlm)<1>=\n\/(_nlm)\n(_n)*\n(_f)f.?\n(_o)(on).?\n\" \"(_o)o.?\n(_n)(_n)*\n<1>(_a)a.?=\n(_nlm)(_n)*\n<20>(_a)(le).?=\n\n]\n}\n<\/pre>\n
       That’s pretty long and cryptic, even with my efforts to format it cleanly. So let’s take it apart, bit by bit.<\/p>\n
        \n
      1.  It starts by declaring class “F”. “F” has one method, “f”:\n
          \n
        1.  “F.f” instantiates an A, and an O, and stores a reference to itself in (_t).<\/li>\n
        2.  It copies the value on top of the stack, and stores it in (_n). This is
          \nthe number of the element of the fibonacci series that it’s trying to generate. <\/li>\n
        3.  It compares (_n) with 2 and stores the result in (_isle), and then if
          \n_n was less than or equal to 2, it returns 1.<\/li>\n
        4.  Otherwise, it subtracts one from (_n), and gets that fibonacci number (f(n-1));
          \nthe subtracts two from (_n), and returns that fibonacci number (f(n-2)), and then adds them together.<\/li>\n<\/ol>\n<\/li>\n
        5.  Then it defines a main method – class M, method m, which instantiates an “A”, an “F”, and an “o”; and loops through calling f for each number from 1 to 20.<\/li>\n<\/ol>\n
           See? Not so hard!<\/p>\n
           How about the infamous 99 bottles of beer? Without my help in reformatting
          \nto make it legible?<\/p>\n
          \n{B[b<99>^]}{P[(c__)oO!t$aA!][n<10>s(ns).?oo.?][poo.?tn.?][b(_m)1=,(_x)<0>\n(_m)*ae.?=(_y)<1>=\/(_x)\"No more\"oo.?(_x)0=(_y)0=\/(_y)(_m)*o(on).?(_y)0=\n\" bottle\"oo.?(_x)<1>(_m)*ae.?=\/(_x)^(_x)0=\"s\"oo.?]}{C[(c__)oO!aA!sS!pP!t\n$][gn*][xn1=,][dnn*<1>as.?=][vn*pb.?\" of beer on the wall,n\"pp.?n*pb.?qe\n\" of beer,n\"pp.?\"Take one down, pass it aroundn\"pp.?ln*<1>as.?=l*pb.?wu\n\" of beer on the wall.nn\"pp.?pn.?]}{M[moO!cC!bB!bb.?cx.?fcg.?=\/fcv.?cd.\n?fcg.?=]}\n<\/pre>\n
           That shouldn’t be too hard to figure out. The key is really just a question of formatting – once you separate it out so that it’s one statement per line, it’s remarkably easy to follow.<\/p>\n
           Finally, I’ll close with a quine:<\/p>\n
          \n{M[m(_s)S!(_o)0O!o.(_s)(ns).?”{M[m(_s)S!(_o)0O!o.(_s)(ns).?”
          \n“14?24?14?24?24?04?24?04?]}”14?24?14?24?24?04?24?04?]}<\/p>\n","protected":false},"excerpt":{"rendered":"
          Todays bit of programming insanity is a bit of a novelty: it’s an object-oriented programming language called Glass, with an interpreter available here. So far in all of my Friday Pathological Programming columns, I haven’t written about a single object-oriented language. But Glass is something special. It’s actually sort of a warped cross between Smalltalk […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[92],"tags":[],"class_list":["post-329","post","type-post","status-publish","format-standard","hentry","category-pathological-programming"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p4lzZS-5j","jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/posts\/329","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/comments?post=329"}],"version-history":[{"count":0,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/posts\/329\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/media?parent=329"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/categories?post=329"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.goodmath.org\/blog\/wp-json\/wp\/v2\/tags?post=329"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}