Newsgroups: comp.object,comp.lang.eiffel,comp.lang.sather,comp.lang.beta,comp.lang.modula3
Path: news.daimi.aau.dk!news.uni-c.dk!sunic!uunet!ftpbox!mothost!schbbs!news
From: shang@corp.mot.com (David L. Shang)
Subject: Cluster -- wsa Re: Cows, Hogs & Farms
Reply-To: shang@corp.mot.com
Organization: MOTOROLA 
Date: Thu, 5 Jan 1995 19:17:51 GMT
Message-ID: <1995Jan5.191751.11072@schbbs.mot.com>
References: <ALFH.95Jan4184933@gyda.ifi.uio.no>
Sender: news@schbbs.mot.com (SCHBBS News Account)
Nntp-Posting-Host: 129.188.128.126
Lines: 155
Xref: news.daimi.aau.dk comp.object:23453 comp.lang.eiffel:7109 comp.lang.sather:1382 comp.lang.beta:196 comp.lang.modula3:3292

In article <ALFH.95Jan4184933@gyda.ifi.uio.no> alfh@gyda.ifi.uio.no (Alf-Ivar  
Holm) writes:
> In article <1995Jan3.223031@hobbit> hathawa2@marshall.edu (Mark S. Hathaway)  
writes:
> 
> > I've not seen BETA and have never heard of Cluster.  Could you provide
> > a pointer-->ftp_site or other info. about them?  :-)
> 
> The BETA home page is found at:
> 
> 	http://www.daimi.aau.dk/~beta/info
> 
> I have no info on Cluster.
> 
> 	Affi

Cluster: An Informal Report. SIGPLAN Notices 26:1(1991) 57-76.

Towards a Combinative Distributed OS in Cluster. IEEE CS Proc. 10th Intl.
Conf. on Distributed Computing Systems, Paris, May, 1990.

Type-Safe Reuse of Prototype Software. Proc. of 3rd SEKE Intl. Conf.
Skokie, Illinois, 1991.

Covariant Specification. SIGPLAN Notices 29:12(1994) 58-65.

Covariant Deepsubtyping Reconsidered. Unpulished.

Cluster in implemented under the DOS version in 1987.

I don't consider Cluster is an execellent practical programming language. I  
completely redefined the object-oriented terminology and use an hermetic  
syntax, which makes the language hard to understand and to use. However, there  
are a number of new concepts which are useful for bridging the gap between the  
static and dynamic typing systems, for dealing with covariant deep subtyping  
safely, and for programming at a meta level to create, for example, various  
concurrent models, various object storage protocols, and so on.

In the recent years of my study on various other OOPLs, I found that Cluster's  
concepts can be integrated with common notions very well. I am in the redesign  
of the language -- Cluster-2 -- or some other name. It is not just another  
language added to the pile.

The sytax and semantics of the new language will be a natual extension to  
ordinary languages. The basic sytax will be Pascal-like with some C/C++'s  
convnient feature. But the expanded sytax and semantics will be far beyond the  
Pascal/C++ language.

Just an example to show a little bit of the langauge style:

	function foo (input1: Type1; input2: Type2): OutputType
	declare
		// local declarations here
	enter
		// function body here;
	end;

I use "enter" instead of "begin" because "enter" is not a counterpart of "end",  
rather, is in the equal position of "declare".

People who knows Pascal will have a smooth transition to the above format.  
However, for people who want to explore a more flexible structure, they have to  
learn more.

Firstly, when we say that "foo" is a "function", we actually mean that "foo" is  
a class and its superclass is "function". Therefore, language users can design  
their own super "function" classes like "process", "thread", "task",  
"remoteProcedure", "DatabaseTransaction", and so on. And then, they can have:

	process foo (input1: Type1; input2: Type2): OutputType
	declare
		// local declarations here
	enter
		// function body here;
	end;

Calling "foo" will create a process.

Secondly, the above format is a simple format from a more general format for a  
class:

	class foo is function
	declare
		// local declarations here
	enter (input1: Type1; input2: Type2): OutputType
		// function body here;
	end;

You can have multiple input interfaces:

	class foo is function
	declare
		// local declarations here
	enter (input1: Type1): OutputType
		// function body1 here;
	enter (input1: Type1; input2: Type2): OutputType
		// function body2 here;
	end;

Thirdly, class can be nested. You can have something like:

	class foo is task
	declare
		// local declarations of variables shared
		// by multiple threads
	   thread thd1 ( ... )  // local class declaration
	   enter
		// thd1 code
	   end;
	   thread thd2 ( ... )
	   enter
		// thd2 code
	   end;
	   ...
	enter ( (*input for task creation*) )
		// tast initialization code;
	end;

Note that both "task" and "thread" are user-defined classes. This is a simular  
form of a class declaration:

	class foo is object
	declare
		// local declarations of variables shared
		// by methods
	   method mhd1 ( ... )
	   enter
		// mhd1 code
	   end;
	   method mhd2 ( ... )
	   enter
		// mhd2 code
	   end;
	   ...
	enter ( (*input for task creation*) )
		// object construct (initilization) code;
	end;

The difference is that the later is sequential while the fommer is concurrent.  
The key point is that the language does NOT provide built-in features like  
"thread", "method", rather, it provides only the framework to build those  
features. And this framework is uniformed by the class concept.

Lastly, class can be parameterized. And the supported parameterization is not  
the coventional one, though the syntax is very similar to Eiffel's generic  
class. Generic classes are real classes and are fully interagted into the type  
system.

David Shang