Verification and analysis of domain-specific models of physical characteristics in embedded control software

ContextA considerable portion of the software systems today are adopted in the embedded control domain. Embedded control software deals with controlling a physical system, and as such models of physical characteristics become part of the embedded control software.ObjectiveDue to the evolution of system properties and increasing complexity, faults can be left undetected in these models of physical characteristics. Therefore, their accuracy must be verified at runtime. Traditional runtime verification techniques that are based on states/events in software execution are inadequate in this case. The behavior suggested by models of physical characteristics cannot be mapped to behavioral properties of software. Moreover, implementation in a general-purpose programming language makes these models hard to locate and verify. Therefore, this paper proposes a novel approach to perform runtime verification of models of physical characteristics in embedded control software.MethodThe development of an approach for runtime verification of models of physical characteristics and the application of the approach to two industrial case studies from the printing systems domain.ResultsThis paper presents a novel approach to specify models of physical characteristics using a domain-specific language, to define monitors that detect inconsistencies by exploiting redundancy in these models, and to realize these monitors using an aspect-oriented approach. We complement runtime verification with static analysis to verify the composition of domain-specific models with the control software written in a general-purpose language.ConclusionsThe presented approach enables runtime verification of implemented models of physical characteristics to detect inconsistencies in these models, as well as broken hardware components and wear and tear of hardware in the physical system. The application of declarative aspect-oriented techniques to realize runtime verification monitors increases modularity and provides the ability to statically verify this realization. The complementary static and runtime verification techniques increase the reliability of embedded control software.     

Taking Parnas's Principles to the Next Level: Declarative Language Design

SequenceL is a general-purpose functional programming language that exploits information hiding in language design, shielding the programmer from the need to know how the language is implemented.     

USING META-PROGRAMMING,CONSTRAINT LOGIC PROGRAMMING AND APPROXIMATE REASONING FOR EXPERT SYSTEMS DESIGN

Abstract

This paper presents an enhancement of the CARESS system—A Constraint Approximative Reasoning System Support—introduced in (Popescu and Roventa, 1994). CARESS is an experimental system with primarily two objectives:

(1)knowledge representation and manipulation techniques and to implement them in PROLOG III, and

(2) to develop a knowledge programming environment for building expert systems. We discuss here the use of meta-programming, constraint logic programming and approximate reasoning for the design of expert systems

It has already been proven that meta-programming and logic programming are powerful techniques for expert system design. Fuzzy logic can be used to model one kind of uncertainty. Constraint logic programming is useful for dealing with the constraints given by operations using fuzzy sets.     

Learning second and subsequent programming languages: A problem of transfer

Learning second and subsequent programming languages is easier than learning a first programming language because many concepts and constructs are shared. However, it is still a hard task. In this protocol analysis of moderately experienced programmers transferring to a new programming language, we classified episodes by whether they involved the syntactic, semantic, or planning level of programming knowledge. We discovered that most episodes involve planning and that in solving a given subproblem there are typically many cycles of language‐independent tactical planning followed by language‐dependent implementation planning. On the other hand, programmers have relatively minor problems with the syntax and semantics of a new language. Our subjects’ protocols and their final programs revealed that the plans they develop are strongly influenced by their knowledge of what would be convenient and appropriate in other languages they know. This prevents them from taking full advantage of the capabilities of the new language.     

Programming with dual numbers and its applications in mechanisms design

Dual numbers are expressed in the form x+y where ². Dual metanumbers are defined in this paper as DualZero, DualInf and DualNaN. The extended dual plane and the extended finite dual plane are introduced to describe dual numbers and dual metanumbers. Handling of dual numbers in the C^H programming language is presented. The I/O, arithmetic and relational operations, and built-in mathematical functions are defined for both dual numbers and dual metanumbers. As a result of polymorphism, the syntaxes of dual arithmetic and relational operations, and built-in dual functions are the same as those for real and complex numbers in the C^H programming language. The valid lvalues related to dual numbers in C^H are defined. The computation of the motion screw for a rigid-body displacement is used as an example to illustrate the creation of user's dual functions. The efficacy of C^H programming with dual numbers is demonstrated by displacement analysis of an RCCC mechanism. For the first time, dual data is handled as a built-in data type in a general-purpose computer programming language. Programming with dual numbers in C^H is simpler than in any other computer programming language.     

