Speculative execution attacks exploit incorrect speculation to execute malicious instructions and leak data via microarchitectural covert channels. Existing mitigations focus on restricting transmission-related instructions related to covert channels. In this paper, we propose the Execute on Clear (EoC), which offers an efficient defense strategy against covert channels in speculative execution attacks. EoC employs a two-stage identification method, which precisely identifies malicious transmission-related instructions by considering both the insecure data dependency and the status of microarchitecture components exploited by the attack. Moreover, with identification results, EoC guarantees the safe execution of transmission-related instructions, preventing unnecessary blocking. By reducing the misidentification and the blocked execution of such instructions, EoC avoids unnecessary maintenance operations and reduces performance overheads. We evaluate EoC on SPEC2006 and PARSEC3.0 workloads, revealing a performance overhead of merely 0.98% and 3.29% in the Spectre and Futuristic defense models, respectively. Notably, EoC exhibits lower performance overhead in comparison to existing methods.

In recent years, speculative execution attacks bring severe threats to hardware security. An attacker tempts the victim process to read secret data during speculative execution and recovers it via micro-architectural covert channels. Most defense strategies in the literature adopt a blocking approach, in which the execution of malicious speculative instructions is withheld until they become safe and, thus, excessive performance overhead is inevitable. Although several non-blocking approaches have also been proposed, extra hardware components are introduced to buffer data of speculative cache accesses, bringing on significant hardware costs. In this paper, we propose the Secure Access Policy (SAP) to enable the non-blocking execution of malicious speculative instructions in an isolated environment, which reuses the existing Line Fill Buffer and Translation Lookaside Buffer, without introducing any new hardware component. The isolated environment, named Safe Shelter area (SS area), maintains the data accessed by malicious speculative instructions and those data cannot be transmitted to the outside. An improved taint tracking technique is introduced to effectively reduce the number of accesses to the SS area. In addition, an extended cache coherence mechanism and a process-bound technique are also proposed to guarantee the validity and security of SS area’s data. We evaluate SAP on SPEC2006 and PARSEC3.0 workloads. The evaluation results show that SAP can effectively defend those attacks leveraging speculative executions and cache covert channels, and outperforms existing approaches in performance overhead, 2.35% and 3.21% in the Spectre and Futuristic defense models, respectively.

To learn complex memory access patterns effectively, many spatial data prefetchers have been proposed that characterize the patterns as fixed-length delta sequences. However, because complex patterns are variable in workloads, it is difficult for fixed-length delta sequences to recognize them with both high competitive coverage and accuracy. That is, longer delta sequences increase accuracy at a lower probability of pattern matching, while shorter delta sequences increase coverage at a higher probability of false predictions. A classical strategy is to introduce the multiple matching mechanism associated with variable-length delta sequences, but sequences have to be redundantly stored in multiple tables.

As a promising alternative to centralized scheduling, sample-based scheduling is especially suitable for high fan-out workloads that contain a large number of interactive jobs. Compared to centralized schedulers, existing sample-based schedulers do not hold a global view of the cluster's resource status. Instead, the scheduling decisions are made solely based on the status of a small set of randomly sampled workers. Although this simple approach is highly efficient in large clusters, the lack of global knowledge of the cluster can lead to sub-optimal task placement decisions and difficulties in enforcing global scheduling policies. In this paper, we address these challenges in existing sample-based scheduling approaches by allowing the scheduler to maintain an approximate version of the global resource status through caching the worker node's status extracted from reply messages. More specifically, we introduce the private cluster-state technique (PCS) for the scheduler to obtain such global information. We show that the scheduler can make better scheduling decisions by utilizing PCS and the scheduler can become more capable in enforcing global scheduling policies. The use of PCS is of low cost since it does not initiate new communication in sample-based scheduling. Our approach is implemented in PSCSampler, a full distribute sample-based scheduler, which gains global knowledge from PCS. Experiment results from both simulation runs and Amazon cluster runs show that compared to Sparrow, PCSsampler can significantly reduce both 50thpercentile and 90thpercentile runtime. The firsttime success rate of PCSsampler in gang scheduling is closer to an omniscient centralized scheduler than baseline sample based scheduler.

