CHAIMS-project: overview of ongoing and future tasks and open questions
Dorothea Beringer
Version: 4/15/98

Tasks

Task	Who	Priority	depends	used in	Deadline	Status	Completed	
RMI		medium			June 1, 98			
RMI-Spec	ct				Apr 12, 98 ?			
RMI-Wrap1	ct		RMI-Spec		May 1, 98 ?			
RMI-Wrap2	ct		RMI-Wrap1		May 15, 98?			
RMI-Ex1	ct		RMI-Wrap2		May 15, 98?			
RMI-Comp	mb ?		RMI-Spec		June 1, 98			
Java-ASN.1	db				June 1, 98			
RMI-Ex2	ct 		RMI-Wrap2, RMI-Ex1, RMI-Comp		June 1, 98			
Compiler	wp							
Comp-Cleanup	wp	high				 this is an ongoing task...		
Comp-Stubs		low						
Comp-Master		medium						
Wrappers	hx							
Spec-ASN.1	 pj,hx	high			May 1, 98			
Wrap-ASN.1	hx	high			May 1. 98			
Wrap-DCE	?	medium						
Wrap-Doc	hx	high	Wrap-ASN.1					
DCE		medium						
DCE-Wrapper								
DCE-Ex								
Mixed-Ex								
IO-Megamodul		high						
IO-ASN.1	hx		Spec-ASN.1		Jan 98			
IO-GUI	ks		IO-ASN.1		Jan 98			
Demos								
Web-Demo1	ct	high			?	nearly finished		
Baby-Demo	wp, hx,ks	high	Wrap-ASN.1,
IO ?		May 1, 98			
June-Demo					June 1, 98			
Scheduling		 						
Sched_Core	cw	medium			 ?	design of main classes done		
Sched_Pars	cw	medium	Sched_Core		 ?			
Sched_Term	cw	medium	Sched_Core					
Sched_Extract	?	medium						
Sched_Invoke	?	low						
Repository		low						
								
Publications								
IEEE	db				Feb 98	submitted		
Middleware98	db				March 98	submitted		
DEXA	db				March 98	draft		
								
Proposals								
KDI	gw,db					Letter of intent		
ACS	?							

RMI
Adding a further distribution protocol (RMI) to the CHAIMS system. Megamodules are Java-modules, either native CHAIMS-compliant, or they need to be wrapped.
RMI-Spec: Specification of the interface between CSRT (megaprogram) and megamodules, and thus of the compiler output. Documenting the specification, writing a sample RMI client that contains all the primitives that a RMI server must understand.
RMI-Wrap1: Wrapper for Java-modules and RMI. Without ASN.1-encoding. It includes: interface to (all!)  CHAIMS-messages, faking answers to certain CHAIMS-messages, having reentrant methods.
Artifacts:
- design description
- one or several programs and templates that help to wrap themegamodules
- user guidelines that also describes all the manual steps that need to be done in order to make a megamodule CHAIMS compliant
- two versions of a simple megamodule: native and wrapped (example)
RMI-Wrap2: Enhancing the wrapper for Java-modules by ASN.1-en/decoding. 
Artifacts: updated documents and code of RMI-Wrap1.
RMI-Ex1: Example of wrapping non-CHAIMS-compliant megamodules (e.g. Transportation). 
Artifacts:  
- two versions of a simple megamodule: native and wrapped with the wrapper of RMI-Wrap2
- sample client program that can be used to test a wrapped megamodule
RMI-Comp: Enhancing the compiler to produce client-code for RMI.
RMI-Ex2: Example of a megaprogram that uses Java-modules and the RMI-distribution protocol. Artifacts: megaprogram, compiled megaprogram, wrapped megamodules, readme that describes what goes together and how to compile, configure and execute.

Compiler
Comp-Cleanup: Introducing IF and WHILE primitives, compiling example megaprogram on web, making the compiler and the megamodule wrappers consistent, making all documentation that concerns the compiler consistent (API-description, ......). 
Artifacts:
- compiler
- description of the design
- user-manual: description of all the steps to be taken to compile a megaprogram and getting the CSRT
Comp-Stubs: Automatic generation of the IDL-files and stubs. Goal: the user only has to run the megaprogram through the compiler, and everything he needs is done automatically, so afterwards he can directly execute the megaprogram.
Comp-Master: Master-client that controls the various clients in case of megaprograms using several distribution protocols.

