Detecting anomalous artifact operations in workflows at design time is essential for preventing errors and unexpected behavior during execution. Workflow designers aim to maximize concurrency to enhance efficiency and quality. However, concurrent operations on shared artifacts, such as simultaneous read and write, can lead to anomalies like race conditions that compromise artifact integrity. Existing methods are often limited in their ability to detect such anomalies due to inaccurate anomaly definitions and inefficiencies caused by high space complexity. In this work, we introduce an approach to effectively detect concurrent anomalies leveraging the SP-tree, a tree-like structure that captures both control flow and artifact operations in workflows. We redefine concurrent anomalous behaviors based on the SP-tree framework and develop efficient algorithms to identify these anomalies. Our method operates in two stages: (1) transforming the workflow into an SP-tree and (2) analyzing the SP-tree using our anomaly detection algorithms. Compared with existing techniques, our approach detects all artifact anomalies, reduces time complexity, and simplifies the anomaly detection process. By adopting our approach, workflow designers can more accurately identify concurrent artifact anomalies, reducing the risk of runtime errors and improving the overall reliability of the workflow.

Microservice-Based Workflows (MBWs) are used popularly to govern the composition and coordination of individual microservices to realize business processes. With MBWs, designers often aim to maximize concurrency to increase the chances of successful workflow collaboration and enhance business process efficiency. However, operations involving manipulating and accessing artifacts (data objects) within these workflows may introduce anomalies leading to unexpected artifact states. In workflow design phase, seeking bug-free artifact states is vital to help prevent crashes, errors, and unexpected outcomes during execution. Concurrent artifact anomalies are referred to abnormal parallel operations on the same artifact. Few studies have explored the detection of concurrent anomalies in MBWs, and they are inefficient and ineffective as they struggle with high time complexity and are insensitive to the presence of nested AND gateways. This paper focuses on improving microservices workflows reliability by detecting concurrent anomalies in artifacts during the design. We present a series of methods to detect the anomalies based on SP-tree, a tree structure to record workflow paths and artifact information. Our methods outperform existing ones by detecting more anomalies with lower time and space complexity.

During the design phase of a workflow process, detecting anomalous operations on artifacts is important for preventing errors and unexpected behaviors of the process dynamically. For temporal structured workflows (TSWs), which involve specifying the min and max execution time intervals for each activity, there are few studies on analyzing artifact anomalies compared to non-temporal workflows. Additionally, the existing approaches designed for TSWs are inaccurate in detecting these anomalies either. To improve the analysis of TSWs, this paper presents an improved methodology based on an extended SP-tree structure, called TSP-tree. Our approach involves two steps: first, transforming a TSW into a TSP-tree, and then applying several algorithms to TSP-tree to detect artifact anomalies. Compared to previous methods, our approach provides lower time complexity for detection, simplifies the analysis, and detects more artifact anomalies

With the advent of the Service Oriented Architecture (SOA) in system design, various domain knowledges are included in a service-based application, such as the design of Artificial Intelligence (AI) or augmented reality (AR) systems. While merging one or multiple domains into computation systems, the computation systems can be widely applied in various domain usages with novelty, useful, and surprising properties, which are defined as systems of creative computing. In creative computing, several theoretical evaluation metrics and verification approaches have been proposed for system design in several domains. However, a solid practical design environment for creative service-based systems is rarely considered in current researches. In this paper, we propose a model for creative service software development based on semantic web, which is applied in two phases: (1) requirement specification and (2) service design. In order to bridge the knowledge gap between domain experts and software engineers, and provide a machine-readable format for creative computing, two sub-models, Requirement Specification and Service Structure Models, are constructed in both phases, sequentially. After the latter sub-model is validated, the creative service software is well-constructed based on the services definition and composition represented by the model.

Workflow management systems (WfMS) are considered as accomplish platforms which can provide structured organization in business process and service architecture design. The systems contain workflow models in foundation, which provide flow control in one or more task sequences in parallel. Manipulation and access of artifacts that occur in or between the task sequences can generate unexpected state of artifacts by inappropriate workflow design. The artifact anomalies in a workflow model are classified into two categories, which are types of continuous and concurrent anomalies. A continuous anomaly occurs while an artifact is written redundantly or accessed before production. On the other hand, a concurrent anomaly can occur while an artifact is conflict written in parallel in a workflow model. There are several methods presented for anomaly analysis, however, these methods cannot detect all anomalies due to their definitions and they are either inefficient or lack of proof for the correctness. In this article, we present improved detection methods with an improved C-tree structure, called SP-tree. Based on an updated anomaly definition, our anomaly detection includes two stages: 1) the transformation algorithm generates an equivalent SP-tree from a given structured workflow model; and 2) based on the generated equivalent SP-tree, a series of methods are applied to detect anomalies.