Crowdsourced testing is an emerging trend in software testing, which relies on crowd workers to accomplish test tasks. Due to the cost constraint, a test task usually involves a limited number of crowd workers. Furthermore, more workers does not necessarily result in detecting more bugs. Different workers, who may have different testing experience and expertise, may make much differences in the test outcomes. For example, some inappropriate workers may miss true bug, introduce false bugs or report duplicated bugs, which decreases the test quality. In current practice, a test task is usually dispatched in a random manner, and the quality of testing cannot be guaranteed. Therefore, it is important to select an appropriate subset of workers to perform a test task to ensure high bug detection rate. This paper introduces ExReDiv, a novel hybrid approach to select a set of workers for a test task. It consists of three key strategies: the experience strategy selects experienced workers, the relevance strategy selects workers with expertise relevant to the given test task, the diversity strategy selects diverse workers to avoid detecting duplicated bugs. We evaluate ExReDiv based on 42 test tasks from one of the largest crowdsourced testing platforms in China, and the experimental results show its effectiveness.

Mobile app testing is challenging since each test needs to be executed in a variety of operating contexts including heterogeneous devices, various wireless networks and different locations. Crowdsourcing enables a mobile app test to be distributed as a crowdsourced task to leverage crowd workers to accomplish the test. However, high test quality and expected test context coverage are difficult to achieve in crowdsourced testing. Upon distributing a test task, mobile app providers neither know who to participate nor predict whether all the expected test contexts can be covered in the task. To address this problem, we put forward a novel research problem called Crowdsourced Testing Quality Maximization Under Context Coverage Constraint (Cocoon). Given a mobile app test task, our objective is to recommend a set of workers, from available crowd workers, such that the expected test context coverage and a high test quality can be achieved. We prove that the Cocoon problem is NP-Complete and then introduce two greedy approaches. Based on a real dataset from the largest Chinese crowdsourced testing platform, our evaluation shows the effectiveness and efficiency of the two approaches, which can be potentially used as online services in practice.

Crowdsourced testing is an emerging trend in software testing, which relies on crowd workers to accomplish test tasks.Typically, a crowdsourced testing task aims to detect as many bugs as possible within a limited budget.For a specific test task, not all crowd workers are qualified to perform it, and different test tasks require crowd workers to have different experiences, domain knowledge, etc. Inappropriate workers may miss true bugs, introduce false bugs, or report duplicated bugs, which could not only decrease the quality of test outcomes, but also increase the cost of hiring workers.Thus, how to select the appropriate crowd workers for specific test tasks is a challenge in crowdsourced testing.This paper proposes a Multi-Objective crowd wOrker SElection approach (MOOSE), which includes three objectives: maximizing the coverage of test requirement, minimizing the cost, and maximizing bug-detection experience of the selected crowd workers.Specifically, MOOSE leverages NSGA-II, a widely used multi-objective evolutionary algorithm, to optimize the three objectives when selecting workers.We evaluate MOOSE on 42 test tasks (involve 844 crowd workers and 3,984 test reports) from one of the largest crowdsourced testing platforms in China, and the experimental results show MOOSE could improve the best baseline by 17% on average in bug detection rate.

Sample-based scheduler design has become an emerging research topic for its high scalability and simple scheduling process in today's big data cluster.One major limitation of such design is its lack of global cluster knowledge, which leads to sub-optimal decisions.Some cutting edge schedulers solve this issue by deploying an extra centralized component in the cluster to capture the real-time cluster state and inform all schedulers.However, such solution is with high cost and low scalability.As an alternative, we introduce the Collaborated-Cluster State(CCS) technique in this paper.CCS is a low cost solution that merely harms the scalability of sample-based design, while achieving similar performance gain as ECC.Experiments with Google and Yahoo production trace both show that CCS under most scenarios can keep up with ECC's performance while reducing 87.7% (in Google trace) and 73.9% (in Yahoo trace) of communications.

Sample based distributed scheduling methods have been shown to be promising lower overhead alternatives to their centralized counterparts. These methods can make fast decisions based on information gathered from just a small number of worker nodes instead of the whole cluster. Most recent works in the field tend to adopt a combination of probe actions and worker-end queues in their design. However, as individual worker nodes are becoming increasingly powerful thanks to the rapid hardware evolution, we argue that one-node sampling is now a viable choice. Specifically, we show that it is now possible to achieve even lower scheduling latency by latency by abolishing probes and worker-end queues altogether. With this insight, we introduce Tiresias, a low overhead distributed scheduler based on one-node sampling and a novel task hopping mechanism. Comparing to Sparrow's approach, experiment on Google trace shows Tiresias could reduce 20% and 60% of Sparrow's 50th percentile and 90th percentile job runtime, respectively. In addition, our experiment also shows Tiresias is especially effective in reducing the delay of small jobs in non-highly loaded clusters.

