The Specification of Computer Graphics Systems

We describe ongoing work on building an environment to support reasoning in proof assistants that represent formal systems using higher-order abstract syntax (HOAS). We use a simple and general specification language whose syntax supports HOAS. Using this language, we can encode the syntax and inference rules of a variety of formal systems, such as programming languages and logics. We describe our tool, implemented in OCaml, which parses this syntax, and translates it to a Coq library that includes definitions and hints for aiding automated proof in the Hybrid system. Hybrid itself is implemented in Coq, and designed specifically to reason about such formal systems. Given an input specification, the library that is automatically generated by our tool imports the general Hybrid library and adds definitions and hints for aiding automated proof in Hybrid about the specific programming language or logic defined in the specification. This work is part of a larger project to compare reasoning in systems supporting HOAS. Our current work focuses on Hybrid, Abella, Twelf, and Beluga, and the specification language is designed to be general enough to allow the automatic generation of libraries for all of these systems from a single specification.

In article considered and investigated еheoretical and practical recommendations for the formation of the mechanism of versioning the software environment of development time, which is automated, flexible and universal, and does not depend on specific programming languages, software components and other features of the software environment, are considered, researched and developed. It combines two approaches: universal file-by-file and individual for software products that support internal mechanisms for creating simple and incremental file copies of data. The analysis of the constituent elements of such a mechanism and the functional load of each of them is given, its role in the general structure is substantiated.

One of the modern paradigms to develop an application is object oriented analysis and design. In this paradigm, there are several objects and each object plays some specific roles in applications. In an application, we must distinguish between procedural semantics and declarative semantics for their implementation in a specific programming language. For the procedural semantics, we can write a set of instructions that must be executed sequentially. The declarative semantics declare a set of facts and rules. They do not specify the sequence of steps for doing the processing. In this paper, we present four taxonomies for the rules in object-oriented paradigm and discuss how the paradigm can be extended to support declarative semantic of applications. Then, the rules in the taxonomies are evaluated in four case studies. After that, an approach is recommended for finding and implementation of declarative semantics, based on some practical experience obtained from the evaluation.

Communicating with machines in the same way we do with other people has been a long-time goal in computer science. One of its many advantages would be the ability to give instructions to our computers without the need of learning how to use specific software or programming languages. Since we’re dealing with human language, it would make sense to use a model of the human brain to build a system with such capabilities. In this work, the Hierarchical Temporal Memory algorithms are explored and evaluated as a biologically inspired tool capable of working with natural language. It’s proposed that task execution can be achieved by training the algorithms to map certain sentences with keywords that correspond to the tasks. Different encoders are tested, that translate words into a proper representation for the algorithms. The configuration of algorithms and encoders with the highest success rate is able to correctly map up to 90% of the sentences from a custom training set. The behaviour of the success rates does not vary greatly between different subsets of the training set, suggesting that the learning system is able to find patterns and make inferences about missing data.

Different semantic models for a nondeterministic programming language are defined, analysed, and compared in the formal framework of algebraic specifications of programming languages by abstract types. Four abstract types are given representing choice ("erratic") nondeterminism, backtrack ("demonic") nondeterminism, unbounded ("angelic") nondeterminism and loose nondeterminism. The classes of algebras of these types represent classes of semantic models. A comparison of these classes of semantic models shows the connections and differences between the four different concepts of nondeterminism as found in programming languages.

A tool and a methodology to use macros for abstracting variations in code for different computational demands

It is well recognized that Agent Communication Languages (ACL’s) are a critical element of Multi-Agent Systems and a key to their successful application in commerce and industry. The field of protocol engineering, which addresses the problems of specifying and verifying machine communication languages and testing implementations, has developed powerful theoretical and automated techniques for doing this, and more importantly, a mature understanding of the requirements that communication language and protocol specifications should meet. Unfortunately, those developing and promulgating ACL’s appear not to have taken advantage of this body of knowledge. An examination of the current ACL specifications being developed by the Foundation for Intelligent Physical Agents (FIPA) reveals a confusing amalgam of different formal and informal specification techniques whose net result is ambiguous, inconsistent and certainly under-specified. Allowances must be made, as these are draft specifications, but rather than providing a verified foundation for reliable communication between heterogeneous agents, they seem likely to lead to a host of unreliable and incompatible implementations, or to be ignored in favour of more pragmatic and robust approaches. In this paper, we propose a set of requirements against which an ACL specification can be judged, briefly explore some of the shortcomings of the FIPA ACL and their origins, and contrast it with a small ACL which was designed with reliability and ease of verification as prime objectives.KeywordsAgent CommunicationCommunication LanguageMessage TypePragmatic PerspectiveContent LanguageThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Structural operational semantics is a simple, yet powerful mathematical theory for describing the behaviour of programs in an implementation-independent manner. This book provides a self-contained introduction to structural operational semantics, featuring semantic definitions using big-step and small-step semantics of many standard programming language constructs, including control structures, structured declarations and objects, parameter mechanisms and procedural abstraction, concurrency, nondeterminism and the features of functional programming languages. Along the way, the text introduces and applies the relevant proof techniques, including forms of induction and notions of semantic equivalence (including bisimilarity). Thoroughly class-tested, this book has evolved from lecture notes used by the author over a 10-year period at Aalborg University to teach undergraduate and graduate students. The result is a thorough introduction that makes the subject clear to students and computing professionals without sacrificing its rigour. No experience with any specific programming language is required.