Mayfly: A general-purpose, scalable, parallel processing architecture

TheMayfly is a scalable general-purpose parallel processing system being designed at HP Laboratories, in collaboration with colleagues at the University of Utah. The system is intended to efficiently support parallel variants of modern programming languages such as Lisp, Prolog, and Object Oriented Programming models. These languages impose a common requirement on the hardware platform to supportdynamic system needs such as runtime type checking and dynamic storage management. The main programming language for the Mayfly is a concurrent dialect of Scheme. The system is based on a distributed-memory model, and communication between processing elements is supported by message passing. The initial prototype of Mayfly will consist of 19 identical processing elements interconnected in a hexagonal mesh structure. In order to achieve the goal of scalable performance, each processing element is a parallel processor as well, which permits the application code, runtime operating system, and communication to all run in parallel. A 7 processing element subset of the prototype is presently operational. This paper describes the hardware architecture after a brief background synopsis of the software system structure.     

Programming languages for distributed applications

Much progress has been made in distributed computing in the areas of distribution structure, open computing, fault tolerance, and security. Yet, writing distributed applications remains difficult because the programmer has to manage models of these areas explicitly. A major challenge is to integrate the four models into a coherent development platform. Such a platform should make it possible to cleanly separate an application’s functionality from the other four concerns. Concurrent constraint programming, an evolution of concurrent logic programming, has both the expressiveness and the formal foundation needed to attempt this integration. As a first step, we have designed and built a platform that separates an application’s functionality from its distribution structure. We have prototyped several collaborative tools with this platform, including a shared graphic editor whose design is presented in detail. The platform efficiently implements Distributed Oz, which extends the Oz language with constructs to express the distribution structure and with basic primitives for open computing, failure detection and handling, and resource control. Oz appears to the programmer as a concurrent object-oriented language with dataflow synchronization. Oz is based on a higher-order, state-aware, concurrent constraint computation model. Seif Haridi, Ph.D.: He received his Ph.D. in computer science in 1981 from the Royal Institute of Technology, Sweden. After spending 18 months at IBM T. J. Watson Research Center, he moved to the Swedish Institute of Computer Science (SICS) to form a research lab on logic programming and parallel systems. Dr. Haridi is currently the research director of the Swedish Institute of Computer Science. He has been an active researcher in the area of logic and constraint programming and parallel processing since the beginning of the eighties. His earlier work includes contributions to the design of SICStus Prolog, various parallel Prolog systems and a class of scalable cache-coherent multiprocessors known as Cache-Only Memory Architecture (COMA). During the nineties most of his work focused on the design of multiparadigm programming systems based on Concurrent Constraint Programming (CCP). Currently, he is interested in programming systems and software methodology for distributed and agent-based applications. Peter Van Roy, Ph.D.: He obtained an engineering degree from the Vrije Universiteit Brussel (1983), Masters and Ph.D. degrees from the University of California at Berkeley (1984, 1990), and the Habilitation à Diriger des Recherches from Paris VII Denis Diderot (1996). He has made major contributions to logic language implementation. His research showed for the first time that Prolog can be implemented with the same execution efficiency as C. He was principal developer or codeveloper of Aquarius Prolog, Wild_Life, Logical State Threads, and FractaSketch. He joined the Oz project in 1994 and is currently working on Distributed Oz. His research interests are motivated by the desire to provide increased expressivity and efficiency to application developers. Per Brand: He is a researcher at the Swedish Institute of Computer Science. He has previously worked on the design and implementation of OR-parallel Prolog (the Aurora project) and optimized compilation techniques for Concurrent Constraint Programming Languages (in particular, AKL). He has been a member of the Distributed Oz design team since the project began. His research interests are focused on techniques, languages, and methodology for distributed programming. Christian Schulte: He studied computer science at the University of Karlsruhe, Germany, from 1987 to 1992 where he received his diploma. Since 1992 he has been a member of the Programming Systems Lab at DFKI. He is one of the principal designers of Oz. His research interests include design, implementation, and application of concurrent and distributed programming languages as well as constraint programming.     

