CAL software design for transferability

The successful transfer of CAL software is often thwarted by differences between the computer system on which the software was developed and that on which it is required to be implemented. Facilities which CAL programs may exploit are usually those most vulnerable to change between different computer systems.Drawing upon experience gained in the design, programming, and subsequent transfer of CAL programs in engineering, examples are given of features which may cause problems during implementation and alternatives or improvements are suggested. FORTRAN and GINO-F are proposed as machine and device independent standards, for implementation language and graphics subroutine library, respectively.Good programming practices are described with a view to obtaining readable and easily maintained programs of a sound quality. Importance is placed on modularity in design as the key to writing transportable programs. The idea that every module should conceal some design decisions from all other modules is described with reference to modules that have proved to be particularly useful or advisable. This technique enables a design to be produced in which machine dependencies and difficult design decisions may be confined to a handful of routines. This makes the program more adaptable and gives the teacher and programmer greater freedom to change the implementation, allowing the program to move to any computer system where similar functions can be implemented.     

Integrating library modules into Pascal programs

We present the results of our experience in introducing modularity into the programming language Pascal in order to aid the creation and use of library modules. Our system performs the symbolic linking of source language modules producing a single Pascal text ready for compilation; performing the link phase before compilation anticipates interface consistency checks, and suggests a possible improvement of program development systems. Our extension is implemented in a preprocessor which ensures a complete compatibility with any standard Pascal compiler. In this paper we examine the main features of some high-level programming languages which support modularization and data abstraction and some experiences in introducing modularity into Pascal; on this basis we describe our choice in detail. The design and implementation details are discussed and some examples are presented.     

Deriving guidelines for cross-vendor reuse of IEC 61131-3 modules based on Normalized Systems theorems

Flexibility, maintainability and evolvability are very desirable properties for modern automation control systems. In order to achieve these characteristics, modularity is regarded as an important concept in several scientific domains. The reuse of modules facilitates the reproduction of functionality, or extensions of existing systems in similar environments. However, it is often necessary to ‘prepare’ such an environment to be able to reuse the intended programmed functionality. In an IEC 61131-3 environment, cross-vendor reuse of modules is problematic due to dependencies in proprietary programming environments and existing configurations. In this paper, we aim to enable cross-vendor reuse of modules by controlling these dependencies. Our approach is based on the Normalized Systems Theory, from which we derived three guidelines for the design of reusable modules in an IEC 61131-3 environment for automation control projects. These guidelines are intended to support programmers in controlling dependencies, regardless of the commercial programming environment they work with.     

Design and implementation of robot-operated adaptable and modular fixtures

This paper presents the design issues and hardware implementation for robot-operated automatic modular and adaptable fixtures. Modular fixtures are workholding devices made from stackable self-contained modular elements. Adaptable fixtures provide surface contact with the workpiece and therefore can adapt to the workpiece geometry. These fixtures are shown to have several advantages over conventional fixtures. Issues in modularity and adaptability for workpiece fixturing are discussed for the purpose of evaluating automatic modular fixtures in flexible manufacturing systems. The basic design requirements for robot-operated modular and adaptable fixturing systems are developed and classified into mechanical and operational. Automatic assembly issues such as the use of special mating surfaces, compact actuators for active modules, as well as the importance of communications between the robot manipulator and the modular fixture are discussed.

Hardware design and implementation of a shape memory alloy actuated locking module and a discrete conformable surface module are presented. Performance characteristics such as free-play, stiffness and time response were evaluated experimentally for the locking module. Several workpiece geometries are tested on the comformable surface module.     

Architectural support for designing fault-tolerant open distributedsystems

An overview of the main techniques for designing fault-tolerant software and hardware systems is provided. The important features of the building blocks (computers, memories, buses, etc.) that can support an efficient implementation of fault-tolerant open distributed systems (FTODSs) are identified. Taking into account the features of these building blocks, an organization for FTODS is proposed. A distributed voting algorithm and a two-level hierarchy for permanent memory are key elements in this scheme. The algorithms needed for transferring files and synchronizing the concurrent activities of the computing modules and for recovery-are ISO standard protocols. Low-level voting and recovery algorithms that can run as a layer of software above the operating system make the open distributed system an attractive environment for applying fault-tolerant techniques     

