From: (Robert Cooper)
Product: Isis Reliable Distributed Object Manager(tm) (RDOM)
Company: Isis Distributed Systems, Inc., Ithaca NY, USA.

Isis RDOM(tm) is a fault tolerant distributed ORB platform for reliable
multi-lingual object-oriented applications. RDOM provides an "object group"
paradigm for constructing complex applications out of collections of
cooperating objects. RDOM is built on top of the Isis Distributed
Toolkit(tm). RDOM provides interfaces from Smalltalk (Parcplace),
Objective-C, and C++, and runs on most Unix workstations. RDOM is currently
not CORBA compliant, but will be brought to compliance during 3Q93.


RDOM has been at beta test sites since January. General release of
the Smalltalk and Objective-C language interfaces is expected in June.
The C++ interface in August. Customers include AMD, Consilium and Swiss
Bank Corp).  

> Orbix

Iona Technologies Ltd.
O'Reilly Institute
Westland Row
Dublin 2

"ORB, CORBA compliant.
Product launched June, 93 at the OMG Object World.
Now shipping.  Provides C++ support (gives distributed
C++ programming using CORBA);  C++-IDL binding was jointly submitted with
SunSoft/HP to OMG recent call. "
etc etc

Chris Horn,                                        tel: +353-1-6790677
Iona Technologies,                                 fax: +353-1-6798039
O'Reilly Institute,                                email:
Westland Row
IRL - Dublin 2

3.8.7  Books, Articles, And Literature

This section is expected to grow considerably in the future.

"Distributed Object Computing With CORBA", C++ Report, July/August 1993

The Object Database Standard: ODMG-93
edited by: R.G.G. Cattell
published by Morgan Kaufmann Publishers, San Mateo, California
[Covers CORBA standards with respect to OODBs]

3.9)  Why Is Garbage Collection a Good Thing?

  From: Paul Johnson (

Garbage collection (GC) is a facility in the run-time system associated with a
language which will automatically reclaim objects which are no longer used.
OO Languages which require garbage collection include Eiffel, Smalltalk and
CLOS.  C and C++ can have garbage collection retrofitted (see [3] below).
[Ada has switchable GC, too -bob]

Without GC programmers must explicitly deallocate dynamic storage when
it is no longer needed (in C this is done by a call to free(3)).
There are a number of problems with this:

1: Bugs due to errors in storage deallocation are very hard to find,
   although products are available which can help.

2: In some circumstances the decision about whether to deallocate
   storage cannot be made by the programmer.  Drawing editors and
   interpreters often suffer from this.  The usual result is that the
   programmer has to write an application-specific garbage collector.

3: An object which is responsible for deallocating storage must be
   certain that no other object still needs that storage.  Thus many
   modules must co-operate closely.  This leads to a tight binding
   between supposedly independent modules.

4: Libraries with different deallocation strategies are often
   incompatible, hindering reuse.

5: In order to avoid problems 3 and 4, programmers may end up copying
   and comparing whole objects rather than just references.  This is a
   particular problem with temporary values produced by C++ overloaded

6: Because keeping track of storage is extra work, programmers often
   resort to statically allocated arrays.  This in turn leads to
   arbitrary restrictions on input data which can cause failure when
   the assumptions behind the chosen limits no longer apply.  For
   instance many C compilers limit expression nesting, identifier
   length, include file nesting and macro stack depth.  This causes
   problems for programs that generate C.

One partial solution to a lack of GC is reference counting.  In this
scheme each object keeps a count of references to it.  When this count
drops to zero the object is automatically deallocated.  However this
is inefficient (swapping two references will result in three
decrements, three increments and six comparisons) and cannot reclaim
circular data structures.  Two systems that use a reference count GC
are the Interviews C++ graphics library and the Unix file system (the
link count).

Opponents of GC reply that it introduces an overhead which is
unacceptable in some applications.  However the overhead of manual
storage deallocation is probably as high as GC.  GC algorithms are
also available with good real-time behaviour.

[Further, GC can perform compaction improving locality of reference.]

Further Reading:

[1] "Object-Oriented Software Construction" by Meyer puts the argument
for GC.

[2] "Uniprocessor Garbage Collection Techniques," by Paul R. Wilson,
in Memory Management (proceedings of 1992 Int'l Workshop on Memory 
Management, Sept. 1992, St. Malo, France, Yves Bekkers and Jacques Cohen, 
eds.), Springer Verlag Lecture Notes in Computer Science #637.

This is an excellent summary of the state of the art in GC algorithms.  This
and other papers about garbage collection are available in PostScript via
anonymous ftp (  [See APPENDIX E]

[3] "Garbage Collection in an Uncooperative Environment" by Boehm and
Weiser.  Software --- Practise and Experience vol 18(9), pp 807-820.
Sept 1988.  This describes GC in C and C++.

3.10)  What Can I Do To Teach OO To The Kids?

Smalltalk (in its original 1972 version) was initially intended to make
computer programming easy enough for children.  The idea was that manipulating
objects was something more intuitive and natural than coding procedures.

Other entries or suggestions are welcome, please send to the author of the FAQ.

3.11) What Is Available On Object-Oriented Testing?