The microservice architecture is a Service-Oriented Architecture (SOA) where a service-based application can be composed of a number of smaller but independently concurrent running units, called microservices, to improve the performance and maintainability of the application. In an application with microservice architecture, an unexpected artifact state(s) inside a microservice may be exchanged to another microservice or other service units and corrupt the whole system of the application. On the other hand, the abnormal artifact operation pairs can be categorized into continuous and concurrent artifact anomalies which indicate that two sequential and parallel operations working on the same artifact resulting in abnormal behavior semantically. The recent studies showed that an SP-tree structure adopted in the detections of both anomalies inside a structured workflow can reduce the computation complexity of detection as linear. In this paper, we present a series of methods based on SP-tree to detect the artifact anomalies inside each microservice of the application during the design phase. Different from the design of applications with traditional services, where each service is assumed to contain all possible types of anomalies and cannot be modified directly, the designer of microservice is concerned with the limited scope and can modify each microservice based on the anomaly detection results. Our contribution includes identifying the artifact properties in a microservice architecture and the methods to detect the anomalies based on these properties which can simplify the detection of artifact anomaly in service-based applications.

Workflow models are widely applied in business software design. A workflow model contains a set of systematic ordered tasks to achieve designated business goal(s) under the designed flow control. Analyzing artifact usage during design phase can prevent unexpected artifact result due to abnormal artifact operation(s). A sequential anomaly indicates a pair of activities operating on the same artifact that can result in redundant write or missing production. On the other hand, the iteration of a loop structure in a workflow cannot be statically analyzed, thus, detecting process of artifact anomalies in a loop is costly. In this paper, we present an effective method to detect all anomalies associated with a loop by removing the redundant computation due to the repeated structure of the body and control in the iterations. After the removing, the anomalies can be detected on a single iteration generated instead. Here, the process of anomaly detection is now simplified into two phases: First, a workflow model is transformed into a corresponding C-tree structure and next, the proposed anomaly detection methodology is applied to the C-tree. Compared with current approaches, our method can reduce the space complexity and decrease the execution times of anomaly detection as linear.

The microservice architecture is a variation of a Service-Oriented Architecture (SOA) that allows a service to be broken down into a number of smaller but independently concurrent running units so that both performance and maintainability of the application can get a big improvement. In this paper, we introduce an approach to constructing a software with layered and distributed microservices using object-oriented specifications. The proposed approach could increase the concurrency of the application system and thus improve the performance and could increase the reusability of microservices.

To guarantee the correctness of workflow execution, it is essential to analyze the structural and artifact integrity of workflows. The current best approach of artifact workflow anomaly detection is O(|E|) for structured workflows, however, each of the anomalies returned in the approach contains (artifact, operator) at each workflow node. In this paper, we present an innovative methodology which contains the following two characteristics: 1) A C-Tree (defined in Section 3) structure which separates sequential and parallel issues in workflow analysis and increases the convenience and elegancy of anomaly detection; and 2) A loop-reduction method which helps lower the size of nodes to be analyzed while not losing the abilities of detecting anomalies within workflow models. The anomaly detection is done by 1) transforming the BPMN into the C-Tree, 2) and detecting the anomaly in the C-tree. Compared with current best approach, 1) Our method can show the first operator and its location of an anomaly detected directly, although it cannot speed up the execution time, 2) The execution times of anomaly detection inside loop is decreased, and 3) Our method can detect concurrent (parallel) workflow anomaly based on C-Tree.

Along with the growing attention, cloud computing is not only changing the computing paradigm, but also the style of computing in which dynamically scalable and virtualized resources are provided as services over the Internet. Cloud computing introduces a lot of chances, as well as, challenges in the new trend. Taiwan has been well known as a major Information Communication Technology (ICT) manufacturing traditionally. Many Taiwan's hardware products have been top ranked in the global market. Taiwan has realized the trend that Cloud Computing is leading to and has reacted to integrate its resources from the government, industry, academia, and research centers, by initiating strong incentive programs for cloud computing, with an intension to transform an ICT Island into a Cloud Village. In this article, we describe the status of the development of cloud computing technologies and its future challenges for Taiwan.