Techniques of integrating Datalog with PROLOG

Since extending DATALOG to a general-purpose programming language seems very difficult,many projects have embedded a DATALOG-based query laguage into a procedural host language,such as CORAL,Glue-Nail,etc.Although DATALOG can be consideed as function-free PROLOG,they are very different in many aspects.For instance,DATALOG is declarative while PROLOG isn‘t,DATALOG takes “a-set-at-a-time” mode of evaluation but PROLOG takes “a-tuple-at-a-time”one,DATALOG is only a query language whereas PROLOG is a general-purpose programming language.It is thought that integrating DATALOG with PROLOG may take their advantages.KBASEP is such a language.It uses KBASE as the query language and PROLOG as its procedural host language,where KBASE is a ne extemsion of DATALOG with negation and function.This paper introduces the integration techniques used in KBASE-P system.     

Temporal disjunctive logic programming

In this paper we introduce the logic programming languageDisjunctive Chronolog which combines the programming paradigms of temporal and disjunctive logic programming. Disjunctive Chronolog is capable of expressing dynamic behaviour as well as uncertainty, two notions that are very common in a variety of real systems. We present the minimal temporal model semantics and the fixpoint semantics for the new programming language and demonstrate their equivalence. We also show how proof procedures developed for disjunctive logic programs can be easily extended to apply to Disjunctive Chronolog programs. Manolis Gergatsoulis, Ph.D.: He received his B.Sc. in Physics in 1983, the M.Sc. and the Ph.D. degrees in Computer Science in 1986 and 1995 respectively all from the University of Athens, Greece. Since 1996 he is a Research Associate in the Institute of Informatics and Telecommunications, NCSR ‘Demokritos’, Athens. His research interests include logic and temporal programming, program transformations and synthesis, as well as theory of programming languages. Panagiotis Rondogiannis, Ph.D.: He received his B.Sc. from the Department of Computer Engineering and Informatics, University of Patras, Greece, in 1989, and his M.Sc. and Ph.D. from the Department of Computer Science, University of Victoria, Canada, in 1991 and 1994 respectively. From 1995 to 1996 he served in the Greek army. From 1996 to 1997 he was a visiting professor in the Department of Computer Science, University of Ioannina, Greece, and since 1997 he is a Lecturer in the same Department. In January 2000 he was elected Assistant Professor in the Department of Informatics at the University of Athens. His research interests include functional, logic and temporal programming, as well as theory of programming languages. Themis Panayiotopoulos, Ph.D.: He received his Diploma on Electrical Engineering from the Department of Electrical Engineering, National Technical Univesity of Athens, in 1984, and his Ph.D. on Artificial Intelligence from the above mentioned department in 1989. From 1991 to 1994 he was a visiting professor at the Department of Mathematics, University of the Aegean, Samos, Greece and a Research Associate at the Institute of Informatics and Telecommunications of “Democritos” National Research Center. Since 1995 he is an Assistant Prof. at the Department of Computer Science, University of Piraeus. His research interests include temporal programming, logic programming, expert systems and intelligent agent architectures.     

MOVIE model for open-systems-based high-performance distributed computing

MOVIE (Multitasking Object-oriented Visual Interactive Environment) is a new software system for high-performance distributed computing (HPDC), currently in the advanced design and implementation stage at Northeast Parallel Architectures Center (NPAC), Syracuse University. The MOVIE system is structured as a multiserver network of interpreters of the high-level object-oriented programming language MovieScript. MovieScript derives from PostScript and extends it in the C⁺⁺ syntax-based object-oriented interpreted style towards 3D graphics, high-performance computing and general-purpose high-level communication protocol for distributed and MIMD-parallel computing. The paper describes the overall open systems-based MOVIE design and itemizes currently implemented, developed and planned components of the system.     

