scholarly journals A GRAPH-BASED SYSTEM FOR MANAGING CONFIGURATIONS OF ENGINEERING DESIGN DOCUMENTS

1996 ◽  
Vol 06 (04) ◽  
pp. 549-583 ◽  
Author(s):  
BERNHARD WESTFECHTEL
Keyword(s):  
Programming Languages ◽  
Engineering Design ◽  
Configuration Management ◽  
Database Systems ◽  
Software Systems ◽  
Rewriting Systems ◽  
Knowledge Based ◽  
Management Concepts ◽  
Design Documents ◽  
High Level

Due to increasing complexity of hardware and software systems, configuration management has been receiving more and more attention in nearly all engineering domains (e.g. electrical, mechanical, and software engineering). This observation has driven us to develop a domain-independent and adaptable configuration management model (called CoMa) for managing systems of engineering design documents. The CoMa model integrates composition hierarchies, dependencies, and versions into a coherent framework based on a sparse set of essential configuration management concepts. In order to give a clear and comprehensible specification, the CoMa model is defined in a high-level, multi-paradigm specification language (PROGRES) which combines concepts from various disciplines (database systems, knowledge-based systems, graph rewriting systems, programming languages). Finally, we also present an implementation which conforms to the formal specification and provides graphical, structure-oriented tools offering a bunch of sophisticated commands and operating in a heterogeneous environment.

A REUSE-ORIENTED WORKFLOW DEFINITION LANGUAGE

2003 ◽  
Vol 12 (01) ◽  
pp. 1-36 ◽  
Author(s):  
MARIE JOSÉ BLIN ◽  
JACQUES WAINER ◽  
CLAUDIA BAUZER MEDEIROS
Keyword(s):  
Programming Languages ◽  
Building Blocks ◽  
Database Systems ◽  
Exception Handling ◽  
Control Flow ◽  
New Formalism ◽  
Definition Of ◽  
High Level ◽  
And Control ◽  
High Degree

This paper presents a new formalism for workflow process definition, which combines research in programming languages and in database systems. This formalism is based on creating a library of workflow building blocks, which can be progressively combined and nested to construct complex workflows. Workflows are specified declaratively, using a simple high level language, which allows the dynamic definition of exception handling and events, as well as dynamically overriding workflow definition. This ensures a high degree of flexibility in data and control flow specification, as well as in reuse of workflow specifications to construct other workflows. The resulting workflow execution environment is well suited to supporting cooperative work.

Knowledge-based systems, Lisp, and very high level implementation languages

1992 ◽  
Vol 7 (2) ◽  
pp. 147-155
Author(s):  
Eric Sandewall
Keyword(s):  
Operating System ◽  
Programming Languages ◽  
Knowledge Based Systems ◽  
Machine Code ◽  
Low Level ◽  
Knowledge Based ◽  
High Level ◽  
Very High

AbstractIt is usually agreed that programming languages for implementing (other) programming languages, or ‘implementation languages’, should be simple low-level languages which are close to the machine code and to the operating system. In this paper it is argued that a very high level implementation language is a good idea, of particular importance for knowledge-based systems, and that Lisp (as a language and as a system) is very well suited to be a very high level implementation language. The significance of special-purpose programming languages is also discussed, and the requirements that they have for a very high level implementation language are considered.

AN ABSTRACT, SHARED AND PERSISTENT DATA STRUCTURE FOR SUPPORTING DATABASE MANAGEMENT AND MULTILINGUAL NATURAL LANGUAGE PROCESSING

1993 ◽  
Vol 03 (03) ◽  
pp. 369-382 ◽  
Author(s):  
CUI ZHANG ◽  
RICHARD F. WALTERS
Keyword(s):  
Data Structure ◽  
Programming Languages ◽  
Language Processing ◽  
Database Management ◽  
English Language ◽  
Database Systems ◽  
General Purpose ◽  
Programming Environment ◽  
Persistent Data ◽  
High Level

Neither today’s general purpose programming environment nor high-level programming languages, including those designed for AI purposes, provide adequate support for database systems. Furthermore, non-English language databases are difficult to treat either in existing database systems or with current high-level languages, because they require culture-sensitive operations on multiple foreign character sets. In this paper, we present an abstract, shared and persistent data structure, called HL+, capable of supporting database management applications. We also describe the means for coping with the aforementioned problems by accessing HL+ features of database management from high-level programming languages with an extensible programmable high-level language interface. Extensions to the data structure to accommodate processing of multiple foreign character strings are also described, and examples of multilingual applications are given.