Background: Links between issue reports and their fixing commits play an important role in software maintenance. Such link data are often missing in practice and many approaches have been proposed in order to recover them automatically. Most of existing approaches focus on comparing log messages and source code files in commits with issues reports. Besides the two kinds of data in commits, non-source documents (NSDs) such as change logs usually record the fixing activities and sometimes share similar texts as those in issue reports. However, few discussions have been made on the role of NSDs in designing link recovery approaches.

Agile software engineering increasingly seeks to incorporate design modification and continuous refactoring in order to maintain code quality even in highly dynamic environments. However, there does not currently appear to be an industry-wide consensus on how to do this and research in this area expresses conflicting opinions. This paper presents an empirical study based upon an industry survey aimed at understanding the different ways that refactoring is thought of by the different people carrying out different roles in agile processes and how these different people weigh the importance of refactoring versus other kinds of tasks in the process. The study found good support for the importance of refactoring, but most respondents agreed that deferred refactoring impacts the agility of their process. Thus there was no universally agreed-upon strategy for planning refactoring. The survey findings also indicated that different roles have different perspectives on the different kinds of tasks in an agile process although all seem to want to increase the priority given to refactoring during planning for the iterations in agile development. Analysis of the survey raised many interesting questions suggesting the need for a considerable amount of future research.

Many organisations have turned to crowdsource their software development projects. This raises important pricing questions, a problem that has not previously been addressed for the emerging crowdsourcing development paradigm. We address this problem by introducing 16 cost drivers for crowdsourced development activities and evaluate 12 predictive pricing models using 4 popular performance measures. We evaluate our predictive models on TopCoder, the largest current crowdsourcing platform for software development. We analyse all 5,910 software development tasks (for which partial data is available), using these to extract our proposed cost drivers. We evaluate our predictive models using the 490 completed projects (for which full details are available). Our results provide evidence to support our primary finding that useful prediction quality is achievable (Pred(30)>0.8). We also show that simple actionable advice can be extracted from our models to assist the 430,000 developers who are members of the TopCoder software development market.

Software projects are always facing various risks. These risks should be identified, analyzed, prioritized, mitigated, monitored and controlled. After risks are identified and analyzed, resources must then be devoted to mitigation. However, risk prioritization and mitigation planning are complicated problems. Especially in project portfolio management (PPM), resource contention among projects leads to difficulty in choosing and executing mitigation actions. This paper introduces a search based risk mitigation planning method that is useful in PPM. It integrates the analysis of risks, consideration of available resources, and evaluation of possible effects when taking risk mitigation actions. The method uses a genetic algorithm to search for the risk mitigation plan of optimal value. A case study shows how this method can identify effective risk mitigation plans, thus providing useful decision support for managers.

Managing the costs and risks of evolution is a challenging problem in the RE community. The challenge lies in the difficulty of analyzing and assessing the proneness to requirement changes across multiple versions, especially when the scale of requirements is large. In this paper, we define a series of metrics to characterize historic evolution information, and propose a novel method for predicting requirements that are likely to evolve in the future based on the metrics. We apply the prediction method to analyze the product updates history through a case study. The empirical results show that this method can provide a tradeoff solution that narrows down the scope of change analysis to a small set of requirements, but it still can retrieve nearly half of the future changes. The results indicate that the defined metrics are sensitive to the history of requirements evolution, and the prediction method can reach a valuable outcome for requirement engineers to balance their workload and risks.

Complexity cohesion and coupling have been recognized as prominent indicators for software quality. One characterization of software complexity is the existence of dependency relationship. Moreover, degree of dependency reflects the cohesion and coupling between software elements. Dependencies on design and implementation phase have been proven as important predictors for software bugs. We empirically investigated how requirements dependencies correlate with and predict software integration bugs, which can provide early estimate regarding software quality, therefore facilitate decision making early in the software lifecycle. We conducted network analysis on requirements dependency networks of two commercial software projects. We then performed correlation analysis between network measures (e.g., degree, closeness) and number of bugs. Afterwards, bug prediction models were built using these network measures. Significant correlation is observed between most of our network measures and number of bugs. These network measures can predict the number of bugs with high accuracy and sensitivity. We further identified the significant predictors for bug prediction. Besides, the indication effect of network measures on bug number varies among different types of requirements dependency. These observations show that requirements dependency network can be used as an early indicator of software Integration bugs.