Wrapper
Spec-ASN.1: Specification of the format of the datablobs and the mechanisms by which input, output and de-/encoding will work. Artifact: Short textual description of the chosen approach.
Wrap-ASN.1: Adding the de-/encoding of ASN.1 to the wrapper software. Artifacts: code plus enhanced design description.
Wrap-Doc: Documenting how to wrap non-CHAIMS-compliant megamodules, e.g. the Roomreservation module. 
Artifacts:
- two versions of the Roomreservation megamodule, once as they are now, once wrapped.
- description (user-manual) of how to use the wrapper software
- wrapper as well as description accessible on the web
Wrap-DCE: Adapting the wrapper templates for DCE.

IO-Megamodule 
IO-ASN.1: Providing all the conversion functions necessary for the IO-megamodule, and also compiler.
IO-GUI: Java-megamodule that is fully CHAIMS-compliant (i.e. accepts CHAIMS messages and is reentrant for input functions).

Demos
Baby-Demo: The baby-demo demonstrates that our basic concepts hold and we can integrate wrappers and compilers, it will contain:
- the wrapped megamodule Roomreservation
- a simple megaprogam without any control structures
- some kind of I/O
Things to be done for the baby-demo: 
- wrapping Roomreservation (Hao, Pankaj)
- making compiler output compatible to wrappers (Woody)
- finishing conversion function for output (Hao)
- finishing the I/O-megamodule for output of datablobs: integrating conversion function and making the I/O-megamodule CHAIMS-compliant (Kazuki)
- integrating it: writing, compiling and executing small megaprogram (Woody)
June-Demo: Demo using the transportation modules (C++ and CORBA) and the IO-megamodule (CORBA).
Scheduling
Sched_Core: Designing, implementing and documenting the basic classes of the scheduler that will hold the information resulting from the parsing process and enable the shifting around and introducing of statements.
Sched_Pars: Implementing a parser that fills up the internal data structure and a generator that generates the new output-file.
Sched_Term: Implementing optimization concerning TERMINATE: each invocation should be terminated as soon as no longer needed, either by a TERMINATE on the megamodule, or by a TERMINATE on the invocation.
Sched_Extract: Implementing optimization concerning EXTRACT: results should be extracted only directly before they are needed.
Sched_Invoke: Implementing optimization concerning INVOKE: depending on the execution time of the methods to be invoked, certain methods should be invoked earlier or even without knowing if they are needed at all.

Open points, missing parts, flaws, ...
Open Point	What	Variants	Decision	
COMPILER				
Masterclient	In Java or C++? 
Architecture? Implementation...			
Syntax-Checks	Checking the syntax of a megaprogram prior to compilation? Error-handling?			
Interpreter	Is an interpreter possible with current architecture?			
LANGUAGE				
ExtractWhenDone	New primitive: to avoid clumsy coding, as a shortcut for certain cases that occur quite often.	Compiler automatically generates lower level code with WHILE (ih.EXAMINE=! DONE) {}, or makes polling of all invocations waiting to be extracted.		
GetParam	To get types and default values of parameters		Implemented.	
Get-,SetAttributes	What it is for exactly? What are its Parameters and Results? Scenarios?			
SET/GETATTRIBUTES	What are the parameters? type? certainly not blobs.....
Examples that use it?		Gio will make same examples...	
EXTRACT	Returning assoc. list instead of just one value, having parameters that denote the values to be returned.	Would involve the introduction of associative lists in the megaprogramming language.		
COPY,   associative lists	When EXTRACT returns a list of name-value pairs, we need operators to get one specific element of that list to be used as input for an INVOKE.			
Transforming datablobs	If one method takes as one parameter a value that consists of several values of other methods, we cannot handle it.	Operations for merging and splitting up datablobs. How? Datatype-defintiions? Concptually clean? Dedicated megamodule-suite specific megamodules?		
ESTIMATE (methodname)	should return a triple:
- time (in seconds)
- fee for one invocation (in $)
- volume of return-data (in kbytes)			
Boolean variables	Needed to set flags for scheduling when having more sophisticated preprocessor.			
Comparing estimates	For comparing estimates we need comparison of integers. For making EXTRACT’s we need comparison for InvocationStatus. 	Using mathmodule: does not work, because comparison would be used again for making an extract (WHILE-loop), and returned datablob cannot be inspected by megaprogram.	Camparisons for all basic CHAIMS-types implemented (=, !=, and <,> for numbers only)	
Control-data	What types? What kind of operations within CHAIMS-language? Where can it come from? Can user-data become control-data? 