Pervasive applications, like smart living, geriatrics care, agricultural development, etc, are rapidly developed recently. Situation-awareness and workflow-centric are important characteristics of the applications. Service-oriented architecture which provides flexibility in integrating heterogeneous devices and communication networks might improve the execution of pervasive applications. To integrate these techniques, we present an application model composed of a situation model, workflows, and required services for development of pervasive applications. A service-based framework supporting situation-awareness and workflow management is sketched to support execution of pervasive applications. This paper also presents the framework and its pervasive applications development. Finally, a case study is used for demonstration.

Workflow is a set of tasks which are systematized to achieve certain business goal(s), where the tasks run in a particular order under automatic control. Artifacts, collections of data items, are necessary for task (process) executions in a workflow. However, an execution may yield unexpected results due to improper artifact manipulation: e.g., activities miss artifact or artifact conflict occur at an activity dynamically. Therefore, the analyses on artifact usage in design phase are very important for quality insurance. This paper presents a model of artifact flow diagrams to state the artifact usage anomalies in processes transmitting artifacts based on DCDC, distinct control and data channel, model. There are four types of artifact usage anomalies identified in DCDC and the formal statement of each anomaly is described correspondingly for future study of anomaly search.

We propose in this paper a design of the proxy supporting nearest-neighbor queries. We also propose several algorithms to create and extend estimate valid regions. An estimate valid regions degradation algorithm and a cache replacement policy are proposed to reclaim cache space when the cache space is insufficient. To evaluate the performance of the proposed architecture and algorithms, several experiments are conducted. The experimental results show that the our design and algorithms are able to improve proxy hit rate and reduce average waiting time.

Most workflow management systems nowadays are based on centralized client/server architecture. Under this architecture, the response time of request might increase unacceptably when the number of users who login to the system increase quickly and a large amount of requests are sent to the centralized server within a short time period. Parallel server architecture could help to resolve the performance bottleneck of a single server. However, a static parallel architecture with a fixed number of servers is not efficient at resource utilization because the numbers of users and their requests usually change time by time, especially for big and fast changes. This paper presents an effective architecture of dynamic resource-provisioning and then the implementation for a parallel workflow management system. There are a series of experiments conducted and the results indicate that it is an effective approach to handling the time-varying workloads in real world WfMS.

Agile methods have become a hot-spot in contemporary research and practice on software engineering. There are numerous successful and classic cases for applying agile methods. However, software processes must adapt to the characteristics of projects, people and organizations. Since each software project is unique, we can hardly define a series of universal and repeatable processes for all agile projects. A pattern is a general solution to a common problem or issue, one from which a specific solution may be derived. This paper introduces concept of pattern into software process and organizes experience proved to be effective in agile methods as a group of patterns. Based on this group of process patterns, we propose a process pattern language PPL for agile methods. Any agile project can find a series of process patterns from PPL according to its characteristics, and generate an appropriate process by following instructions from these patterns. We also give an example of applying this pattern language to generate software processes.

Use cases have been applied to describe how a web service will is used. Use cases can be categorized into classes of usage scenarios, which are often then defined as sequences of actions for accomplishing specific tasks. Neither use case nor scenario is not object-oriented (OO). For a web service to be implemented with OO programming technique(s), adopting object concept to system specifications from the scenarios can reduce the experience dependency on platforms transition. The paper proposes a model, named object oriented Petri nets with modularity (OOMPNets), which introduces colored Petri nets into OO techniques. Based on the scenario, OOMPNets can be allowed to describe objects incrementally. Besides, the analysis techniques based on colored Petri nets can be applied for that of OOMPNets to reduce the effects of specification errors.

There are many works done and successful results for workflow, but few researchers work in artifact analysis. A workflow execution may fail because of incorrect structures, or resource conflict. It might also fail due to inaccurate artifact manipulation e.g., inconsistency between data flow and control flow, contradictions between artifact operations..., etc. This paper identifies six types of artifact inaccuracy impacting on workflow execution. Moreover, algorithms to detecting artifact inaccuracies in workflow specifications are demonstrated