Modern data collection and analysis pipelines often involve a sophisticated mix of applications written in general purpose and specialized programming languages. Many formats commonly used to import and export data between different programs or systems, such as CSV or JSON, are verbose, inefficient, not type-safe, or tied to a specific programming language. Protocol Buffers are a popular method of serializing structured data between applications - while remaining independent of programming languages or operating systems. They offer a unique combination of features, performance, and maturity that seems particularly well suited for data-driven applications and numerical computing. The RProtoBuf package provides a complete interface to Protocol Buffers from the R environment for statistical computing. This paper outlines the general class of data serialization requirements for statistical computing, describes the implementation of the RProtoBuf package, and illustrates its use with example applications in large-scale data collection pipelines and web services.

This textbook is intended for an introductory course on Compiler Design, suitable for use in an undergraduate programme in computer science or related fields.Introduction to Compiler Design presents techniques for making realistic, though non-optimizing compilers for simple programming languages using methods that are close to those used in real compilers, albeit slightly simplified in places for presentation purposes. All phases required for translating a high-level language to machine language is covered, including lexing, parsing, intermediate-code generation, machine-code generation and register allocation. Interpretation is covered briefly.Aiming to be neutral with respect to implementation languages, algorithms are presented in pseudo-code rather than in any specific programming language, and suggestions for implementation in several different language flavors are in many cases given. The techniques are illustrated with examples and exercises.The author has taught Compiler Design at the University of Copenhagen for over a decade, and the book is based on material used in the undergraduate Compiler Design course there.Additional material for use with this book, including solutions toselected exercises, is available at http://www.diku.dk/~torbenm/ICD

One of the key factors for automation systems in the domains smart grids, digital factories and modern process systems are the permanently shift of their requirements. Thus, software has to be evolve over time. This issue has been addressed by different solutions for evolving automation software. Though, they have their specific benefits, but lacks on deficiencies like a specific (non-standard) programming model, specific programming languages and a very narrow focus of a specific automation domain. In contrast to this a novel approach will be discussed to provide a more flexible and quite general solution, a common middleware, to reconfigure automation software dynamically with minimal downtime. A middleware to integrate different programming languages, container systems, frameworks, libraries, control applications and drivers as well.

Shadows are well known as a programming language feature in the application area of MUDs (a certain type of multi-player online game). We argue that agile methodologies can be enhanced by the use of shadows as this feature because of its inherent ability to dynamically change the behavior of classes and objects, provides mechanisms to ease common tasks such as prototyping, deprecating, dynamic classification and interclassing at run-time. Therefore shadows should be considered a notion beyond any specific programming languages in order to facilitate its use in model-driven software engineering. For this we introduce Shadows-UML, an UML extension, that would help to push forward the convergence between model-driven and agile methodologies.

The integration of equipment and other devices built into industrial robot cells with modern Ethernet interface technologies and low-cost mass produced devices (such as vision systems, laser scanners, force torque-sensors, PLCs and PDAs etc.) enables integrators to offer more powerful and smarter solutions. Nevertheless, the programming of all these devices efficiently requires very specific knowledge about them, such as their hardware architectures and specific programming languages as well as details about the system's low level communication protocols. To address these issues, this paper describes and analyses the Plug-and-Play architecture. This is one of the most interesting service-oriented architectures (SOAs) available, which exhibits characteristics that are well adapted to industrial robotics cells. To validate their programming features and applicability, a test bed was specially designed. This provides a new graphical service orchestration which was implemented using Workflow Foundation 4 of .NET. The obtained results allowed us to verify that the use of integration schemes based on SOAs reduces the system integration time and is better adapted to industrial robotic cell system integrators.

: In 1989, Estelle was approved as one of two ISO International Standard Formal Description Techniques (FDT) for the formal specification of computer communication protocols. Based on communicating extended finite state machines (CEFSM), Estelle has a formal, mathematical, implementation-independent semantics. It is an expressive, well-defined, well-structured language that is capable of specifying distributed, concurrent information processing systems in a complete, consistent, concise and unambiguous manner. Over the past 3 years with the support of ARO and US Army CECOM, the PI has derived a number of results in the areas: Extensions and enhancements of Estelle; Protocol Visualization, and Automatic Test Case Generation. These results described herein.

There are several acoustic monitoring software packages that allow for the creation and execution of algorithms that automate detection, classification, and localization (DCL). Algorithms written for one program are generally not portable to other programs, and usually must be written in a specific programming language. We have developed an application programming interface (API) that seeks to resolve these issues by providing a plugin framework for creating algorithms for two acoustic monitoring packages: Ishmael and PAMGuard. This API will allow new detection, classification, and localization algorithms to be written for these programs without requiring knowledge of the monitoring software’s source code or inner workings, and lets a single implementation run on either platform. The API also allows users to write DCL algorithms in a wide variety of languages. We hope that this will promote the sharing and reuse of algorithm code. [Funding from ONR.]