[This entry was donated by Doug Shaker and is certainly a FAQ]

Testing of Object-Oriented Programming (TOOP) FAQ/Resource Summary

Posted to comp.object, comp.lang.c++, comp.lang.smalltalk and

Last revised on 93.10.27.  The most notable change is in the additions
to the Software section.  Also a couple of articles added to the
Written Material section.

> What?

This is a summary of resources on the Testing of Object-Oriented
Programming that have been mentioned to me over the net, in email,
or other means.  Sections include Written Material, Courses, and
Software.  It is kind of like an FAQ, though it isn't organized 
that way.

> Who?

I work for a Unix software house, Qualix Group, in the US.   Here is
my sig:
 - Doug Shaker
	voice:	415/572-0200
	fax:	415/572-1300
	mail:	Qualix Group
		1900 S. Norfolk St., #224
		San Mateo, CA 94403
I am NOT a researcher on the testing of object-oriented programming.
I just collate the stuff that is sent to me by people who REALLY know
something.  See the section "ACKs" at the end.

I just think it is important.

> Why?

Why is this important? If classes are really to be reused in
confidence, they must be blatantly correct.  The classes must be easily
testable during initial evaluation by the client programmer.  They must
also be testable under different OS configurations, different compiler
optimizations, etc.  This means that testing modules must be
constructed in a way which is recognized as correct and the modules
must be shipped with the class libraries.  

As soon as one major class library vendor starts to ship real test code
with their libraries, all of the other vendors will be forced, by
market pressure, to do so as well, or face market share erosion.  Think
about it.  If you had to recommend a class library to a committee that
was choosing a basis for the next five years of work, wouldn't you feel
safer with a class library that could be auto-tested in your

> Written Material

Berard, Edward.  Essays on Object-Oriented Software Engineering.  
	Prentice-Hall, Englewood Cliffs, NJ. $35.
	This book has two chapters on testing of object-oriented software, 
	focusing on how to do it.

Berard, Edward.  Project Management Handbook.  Must be purchased
	direct from Berard Software Engineering, Ltd., 902 Wind River
	Lane, Suite 203, Gaithersburg, Maryland 20878.  $225.
	The book focuses on the management of OOP projects.  It
	includes one chapter on testing OO software and one chapter
	on quality assurance.

Bezier, Boris, "Software Testing Techniques", 2nd edition, Van Nostrand
	Reinhold, 1990, 503pp, $43, ISBN 0-442-20672-0.  While this is
	not specifically about testing of OOP, it is mentioned so often
	by so many people as a definitive software testing work, that
	I have to mention it anyway.

Cheatham Thomas J., and Lee Mellinger, "Testing Object-Oriented
	Software Systems",  Proceedings of the 18th ACM Annual Computer
	Science Conference, ACM, Inc., New York, NY, 1990, pp. 161-165.

