Idioms in hush

• The handle/body idiom
• Virtual self-reference
• Dynamic role switching
• The art of hush programming

In this section a brief overview will be given of the basic concepts underlying hush. Then we will discuss the idioms used in realizing hush and its extensions, in particular an adapted version of the handle/body idiom originally introduced in  [Coplien92], the virtual self-reference idioms and the dynamic role switching idiom. At the end of this section we will discuss the implications these idioms have for developing hush applications. Readers not interested in hush may safely skip the introduction that follows and the discussion at the end of this section.

The hush framework is object-oriented in that it allows for a component-wise approach to developing applications. Yet, in addition to object class interfaces, it offers the opportunity to employ a script language, such as Tcl and Prolog, to develop applications and prototypes. The hush framework is a multi-paradigm framework, not only by supporting a multi-lingual approach, but also by providing support for distributed client/server solutions in a transparent (read CORBA) manner.

In this section we will look at the idioms employed for the realization of the framework. In developing hush we observed that there is a tension between defining a clean object model and providing the flexibility needed to support a multiparadigm approach. We resolved this tension by choosing to differentiate between the object model (that is class interfaces) offered to the average user of the framework and the object model offered to advanced users and system-level developers.

In this approach, idioms play a central role. We achieved the desired flexibility by systematically employing a limited number of basic idioms. We succeeded in hiding these idioms from the average user of the framework. However, the simplicity of our original object model is only apparent. Advanced or system-level developers who intend to define extensions to the framework must be well aware of the patterns underlying the basic concepts, that is the functionality requirements of the classes involved, and the idioms employed in realizing these requirements.

The hush framework -- basic concepts

In developing hush, we decided from the start to support a multiparadigm approach to software development and consequently we had to define the mutual interaction between the various language paradigms, as for example the interaction between C++ and a scripting language, such as Tcl. Current scripting languages, including Python and Tcl, provide facilities for being embedded in C and C++, but extending these languages with functionality defined in C or C++ and employing the language from within C/C++ is rather cumbersome. The hush library offers a uniform interface to a number of script languages and, in addition, it offers a variety of widgets and multimedia extensions, which are accessible through any of the script interpreters as well as the C++ interface. These concepts are embodied in (pseudo) abstract classes that are realized by employing idioms extending the handle/body idiom, as explained later on.

    interface kit { 
   kit  


  
  	void eval(string cmd);
  	string result();
  
  	void bind(string name, handler h);
     };
  

     interface handler { 
   handler  


  	int dispatch( event e );   
// to dispatch events


  	int operator();
     };
  

     interface widget : handler { 
   widget  


  	...
  	void bind( handler h );
  	void bind( string action, handler h );
  	...
     };
  

     interface event : handler { 
   event  


  	operator();
     };
  

  class A { 
   A -- naive  


  
  public A() { }
  
  public void f1() { System.out.println("A.f1"); f2(); }
  public void f2() { System.out.println("A.f2"); }
  };
  

  class A { 
   A  


  
  public A() { body = new BodyOfA(this); }
  protected A(int x) {   }
  
  public void f1() { body.f1(); }
  public void f2() { body.f2(); }
  public void f3() { System.out.println("A.f3"); }
  
  private A body;
  };
  

  class BodyOfA extends A { 
   BodyOfA -- naive  


  
  public BodyOfA() { super(911); }
  
  public void f1() { System.out.println("A.f1"); f2(); }
  public void f2() { System.out.println("A.f2"); }
  
  };
  

  class C extends A { 
   C  


  public void f2() { System.out.println("C.f2"); }
  };
  

    C c = new C; c.f1();    
  

  class BodyOfA extends A { 
   BodyOfA  


  
  public BodyOfA(A h) { super(911); handle = h; }
  
  public void f1() { System.out.println("A.f1"); handle.f2(); }
  public void f2() { System.out.println("A.f2"); }
  
  A handle;   // reference to invocation context
  };
  

  class item { 
   item  


  
  public item(String x) { _name = x; _self = null; }
  
  String name() { return exists()?self().name():_name; }
  
  public void redirect(item x) { _self = x; } 
  
  boolean exists() { return _self != null; }
  public item self() { return exists()?_self.self():this; }
  
  item _self;
  String _name;
  };
  

  public class go {
  
  public static void main(String[] args) {
  	item a = new item("a");
  	item b = new item("b");
  	a.redirect(b);
  	System.out.println(a.name()); 
 indeed, b


  	}
  
  };
  

  class actor { 
   actor  


  
  public static final int Person = 0;
  public static final int Student = 1;
  public static final int Employer = 2;
  public static final int Final = 3;
  
  public void walk() { if (exists()) self().walk(); }
  public void talk() { if (exists()) self().talk(); }
  public void think() { if (exists()) self().think(); }
  public void act() { if (exists()) self().act(); }
  
  
  public boolean exists() { return false; }
  public actor self() {  return this; }
  
  public void become(actor A) { }
  public void become(int R) { }
  };
  

  class student extends actor { 
   student  


  public void talk() { System.out.println("OOP"); }
  public void think() { System.out.println("Z"); }
  };
  

  class employer extends actor { 
   employer  


  public void talk() { System.out.println("money"); }
  public void act() { System.out.println("business"); }
  };
  

  class person extends actor { 
   person  


  
  public person() { 
  	role = new actor[ Final+1 ];
  	for( int i = Person; i <= Final; i++ ) role[i]=this;
  	become(Person);
  	}
  
  public boolean exists() { return role[_role] != this; }
  
  
  public actor self() { 
  	if ( role[ Person ] != this ) return role[ Person ].self();
  	else return role[_role];
  	}
  
  public void become(actor p) { role[ Person ] = p; }
  
  
  public void become(int R) {
  
  if (role[ Person ] != this) self().become(R);
  else {
  	_role = R;
  	if ( role[_role] == this ) {
  		switch(_role) {
  		  case Person: break; // nothing changes
  		  case Student: role[_role] = new student(); break;
  		  case Employer: role[_role] = new employer(); break;
  		  case Final: role[_role] = new actor(); break;
  		  default: break; // nothing happens
  		  }
  	}
       } }
  
  int _role;
  actor role[];
  };
  

  class adult extends person {  
   adult  


  public void talk() { System.out.println("interesting"); }
  };
  

  public class go { 
   example  


  
  public static void main(String[] args) {
  	person p = new person(); p.talk(); // empty
  	p.become(actor.Student); p.talk(); // OOP
  	p.become(actor.Employer); p.talk(); // money
  	p.become(new adult()); p.talk(); // interesting
  	p.become(actor.Student); p.talk(); // OOP
  	p.become(p); p.talk(); // old role: employer
  	p.become(actor.Person); p.talk(); // initial state
  	}
  };