Summary form only given. Workflow management systems (WfMSs) are usually designed to run with the workflow (process) definitions and artifact definitions from repository. The static characteristics for process definitions might reduce the practicability of the systems. The cost to develop a WfMS is so high that it is reasonable to take the flexibility of system architecture into account. In this paper, we present an approach to adapt to dynamic changes on workflow definitions with agents. In our agent-based workflow system, the definition of a workflow can be modified by the agent itself. Therefore, agents can modify their guidance for workers, and the system is more flexible to meet the specification modification.

Workflow management technology helps modulizing and controlling complex business processes within an enterprise. Generally speaking, a workflow management system (WfMS) is composed of two primary components, a design environment and a run-time system. Structural, timing and resource verifications of a workflow specification are required to help assure the correctness of the specified system. In this paper, we address an incremental methodology to analyze resource consistency and timing constraints after each editing activity of a workflow specification and to provide proper feedbacks to designer or maintainer of the workflow specification.

BDI is one of the models in agent systems. Currently; most of BDI agents' researches are focused on the ability for agents to dynamically select plans to achieve a goal. There are fewer discussions on intention scheduling, the order in which the selected plans are executed. Agents must adapt to dynamical and unpredictable changes. Without a proper scheduling scheme, an agent may repeat unnecessary works, waste valuable resource or even fail the users' expect altogether. In this paper, we present an effective intention-scheduling scheme in BDI reasoning process.

Workflow management systems (WfMSs) are accepted worldwide due to their capability to model and control business processes. With WfMS, enterprises can improve work efficiency and react to the emergent situation quickly. However, most WfMSs adopt the centralized architecture in an organization so that they usually lack of a cooperative communication mechanism across different organizations. In this paper, we propose a cooperative framework for inter-organizational workflow systems. The framework consists of an inter-workflow meta-model, CA-PLAN (Cooperative Agentflow Process LANguage), and a prototype system based on Agentflow, a system developed in our laboratory. The cooperation mechanism between WfMSs in CA-PLAN is modeled as a Remote Call Process (RCP) paradigm. A process service is a mechanism that defines a process to participate in an inter-organizational process among different WfMSs and specifies the associated arguments in and out. A remote process is a proxy mechanism that refers to a process service on another WfMS. RCP provides the mechanism by which the process service and the remote process communicate and pass information back and forth and process monitor mechanism. The mechanism, also allowing dynamic changes and reconfiguration, can adapt dynamic and competitive business environment. Through RCP, the cooperative process across organizations becomes simple, faster, and flexible.

A workflow system provides enterprises with automatic and paperless process management. The idea of Enterprise JavaBeans (EJB) is to utilize components from various vendors to construct an application which has the characteristics of scalability, security, distributed, and fast development. An EJB module and enterprise beans are implemented. A workflow designer may use this module to invoke the business methods defined in the enterprise bean on the outer application server. The EJB module may facilitate component development of a workflow system, and reuse existing components to fulfill the function needed.

Business processes are often complex and varying. Workflow technologies help people minimize errors and delays in the progress of a process within an enterprise. Within a workflow management system (WFMS), a process or even a project can be specified and interpreted to work directly. In this paper, we present an editing system and its two major components, PDE (Process Definition Editor) and FormDesigner, for the specification of a process. PDE is a graphical editor for constructing /modifying process definitions. FormDesigner assumes the responsibility of integrating software components for building/modifying active application forms. With PDE and FormDesigner, a workflow application system can be constructed/modified rapidly and easily so that the WFMS is allowed to run smoothly.

In this paper, a model called object-oriented attribute grammar (OOAG), which combines both compositional and generative techniques, is presented to effectively construct flow-based tools that deal with fine-grained language semantics as well as a mass of graphics-drawing activities. OOAG, which consists of two interrelated parts: a model-view-shape (MVS) class framework and an AG++, an object-oriented extension to traditional AGs, is intended to preserve both advantages introduced by respective OO and AG models, such as rapid prototyping, reusability, extensibility, incrementality, and applicability. So far, a flow-based editor associated with two flow-analyzer prototypes, DU/UD tools and a program slicer, have been implemented using OOAG on the Windows environment. Our flow-based editor can be used to construct programs by specifying the associated flow information in a visual way, while (incremental) flow analyzers incorporated into the editor can help analyze incomplete program fragments to locate and inform the user of possible errors or anomalies during programming.

