Standard Specification for S-100 Bus Interface Devices

This proposed standard eliminates many of the problems in the S-100 bus and upgrades it for 16-bit microprocessors. It is offered here for public comment before submission to the IEEE Standards Board.     

A distributed synchronization mechanism for interacting processes

Reliable synchronization is intended to ensure a graceful degradation of the system in the event of a failure. Solutions to synchronization problems of this kind under constant space conditions are presented. Lamport's bakery algorithm and generalized critical region have been modified and extended for application to this problem.     

CONCUR: A language for continuous, concurrent processes

Hendrix's robot modeling system presented a simulation method in which time is represented as a continuous phenomenon. This paper introduces the language CONCUR, which realizes Hendrix's concept through an extension of the LISP environment. CONCUR uses generalized procedures (scenarios) operating in a data-driven mode to implement Hendrix's events. The heart of CONCUR is a generalized pattern-matcher which permits operators within the patterns to bind variables and modify the match process. We include several detailed examples in addition to an implementation of the pattern matcher.     

Towards a language for concurrent processes

In this paper we shall discuss concurrency in programming languages, with a view towards designing a process-oriented language which, by its inherent parallelism, is well suited to exploit the forthcoming generation of distributed processor networks. We shall start by discussing the traditional approach towards managing concurrency, with ‘monitors’ co-ordinating the interactions of ‘processes’, and shall demonstrate that this approach actually degrades concurrency by imposing sequentiality during interactions because it is based on the premise of co-ordinating secure access to shared resources. As a tool for interprocess communication it is felt that the ‘monitor’ is too far removed from the abstract nature of the problem, and so, as a purely engineering solution, it imposes too broad and too prolonged an exclusion to be acceptable in general. Instead we turn to a simpler, and ultimately more powerful notion of ‘message passing’ between parallel processes. We shall show how, if the message system is polymorphic, any data value, however large it is, can pass freely between any pair of processes. By making the processes themselves values in the language we shall discover that message networks can come into being dynamically, and tailor themselves to their applications as and when necessary by ‘short-circuiting’ extensive communications paths. We shall also see how, if the message system is inherently asynchronous, the degree of the parallelism in a system can be enhanced, not degraded, as more and elaborate communications paths develop, the only sequentiality in the system as a whole being imposed by synchronizing processes, not the message passing system itself. After discussing the various built-in system facilities that permit processes to dynamically find out about and study one another, thus permitting processes to set up and thereafter supervise whole subsystems, we shall round off by discussing the advantages of introducing the machines themselves into the language, making it possible for processes to become aware of, and then ‘migrate’ within, the topological structure of a multi-processor distributed network, moving closer to their application, or just to a less-loaded processor, as the need arises. To conclude we shall contrast this new-style process-oriented language with various existing programming languages which have experimented with concurrency, either implicitly or explicitly, in order to see if, and if so how, this new style is any simpler and more powerful than its precursors.     

Proving properties of interacting processes

Summary The Set of Interacting Procedures (SIP) model, a graph model suitable for representing interacting computations, is presented. It includes nótation for creating and destroying processes, permits well-defined critical sections, and facilitates examining the logical properties of the modeled procedures. The essential parts of a theory of correctness of interacting processes are informally presented. These include a definition of correctness with respect to an assertion, a non-interference condition which justifies the use of the SIP model, and a set of sufficient conditions for correctness. To illustrate the use of the model and theory, a solution to the reader-writer problem is presented and modeled. An assertion expressing the correctness of the solution is formulated, and the SIP model of the solution is shown to be correct with respect to the assertion. Finally, the non-interference condition shows that the conclusions about the model also apply to the solution itself.     

Specification of communicating processes: temporal logic versus refusals-based refinement

