A graph-based expert system approach to geometric feature recognition

Geometric feature recognition is a crucial task in the development of concurrent engineering software. This paper presents a new methodology for geometric feature recognition which combines the advantages of face-edge adjacency graphs and expert systems. The methodology uses several new concepts such as enhanced winged edge data structure (EWEDS) and multi-attributed adjacency graphs (MAAG). The object model is presented as a set of facts. The rules for the recognition of each feature are derived from the corresponding feature-MAAG. This simplifies the process of writing the rules while enabling the inclusion of new features into the rule base as they are encountered.     

A generic static analyzer for multithreaded Java programs

In this paper, we present heckmate , the first generic static analyzer of multithreaded Java programs based on abstract interpretation. heckmate can be tuned at different levels of precision and efficiency in order to prove various properties (e.g., absence of divisions by zero and data races), and it is sound for multithreaded programs. It supports all the most relevant features of Java multithreading, such as dynamic thread creation, runtime creation of monitors, and dynamic allocation of memory. The experimental results demonstrate that heckmate is accurate and efficient enough to analyze programs with some thousands of statements and a potentially infinite number of threads. Copyright © 2012 John Wiley & Sons, Ltd.     

Audio support for an object-oriented database-management system

We describe the development of the data type audio in an object-oriented database management system (DBMS). The interface of the data type includes operations to store, retrieve, and manipulate audio data. Additionally, a transport protocol supports continuous recording and presentation at the users' workstations in a client-server environment. Design considerations are outlined and lead us to use no compression algorithms and to handle parametrized sample rates and sizes transparently for the user. Specific manipulation operations, such as low-pass filtering and dynamic compression, are described in detail. The implementation of an interactive audio tool shows that the data type audio can be used in the same way as conventional data types. We give an outlook on further built-in support of time-dependent media that a comprehensive multimedia DBMS should offer.     

Robot programming system for assembly: Conceptual graph-based approach

This work develops a method for robot program synthesis. Currently, the programming task is one of the major hurdles of robotic application. Progress towards automatic synthesis of robot programs will ease industrial robot application. The proposed system provides a means towards automated (guided by knowledge) conversion of a user's request, expressed in natural language, to the appropriate conceptual model of the required task. This model incorporates the information necessary for understanding, planning, and sensory-guided performance of the required robotic task.First, we state the problem of robotic assembly and recognize its hierarchic structure as the structure of a system that builds a predesigned assembly. Next, we present and analyze the requirements of the robotic assembly domain. This analysis enables us to draw conclusions concerning the most suitable methodology for the development of a support system for assembly program synthesis and interpretation. It is the conceptual graph-based approach. Then we present the algorithm of the proposed conceptual graph-based system and show how the system synthesizes robotic assembly operations, such as valid assembly sequences and sequences of special treatments for the assembled components (including the determination of the required resources). Finally, a case study illustrates the approach developed here on a large family of multi-axisymmetric components. We also present illustrative examples of working sessions with the current implementation of the system.     

A semantics for a class of non-deterministic and causal production system programs

We define a class of function-free rule-based production system (PS) programs that exhibit non-deterministic and/or causal behavior. We develop a fixpoint semantics and an equivalent declarative semantics for these programs. The criterion to recognize the class of non-deterministic causal (NDC) PS programs is based upon extending and relaxing the concept of stratification, to partition the rules of the program. Unlike strict stratification, this relaxed stratification criterion allows a more flexible partitioning of the rules and admits programs whose execution is non-deterministic or causal or both. The fixpoint semantics is based upon a monotonic fixpoint operator which guarantees that the execution of the program will terminate. Each fixpoint corresponds to a minimal database of answers for the NDC PS program. Since the execution of the program is non-deterministic, several fixpoints may be obtained. To obtain a declarative meaning for the PS program, we associate a normal logic program with each NDC PS program. We use the generalized disjunctive well-founded semantics to provide a meaning to the normal logic program Through these semantics, a well-founded state is associated with and a set of possible extensions, each of which are minimal models for the well-founded state, are obtained. We show that the fixpoint semantics for the NDC PS programs is sound and complete with respect to the declarative semantics for the corresponding normal logic program .This research is partially sponsored by the National Science Foundation under grant IRI-9008208 and by the Institute for Advanced Computer Studies.     

Towards a generic model for object-oriented information system modelling

With the proliferation of object-oriented methods for information systems design, and the terminology used by each one, an intermediate step is indispensable in the transition between the design and the different implementation environments. Regardless of any method, this step aims at the unification of all concepts in a generic model called MGCO2.     

Logical foundations for representing object-oriented systems

Abstract

