6	An Evaluation of FT-Linda

	=================== Overview of proposed sections ================

	6.1	Related Work
	6.x	Novelty and Universality of the Programming Model	
	6.x	Coherence of the Langauge Design
	6.x	Rationale for Restrictions on and Form  of AGS
	6.x 	Comparing FT-Linda and Transactional Lindas
	6.x	Paths not Taken (AND ALSO OTHER POSSIBLE EXTENSIONS?)
	6.x	Observed Deficiencies of FT-Linda
	6.8	Summary

	=================== Details of proposed sections ================

	6.1	Related Work
	
			[ Take from TPDS and expand ]
		
			HAS TO BE FIRST (6.1), TO GIVE CONTEXT 
			FOR REST OF CHAP!

			HOW EXACTLY TO TALK ABOUT 
			CHECKPOINTING TS+PROCESSES???

	6.x	Novelty and Universality of the Programming Model	

		- 	AGS novel: nobody else provides multi-ops but 
				no transactions

		- 	other FT-Linda features novel:
			* 	multiple TSs (esp w/attributes)
			* 	disjunction
			* 	strong semantics (MOM has oldest-matching, but
						ours was well in place before we
						read of this)

		- 	FT-Linda is general: it can implement the 3 major
		  	ftol structuring paradigms, plus many ones for
		  	scientific/parallel programming paradigms	

	6.x	Coherence of the Langauge Design

		- 	multiple TSs natural extensions
		-  	TS attributes orthogonal and combined intuitively
		-  	AGS restrictions clean and clear
		- 	tuple transfer primitives clean and clear
		- 	disjunction intuitive

	6.x	Rationale for Restrictions on and Form  of AGS
		[ unpolished section title! ]

			Explain AGS restrictions clearly, explain
			slippery slope if start allowing expressions and
			functions and conditional statements, etc.
	
			Could mention that Orca's operation guards have to
			be side-effect free, so operations only block
			before they begin execution.  This is important,
			since operations must execute atomically.  
			Dave see Coffin diss. p. 169 for a discussion of this.

			Could explain how the blocking restriction lets you 
			avoid worring about concurrency and rolling back TS 
			ops in the event of a failure.  Dennis Shasha thought
			that one very nice feature of FT-Linda was that
			there was no concurrency in the RTS.

	6.x 	Comparing FT-Linda and Transactional Lindas


	6.x	Paths not Taken (AND ALSO OTHER POSSIBLE EXTENSIONS?)

		-	Could mention that we could allow non-Linda guards
			using variables.  This could even be combined with
			a Linda op, e.g.

				bool flag = ....	
				< not flag and not inp(foo...) => ... >

			MAYBE THIS SHOULD GO IN SEC 3.4???!!!

		- Real-Time TSs/Ops/AGSs

		- First-Class AGSs [Bizzare]
			The ability to construct the AGC code at runtime 
			might be helpful (but very difficulty to get issues
			right---including scoping---just like with first-class
			tuples).  For example, a transaction manager could be 
			given a list of variable IDS to start with.  It would
			grab the locks at start time.  At commit time, 
			it could construct an AGS that for each
			variable ID in the list would do the following:
				- remove LOCK_INUSE and restore LOCK
				- remove VAR with old value and add VAR 
					with new value

		-	A way to move all tuples atomically from one form 
			into another, equivalent (w.r.t tuples) to 
	
			while ( < inp(VAR_INUSE, ?var, ?val) => 
					out(VAR, var, val) > )
		
			One possible form would be
	
				movefrom(VAR_INUSE, ?var, ?val)
				to(VAR, var, val)
		
		-	Timeouts for an AGS a la Ada accept statements.  
			See Cannon/Dunn work..

		-	Else clauses for an AGA a la Ada.

		-	TS create/destroy/clear commands inside AGSs.  
			This helps us avoid the possibility of a junk TS
			left in the event of a failure.

	6.x	Observed Deficiencies of FT-Linda

		[Generally results of conscious design decisions/tradeoffs...]

		-	Not as simple to use as transactions or
			checkpointing+processes:

			*	Have to figure own windows of vulneratibility
				and remove them, both through AGS and
				monitor process.  Not for FORTRAN programmers
				(unless they can follow a paradigm's recipe ...)

		-	No internal computations with atomic TS ops	

		-	No variable number of TS operations

		-	No provisions to handle total failures

		-	Does not allow failure of worker process
			apart from processor failure.

	6.x	Summary