ソフトウェア工学特論 (11)

1. ソフトウェア工学特論 (11) 田中　譲

2. Dynamic Interoperability of Pads and Workflow Modeling

3. Dynamic Interoperability of Pads Distributed across Networks • IntelligentPad represent both data and application resources as pads. • The dynamic combination of distributed resources requires both dynamic interoperability of pads and the reference of a remote pad. • This remote reference itself should take the form of a pad in the IntelligentPad Architecture. We call it a meta-pad.

4. IntelligentPad provides only two operations to define interoperations of pads. • They are ‘paste’ and ‘drag-and-drop’ operations. • A ‘paste’ operation dynamically defines a static functional linkage between two pads. Once the linkage is defined, it exists until it is broken by a ‘peel’ operation. • A ‘drag-and-drop’ operation, on the other hand, dynamically applies the function of a target pad to an object pad. This function is applied only once to the object pad when it is dropped on the target pad. • The interoperation defined by a ‘paste’ operation is said to be static, while the one by a ‘drag-and-drop’ operation is said to be dynamic.

5. The target pad of a ‘drag-and-drop’ operation should be an annihilator pad, which receives the dropped pad, stores this pad in itself, and hides this pad from the surface of itself. • The target pad may access any slots of the object pad. The target pad needs to know the slot name before it accesses this slot.

6. The output of a pad from a tool pad should pop up this pad on a pad that works as an output port of the tool, which allows the user to directly drag this output pad for further manipulations. • Such a pad that works as an output port receives a pad as its new stored value either from another pad or from an external system, generates this pad as a visual object, and pops it up on itself. • We call such a pad a generator pad.

7. The next figure shows a composite pad with one annihilator pad and two generator pads. • They are connected to an input slot and two output slots of the base pad, which, when an object is input to its input slot, outputs two of its copies through its two output slots. • When you drop an arbitrary pad on the annihilator pad, you will obtain two of its copies on the two generator pads. • To use these copies, you can just drag them out of the two generator pads. • The annihilator pad absorbs the dropped pad and sends this pad to the underlying base pad, which then makes its copy and sets this copy together with the original to the two output slots. • These output slots are connected to the two generator pads. • The base pad sends an ‘update’ message to the generator pads to fetch the current value of their connected slots, which then makes these generator pads pop up the fetched copies of the input pad.

9. In IntelligentPad, any processing service, when considered as an independent object, should take the form of a composite pad. • The same is true for its input and output objects, whether they are data, texts, figures, images, or programs. • They should all take the form of pads. • The drag-and-drop operation is the only way for end users to dynamically associate each processing service with its input and output objects. • The end-user computing with various types of processing services needs to make these service tools defined as pad converter pads that convert dropped pads to pop up result pads as outputs.

10. Our architecture for dynamic interoperability aims at the step-wise bottom up integration of already existing systems, i.e., integration of personal environments to a group environment, group environments to a department environment, department environments to a company environment, and company environments to an enterprise environment. • We assume here that all these environments are implemented in IntelligentPad systems. • They are all assumed to purely consist of pads. • We have no plan to integrate legacy software without a priori wrapping each of them to work as a pad. • Bottom up integration aims to integrate already running systems to work interactively and consistently without changing these systems.

11. The most difficult problem in bottom-up integration is how already existing systems that are distributed across networks can know each other to communicate. • To solve this problem, we introduce a concept of meta-pads. • A meta-pad works as a proxy of some primitive pad, which we call the referent of this meta-pad. • A meta-pad can be sent to any machine different from the machine with its referent.

12. Meta-pads are different from proxy pads. • A proxy pad works for an external object, while a meta-pad works for a remote primitive pad. • A pad may have more than one copy of its meta-pad. • Meta-pads and their referent always know how to access each others even if some of them travel across networks. • Each meta-pad holds the address of its referent pad, while the referent holds an address list of its meta-pads. • Here we classify referent primitive pads into five categories. • They are pad annihilators, pad generators, pad converters, pad gates, and the others. The functions of their meta-pads differ from each other.

13. A meta-pad for a pad annihilator is used to drop a locally available pad onto a remote annihilator pad. • When a pad is dropped on it, the meta-pad transports this pad to its referent annihilator, and drops it there.