Doong, Roong-Ko and Phyllis G. Frankl, "Case Studies on Testing 
	Object-Oriented Programs", Proceedings of the 4th Symposium on
	Testing, Analysis, and Verification (TAV4), 1991, ACM, Inc.,
	New York, NY, 1991, pp. 165-177.

Fiedler, Steven P., "Object-Oriented Unit Testing", Hewlett-Packard 
	Journal, April, 1989, pp. 69-74.

Firesmith, D.G., "Testing Object-Oriented Software", Proceedings 
	of 11th. TOOLS USA Conference, Santa Barbara, Aug 1993, pp 407-426.

Frankl, Phyllis G. and Roong-Ko Doong, "Tools for Testing 
	Object-Oriented Programs", Proceedings of the 8th Pacific
	Northwest Conference on Software Quality, 1990, pp. 309-324.
	One author can be reached at

Graham, J.A., Drakeford, A.C.T., Turner, C.D. 1993. The Verification, 
	Validation and Testing of Object Oriented Systems, BT Technol
	J.  Vol 11, No 3. One author's email address is

Harrold, Mary Jean, John D. McGregor, and Kevin J. Fitzpatrick, 
	"Incremental Testing of Object-Oriented Class Structures",
	International Conference on Software Engineering, May, 1992,
	ACM, Inc., pp. 68 - 80.

Hoffman, Daniel and Paul Strooper.  A Case Study in Class Testing.
	To be Presented at the IBM Center for Advanced Studies Fall
	Conference, October 1993, Toronto.  Email addresses for authors
	are and  Describes an
	approach to testing which the authors call Testgraphs.  An
	example is worked out in C++ which tests a commercial class.

Hoffman, D. M.  A CASE Study in Module Testing.  In Proc. Conf. Software
	Maintenance, pp. 100-105. IEEE Computer Society, October 1989.

Hoffman, D.M. and P.A. Strooper.  Graph-Based Class Testing.  In 
	7th Australian Software Engineering Conference (to appear), 1993.

Klimas, Edward "Quality Assurance Issues for Smalltalk Based Applications", 
	The Smalltalk Report, Vol. 1, No. 9, pp.3-7.  The author's
	email address is "".

Lakos, John S.  "Designing-In Quality in Large C++ Projects" Presented
	at the 10th Annual Pacific Northwest Software Quality Conference,
	Portland, Oregon, October 21, 1993.  Abstract:
		The focus of this paper is on ensuring quality by
		designing software that avoids acyclic component
		dependencies.  This in-turn permits incremental,
		hierarchical testing.  The importance of good physical
		design becomes a key factor only for large and very
		large projects.  Intuition gained from smaller projects
		leads to errors in large designs.  Compile-coupling
		("Insulation") is also discussed.
	Copies of the postscript file can be obtained by sending email
	to "".

Leavens, G. T., "Modular Specification and Verification of 
	Object-Oriented Programs", IEEE Software, July 1991, pp. 72-80.

Love, Tom.  Object Lessons.  SIGS Books, 588 Broadway #604, New York, NY 
	10012. $49.
	This book eloquently elucidates the need for testing of object-
	oriented code and has a chapter on how it was done at Stepstone
	during the first release of their initial class library.

Marick, Brian.  The Craft of Software Testing, Prentice-Hall, in press.
	Makes the argument that testing of object-oriented software is
	simply a special case of testing software which retains state
	and which is resused.  The author can be reached at

Narick, Brian. "Testing Software that Reuses", Technical Note 2, Testing
	Foundations, Champaign, Illinois, 1992. Copies may be obtainable 
	via email. The author can be reached at

Murphy, G.C., Wong, P. 1992, Towards a Testing Methodology for 
	Object Oriented Systems, M.P.R Teltech Ltd. A poster at the
	Conference on Object Oriented Programming Systems, Languages
	and Applications ACM. Copies of this paper can be obtained

Murphy, G. and P. Wong.  Object-Oriented Systems Testing Methodlogy: An
	Overview.  Techical Report TR92-0656, MPR Teltech Ltd., October 