Background: Change propagation analysis helps predict the parts of the software that may be affected if a change is made. Existing research on change propagation focuses on design and code level changes. However, as a software evolves, the requirements that drive these changes also have intricate dependencies. Understanding the effect of these requirement dependencies on change prorogation is useful but not trivial. More than twenty requirements dependency types have been identified in the literature, however there still lacks an evaluation of the applicability of these dependency types in requirements and change propagation analysis. Aim: We aim to investigate whether these dependency types are useful for change propagation analysis. Method: We conducted a case study in a real-world industry project. This case study evaluates two representative dependency models covering twenty five types of dependencies. Results: Our initial evaluation has found that five dependency types are particularly useful in change propagation analysis and practitioners with different backgrounds have various viewpoints on change propagation. Thus change impact analysis should involve a wide range of stakeholders including project managers, requirements engineers, designers and developers. Conclusions: Our case study provides insights into requirements dependencies and their effects on change propagation analysis for both research and practice.

Background: Software systems must evolve in order to adapt in a timely fashion to the rapid changes of stakeholder needs, technologies, business environment and society regulations. Numerous studies have shown that cost, schedule or defect density of a software project may escalate as the requirements evolve. Requirements evolution management has become one important topic in requirements engineering research. Aim: To depict a holistic state-of-the-art of requirement evolution management. Method: We undertook a systematic review on requirements evolution management. Results: 125 relevant studies were identified and reviewed. This paper reports the preliminary results from this review: (1) the terminology and definition of requirements evolution; (2) fourteen key activities in requirements evolution management; (3) twenty-eight metrics of requirements evolution for three measurement goals. Conclusions: Requirements evolution is a process of continuous change of requirements in a certain direction. Most existing studies focus on how to deal with evolution after it happens. In the future, more research attention on exploring the evolution laws and predicting evolution is encouraged.

SUMMARY For a successful software project, acceptable quality must be achieved within an acceptable cost, demonstrating business value to customers and satisfactorily meeting delivery timeliness. Testing serves as the most widely used approaches to determine that the intended functionalities are performed correctly and achieve the desired level of services; however, it is also a labor‐intensive and expensive process during the whole software life cycle. Most current testing processes are often technique‐centered, rather than organized to maximize business value. In this article, we extend and elaborate the ‘4+1’ theoretical lenses of Value‐based Software Engineering (VBSE) framework in the software testing process; propose a multi‐objective feature prioritization strategy for testing planning and controlling, which aligns the internal testing process with value objectives coming from customers and markets. Our case study in a real‐life business project shows that this method allows reasoning about the software testing process in different dimensions: it helps to manage the testing process effectively and efficiently, provides information for continuous internal software process improvement, and increases customer satisfaction, which makes winners of all success‐critical stakeholders (SCSs) in the software testing process. Copyright © 2010 John Wiley & Sons, Ltd.

Nowadays, commercial or in-house customized process management tools have been prevalently adopted for supporting software project management and process improvement. In this paper we report a case study to empirically investigate and evaluate the usage status and implications of a supporting tool named QONE in industrial environment in China. Decision theory is adopted in study design. The analysis is mainly based on the usage data from a typical industrial project. Further questionnaires and follow-up interviews with the end-users are also conducted. The analysis results reveal that 1) the effects of such supporting tool vary with respect to different task types, 2) tasks with smaller granularity are comparatively easier to predict and control, 3) missing data reporting analysis helps to reveal opportunities for further process improvement and tool enhancement. This investigation aims to help us take advantages of such supporting tools and benefit software development eventually.

The features in multi-threaded programs, such as recursion, dynamic creation and communication, pose a great challenge to formal verification. A widely adopted strategy is to verify tentatively a system with a smaller size, by limiting the depth of recursion or the number of replicated processes, to find errors without ensuring the full correctness. The model checking of parameterized systems, a parametric infinite family of systems, is to decide if a property holds in every size instance. There has been a quest for finding cut-offs for the verification of parameterized systems. The basic idea is to find a cut-off on the number of replicated processes or on the maximum length of paths needed to prove a property, standing a chance of improving verification efficiency substantially if one can come up with small or modest cut-offs. In this paper, a novel approach, called Forward Bounded Reachability Analysis (FBRA), based upon the cut-off on the maximum lengths of paths is proposed for the verification of parameterized systems. Experimental results show that verification efficiency has been significantly improved as a result of the introduction of our new cut-offs.