15. A meta-pad for a pad generator is used to retrieve a new pad that is popped up on the pad generator at a remote site. • When a pad is popped up on its referent, the meta-pad receives a meta-pad of this newly generated pad and pops it up on itself.

17. A pad converter performs some conversion of pads. It has input-port slots and output-port slots. • Each input-port slot has its corresponding queue buffer. • When it receives a ‘set’ message with some pad as its parameter, an input-port slot adds this pad to the corresponding input queue. • Each output-port slot, when accessed by a ‘gimme’ message, gets the pad stored in the corresponding register, and returns this pad to the message sender; if the corresponding register is empty, this output-port slot returns ‘nil’.

18. A pad converter starts its execution as an independent process whenever the preceding conversion has been completed, and all the new inputs necessary for the new conversion are available in input queues. • For each output slot, this conversion process sets the corresponding register with a new pad, and sends an ‘update’ message to the child pads connected to this slot. • Each conversion is considered to complete when all the output slots have been accessed by ‘gimme’ messages to return new pads to their senders.

19. To input a pad into an input-port slot by a drag-and-drop operation, we need to paste an InputPortPad with its connection to this slot. • Similarly, to pop up a pad in an output-port slot, we need to paste an OutputPortPad with its connection to this slot. • They are respectively an annihilator pad and a generator pad. • Each OutputPortPad, when it receives an ‘update’ message, sends its parent pad a ‘gimme’ message to get the next output pad, and pops this pad on itself.

20. A meta-pad for a pad converter has a subset of those slots in its referent pad converter. • It has input-port slots and output-port slots. • These ports, however, have no queue buffers. • Each of its input-port slots, when receiving a pad or its meta-pad, inputs this pad to the corresponding input-port slot of the referent pad converter. • Every meta-pad that is input to a pad converter autonomously retrieves its referent to replace itself with its referent when required by the pad-conversion processing. • Each of its output-port slots, when accessed by a ‘gimme’ message, sends this message to the corresponding slot of the referent; if the referent returns a pad, this output port slot returns a meta-pad of this read out pad to the message sender; otherwise, it returns ‘nil’. • A meta-pad of a pad converter allows a user to use this pad converter from a remote site.

22. A pad gate works as a queue buffer of pads; it has two modesthe output-enabled mode and the output-disabled mode. • It is a pad with a single input-port slot, a single output-port slot, and a control slot. • Pads are input through the input-port slot, and stored in the queue. • When its queue is empty, a pad gate pad stays in the output-disabled mode. • Otherwise, when a ‘set’ message accesses its control slot, a pad gate changes its mode to the output-enabled mode. • If a ‘gimme’ message accesses its output-port slot during its output-enabled mode, a pad gate outputs the first pad in the queue as the return value, and changes its mode to the output-disabled mode. • If a ‘gimme’ message accesses its output port slot during its output-disabled mode, it returns ‘nil’. • A pad gate pad issues an ‘update’ message to its child pads whenever it changes its mode from the output-disabled mode to the output-enabled mode.

23. A meta-pad for a pad gate has three slots, i.e., an input-port slot, an output-port slot, and a control slot. • It has, however, no queue buffers. • Its input-port slot, when receiving a pad or its meta-pad, inputs this pad to the input-port slot of the referent. • Its output-port slot, when accessed by a ‘gimme’ message, sends this message to the output-port slot of the referent; if the referent returns a pad, this output-port slot returns a meta-pad of this read-out pad to the message sender; otherwise, it returns ‘nil’. • Pad gates convert no input meta-pads to their referents. • They treat their inputs as tokens without referring to the contents. • An access of the control slot of a meta-pad is transferred to its referent pad-gate pad. • A meta-pad of a pad gate allows a user to use this pad gate from a remote site.

25. In addition to the functions described above, every meta-pad has a signal slot and the following functions. • When receiving an ‘update’ message, every meta-pad makes its referent pad invoke the ‘update’ method. • This function is used to detect a local signal and to invoke the ‘update’ procedure of a remote pad. • When its referent pad is updated, every meta-pad changes its signal slot value to ‘true’, and issues both an ‘update’ message and a ‘set’ message with ‘true’ as the parameter. • This function is used to locally detect an update of a remote referent pad. • The signal slot can be reset to ‘false’ by sending a ‘set’ message with ‘false’ as its parameter.