In this paper we consider the relationship between refinement-oriented specification and specifications using a temporal logic. We investigate the extent to which one can check whether a program in a process algebra, such as Communicating Sequential Processes (CSP), satisfies a temporal logic specification using a refinement-based model checker, such as FDR. We consider what atomic formulae are appropriate in a temporal logic for specifying communicating processes, in particular where one wants to talk about the availability of events. We then show that, perhaps surprisingly, the standard stable failures model is not adequate for capturing specifications in such a logic: instead the refusal traces model must be used. We formalise the logic by giving it a semantics in this model. We show that the temporal operators eventually and until, and negation, cannot, in general, be tested for via simple refinement checks. For the remaining fragment of the logic, we present a translation into simple refinement checks. Finally, we show that refusal traces equivalence is characterised by a slightly augmented version of that fragment. M. J. Butler     

Specification and automated validation of staged reconfiguration processes for dynamic software product lines

Dynamic software product lines (DSPLs) propose elaborated design and implementation principles for engineering highly configurable runtime-adaptive systems in a sustainable and feature-oriented way. For this, DSPLs add to classical software product lines (SPL) the notions of (1) staged (pre-)configurations with dedicated binding times for each individual feature, and (2) continuous runtime reconfigurations of dynamic features throughout the entire product life cycle. Especially in the context of safety- and mission-critical systems, the design of reliable DSPLs requires capabilities for accurately specifying and validating arbitrary complex constraints among configuration parameters and/or respective reconfiguration options. Compared to classical SPL domain analysis which is usually based on Boolean constraint solving, DSPL validation, therefore, further requires capabilities for checking temporal properties of reconfiguration processes. In this article, we present a comprehensive approach for modeling and automatically verifying essential validity properties of staged reconfiguration processes with complex binding time constraints during DSPL domain engineering. The novel modeling concepts introduced are motivated by (re-)configuration constraints apparent in a real-world industrial case study from the automation engineering domain, which are not properly expressible and analyzable using state-of-the-art SPL domain modeling approaches. We present a prototypical tool implementation based on the model checker SPIN and present evaluation results obtained from our industrial case study, demonstrating the applicability of the approach.     

Independent design of multi-loop PI/PID controllers for interacting multivariable processes

The interactions between input/output variables are a common phenomenon and the main obstacle encountered in the design of multi-loop controllers for interacting multivariable processes. In this study, a novel method for the independent design of multi-loop PI/PID controllers is proposed. The idea of an effective open-loop transfer function (EOTF) is first introduced to decompose a multi-loop control system into a set of equivalent independent single loops. Using a model reduction technique, the EOTF is further approximated to the reduced-order form. Based on the corresponding EOTF model, the individual controller of each single loop is then independently designed by applying the internal model control (IMC)-based PID tuning approach for single-input/single-output (SISO) systems, while the main effects of the dynamic interactions are properly taken into account. Several illustrative examples are employed to demonstrate the effectiveness of the proposed method.     

Knowledge representation and processing in interacting sensory and language neurosystems

The choice of our topic, which is of both exploratory and applied value, has been determined by the confluence of neurocybernetics and neurophysiology, neuropsychology and cognitology, semiotics and neurobionics (the latter as one of the directions of artificial intelligence). On the whole, the questions considered in this article fall in the domains of cybernetics, in the wide, classical sense of this term [1], and neurophysioiogy, at the system level of information representation and processing. The article relies on previous publications [2–7], which have been generalized and extended. Translated from Kibernetika i Sistemnyi Analiz, No. 2, pp. 3–11, March–April, 1998.     

Towards a decision-aware declarative process modeling language for knowledge-intensive processes

Modeling loosely framed and knowledge-intensive business processes with the currently available process modeling languages is very challenging. Some lack the flexibility to model this type of processes, while others are missing one or more perspectives needed to add the necessary level of detail to the models. In this paper we have composed a list of requirements that a modeling language should fulfil in order to adequately support the modeling of this type of processes. Based on these requirements, a metamodel for a new modeling language was developed that satisfies them all. The new language, called DeciClare, incorporates parts of several existing modeling languages, integrating them with new solutions to requirements that had not yet been met. Deciclare is a declarative modeling language at its core, and therefore, can inherently deal with the flexibility required to model loosely framed processes. The complementary resource and data perspectives add the capability to reason about, respectively, resources and data values. The latter makes it possible to encapsulate the knowledge that governs the process flow by offering support for decision modeling. The abstract syntax of DeciClare has been implemented in the form of an Ecore model. Based on this implementation, the language-domain appropriateness of the language was validated by domain experts using the arm fracture case as application scenario.     