Object-oriented programming languages are designed for computing or simulating the behaviour of interacting objects, but their encapsulated contexts and procedural methods are not well suited to non-procedural techniques in theorem provers, optimizers, and automated design and analysis tools. Logic is the non-procedural system par excellence, but the predicate calculus notation for logic is awkward for representing and reasoning about encapsulated contexts. Conceptual graphs are a graphic system of logic that is better suited to O-O systems. First, they explicitly represent the contexts that are ignored or obscured in predicate calculus. Second, Peirce's rules of inference for reasoning with graphs are explicitly formulated in terms of contexts and the conditions for importing and exporting information from contexts. This article describes the context mechanisms of conceptual graphs, the rules of inference for reasoning with the graphs, and their use as a design language for object-oriented systems.     

Heap-abstraction for an object-oriented calculus with thread classes

This paper formalizes an open semantics for a calculus featuring thread classes, where the environment, consisting in particular of an overapproximation of the heap topology, is abstractly represented. From an observational point of view, considering classes as part of a component makes instantiation a possible interaction between com- ponent and environment or observer. For thread classes it means that a component may create external activity, which influences what can be observed. The fact that cross-border instantiation is possible requires that the connectivity of the objects needs to be incorporated into the semantics. We extend our prior work not only by adding thread classes, but also in that thread names may be communicated, which means that the semantics needs to account explicitly for the possible acquaintance of objects with threads. We show soundness of the abstraction. Part of this work has been financially supported by the NWO/DFG project Mobi-J (RO 1122/9-4), by the DFG project AVACS (SFB/TR-14-AVACS), by the EU-project IST-33826 Credo: Modeling and analysis of evolutionary structures for distributed services (see )     

A systematic literature review on the detection of smells and their evolution in object-oriented and service-oriented systems

This systematic literature review paper investigates the key techniques employed to identify smells in different paradigms of software engineering from object-oriented (OO) to service-oriented (SO). In this review, we want to identify commonalities and differences in the identification of smells in OO and SO systems. Our research method relies on an automatic search from the relevant digital libraries to find the studies published since January 2000 on smells until December 2017. We have conducted a pilot and author-based search that allows us to select the 78 most relevant studies after applying inclusion and exclusion criteria. We evaluated the studies based on the smell detection techniques and the evolution of different methodologies in OO and SO. Among the 78 relevant studies selected, we have identified six different studies in which linguistic source code analysis received less attention from the researchers as compared to the static source code analysis. Smells like the yo-yo problem, unnamed coupling, intensive coupling, and interface bloat received considerably less attention in the literature. We also identified a catalog of 30 smells infrequently reported for SO systems and that require further attention. Moreover, a suite of 20 smells reported for SO systems can also be detected using static source code metrics in OO. Finally, our review highlighted three major research trends that are further subdivided into 20 research patterns initiating the detection of smells toward their correction.     

A type system for logic programs

A theory for a type system for logic programs is developed which addressesthe question of well-typing, type inference, and compile-time and run-time type checking. A type is a recursively enumerable set of ground atoms, which is tuple-distributive. The association of a type to a program is intended to mean that only ground atoms that are elements of the type may be derived from the program. A declarative definition of well-typed programs is formulated, based on an intuitive approach related to the fixpoint semantics of logic programs. Whether a program is well typed is undecidable in general. We define a restricted class of types, called regular types, for which type checking is decidable. Regular unary logic programs are proposed as a specification language for regular types. An algorithm for type-checking a logic program with respect to a regular type definition is described, and its complexity is analyzed. Finally, the practicality of the type system is discussed, and some examples are shown. The type system has been implemented in FCP for FCP and is incorporated in the Logix system.     

Deciding branching time properties for asynchronous programs

Asynchronous programming is a paradigm that supports asynchronous function calls in addition to synchronous function calls. Programs in such a setting can be modeled by automata with counters that keep track of the number of pending asynchronous calls for each function, as well as a call stack for synchronous recursive computation. These programs have the restriction that an asynchronous call is processed only when the call stack is empty. The decidability of the control state reachability problem for such systems was recently established. In this paper, we consider the problems of checking other branching time properties for such systems. Specifically we consider the following problems — termination, which asks if there is an infinite (non-terminating) computation exhibited by the system; control state maintainability, which asks if there is a maximal execution of the system, where all the state visited lie in some “good” set; whether the system can be simulated by a given finite state system; and whether the system can simulate a given finite state system. We present decision algorithms for all these problems.     

A Duality in Proof Systems for Recursive Type Equality and for Bisimulation Equivalence on Cyclic Term Graphs

This paper is concerned with a proof-theoretic observation about two kinds of proof systems for regular cyclic objects. It is presented for the case of two formal systems that are complete with respect to the notion of “recursive type equality” on a restricted class of recursive types in μ-term notation. Here we show the existence of an immediate duality with a geometrical visualization between proofs in a variant of the coinductive axiom system due to Brandt and Henglein and “consistency-unfoldings” in a variant of a 'syntactic-matching' proof system for testing equations between recursive types due to Ariola and Klop.Finally we sketch an analogous result of a duality between a similar pair of proof systems for bisimulation equivalence on equational specifications of cyclic term graphs.     