Markov reliability models of fault-tolerant distributed computing systems

A hierachical view of fault-tolerant distributed computers is presented, viewing a distributed computing system as composed of interconnected, interacting, functional modules. Each module, modeled by a directed-state graph, is governed by internal random failure events and counteracting recovery processes, and also by coupling of external random events from other modules. It is shown that, under certain assumptions, the system is governed by a multidimensional Markov process, with non-Markov module processes as components. Mathematical properties of this model are formally analyzed. Performance measures are found from the steady-state distribution and visitation rate of each system and module state. A numerical example is presented exemplifying its practical application. The results are shown to fit very well the actual statistical data collected on an AT&T Bell Laboratories Electronic Switching System.     

Experience with Modular Concurrent Programming

This paper summarizes the initial experience with the programming language Concurrent Pascal in the design of three model operating systems. A Concurrent Pascal program consists of modules called processes, monitors, and classes. The compiler checks that the data structures of each module are accessed only by the operations defined in the module. The author emphasizes that the creative aspect of program construction is the initial selection of modules and the connection of them into hierarchical structures. By comparison the detailed implementation of each module is straightforward. The most important result is that it is possible to build a concurrent program of one thousand lines out of one-page modules that can be comprehended at a glance.     

Applying and evaluating concern-sensitive design heuristics

Manifestation of crosscutting concerns in software systems is often an indicative of design modularity flaws and further design instabilities as those systems evolve. Without proper design evaluation mechanisms, the identification of harmful crosscutting concerns can become counter-productive and impractical. Nowadays, metrics and heuristics are the basic mechanisms to support their identification and classification either in object-oriented or aspect-oriented programs. However, conventional mechanisms have a number of limitations to support an effective identification and classification of crosscutting concerns in a software system. In this paper, we claim that those limitations are mostly caused by the fact that existing metrics and heuristics are not sensitive to primitive concern properties, such as either their degree of tangling and scattering or their specific structural shapes. This means that modularity assessment is rooted only at conventional attributes of modules, such as module cohesion, coupling and size. This paper proposes a representative suite of concern-sensitive heuristic rules. The proposed heuristics are supported by a prototype tool. The paper also reports an exploratory study to evaluate the accuracy of the proposed heuristics by applying them to seven systems. The results of this exploratory analysis give evidences that the heuristics offer support for: (i) addressing the shortcomings of conventional metrics-based assessments, (ii) reducing the manifestation of false positives and false negatives in modularity assessment, (iii) detecting sources of design instability, and (iv) finding the presence of design modularity flaws in both object-oriented and aspect-oriented programs. Although our results are limited to a number of decisions we made in this study, they indicate a promising research direction. Further analyses are required to confirm or refute our preliminary findings and, so, this study should be seen as a stepping stone on understanding how concerns can be useful assessment abstractions. We conclude this paper by discussing the limitations of this exploratory study focusing on some situations which hinder the accuracy of concern-sensitive heuristics.     

Reaching agreement on processor-group membrship in synchronous distributed systems

Reaching agreement on the identity of correctly functioning processors of a distributed system in the presence of random communication delays, failures and processor joins is a fundamental problem in fault-tolerant distributed systems. Assuming a synchronous communication network that is not subject to partition occurrences, we specify the processor-group membership problem and we propose three simple protocols for solving it. The protocols provide all correct processors with consistent views of the processor-group membership and guarantee bounded processor failure detection and join delays. Flaviu Cristian is a computer scientist at the IBM Almaden Research Center in San Jose, California. He received his PhD from the University of Grenoble, France, in 1979. After carrying out research in operating systems and programming methodology in France and working on the specification, design, and verification of fault-tolerant software in England, he joined IBM in 1982. Since then he has worked in the area of fault-tolerant distributed systems and protocols. He has participated in the design and implementation of a highly available distributed system prototype at the Almaden Research Center, has reviewed and consulted for several fault-tolerant distributed system designs, both in Europe and the American divisions of IBM, and is now a technical leader in the design of a new Air Traffic Control System for the US which must satisfy very stringent availability requirements.     

