An acronym for "object-oriented". (or was that "object-obsessed ?-) RS
Tcl abounds in extensions providing an object orientation (OO) programming style - see that previous link to read about incr Tcl and the others. See Category Object Orientation for additional relevant hits.
Further, there are activities such as object-oriented analysis (OOA) and object-oriented design (OOD) that concern themselves with analyzing a system (or a solution to a problem) in terms of objects and their behaviors.
"An object or two may sometimes be nice, just like a glass of beer. But one shouldn't start drinking at breakfast." (RS)
RS In a smokebreak, I whipped up this hierarchy of things, by weight:
Every "heavier" thing can contain zero or more of "lighter" things. And on each level one can implement "objects". Most use 4., TOOT uses 7. procs with -static variables could allow (some) OO in 5. Databases are (fat) objects at level 1.
Another shade of meaning for OO is
What: OO Where: http://www.cs.umn.edu/%7Edejong/tcl/OO.zip Description: OO extension that works in Tcl 7, Tcl 8, and Jacl. Updated: 08/1998 Contact: mailto:dejong at cs.umn.edu
As RS aptly observes in "interp alias", object methods can be described as syntactic sugar for a certain form of dispatching. - RS I'd even go further and say that quite a bunch of what is called OO can be done in pure Tcl without a "framework", just the code might look clumsy and distracting. Just choose how to implement instance variables:
The task of frameworks, be they written in Tcl or C, is just to hide away gorey details of the implementation - in other words, sugar it :) As an example, here's a Stack class with push and pop methods:
namespace eval Stack {set n 0} proc Stack::Stack {} { #-- construktor variable n set instance [namespace current]::[incr n] namespace eval $instance {variable s {}} interp alias {} $instance {} ::Stack::do $instance ;# $object method arg.. sugar } proc Stack::do {self method args} { #-- Dispatcher with methods upvar #0 ${self}::s s switch -- $method { push {eval lappend s $args} pop { if ![llength $s] {error "stack underflow"} K [lindex $s end] [set s [lrange $s 0 end-1]] } default {error "unknown method $method"} } } proc K {a b} {set a}
Other examples for this "bare-bone OO" are at Tiny OO with Jim and Jim closures. A framework would just have to make sure that the above code is functionally equivalent to, e.g. (in a fantasy OO style):
class Stack { variable s method push args {eval lappend s $args} method pop {} { if ![llength $s] {error "stack underflow"} K [lindex $s end] [set s [lrange $s 0 end-1]] } }