Perry, D.E. and G.E. Kaiser, "Adequate Testing and Object-Oriented 
	Programming", Journal of Object-Oriented Programming, 
	2(5):13-19, Jan/Feb 1990.

Purchase, Jan A. and Russel L. Winder, "Debugging tools for 
	object-oriented programming", Journal of Object-Oriented 
	Programming, June, 1991, Vol. 4, No. 3, pp. 10 - 27.

Smith, M. D. and D. J. Robson, " A Framework for Testing Object-Oriented 
	Programs", JOOP, 5(3):45-53, June 1992.
	Describes ways in which the usual approach to software testing
	could be adapted for object-oriented software.
	This paper, or one with the same title and authors, is
	available by anonymouns ftp from as

Smith, M. D. and D. J. Robson, "Object-Oriented Programming - the 
	Problems of Validation",  Proceedings of the 6th International 
	Conference on Software Maintenance 1990, IEEE Computer Society 
	Press, Los Alamitos, CA., pp. 272-281.

Taylor, David. "A quality-first program for object technology", Object 
	Magazine, Vol. 2, No. 2, July-August 1992, pp17-18. SIGs
	Publications.  The article talks some about why testing is
	important for OOP and describes one quality program.

Theilen, David.  "No Bugs.  Delivering error free code in C and C++.",
	Addison-Wesley, 1992, ISBN:0-201-60890-1.

Turner, C. D. and D. J. Robson, "The Testing of Object-Oriented Programs",
	Technical Report TR-13/92, Computer Science Division, School of
	Engineering and Computer Sciences (SECS), University of Durham,
	Includes a survey of existing literature on testing of OO
	programs.  Testing of OOP is compared with traditional software
	testing.  A state-based approach is described.
	This paper is available by anonymous ftp from in
	/pub/papers. Get "" for A4 paper and "" for
	US letter paper formatting.

Turner, C. D. and D. J. Robson, "A Suite of Tools for the State-Based
	Testing of Object-Oriented Programs", Technical Report
	TR-14/92, Computer Science Division, School of Engineering and
	Computer Science (SECS), University of Durham, Durham,
	England.  Describes a series of tools for the generation and
	execution of test cases for OOP.  These tools assume a
	state-based testing approach.
	This paper is available by anonymous ftp from in
	/pub/papers.  Get "" for A4 paper formatting or get
	"" for US letter formatting.

Turner, C. D. and D. J. Robson, "Guidance for the Testing of Object-
	Oriented Programs", Technical Report TR-2/93, Computer Science
	Division, School of Engineering and Computer Science (SECS),
	University of Durham, Durham, England.  Discusses different
	methods of making class declarations and the implications of
	those methods for testing.
	This paper is available by anonymous ftp from in
	/pub/papers.  Get "" for A4 paper formatting or get
	"" for US letter formatting.

Turner, C. D. and D. J. Robson, "State-Based Testing and Inheritance",
	Technical Report TR-1/93, Computer Science Division, School of
	Engineering and Computer Science (SECS), University of Durham,
	Durham, England.
	Discusses the implications of inheritance for testing,
	particularily incremental testing.
	This paper is available by anonymous ftp from in
	/pub/papers.  Get" for A4 paper formatting or get
	"" for US letter formatting.

Wong, P. Automated Class Exerciser (ACE) User's Guide.  Technical
	Report TR92-0655, MPR Teltech Ltd., September 1992.
> Courses

Berard Software Engineering, Inc. teaches a seminar on Testing of
Object-Oriented Software (TOOS).  The next one scheduled that I know of
is November 8-12, in Washington.  Call 301-417-9884 for details.

Quality Fractals, Inc. has a course called "Testing Object-Oriented
Software".  Contact: 508-359-7273 (Box 337, Medfield, MA 02052).  The
course is taught by Shel Siegel of YESS!, Inc.  Contact: 916-944-1032.

> Software