See also minutes weekly meeting 6/24/98.	If user-data can become control-data, then either the megamodule has to send as control-data to the megaprogram (==> enhancing EXTRACT or adding new primitive), or the megaprogram has to get the capability of looking into blobs and transforming them into control-data.		
Gentype: name	What do we use name for? Should the wrapper rely on this name when assigning parameters to methods? Just for mediator megamodules?	We need conceptual description of Gentype. What should compiler put in there for hard-coded values? = parameter-name?		
Types of user-data	The only type for user-data right now is datablob. No integers, boolean, etc.... (though a user can use strings, boolean, integer for hard-coded values when he knows, the megamodule expects that type - this is somehow an incosistency).	Allowing all simple CHAIMS-types and datablobs?		
recognizing end of commands in megaprogram	Right now the parser assumes that a command is ended by a newline-character, which is not true for longer commands written over several lines.	- reeintroducing ;
- parser deals with logical structure		
CHAIMS-language: callId’s	Copying of callId’s should be explicitely forbidden.			
Appealing front-end	Our current front-end (CHAIMS-language) is quite akward - it claims to be on a high-level, yet the megaprogrammer mainly does silly coding.	1) Short-cuts, e.g. EXTRACTWHENDONE, automatice generation of estimate code....
2) Graphical user-interface (maybe easy to create with nowadays graphical tools) that generates input for CHAIMS-compiler. Compare also to workflow-management systems like changengine of HP.
3) A real high-level language... yet graphical input could be clearer.		
CHAIMS - procedural language?	Right now, CHAIMS is procedural language. Is that okay? 
See also minutes weekly meeting 6/24/98.	- graphical language describing data-dependancies
- query-language		
WRAPPER				
wrapper: timeouts	what happens when network connection is lost? 	(timeout, ping for testing if machine is still there, ark for checking if a specific port is still occupied,....)		
megamodule.TERMINATE()	megamodule cannot determine which active invocations it has to close down, because it does not know which ones are from which client	1) before the megamodule connection is closed down, the client has to terminate each invocation ==> compiler has to create code for making list of active invocations
2) wrapper knows which invocations are from whom	2), new parameter clientID for INVOKE, SETATTRIBUTE, TERMINATE_ALL

Implemented in RMI-Wrapper, not yet in CORBA-Wrapper	
Implementation of SetAttributes in wrapper	Global attributes should not be shared by several clients ==> they only should be changed for all following invocations of a specific client ==> megamodule would need notion of who is making a specific invokation and managing which invocations and “global” parameters belong to which client.... 	RMI: object openconnection could contain the information about which socket has connected to a server and from whom a method call comes; is this knowledge accessable?
CORBA: this knowledge is hidden from the user
TCP/IP: every package includes the knowledge about from whom it comes	see above	
SETUP	In CHAIMS-protocol: void SETUP()	 instead of current stuff...		
ESTIMATE	By default, wrappers should estimate time by summing up previous execution times, instead of returning just 0..			
OTHER PARTS				
Cost-function for scheduler	- should take into account real values for fee and volume
- more sophisticated cost-function?	- Cost function for moving invokes outside of an if-block: taking into account estimates of  other invokes and extracts between the possible invoke and the beginning of if...
- more interpreter-like and rule-based implementation		
Repostiory, Scheduler	In order to save resources (and fees) for no longer used resources for holding results at the server side, the scheduler should terminate all invocations that are no longer accessed. Yet there is a special subclass of invocations that should not be killed automatically, because they perform tasks without providing results to the megaprogram, e.g. printing.	Flag “no_result” in repository for each method that should not be terminated automatically by scheduler.		
IO-megamodule	input and output should take an additional parameter for text to be printed to the screen		Implemented.	
Helper modules	Right not, we use megamodules for I/O and math, they transfer data as datablobs like every other module. ==> Not usable for computation on control-data.	Helper-modules with special primitives.		
Look-up of method names, automatic comparison of competing services	Right now, we look up megamodule names and not method names in the repository. If two megamodules offer the same services, the megaprogrammer has to know that. 	- same megamodule name for servers with same services, or additional megamodule name for servers with overlapping services
- also lookup for methodnames, so same methodname can be used for different methods that do same thing
- automatic generation of any code related to get estimates from two megamodules offering same services, and for choosing the better one		
ASN.1-Gentype: new simple types	The two new simple types realn and bytes need to be added to:
- RMI-Wrapper
- convert-package for Java			
Repository	Information for users and compiler concerning methods and their arguments (names, and if other types than blob allowed also type)		db makes suggestion...	
Error handling	When an error occurs in the server or connection, there is no way to inform the client/server. Also the user never gets errors, even not from compiler.	- timeouts if connection gets lost
- CORBA-protocol: returning an error-code instead of void for all CHAIMS-primitives
- error-messages in parser of compiler for user to standard-out		
Error-handling	Primitives should be able to return an error-status. Time-outs of megamodules. Parsing errors in compiler. Error-information to user (how?).	No consistent concepts yet.		
VARIA				
WfMS, BPMS	How do we differ from workflow and business process management systems? Where are we subset? What do we add?