支持IPv6的网络访问控制网关的设计与实现

如何使用户能够方便的访问互联网协议（IPv6）资源,同时有效地管理网络资源成为一个亟待解决的问题。重点研究了NetfiIter框架的运行机制和实现方法、iptables配置工具、网络端口地址转换一协议转换（NAPT-PT）技术和Linux内核模块编程方法,介绍了系统的总体设计目标及设计方案,描述了系统开发环境,阐述了各个模块的设计和模块之间的工作关系。并根据系统模块的划分,具体说明每个模块的功能及其实现的原理和流程。     

Aspect-oriented programming will improve quality

Software engineers are always looking for ways to improve modularity in software. Doing so makes software easier to develop and maintain and improves its overall quality. Recently, aspect-oriented programming emerged as a new modularity technique that aims to cleanly separate the implementation of crosscutting concerns (requirements and design elements that affect multiple modules). AOP is an evolutionary step that improves the implementation's comprehensibility and simplifies incorporating new requirements as well as changes to existing ones. This systematic approach promises direct mapping of requirements and design intentions to the implementation. Such a mapping lets you trace the reasoning behind a piece of code's existence. Efficiently implementing crosscutting concerns also has an important indirect benefit: it frees resources to concentrate on the quality of the core implementation. All these factors work together to improve software quality.     

Experience with distributed Smalltalk

Distributed Smalltalk (DS) is an implementation of Smalltalk that supports the interaction of many Smalltalk users on many machines. It provides communication and interaction among remote Smalltalk users, direct access to remote objects, and a degree of object sharing among users. The distributed aspects of the system are largely user transparent. Many of the major design issues and implementation decisions associated with Distributed Smalltalk have previously been reported. This paper concentrates on the impact of those decisions and describes how DS is used to build distributed applications. Three example applications are described: remote file access, animated distributed objects, and offloading a compute-intensive task to a non-Smalltalk host. Based on our experience with DS, we present an evaluation of its design and implementation.     

Transformation and exchange of multimedia objects in distributed multimedia systems

One of the challenges in the design of a distributed multimedia system is devising suitable specification models for various schemas in different levels of the system. Another important research issue is the integration and synchronization of heterogeneous multimedia objects. In this paper, we present our models for multimedia schemas and transformation algorithms. They transform high-level multimedia objects into schemas that can be used to support the presentation and communication of the multimedia objects. A key module in the system is the Object Exchange Manager (OEM). In this paper, we present the design and implementation of the OEM module, and discuss in detail the interaction between the OEM and other modules in a distributed multimedia system.     

基于某型控制盒单板测试软件的通用化设计

以某型控制盒单板测控系统研制为背景,为了满足测控系统的通用化、模块化要求,提出了通用化的设计方案;讨论了测控系统的总体结构、硬件配置、软件模块化设计、软件流程,设计研制了基于通用化思想的通用硬件测试系统;经过后期的硬件测试表明,较传统的测控系统,该系统通用性好,操作方便,具有良好的扩展性,对提高武器系统的可维护性和可靠性有重要的意义。     

The design of a neural network with a biologically motivatedarchitecture

An associative neural network whose architecture is greatly influenced by biological data is described. The proposed neural network is significantly different in architecture and connectivity from previous models. Its emphasis is on high parallelism and modularity. The network connectivity is enriched by recurrent connections within the modules. Each module is, effectively, a Hopfield net. Connections within a module are plastic and are modified by associative learning. Connections between modules are fixed and thus not subject to learning. Although the network is tested with character recognition, it cannot be directly used as such for real-world applications. It must be incorporated as a module in a more complex structure. The architectural principles of the proposed network model can be used in the design of other modules of a whole system. Its architecture is such that it constitutes a good mathematical prototype to analyze the properties of modularity, recurrent connections, and feedback. The model does not make any contribution to the subject of learning in neural networks.     