Edison-80, a language for modular programming of parallel processes

Edison-80, a superset of the programming language Edison, was implemented on an Intel development system. It aims at providing software designers with a programming environment, which combines the benefits of abstraction of high-level languages with those of machine-orientation and is powerful enough to support the development of nontrivial system software with a spectrum of facilities, including parallel processing. Modifications (e.g., the separate compilation facility) are introduced into Edison-80 to make it more powerful than the original. In spite of being an interpreted language, the resulting Edison-80 object code is down-loadable and compatible with the existing compiled languages on the system, so that they can be linked together and run on user systems. Experiences of implementation will be reported.     

Denotational semantics of mixed computation processes for a structural programming language

Conclustions The paper formalizes two denotational models for mixed computation process in a structural programming language. A criterion of functional correctness is formulated and theorems are proved that show that the described models are functionally correct. The proposed models define more precisely the concept of mixed computations discussed in [1, 2], and make it, possible formally to prove their properties. Moreover, they can be regarded as formal specifications of the respective components of a mixed-computer software.Translated from Kibernetika, No. 1, pp. 16–27, 43, January–February, 1988.     

一种改进的Hausdorff距离模板匹配算法

检测和提取图像中的目标图像是图像处理和模式识别等领域里非常活跃的问题.因为Hausdorff距离对于目标遮挡、图像噪声和图像晃动等情况具有较好的鲁棒性,因此使用Hausdorff距离进行图像匹配是较常用的方法之一.为了降低此算法的计算复杂度,提高匹配效率,提出了一种能够从待匹配图像中高效匹配出模板图像的改进算法.将文中提出的改进算法分别应用到一幅图像和视频序列图像中,实验结果证明了该算法的高效性.     

基于参照模型的联机手写汉字笔划提取及识别

本文提出一种基于参照模型的联机手写汉字的笔划提取及识别的新方法 ,在该方法中不但考虑了流字识别中笔划的提取、匹配 ,还充分考虑到笔划间的连接关系 ,在手写汉字识别中取得了较好的效果。     

Specification and implementation of directional operators in a 3D spatial query language for building information models

A spatial query language enables the spatial analysis of building information models and the extraction of partial models that fulfill certain spatial constraints. Among other features, the developed spatial query language includes directional operators, i.e., operators that reflect the directional relationships between 3D spatial objects, such as northOf, southOf, eastOf, westOf, above and below. The paper presents in-depth definitions of the semantics of two new directional models for extended 3D objects, the projection-based and the halfspace-based model, by using point-set theory notation. It further describes the possible implementation of directional operators using a newly developed space-partitioning data structure called slot-tree, which is derived from the objects’ octree representation. The slot-tree allows for the application of recursive algorithms that successively increase the discrete resolution of the spatial objects employed and thereby enables the user to trade-off between computational effort and the required accuracy. The article also introduces detailed investigations on the runtime performance of the developed algorithms.     

Specification of integrity-preserving operations in information systems by using a formal UML-based language

Information system specification requires careful consideration of data integrity. We present an approach to the definition of a variant of UML that allows the rigorous specification of operations and transactions that enforce data constraints. The approach to structural language definition, summarised in Appendix A, extends that used for conventional UML, comprising metamodels of the abstract syntax of structural aspects, with denotational semantics. We add operation semantics using a formal notation, B. Issues relating to the tool-assisted specification of integrity-preserving transactions are discussed.     

Denotational semantics of communicating processes based on a language for applicative multiprogramming

The denotational semantics of a simple language for describing tightly coupled ‘synchronous’ systems is defined by translating it into a language for applicative multiprogramming. The applicative language has originally been developed for describing nondeterministic stream-processing functions and loosely-coupled systems of communicating processes. Nevertheless, it can be used after very slight generalizations as a semantic target language for defining the meaning of programs representing tightly-coupled, synchronous systems.