There is a smalltalk class library in the Univ. of Illinois archives
which includes a simple Tester class written by Bruce Samuelson
( It is a general superclass for application
specific classes that test non-interactive objects such as trees,
collections, or numbers. It is not suitable for testing user interface
components such as windows, cursors, or scroll bars. The filein
includes Tree classes, Tester itself, and subclasses of Tester that are
used to validate the Tree classes. For ParcPlace Smalltalk (ObjectWorks
4.1 and VisualWorks 1.0). To get it ftp the file
"/pub/st80_vw/TreeLW1.1" from

IPL Ltd. (in the UK) has a testing tool called Cantata which allows for
testing C++, but as far as I am able to determine, it has no special
features for C++ testing.  From the product literature:
	Cantata allows testing to be performed in an intuitive way
	making the tool exceptionally easy to use and productive in
	operation. Cantata is suitable for testing software written in
	either C or C++.

	Cantata provides comprehensive facilities for all forms of
	dynamic testing, including: functional testing, structural
	testing, unit testing and integration testing. Cantata has been
	specifically designed to operate in both host and target
	systems and so allow full portability of tests between these
For more information contact IPL:
	IPL Ltd.
	Eveleigh House, Grove Street, 
	Bath  BA1 5LR
	(0225) 444888
	(0225) 444400 (FAX)

TestCenter from CenterLine will do coverage testing of C++ (and C)
code.  Also does some memory debugging (similar to Purify) and regression
testing.  Highlights from CenterLine literature:
  *Automatic run-time error-checking on executables to enhance quality 
  *Automatic memory leak detection on executables to optimize memory use
  *Graphical test coverage to highlight any code not executed during test runs
  *Intuitive GUI for easy test analysis 
  *Programmatic interface to output files and cumulative code coverage 
   to support batch-mode and regression testing
  *No recompilation needed, resulting in quick turnaround
  *Complete C and C++ language support
  *Integration with leading programming tools for maximum productivity gains

MicroTech Pacific Research ( has a C++ class testing tool called
ACE (Automated Class Exerciser) which is available under non-disclosure
agreement.  It is not currently for sale.  If you are interested,
contact Paul Townsend,

Software Research Inc. (625 Third St, San Francisco, CA 94107-1997,
voice: 1-415-957-1441, email: has a coverage tool for C++
that is called tcat++.  It is an extension of SRI's tcat program.

Quality Assured Software Engineering (938 Willowleaf Dr., Suite 2806,
San Jose, CA 95128, voice: 1-408-298-3824 ) has a coverage tool for
C and C++ called MetaC.  It also dones some syntax checking and memory
allocation checking.

A group of volunteers is building a C++ test harness for the automated
testing of C++, C and Perl programs.  The system is called ETET (Extended
Test Environment Toolkit).  To join the group of volunteers, send email to
The software is available via anonymous FTP from
( as "/pub/etet/etet1.10.1.tar.Z".  They are looking for
other FTP sites - sned email to the above address if you can provide
one.  This is a beta release and _should_ compile on any POSIX.1 system.
As much of this work is being done by SunSoft, my guess is that the
software will have the fewest problems on SunOS or Solaris releases.

> ACKs

Thanks to the following for helping assemble this list:
	Benjamin C. Cohen,
	Brian Marick,
	Bruce Samuleson,
	Daniel M. Hoffman,
	Edward Klimas,
	John Graham,
	Jim Youlio,
	Jeffery Brown,
	Lars Jonsson,
	Manfred Scheifert,
	Mark Swanson,
	Mary L. Schweizer,
	Michael Einkauf,
	Paul Townsend,
	Phyllis G. Frankl,
	Rachel Harrison,
	Risto Hakli,
	Russ Hopler,
	Stephane Barbey,
	Tony Reis,
	Yawar Ali,

3.12) What Distributed Systems Are Available?

The following post helps to provide some answers with at least a partial list.
See also Appendix E.

From: (Bob Marcus)
Newsgroups: comp.object,comp.client-server
Go Back Up

Go To Previous

Go To Next