scholarly journals Integration of MatLab and R with high-level languages using C# and Microsoft Visual Studio as an example

2021 ◽  
Vol 2131 (2) ◽  
pp. 022096
Author(s):  
A V Krasnovidov ◽  
A D Khomonenko
Keyword(s):  
Data Processing ◽  
Programming Languages ◽  
Statistical Data ◽  
Appropriate Technology ◽  
Software Systems ◽  
Statistical Data Processing ◽  
Single Interface ◽  
High Interaction ◽  
Interaction Efficiency ◽  
High Level

Abstract The paper discusses the technology of integration (providing a single interface of interaction) of different software systems working in a single environment. The levels of integration are indicated, the composition of subtasks (subsystems), which can be solved efficiently using various computing environments, are highlighted. The expediency of joint use of MatLab and R systems with high-level programming languages C ++ and C # is shown due to the limited or lack of tools for creating a convenient graphical user interface for mathematical systems, as well as the weak adaptability of programming languages for mathematical or statistical data processing and solving modeling problems. The aim of the article is to justify the most appropriate technology for integrating MatLab and R with highlevel programming languages to ensure high interaction efficiency and a user-friendly interface for complex mathematical or statistical data processing problems. The analysis of the possibilities and ways of solving the organization of interaction of MatLab and R systems with high-level languages carried out on the example of C # and the Microsoft Visual Studio environment. The possibilities of interaction of the R system and the MatLab system with highlevel programming languages, respectively, are considered. An example of software implementation of the integration of R and MatLab with a C# application is given. The capabilities of the developed program as a whole and the functionality of each of the subsystems used (R, MatLab and applications in C #) are indicated. The most preferable variant of integration of the considered systems - with the use of .NetFramework platform - is singled out. The advantages of using the Common Language Runtime for the implementation of the considered option of integrating R, MatLab and C # applications are noted.

Investigation and Impact of Knowledge-Based Information on Programming Languages Based on Probabilistic Models

2010 ◽  
Vol 39 ◽  
pp. 436-440
Author(s):  
Zhi Ming Qu
Keyword(s):  
Expert Systems ◽  
Programming Languages ◽  
Probabilistic Models ◽  
Role Playing ◽  
Position Paper ◽  
The Other ◽  
Erasure Coding ◽  
Role Playing Games ◽  
Knowledge Based ◽  
Other Hand

In recent years, much research has been devoted to the refinement of IPv6; on the other hand, few have investigated the confusing unification of interrupts and Internet QoS. In this position paper, it demonstrates the emulation of interrupts. In order to overcome this quagmire, a novel system is presented for the intuitive unification of expert systems and massive multiplayer online role-playing games. It is concluded that erasure coding can be verified to make heterogeneous, interposable, and event-driven, which is proved to be applicable.

CSim 2

2021 ◽  
Vol 43 (1) ◽  
pp. 1-46
Author(s):  
David Sanan ◽  
Yongwang Zhao ◽  
Shang-Wei Lin ◽  
Liu Yang
Keyword(s):  
Programming Languages ◽  
Concurrent Systems ◽  
Theorem Prover ◽  
Compositional Techniques ◽  
Machine Code ◽  
Top Down ◽  
Hol Theorem Prover ◽  
High Level ◽  
High Degree

To make feasible and scalable the verification of large and complex concurrent systems, it is necessary the use of compositional techniques even at the highest abstraction layers. When focusing on the lowest software abstraction layers, such as the implementation or the machine code, the high level of detail of those layers makes the direct verification of properties very difficult and expensive. It is therefore essential to use techniques allowing to simplify the verification on these layers. One technique to tackle this challenge is top-down verification where by means of simulation properties verified on top layers (representing abstract specifications of a system) are propagated down to the lowest layers (that are an implementation of the top layers). There is no need to say that simulation of concurrent systems implies a greater level of complexity, and having compositional techniques to check simulation between layers is also desirable when seeking for both feasibility and scalability of the refinement verification. In this article, we present CSim 2 a (compositional) rely-guarantee-based framework for the top-down verification of complex concurrent systems in the Isabelle/HOL theorem prover. CSim 2 uses CSimpl, a language with a high degree of expressiveness designed for the specification of concurrent programs. Thanks to its expressibility, CSimpl is able to model many of the features found in real world programming languages like exceptions, assertions, and procedures. CSim 2 provides a framework for the verification of rely-guarantee properties to compositionally reason on CSimpl specifications. Focusing on top-down verification, CSim 2 provides a simulation-based framework for the preservation of CSimpl rely-guarantee properties from specifications to implementations. By using the simulation framework, properties proven on the top layers (abstract specifications) are compositionally propagated down to the lowest layers (source or machine code) in each concurrent component of the system. Finally, we show the usability of CSim 2 by running a case study over two CSimpl specifications of an Arinc-653 communication service. In this case study, we prove a complex property on a specification, and we use CSim 2 to preserve the property on lower abstraction layers.