Visual Lisp/CLOS programming in OpenMusic

OpenMusic (OM) is a visual programming language developed on top of Common Lisp and CLOS, in which most of the functional and object-oriented programming concepts can be implemented and carried out graphically. Although this visual language was designed for musical applications, the focus in this paper is to describe and study OM as a complete general-purpose programming environment.     

Standardizing the narrative of use cases: A controlled vocabulary of web user tasks

ContextFor user interfaces design, the use of appropriate terminology in writing use case narratives may determine the effectiveness of the design process, facilitating communication within multidisciplinary web development teams and leading to agreed designs.ObjectiveThis paper proposes a user task vocabulary for web user interface design. This vocabulary compiles terms related to the use of web applications, regardless of the application domain, as a way of standardizing the terminology used in the elaboration of use case narrative. The use of the vocabulary would help to reduce misunderstandings within multidisciplinary web development teams.MethodThe construction of the vocabulary is based on the combination of both committee and empirical approaches. Committee approaches rely on experts in designing web applications, while empirical ones are focused on analyzing content objects, such as interaction design patterns and use case narratives.ResultsThe final version of the monolingual controlled vocabulary of web user tasks compiles a total of 40 tasks; each of them has a key term and a definition of the interaction carried out by users. Additionally, 41 semantic relationships were collected and represented as synonyms. The vocabulary has been assessed through an expert evaluation, proving its correctness and completeness, and an usability evaluation checking the efficacy of the vocabulary.ConclusionThe language employed in use case narratives can determine the value of use cases for designing user interfaces. The usage of a controlled vocabulary may allow designers to elaborate unambiguous use case narratives as a way of creating consistent task models for designing web user interfaces.     

An extensive empirical study on C++ concurrency constructs

ContextNowadays concurrent programming is in large demand. The inherent support for concurrency is therefore increasingly important in programming languages. As for C++, an abundance of standard concurrency constructs have been supported since C++11. However, to date there is little work investigating how these constructs are actually used in developing real software.ObjectiveIn this paper, we perform an extensive empirical study to investigate the actual adoption of C++ concurrency constructs in open-source applications, with the goal to provide useful information for language designers and practitioners to improve the design and use of concurrency constructs.MethodWe first conduct a survey to understand the developers’ perception of concurrency constructs. Then, we analyze 492 open-source concurrent applications, comprising 131 million lines of C++ code, to collect the data of the practical adoption of concurrency constructs. Finally, we perform statistical analysis on the collected data and get the quantitative analysis results.ResultsUsing the experimental data, we uncover many interesting findings with respect to the usage of concurrency constructs, the management of synchronization, the relationship between standard concurrency constructs and third-party concurrency constructs, and the difference of applications in using concurrency constructs. For example, we find that: (1) thread-based constructs are significantly more often used to write concurrent programs than atomics-based constructs and task-based constructs; (2) lock-based constructs are significantly more often used to manage synchronization than lock-free constructs and blocking constructs; (3) developers in most projects do not move from third-party concurrency constructs to standard concurrency constructs; and (4) small-size applications introduce concurrency constructs more intensively and more quickly than medium-size applications and large-size applications.ConclusionsThis is the first extensive empirical study on C++ concurrency constructs. The results of this paper should be helpful for designing, teaching, and using C++ concurrency constructs.     

Seamless hardware-software integration in reconfigurable computing systems

Ideally, reconfigurable-system programmers and designers should code algorithms and write hardware accelerators independently of the underlying platform. To realize this scenario, the authors propose a portable, hardware-agnostic programming paradigm, which delegates platform-specific tasks to a system-level virtualization layer. This layer supports a chosen programming model and hides platform details from users much as general-purpose computers do. We introduce multithreaded programming model for reconfigurable computing based on a unified virtual-memory image for both software and hardware application parts. We also address the challenge of achieving seamless hardware-software interfacing and portability with minimal performance penalties.     