The flexibility and rich application frameworks of the Web model make Web applications more prevalent in both Internet and intranet environments. Programmers enjoy various Web application frameworks with support ranging from simple user interactions based on the plain client-server model, to complicated distributed-object computations based on CORBA. The variety gives users the flexibility to decide a proper framework, and leads to demands for new support tools and a testing framework to test and maintain Web applications. This paper presents an architecture containing several supporting tools which enhance traditional software testing architecture to fit common Web application frameworks. The architecture suits current Web models and reuses several software patterns and architectures from traditional testing environments. In addition, a prototype Web application testing environment is constructed for demonstration.

Web database application programs may consist of hundreds of files. The interoperations among these files could be complex, and most of them are lack of design documents. When a programmer maintains (changes) some programs of an application, the program files affected by the changes need be updated simultaneously to keep the functional consistency. One major difficulty of maintenance is how to identify these affected parts, especially in Web database applications. In this paper, we present a model, called HED model, for the maintenance of Web database applications. HED model decomposes a Web database application into three diagrams, hyperlink diagrams, entity-relationship diagrams, and data-flow diagrams, which are used to represent different aspects of a Web database application. Based on the HED model, the programs files affected by a program change can be identified precisely via the structure and database analyses. In addition, a maintenance tool is implemented to demonstrate the capability of the HED model.

This paper presents a model called object-oriented attribute grammar (OOAG) that can be used to construct a toolset for software maintenance. The kernel of OOAG consists of two inter-related parts: a model-view-shape (MVS) application framework and an AG++, an object-oriented extension to traditional AGs. By combining compositional and generative techniques seamlessly, OOAG preserves both advantages introduced by respective OO and AG models, such as rapid prototyping, reusability, extensibility, and incrementality. So far, a toolset prototype consisting of a number of programming and maintenance tools were implemented using OOAG on the Windows environment. The editors developed can be used to construct programs by specifying the associated flow information in explicit (visual) or implicit (textual) ways, while the (incremental) maintenance tools, such as DU/UD tools and a program slicer, can help analyze incomplete program fragments to locate and inform the user of useful information.

Software systems are growing larger and more complex. The development of a large-scale software system usually requires the collaboration of multiple developers. This paper addresses several desirable features of a practical multi-user, visual object-oriented programming environment (mVOOPE), whose constituent components may be distributed over a long distance, unreliable communication environment such as the Internet. By incorporating three design rationales, more local processing, compact remote communication, and multithreaded collaboration, our mVOOPE makes a trade-off between performance and consistency requirements. The mVOOPE provides programming support with two aspects: visual programming for object-oriented languages and collaborative programming for incremental software development. So far a window-based environment prototype, developed with Visual C++, executes on multiple PCs connected by the network.

This paper presents an object-oriented architecture, called the Model-View-Shape (MVS) architecture, for constructing an Integrated Visual Programming Environment (IVPE), whose constituent tools deal with (fine-grained) language semantics, as well as a mass of graphics-drawing activities. This architecture enforces a layered and loosely-coupled structure, so that the user-interface part of components may be more independent, maintainable, and reusable than those proposed in the original model-view-controller architecture. An MVS class hierarchy, systematically constructed using C++, can be reused and extended with new semantics to rapidly develop new tools for an existing IVPE, or even an IVPE supporting more than one language. The present editors developed can be used to construct programs by specifying the associated flow information in explicit (visual) or implicit (textual) ways, while the (incremental) flow analysers can help analyse incomplete program fragments to locate and inform the user of possible errors or anomalies during programming. © 1998 John Wiley & Sons, Ltd.

Software reuse is an effective way to improve software productivity and quality. Software libraries are getting bigger, while most of them, such as those for object-oriented languages, use simple but somewhat ineffective classification methods. These libraries typically provide search aids for novices, but not for experts. They are not flexible enough to adequately serve users with different abilities. In this paper, a Software Reuse Framework (SRF) for overcoming these drawbacks is proposed. Based on a built-in hierarchical thesaurus, the classification process can be made semi-automatic. SRF is a domain-independent framework that can be adapted to various libraries. SRF also provides four search levels to serve users with different skill levels. Two sample SRF systems are implemented, one for Smalltalk-80 and the other for MFC 4.0 (Microsoft® Foundation Class) libraries. © 1998 John Wiley & Sons, Ltd.

Program slicing has various applications in the fields of software engineering. The object-oriented (OO) paradigm introduces the features of abstraction, encapsulation, inheritance and polymorphism to programs, but is not considered in current program slicing techniques. In this paper, we define two types of program slices, state and behavior slices, by taking the dependencies of OO features into consideration. A state slice for an object is a set of messages and control statements that might affect the state of the object, while a behavior slice is a set of attributes and methods defined in related classes that might affect the behavior of the object. These slices may facilitate programmers to debug and understand OO software. The algorithms developed to compute these slices that are based on an OO dependency graph can obtain more precise results by exploring the internal dependencies of complex objects.