PATTERN MATCHING CODE MINIMIZATION IN REWRITING-BASED PROGRAMMING LANGUAGES

2002 ◽  
Vol 13 (06) ◽  
pp. 873-887
Author(s):  
NADIA NEDJAH ◽  
LUIZA DE MACEDO MOURELLE
Keyword(s):  
Programming Languages ◽  
Pattern Matching ◽  
Term Rewriting ◽  
Directed Acyclic Graphs ◽  
Tree Automaton ◽  
Minimal Tree ◽  
Term Rewriting Systems ◽  
Rewriting Systems ◽  
Acyclic Graphs ◽  
Space Requirements

We compile pattern matching for overlapping patterns in term rewriting systems into a minimal, tree matching automata. The use of directed acyclic graphs that shares all the isomorphic subautomata allows us to reduce space requirements. These are duplicated in the tree automaton. We design an efficient method to identify such subautomata and avoid duplicating their construction while generating the dag automaton. We compute some bounds on the size of the automata, thereby improving on previously known equivalent bounds for the tree automaton.

Application of C Sharp and MATLAB Mixed Programming Based on .Net Assembly in Blind Source Separation

2014 ◽  
Vol 599-601 ◽  
pp. 1407-1410
Author(s):  
Xu Liang ◽  
Ke Ming Wang ◽  
Gui Yu Xin
Keyword(s):  
Numerical Calculation ◽  
Programming Languages ◽  
Blind Source Separation ◽  
Source Separation ◽  
Processing System ◽  
Signal Processing System ◽  
Blind Signal Processing ◽  
Blind Signal ◽  
Mixed Programming ◽  
High Level

Comparing with other High-level programming languages, C Sharp (C#) is more efficient in software development. While MATLAB language provides a series of powerful functions of numerical calculation that facilitate adoption of algorithms, which are widely applied in blind source separation (BSS). Combining the advantages of the two languages, this paper presents an implementation of mixed programming and the development of a simplified blind signal processing system. Application results show the system developed by mixed programming is successful.

NENOK — A SOFTWARE ARCHITECTURE FOR GENERIC INFERENCE

2010 ◽  
Vol 19 (01) ◽  
pp. 65-99 ◽  
Author(s):  
MARC POULY
Keyword(s):  
Programming Languages ◽  
Software Library ◽  
Inference Process ◽  
Software Projects ◽  
Open Problems ◽  
Constraint Systems ◽  
Fast Prototyping ◽  
Inference Algorithms ◽  
Key Competences ◽  
High Level

Computing inference from a given knowledgebase is one of the key competences of computer science. Therefore, numerous formalisms and specialized inference routines have been introduced and implemented for this task. Typical examples are Bayesian networks, constraint systems or different kinds of logic. It is known today that these formalisms can be unified under a common algebraic roof called valuation algebra. Based on this system, generic inference algorithms for the processing of arbitrary valuation algebras can be defined. Researchers benefit from this high level of abstraction to address open problems independently of the underlying formalism. It is therefore all the more astonishing that this theory did not find its way into concrete software projects. Indeed, all modern programming languages for example provide generic sorting procedures, but generic inference algorithms are still mythical creatures. NENOK breaks a new ground and offers an extensive library of generic inference tools based on the valuation algebra framework. All methods are implemented as distributed algorithms that process local and remote knowledgebases in a transparent manner. Besides its main purpose as software library, NENOK also provides a sophisticated graphical user interface to inspect the inference process and the involved graphical structures. This can be used for educational purposes but also as a fast prototyping architecture for inference formalisms.

Sign in / Sign up

Export Citation Format

Share Document