Resource allocation in software development is important and many methods have been proposed. Related empirical research is yet scarce and evidence is required to validate the theoretical methods. This paper introduces the staffing pattern as a metric of resource distribution among project phases, and verifies its effect on software quality and productivity using real project data. The main findings are: (1) there exist different staffing patterns in reality; (2) the staffing pattern has significant effect on software quality (post-release defect density); (3) the staffing pattern has no significant effect on productivity; (4) the effort invested on test, document or code inspection possibly explains the effect of staffing pattern on software quality; (5) the effort consumed by rework perhaps counteracts the effect of other potential factors on productivity. Preliminary heuristics are suggested to resource allocation practices.

Floating Car Data (FCD) provides an economic complement to infrastructure-based traffic monitoring systems. Based on our previous MOIR platform [5], we use FCD as the data source for large-scale real-time traffic monitoring. This new function brings a challenge of efficiently handling of streaming data from a very large number of moving objects. Server overload problems can occur when a system fails to process data and queries in real-tme, which can lead to critical issues such as unbounded delay accumulation, lost monitoring accuracy or lack of spontaneity. These problems can be addressed by adopting suitable load dropping decisions. In this work, we demonstrate several load shedding techniques, focusing on decision-making based on data attributes. With the end results being quantified and visualized using real data for a large city, this proof-of-concept system provides a convincing way of validating our ideas.

As two major performance measures, software productivity and quality convey critical information in supporting many decision making situations during project planning, management, as well as process/organization benchmarking processes. However, there is a lack of investigation on these performance measures with respect to enhancement projects, this leads to, in many enhancement/maintenance cases, the inappropriate application of techniques or benchmarking data resulted from studies using development project data. In this paper, through analysis of 264 enhancement projects in China, we seek to develop in-depth and comprehensive understanding about software enhancement projects, by examining the variance of productivity and defect density by several significant influencing factors, such as business area, region, language, programming tool, project size, and team size.

Software effort estimation techniques abound, each with its own set of advantages and disadvantages, and no one proves to be the single best answer. Combining estimating is an appealing approach. Avoiding the difficult problem of choosing the single "best" technique, it solves the problem by asking which techniques would help to improve accuracy, assuming that each has something to contribute. In this paper, we firstly introduce the systematic "external" combining idea into the field of software effort estimation, and estimate software effort using Optimal Linear Combining (OLC) method with an experimental study based on a real-life data set. The result indicates that combining different techniques can significantly improve the accuracy and consistency of software effort estimation by making full use of information provided by all components, even the much "worse" one.

Effort distribution by phase or activity is an important but often overlooked aspect compared to other steps in the cost estimation process. Poor effort allocation is among the major root causes of rework due to insufficiently resourced early activities. This paper provides results of an empirical study on phase effort distribution data of 75 industry projects, from the China Software Benchmarking Standard Group (CSBSG) database. The phase effort distribution patterns and variation sources are presented, and analysis results show some consistency in effects of software size and team size on code and test phase distribution variations, and some considerable deviations in requirements, design, and transition phases, compared with recommendations in the COCOMO model. Finally, this paper discusses the major findings and threats to validity and presents general guidelines in directing effort allocation. Empirical findings from this study are beneficial for stimulating discussions and debates to improve cost estimation and benchmarking practices.

Although a lot of attention has been paid to software cost estimation since 1960, making accurate effort and schedule estimation is still a challenge. To collect evidence and identify potential areas of improvement in software cost estimation, it is important to investigate the estimation accuracy, the estimation method used, and the factors influencing the adoption of estimation methods in current industry. This paper analyzed 112 projects from the Chinese software project benchmarking dataset and conducted questionnaire survey on 116 organizations to investigate the above information. The paper presents the current situations related to software project estimation in China and provides evidence-based suggestions on how to improve software project estimation. Our survey results suggest, e.g., that large projects were more prone to cost and schedule overruns, that most computing managers and professionals were neither satisfied nor dissatisfied with the project estimation, that very few organizations (15%) used model-based methods, and that the high adoption cost and insignificant benefit after adoption were the main causes for low use of model-based methods.

Since 1990s, the software industry in China has been developed very rapidly and the total revenue in recent three years of 2005, 2006 and 2007 were 390.0, 480.0, and 583.4 billions RMB respectively, increased by 28.3% annually on an average basis [1]. By the end of 2007, there were about 18,000 software enterprises in China, and the population of software professionals was 1.48 millions roughly. In the global software market, China, with annual revenue about 82.2 billions USD (8.74% of the total: 940 billions USD), currently ranks on the fourth after USA, EU and Japan. However, the software industry in China is still comparatively weak. Most software enterprises have only tens of employees and millions RBM of revenue. And the software development productivity in China varies highly across the software industry in terms of organization, development type, business area, region, language, project size and team size [2]. Co-operative efforts from the government, the industry and the academy are needed [3]. Continuous software process improvement is an effective way to change the challenging situation of the software industry in China.

