To verify whether a concrete data type meets the requirements imposed by the specification of the abstract data type is quite straightforward, although not always easy. However, the task of verifying whether a concrete data type is optimally implemented is rather less well defined. To arrive at an optimal implementation may involve a lot of skill and ingenuity, and in general it is hard to decide whether the right choices have been made. Establishing trade-offs and making choices, for better or worse, is a matter of experience, and crucially depends upon the skill in handling the tools and mechanisms available.

When defining concrete data types, the list of requirements defining the canonical class idiom given in slide 2-canonical may be used as a check list to determine whether all the necessary features of a class have been defined. Ultimately, the programmer should strive to realize abstract data types in such a way that their behavior is in some sense indistinguishable from the behavior of the built-in data types. Since this may involve a lot of work, this need not be a primary aim in the first stages of a software development project. But for class libraries to work properly, it is simply essential.

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
  	}
  };
  

  th = new centigrade();
  th = new fahrenheit();
  th.set(f);
  f = th.get();
  

  class thermometer { 
   thermometer  


  
  protected thermometer( float v ) {  temp = v; }
  
  public void set(float v) { temp = v; }
  public float get() { return temp; }
  
  protected float temp;
  };
  

  class centigrade extends thermometer { 
   centigrade  


  
  public centigrade() {  super(0);  }
  public void set(float v) { temp = v + 273; }
  public float get() { return temp - 273; }
  };
  

  class fahrenheit extends thermometer { 
   fahrenheit  


  
  public fahrenheit() { super(0); }
  public void set(float v) { temp = (v - 32) * 5/9 + 273; }
  public float get() { return temp * 9/5 + 32 - 273; }
  };
  

  class displayer extends window { 
   displayer  


  
  public displayer() { ... }
  public void put(String s) { ... }
  public void put(float f) { ... }
  };
  

  class prompter extends window { 
   prompter  


  
  public prompter(String text) { ... }
  public float get() { ... }
  public String gets() { ... }
  };
  

  abstract class event { 
   event  


  pubic void dependent(event e) { ... }
  pubic void process() { ... }
  public void operator(); // abstract method
  
  private event[] dep;
  };
  

  class update extends event { 
   update  


  
  public update(thermometer th, prompter p) {
  	_th =th;  _p = p; 
  	}
  void operator()() {
  	_th.set( _p.get() );
  	process();
  	}
  
  thermometer _th;
  prompter _p;
  };
  

  class show extends event { 
   show  


  
  public show(thermometer th, displayer d) {
  	_th = th;  _d = d; 
  	}
  public void operator() {
  	_d.put( _th.get() );
  	process();
  	}
  
  thermometer _th;
  displayer _d;
  };
  

  thermometer c = new centigrade();
  thermometer f = new fahrenheit();
  
  displayer cd = new displayer("centigrade");
  displayer fd = new displayer("fahrenheit");
  
  prompter cp = new prompter("enter centigrade value");
  prompter fp = new prompter("enter fahrenheit value");
  
  show sc = new show(c,cd);
  show sf = new show(f,fd);
  
  update uc = new update(c,cp);
  update uf = new update(f,fp);
  

  uc.dependent(sc);
  uc.dependent(sf);
  uf.dependent(sc);
  uf.dependent(sf);
  

  menu.insert(uc);
  menu.insert(uf);