Software reuse is an effective way to improve software productivity and quality. Software libraries are getting bigger, while most of them, such as those of object oriented languages, use a simple but somewhat ineffective classification method. These libraries usually provide search aids for novices but not experts. They are not flexible enough to serve users at different levels of familiarity with libraries. We propose a software reuse framework (SRF) for overcoming the above drawbacks. Based on a built-in hierarchical thesaurus, its classification process may be made semi-automatic. SRF is a domain independent framework that can be adapted to various libraries and also provides four search levels to serve users with different levels of familiarity with libraries.

The Internet File System (IFS) extends the scope of file systems from LANs to the Internet, encouraging collaboration and information dissemination on a much broader scale. In addition, Internet resources (e.g. Web pages, Gopher Information, and Network News) become files in IFS, allowing file system APIs and existing tools and commands to be used to manipulate Internet resources just like conventional files. IFS is unique in that it introduces a logical layer between applications and operating systems, and integrates widely-used protocols like FTP, HTTP, GOPHER, NNTP, RSH in this layer. The system is transparent to applications and operating systems, and requires no modification of software nor change in management of Internet file servers. A prototype of IFS is currently running on Sun OS 4.1, Solaris, HP-UX, SVR4, SGI MIPS, and Linux.

A good process management system helps the project members develop software projects. This paper introduces a Software Process Engineering Environment, SPEE. In SPEE, the process designer designs the process definition and project plan in a Process LANguage, PLAN, under a Process Definition Editor, PDE. A software project is developed on a Process Aided Software process enactment Environment, PASE. PASE provides development guidance, activity enforcement, process automation, tool invocations, and execution feedback for process enactment. SPEE, composed on PDE, PLAN, and PASE, provides helps from the plan to the end of a software project.

The efficiency of object-oriented programs has become a point of great interest. One necessary factor for program efficiency is the optimization techniques involved. This paper presents the performance of several variations of a given C++ program and compares them with a version that uses no object-oriented features. Our result indicates that some object-oriented features in C++ are not well optimized in current C++ compilers. We thus discuss some code optimization techniques that can improve the efficiency based on the given C++ program.

Parallel BLAS libraries have recently shown promise as a means of taking advantage of parallel computing in solving scientific problems. However, little work has been done on providing such a parallel library in LAN-connected workstations. Our motivation for this research lies in the strong belief that since LAN-connected workstations are highly cost-effective, it is important to study the issues in such environments. Dynamic load balancing is a method that allows parallel programs to run efficiently in LAN-connected workstations. Introducing dynamic load balancing leads to new design concerns for data distribution, sequential implementation, and library interfaces. Through a series of experiments, we investigate the influence of these factors. We also propose a set of guidelines for developing an efficient parallel Level 3 BLAS library.>

Although the circularity test problem for attribute grammars (AGs) has been proven to be intrinsically exponential, to date, a worst case for the existing circularity test algorithms has yet to be presented. This note presents a worst-case AG in which the number of incomparable dependency graphs induced at the root is exponential. The worst case can help to clarify the complexity of the problem.

An efficient distributed object-oriented computation model based on the process-object model is presented. The model uses remote processes, instead of remote objects, to handle the communications among nodes, where explicit message passings among processes are used to reduce the communication overhead (times) in remote-object models. A remote process object can be forked easily and efficiently to execute a sequence of statements specified locally, and distributed garbage collection is not necessary. The system can be further enhanced in the following areas: (1) concurrency control, (2) protection mechanism, (3) high layer distributed system services, and (4) real-time system support.>

A tool that provides a generic interface window to help users to construct new window types or modify existing window types (e.g. add subviews or extend their functionalities) is presented. The interface window allows the users to specify the configuration and the attributes of a window interactively and permits users to test its functionality by manipulating it directly. It relieves the users from the burden of thinking about the windowing details at the construction or modification of a window. It further encourages the exploration of more design alternatives for windows so that users can prototype and evaluate various window configurations easily to determine the one that will be adapted into the application. With this tool, the construction of new window types and the modification of existing window types become easy and flexible. The windows evolved in such a programming environment can thus be experimented with and tailored to suit the needs of the user.>