The expressive power of the bounded-iteration construct

The bounded-iteration constructforeach x in R/p do t od is very commonly used in database programming, due to the fact that database programs are dominated by data retrieval and manipulation tasks rather than by complex computations. Hence in database programming language design, it is important to understand the expressive power of the bounded-iteration construct and its relationship with other language constructs. We study the bounded-iteration construct within the context of a simple database programming language called theiterative transaction language. The language is shown to have NPTIME expressive power, and the deterministic subclass of it has PTIME expressive power, without any extra machineries or restrictions. We show that the bounded-iteration construct is essential for achieving this expressiveness, by characterizing its relationship with other constructs in the language. We also identify another natural subclass of iterative transactions calledfirst-order transactions with exactly first-order expressive power. The complexity of first-order transactions in terms of nested iterations and intermediate states is connected further to the complexity of first-order updates in terms of quantification depth.This work was supported in part by the Defense Advanced Research Projects Agency under Contract N39-84-C-0211 for Knowledge Based Management Systems and by Rome Air Development Center under Contract 30602-86-C-0026 for Knowledge-Based Software AssistantAn extended abstract of this work appeared in the Proceedings of the Second International Workshop on Database Programming Languages, 1989, 411–421     

An entity-relationship programming language

The syntax for an integrated E-R programming language is presented. The problems that arise when a query language is embedded in a general-purpose programming language are discussed. Other E-R languages are also discussed. The requirements for the language and a syntax for an E-R model in which entity sets are mutually disjoint and each entity type has a unique, perhaps multiattribute, key are presented. The syntax for a more limited model restricted to binary relationships between entity types and without attributes is presented. Some implementation considerations are discussed     

A programming language for learning environments

Most of the recent research on programming languages for education has been centered around the language Logo. In this paper we introduce another candidate language for learning environments, Nial, the nested interactive array language.
Nial is a general-purpose programming language based on a formal theory of mathematics called array theory. This paper introduces Nial as a language for learning programming and developing and using computer-aided instruction tools. A comparison with Logo is provided to evaluate these two languages in terms of their strengths and weaknesses as programming environments for novice programmers. We also demonstrate that a programming environment can be both simple to leam at the novice level and extendible to a powerful and sophisticated language.     

A Novel Computer Architecture to Prevent Destruction by Viruses

In today‘s Internet computing world,illegal activities by crackers pose a serious threat to computer security.It is well known that computer viruses,Trojan horses and other intrusive programs may cause sever and often catastrophic consequences. This paper proposes a novel secure computer architecture based on security-code.Every instruction/data word is added with a security-code denoting its security level.External programs and data are automatically addoed with security-code by hadware when entering a computer system.Instruction with lower security-code cannot run or process instruction/data with higher security level.Security-code cannot be modified by normal instruction.With minor hardware overhead,then new architecture can effectively protect the main computer system from destruction or theft by intrusive programs such as computer viruses.For most PC systems it includes an increase of word-length by 1 bit on register,the memory and the hard disk.     

Cobol for the next millennium

Cobol 2002, the new Cobol standard, is expected to be finalized in approximately 18 months. Cobol 2002 builds on Cobol's first-class data handling capabilities and introduces object oriented features, environmental improvements, and many other modern constructs to the language. The improvements position Cobol as both a business and general-purpose programming language, capable of handling a wide variety of programming tasks     

The problem with threads

For concurrent programming to become mainstream, we must discard threads as a programming model. Nondeterminism should be judiciously and carefully introduced where needed, and it should be explicit in programs. In general-purpose software engineering practice, we have reached a point where one approach to concurrent programming dominates all others namely, threads, sequential processes that share memory. They represent a key concurrency model supported by modern computers, programming languages, and operating systems. In scientific computing, where performance requirements have long demanded concurrent programming, data-parallel language extensions and message-passing libraries such as PVM, MPI, and OpenMP dominate over threads for concurrent programming. Computer architectures intended for scientific computing often differ significantly from so-called general-purpose architectures.