Design and Verification of Distributed Recovery Blocks with CSP

A case study on the application of Communicating Sequential Processes (CSP) to the design and verification of fault-tolerant real-time systems is presented. The distributed recovery block (DRB) scheme is a design technique for the uniform treatment of hardware and software faults in real-time systems. Through a simple fault-tolerant real-time system design using the DRB scheme, the case study illustrates a paradigm for specifying fault-tolerant software and demonstrates how the different behavioural aspects of a fault-tolerant real-time system design can be separately and systematically specified, formulated, and verified using an integrated set of formal techniques based on CSP.     

A cost-based module mining method for the assemble-to-order strategy

The assemble-to-order (ATO) strategy is one of the most popular operations management approaches to achieve mass customized products while maintaining lower costs. In the ATO system, manufacturers keep inventory at the component and module level, and postpone product differentiation until the final stage of production. However, most research on modularity assumes that modules are already known in advance. In fact, in the ATO system, the determination of which components should be pre-assembled as modules mainly depends on the types and volumes of products ordered by customers. That is, module composition and volume should be derived dynamically from the product database based on updated customer orders. To bridge this gap, a two-stage cost-based module mining method for the assemble-to-order strategy is proposed. The first stage determines which sets of components can be formed (pre-assembled) as modules based on a list of customer orders. In the second stage, a cost-based selection approach is developed to evaluate the total cost of each module implementation project generated from the set of feasible modules. The module implementation project with the lowest cost is thus found and suggested to production managers.     

Probabilistic clock synchronization

A probabilistic method is proposed for reading remote clocks in distributed systems subject to unbounded random communication delays. The method can achieve clock synchronization precisions superior to those attainable by previously published clock synchronization algorithms. Its use is illustrated by presenting a time service which maintains externally (and hence, internally) synchronized clocks in the presence of process, communication and clock failures. Flaviu Cristian is a computer scientist at the IBM Almaden Research Center in San Jose, California. He received his PhD from the University of Grenoble, France, in 1979. After carrying out research in operating systems and programming methodology in France, and working on the specification, design, and verification of fault-tolerant programs in England, he joined IBM in 1982. Since then he has worked in the area of fault-tolerant distributed protocols and systems. He has participated in the design and implementation of a highly available system prototype at the Almaden Research Center and has reviewed and consulted for several fault-tolerant distributed system designs, both in Europe and in the American divisions of IBM. He is now a technical leader in the design of a new U.S. Air Traffic Control System which must satisfy very stringent availability requirements.     

Distributed fault-tolerant real-time systems: the Mars approach

The authors describe the Maintainable Real-Time System, a fault-tolerant distributed system for process control, developed under the Mars project started in 1980 at the Technische Universitat Berlin. They explore the characteristics of distributed real-time systems and then present the Mars approach to real-time process control, its architectural design and implementation, and one of its applications. The authors focus on the maintainability of the Mars architecture, describe the Mars operating system, and discuss timing analysis. The control of a rolling mill that produces metal plates and bars is examined     

Modular Pluggable Analyses for Data Structure Consistency

Hob is a program analysis system that enables the focused application of multiple analyses to different modules in the same program. In our approach, each module encapsulates one or more data structures and uses membership in abstract sets to characterize how objects participate in data structures. Each analysis verifies that the implementation of the module 1) preserves important internal data structure consistency properties and 2) correctly implements a set algebra interface that characterizes the effects of operations on the data structure. Collectively, the analyses use the set algebra to 1) characterize how objects participate in multiple data structures and to 2) enable the interanalysis communication required to verify properties that depend on multiple modules analyzed by different analyses. We implemented our system and deployed several pluggable analyses, including a flag analysis plug-in for modules in which abstract set membership is determined by a flag field in each object, a PALE shape analysis plug-in, and a theorem proving plug-in for analyzing arbitrarily complicated data structures. Our experience shows that our system can effectively 1) verify the consistency of data structures encapsulated within a single module and 2) combine analysis results from different analysis plug-ins to verify properties involving objects shared by multiple modules analyzed by different analyses