Software processes are highly people-dependent and knowledge transfer-centric compared to traditional manufacturing processes. Different people are responsible for different types of knowledge transformation according to the skill set and expertise they master. This adds a great deal of complicated factors in resolving the scheduling problem in software development and maintenance process planning. The existing human resource scheduling methods do not take into account the differences between human resource capabilities and capacities in processes execution. This paper presents a constraint-driven human resource scheduling method in software development and maintenance process. A constraint model is set up based on the software process model and human resource model. A constraint-driven scheduling method is provided to realize the optimal human resource scheduling in software development and maintenance process. The method can be used in the mature organizations whose human resources have the determinate capabilities. It provides the excellent decision support to the project manager.

Distribution of effort in software engineering process has been the basis for facilitating more reasonable software project planning. This paper reports empirical results on activity effort distribution patterns of a series of industrial software maintenance projects. The results show that with respect to different influencing factors, the projects demonstrate large variations in their activity effort distribution, which necessitates appropriate adjustments to strategic planning.

In software projects it is crucial to control the actual project schedule, cost and product quality, against the project plan. Variations often occur during the running project, and big ones might have significant impacts on the whole project. Thus, it is necessary to identify causes quickly, and take the right corrective actions in time. This paper provides a threedimensional software development model, called AHA (Activity-Human-Artifact). It combines three key factors, activity, human and artifact, corresponding to project schedule, cost, and product quality, respectively. We also define some relevant elements, attributes and relationships among different dimensions in the AHA model, and their impacts with respect to schedule, cost and quality. On the basis of our model, a project tracking process is developed to guide analysts to locate potential causes for different kinds of variations, and effectively correct them in real projects. We also take a software project as the application scenario to illustrate our model and the tracking process identified.

XP (eXtreme Programming) has become popular for IID (Iteration and Increment Development). It is suitable for small teams, lightweight projects and vague/volatile requirements. However, some challenges are left to developers when they desire to practise XP. A critical one of them is constructing the release plan and negotiating it with customers. In this paper, we propose a risk-driven method for XP release planning. It has been applied in a case study and the results show the method is feasible and effective. XP practicers can follow it to decide a suitable release plan and control the development process.

High-level process management is quantitative management. The Process Performance Baseline (PPB) of process or subprocess under statistical management is the most important concept. It is the basis of process control and improvement. The existing methods for establishing process baseline are too coarse-grained or have some limitation, which lead to inaccurate or ineffective quantitative management. In this paper, we propose an approach called BSR (Baseline-Statistic-Refinement) for establishing and refining software process performance baseline, and present the experience result to validate its effectiveness for quantitative process management.

Multimedia conferencing technology is becoming increasingly important, as it enables people who are located in different cities (or countries) to share as well as interact with their data, comments, images, and video pictures. This paper introduces the multimedia conferencing standards, such as ITU-T T.120, T.130, H.320, H.323, and H.324, which comprise the core technologies for multimedia conferencing. The paper discusses interoperability and compatibility issues which arise from the deployment of different vendor applications. The paper also presents a proposed multimedia conferencing system with H.32X standard capabilities, which is designed to facilitate interoperability and compatibility between different platforms.

As the Internet becomes a challenge for all enterprises, enterprise modeling should be reconsidered and reconstructed using the Internet as the key factor. In this paper, a new enterprise model called the market central process unit distributed function objects (MCPU-DFO) model is proposed for Internet-oriented and e-business enterprise. It is composed of two parts: a market central process unit serving as the heart of an enterprise, and distributed function objects in a star topology network. The objective is to achieve quick market decision making and lower cost communication of distributed architecture.

In distributed computing environments, there is a lack of methodologies for modeling communication mechanisms of distributed objects and facilitating later implementation of the model. In this paper, a solution is presented to describe and model the communication of distributed objects in an object-oriented enterprise model even with real-time requirements. The steps include the analysis of entities, communication requirements, and communication mechanisms involving UML (Unified Modeling Language) diagrams, while having the capability of finishing data flow, control flow, object operations and method definitions at the same time. The solution is based on and demonstrated by the distributed extended version of UML, in which time control and a complex message mechanism are introduced.