27. For every meta-pad, its copies work for independent copies of the same referent, while its shared copies work for the same referent.

28. Extended Form-Flow System

29. Form-flow model in IntelligentPad • The form-flow model consists of several different kinds of components. • They include forms, form converters, form generators, form annihilators, triggers, distributors, mergers, inspectors, gates, detectors, and flow definitions. • Forms visually represent information. • A single form has an arbitrary number of entry cells. They are arbitrarily arranged on the base sheet of the form. Some entry cells may contain smaller forms. Users cannot change their formats. Some forms, however, may allow users to fill in or rewrite some entry cells.

31. A form converter receives input forms and converts them to a single form or a sequence of forms of the same output format that is different from the input format. • It reads out some entry cells of the input forms to compute each entry cell of the output forms. • A form generator generates a form. It is a special type of form converters. The information necessary to generate a form does not come from any other forms, but it comes from an external system such as a database, an e-mail system, a fax machine, an industrial plant, or a user interaction system. • A form annihilator receives input forms and deletes them from the system; it outputs their contents information to an external system such as a database, an e-mail system, a fax machine, an industrial plant, or a user interaction system.

32. A trigger is a module to generate a control signal that opens or closes a gate to control a form-flow from one module to another. Triggers may be various objects. A system alarm clock, for example, is a trigger that issues a control signal at some specified time and date. • A distributor has a single input port and multiple output ports. Depending on its selector signal, it selects one of its output ports to output the form it receives. A merger merges more than one input flow to a single output flow.

33. An inspector receives each input form and outputs either a control signal or a selector signal whose value depends on whether the input form satisfies the specified condition. Its output signal is used to control a gate or a distributor. • A detector, when receiving an input form, immediately outputs this form, and issues a trigger signal.

34. The IntelligentPad architecture implements these components as composite pads. • A form uses a RecordPad as its base pad. • Entry cells of a form may use various pads including text, numerical, chart, image, sound, and video pads. • They are pasted on a RecordPad to compose a form.

35. A FormConverterPad is a blank-sheet pad with several slots including #conversionFormulae slot, #inputForm slots, #outputForm slots, #inputFormFormat slots, #outputFormFormat slots, and #reset slot. • Its #conversionFormulae slot is used to specify formulas to calculate the output-form entries from the input-form entry values. • Each #inputForm slot is used to input a form to the form converter, while each #outputForm slot is used to output a converted form. • Each #inputFormFormat slot and each #outputFormFormat slot are used to keep pointers to example input and output forms that respectively work as the input and output form templates. • The slot #reset is used to initialize the form converter.

36. ConversionFormulaPads are all connected to the single same #conversionFormulae slot of a FormConverterPad. • Each conversion-formula pad enables us to specify its source pads for each of its input variables, its destination pad for its single output variable, and the formula to compute its output variable value from its input variable values. • Suppose that a ConversionFormulaPad defines a conversion function f(x1,x2, … , xn), and associates each input variable xi with a pad Pi, and its single output variable with P0.

37. This ConversionFormulaPad sends a ‘set’ message to its parent FormConverterPad to add a tuple (f(x1,x2, … , xn), pid(P0), pid(P1), pid(P2), …, pid(Pn)) to the list of tuples stored in #conversionFormulae slot of this parent pad, where pid(P) denotes the pad identifier of a pad P. • Source pads are selected out of the entry-cell pads of the example input forms and other ConversionFormulaPads, while destination pads are selected among the entry-cell pads of the example output forms and other ConversionFormulaPads. • The conversion formula can be input to the formula slot of this pad through a text-input pad connected to this slot.

38. Some ConversionFormulaPads treat aggregate functions. • Such a ConversionFormulaPad receives a set of inputs for specified number of times, and calculates an aggregate function such as summation, average, maximum, and minimum to obtain its output value.

39. Once you have finished with the specification of the input-form formats, output-form format, and all the conversion functions, you may use this form converter to perform the defined form conversion. • Its input-port slots are all provided with associated queue buffers. • The conversion is executed by a dedicated process; it is started, whenever the preceding conversion has been completed, and all the input forms necessary for the next conversion become available in input-port queue buffers.