Behavioral interpretation of the object-oriented paradigm for interconnected dynamic system modeling

This article presents a mathematical interpretation of the object-oriented modeling paradigm inspired from the Willems' behavioral approach of systems theory. The object modeling of interconnected dynamic systems is introduced independently from any computer language and expressed as a set computation problem. Two behavioral representations (complete and partial) of an object are defined. Three object relationships, i.e. instantiation, composition and generalization are examined in the behavioral framework. Each definition is illustrated by basic examples, e.g. a storage tank, a resistor, a control valve and an electrical circuit. The implementation of the behavioral representations into the object-oriented language Modelica is finally presented.     

A generic model for Immersive Documentation Environments

We propose a generic model for designing systems relying on augmented reality techniques in the context of an Immersive Documentation Environment (IDE). This model encompasses a user/system interaction paradigm, system architecture and exploitation scenario. We illustrate the use of this model on several virtually documented environment systems providing the user with enhanced interaction capabilities. These systems are dedicated to several applications where the operator needs natural (hands free) access to information, to carry out measurements and/or operate on devices (e.g. maintenance, instruction). These systems merge live images acquired by a video camera with synthetic data (multimedia documents including CAD models and text) and present the result properly registered in the real world. Vocal commands as well as multimodal interaction, associating speech and gesture, are used to improve interaction.     

JDiff: A differencing technique and tool for object-oriented programs

During software evolution, information about changes between different versions of a program is useful for a number of software engineering tasks. For example, configuration-management systems can use change information to assess possible conflicts among updates from different users. For another example, in regression testing, knowledge about which parts of a program are unchanged can help in identifying test cases that need not be rerun. For many of these tasks, a purely syntactic differencing may not provide enough information for the task to be performed effectively. This problem is especially relevant in the case of object-oriented software, for which a syntactic change can have subtle and unforeseen effects. In this paper, we present a technique for comparing object-oriented programs that identifies both differences and correspondences between two versions of a program. The technique is based on a representation that handles object-oriented features and, thus, can capture the behavior of object-oriented programs. We also present JDiff, a tool that implements the technique for Java programs. Finally, we present the results of four empirical studies, performed on many versions of two medium-sized subjects, that show the efficiency and effectiveness of the technique when used on real programs.

二进制程序整型符号转换缺陷的动态检测方法

针对符号转换错误引起缓冲区溢出的这类缺陷提出了一种面向二进制程序整型符号转换缺陷检测方法。以二进制插桩框架为基础,利用类型推断方法识别整型变量的符号类型信息,得到内存相关库函数中为冲突类型的参数的集合,并将其作为潜在的整型符号转换缺陷候选集。在中间代码层面插入检测代码做运行时检测,最终确定真正的整型符号转换缺陷。原型系统Sconvcheck的实验结果表明：该方法可以有效地检测出程序中的整型符号转换缺陷,并准确地定位错误发生的位置,而且误报率较低。     

A distributed programs monitor for berkeley UNIX

Writing and debugging distributed programs can be difficult. When a program is working, it can be difficult to achieve reasonable execution performance. A major cause of these difficulties is a lack of tools for the programmer. We use a model of distributed computation and measurement to implement a program monitoring system for programs running on the Berkeley UNIX 4.2BSD operating system. The model of distributed computation describes the activities of the processes within a distributed program in terms of computation (internal events) and communication (external events). The measurement model focuses on external events and separates the detection of external events, event record selection and data analysis. The implementation of the measurement tools involved changes to the Berkeley UNIX kernel, and the addition of daemon processes to allow the monitoring activity to take place across machine boundaries. A user interface has also been implemented.     

A systematic review of approaches for testing concurrent programs

Concurrent programs are replacing the sequential programs as they utilize the true capabilities of multicore architecture. The extensive use of multicore systems and multithreaded paradigms warrants more attention to the testing of the concurrent programs. The testing concurrent program is not a new field as it has been more than 40 years because the first problem related to the testing concurrent program was addressed by the researchers. The field covers various domains, which include concurrency problems, testing approaches, techniques, graphical representations, tools, and subject systems. This paper aims at providing an overview of research in the domain of testing concurrent programs by classifying it into eight categories: (a) reachability testing, (b) structural testing, (c) model‐based testing, (d) mutation‐based testing, (e) slicing‐based testing, (f) formal methods, (g) random testing, and (h) search‐based testing. The survey is focused on the techniques applied, methodologies followed, and tools used in these aforementioned approaches. Furthermore, the gaps are also identified in different approaches. The paper concludes with the consolidation of various testing parameters along with the future directions. Copyright © 2015 John Wiley & Sons, Ltd.