40. Each input form is first examined if its format matches the example form that the corresponding #inputFormFormat slot points to. • If it fails, this input form is neglected, and the next one in the queue is examined. • Otherwise, the primary slot value of each of its child pads is set to the primary slot of the corresponding child pad of the example form that the corresponding form-format slot points to. • These primary slots are the primary slots for the ‘gimme’ message. Then each function stored in #conversionFormulae slot is applied.

41. A FormConverterPad interprets the list in its #conversionFormulae slot as a data-flow program, and execute this program. • Its execution of an instruction (f(x1,x2, … , xn), pid(P0), pid(P1), pid(P2), …, pid(Pn)) reads, from each source pad, its primary slot for the ‘gimme’ message, use these values to compute the function value, and sends this value to the destination pad through its primary slot for the ‘set’ message. • Let a terminal pad in such a data-flow program denote a pad that appear as an output destination of some instruction, but never as an input source of any instruction. • When all the terminal pads are set with new values, a FormConverterPad makes a copy of the form pointed to by #outputFormFormat slot, then stores this pad into #outputForm slot, and issues an ‘update’ message to its child pads.

42. When its #outputForm slot is accessed by a ‘gimme’ message, and returns a converted form, this FormConverterPad completes a conversion. • If an OutputPortPad is connected to this slot, it then issues a ‘gimme’ message to get the form in #outputForm slot, and to pop up this form on itself. • Some form converter may require more than one input forms coming through the same input port to complete a conversion. • Some others may generate more than one output forms of the same format in a single conversion process.

43. The next figure shows a form converter with one form input and one form output. • This converter outputs a single form as a summary for every consecutive five input forms. • The left ConversionFormulaPad reads two cells of each input form, multiplies these two, and output the product. • The right ConversionFormulaPad receives this product, add this to its current sum, and outputs this sum for every five consecutive inputs. • This sum is reset to zero after every output. • Whenever the summation function outputs a new value to a cell of the output-form template, this template with this value is copied and stored in the #outputForm slot as a new output form.

45. As trigger components, IntelligentPad provides various trigger-signal generators. • They include alarm-clock pads and interval-timer pads. • A gate pad can be used as a FIFO queue of forms; its control signal is used to enable a single output from this queue.

46. A FlowDefinitionPad works as a circuit board on which various tool pads are connected with each other. • It allows us to draw a cable from a primitive pad P1 of one composite tool pad on itself to a primitive pad P2 of another composite tool pad on itself. • This wiring adds a tuple (P2, P1) to the list stored in the FlowDefinitionPad.

47. For each tuple (Pi, Pj) in this list, a FlowDefinitionPad sends a ‘gimme’ message to Pj to read its primary slot for the ‘gimme’ message whenever Pj issues an ‘update’ message. • This FlowDefinitionPad then sends a ‘set’ message to Pi to write this read out value to its primary slot for the ‘set’ message. • The tool pads include form converters, queue buffers, distributors, mergers, and detectors. • These composite tool pads respectively use FormConverterPads, PadQueuePads, PadDistributorPads, MergerPads, and PadDetectorPads as their base pads.

49. A PadQueuePad has #input slot, #output slot, and #outputRequest slot, and works as a queue buffer. • When a pad is input to #input slot, it is added to the end of the pad queue in the buffer. • When a request signal is input to #outputRequest slot, a PadQueuePad outputs the first pad in its pad queue to its #output slot. If it has no pad to output, it will immediately output the next input pad when it comes. • A PadQueuePad issues an ‘update’ message whenever its #output slot is updated. • A PadQueuePad implements a gate that opens/closes the output gate of a queue buffer depending on its control signal.

50. A PadDistributorPad has #input slot, several output slots, and #selector slot. • It has also an input queue, not only for #input slot, but also for #selector slot. • When a pad is input through its #input slot, it is added to the pad queue. • When a selector number is input to #selector slot, it is added to the selector queue. • If the selector queue is not empty, a PadDistributorPad outputs the first pad in the pad queue to the output slot that is selected by the first selector in the selector queue. • If a PadDistributorPad has no pad to output, it will immediately output the next input pad to the next selected output slot when a new pad is input to the pad queue. • A PadDistributorPad issues an ‘update’ message whenever one of its output slots is updated.