检索结果-内蒙古大学图书馆

Relation Algebra as programming language using the Ampersand compiler

JOURNAL OF LOGICAL AND ALGEBRAIC METHODS IN programming 2018年 100卷 113-129页

作者： Joosten, Stef Open Univ Nederland Postbus 2960 NL-6401 DL Heerlen Netherlands Ordina NV Nieuwegein Netherlands

Relation Algebra can be used as a programming language for building information systems. This paper demonstrates the principle by presenting a case study together with the theory behind programming in Relation Algebra. As a case study, we have developed a database application for legal reasoning. We discuss a small part of it to illustrate the mechanisms of programming in Relation Algebra. Beside being declarative, relation algebra comes with attractive prospects for developing software. The compiler that was used for this case study, Ampersand, is the result of an open source project. Ampersand has been tried and tested in practice and is available as free open source software.(1) (C) 2018 Elsevier Inc. All rights reserved.

关键词： Relation Algebra Software development Legal reasoning Information systems design Ampersand reactive programming

来源：评论

学校读者我要写书评

暂无评论

FairThreads: mixing cooperative and preemptive threads in C

引用

CONCURRENCY AND COMPUTATION-PRACTICE & EXPERIENCE 2006年第5期18卷 445-469页

作者： Boussinot, F INRIA CMA EMP MIMOSA Project F-06902 Sophia Antipolis France

FairThreads introduces fair threads which are executed in a cooperative way when linked to a scheduler, and in a preemptive way otherwise. Constructs exist for programming the dynamic linking/unlinking of threads during execution. Users can profit from the cooperative scheduling when threads are linked. For example, data only accessed by the threads linked to the same scheduler does not need to be protected by locks. Users can also profit from the preemptive scheduling provided by the operating system (OS) when threads are unlinked, for example to deal with blocking I/Os. In the cooperative context, for the threads linked to the same scheduler, FairThreads make it possible to use broadcast events. Broadcasting is a powerful, abstract, and modular means of communication. Basically, event broadcasting is made possible by the specific way threads are scheduled by the scheduler to which they are linked (the 'fair' strategy). FairThreads give a way to deal with some limitations of the OS. Automata are special threads, coded as state machines, which do not need the allocation of a native thread and which have efficient execution. Automata also give a means to deal with the limited number of native threads available when large numbers of concurrent tasks are needed, for example in simulations. Copyright (c) 2005 John Wiley & Sons, Ltd.

关键词： concurrency parallelism thread C language multiprocessor reactive programming

来源：评论

学校读者我要写书评

暂无评论

Logic of global synchrony

引用

ACM TRANSACTIONS ON programming LANGUAGES AND SYSTEMS 2004年第2期26卷 221-262页

作者： Chen, YF Sanders, JW Univ Leicester Dept Comp Sci Leicester LE1 7RH Leics England Univ Oxford Oxford OX1 2JD England

An intermediate-level specification formalism (i.e., specification language supported by laws and a semantic model), LOGS, is presented for PRAM and BSP styles of parallel programming. It extends pre-post sequential semantics to reveal states at points of global synchronization. The result is an integration of the pre-post and reactive-process styles of specification. The language consists of only six commands from which other useful commands can be derived. Parallel composition is simply logical conjunction and hence compositional. A simple predicative semantics and a complete set of algebraic laws are presented. Novel ingredients include the separation, in our reactive context, of the processes for nontermination and for abortion which coincide in standard programming models;the use of partitions, combining the terminating behavior of one program with the nonterminating behavior of another;and a fixpoint operator, the partitioned fixpoint. Our semantics benefits from the recent "healthiness function" approach for predicative semantics. Use of LOGS, along with the laws for reasoning about it, is demonstrated on two problems: matrix multiplication ( a terminating numerical computation) and the dining philosophers (a reactive computation). The style of reasoning is so close to programming practice that direct transformation from LOGS specifications to real PRAM and BSP programs becomes possible.

关键词： languages theory bulk-synchronous parallelism PRAM reactive programming

来源：评论

学校读者我要写书评

暂无评论

programming with Implicit Flows

引用

IEEE SOFTWARE 2014年第5期31卷 52-59页

作者： Salvaneschi, Guido Mezini, Mira Eugster, Patrick Tech Univ Darmstadt Darmstadt Germany Univ Lancaster Lancaster LA1 4YW England Purdue Univ W Lafayette IN 47907 USA

Modern software differs significantly from traditional computer applications that mostly process reasonably small amounts of static input data-sets in batch mode. Modern software increasingly processes massive amounts of data, whereby it is also often the case that new input data is produced and/or existing data is modified on the fly. Consequently, programming models that facilitate the development of such software are emerging. What characterizes them is that data, respectively changes thereof, implicitly flow through computation modules. The software engineer declaratively defines computations as compositions of other computations without explicitly modeling how data should flow along dependency relations between data producer and data consumer modules, letting the runtime to automatically manage and optimize data flows.

关键词： Software Engineering Implicit Flows programming Static Input Data Sets programming Models Software Development Computation Modules Data Producer Module Data Consumer Module Data Flow Management Data Flow Optimization programming Big Data Computational Modeling Runtime Software Engineering Data Models Market Research reactive programming Event Stream Big Data Data Flow programming Languages Software Engineering

来源：评论

学校读者我要写书评

暂无评论

Designing Autonomic Management Systems by Using reactive Control Techniques

引用

IEEE TRANSACTIONS ON SOFTWARE ENGINEERING 2016年第7期42卷 640-657页

作者： Berthier, Nicolas Rutten, Eric De Palma, Noel Gueye, Soguy Mak-Kare Univ Grenoble ERODS Team LIG Bat C220 Rue Chim F-38400 St Martin Dheres France INRIA Rennes Bretagne Atlantique SUMO Team Campus Beaulieu F-35042 Rennes France LIG INRIA Grenoble Rhone Alpes Inovallee655 Ave Europe F-38334 Montbonnot St Martin St Ismier France

The ever growing complexity of software systems has led to the emergence of automated solutions for their management. The software assigned to this work is usually called an Autonomic Management System (AMS). It is ordinarily designed as a composition of several managers, which are pieces of software evaluating the dynamics of the system under management through measurements (e.g., workload, memory usage), taking decisions, and acting upon it so that it stays in a set of acceptable operating states. However, careless combination of managers may lead to inconsistencies in the taken decisions, and classical approaches dealing with these coordination problems often rely on intricate and ad hoc solutions. To tackle this problem, we take a global view and underscore that AMSs are intrinsically reactive, as they react to flows of monitoring data by emitting flows of reconfiguration actions. Therefore we propose a new approach for the design of AMSs, based on synchronous programming and discrete controller synthesis techniques. They provide us with high-level languages for modeling the system to manage, as well as means for statically guaranteeing the absence of logical coordination problems. Hence, they suit our main contribution, which is to obtain guarantees at design time about the absence of logical inconsistencies in the taken decisions. We detail our approach, illustrate it by designing an AMS for a realistic multi-tier application, and evaluate its practicality with an implementation.

关键词： Autonomic computing coordination discrete control reactive programming

来源：评论

学校读者我要写书评

暂无评论

reactive model transformation with ATL

引用

SCIENCE OF COMPUTER programming 2017年 136卷 1-16页

作者： Martinez, Salvador Tisi, Massimo Douence, Remi LINA Mines Nantes Inria AtlanMod Team Nantes France LINA Mines Nantes Inria Ascola Team Nantes France

Model-driven applications may maintain large networks of structured data models and transformations among them. The development of such applications is complicated by the need to reflect on the whole network any runtime update performed on models or transformation logic. If not carefully designed, the execution of such updates may be computationally expensive. In this paper we propose a reactive paradigm for programming model transformations, and we implement a reactive model-transformation engine. We argue that this paradigm facilitates the development of autonomous model-driven systems that react to update and request events from the host application by identifying and performing only the needed computation. We implement such approach by providing a reactive engine for the An transformation language. We evaluate the usage scenarios that this paradigm supports and we experimentally measure its ability to reduce computation time in transformation-based applications. (C) 2016 Elsevier B.V. All rights reserved.

关键词： Model-driven engineering Model transformations reactive programming

来源：评论

学校读者我要写书评

暂无评论

Synchronous Deterministic Parallel programming for Multi-Cores with ForeC

引用

ACM TRANSACTIONS ON programming LANGUAGES AND SYSTEMS 2023年第2期45卷 1-74页

作者： Yip, Eugene Girault, Alain Roop, Partha S. Biglari-Abhari, Morteza Univ Bamberg Software Technol Res Grp D-96047 Bamberg Germany Univ Grenoble Alpes INRIA CNRS Grenoble INPLIG Grenoble France Univ Auckland Dept ECE Auckland New Zealand

Embedded real-time systems are tightly integrated with their physical environment. Their correctness depends both on the outputs and timeliness of their computations. The increasing use of multi-core processors in such systems is pushing embedded programmers to be parallel programming experts. However, parallel programming is challenging because of the skills, experiences, and knowledge needed to avoid common parallel programming traps and pitfalls. This article proposes the ForeC synchronous multi-threaded programming language for the deterministic, parallel, and reactive programming of embedded multi-cores. The synchronous semantics of ForeC is designed to greatly simplify the understanding and debugging of parallel programs. ForeC ensures that ForeC programs can be compiled efficiently for parallel execution and be amenable to static timing analysis. ForeC's main innovation is its shared variable semantics that provides thread isolation and deterministic thread communication. All ForeC programs are correct by construction and deadlock free because no non-deterministic constructs are needed. We have benchmarked our ForeC compiler with several medium-sized programs (e.g., a 2.274-line ForeC program with up to 26 threads and distributed on up to 10 cores, which was based on a 2.155-line non-multi-threaded C program). These benchmark programs show that ForeC can achieve better parallel performance than Esterel, a widely used imperative synchronous language for concurrent safety-critical systems, and is competitive in performance to OpenMP, a popular desktop solution for parallel programming (which implements classical multi-threading, hence is intrinsically non-deterministic). We also demonstrate that the worst-case execution time of ForeC programs can be estimated to a high degree of precision.

关键词： programming language semantics parallelism synchronous determinism reactive programming multi-core worst-case execution time code generation

来源：评论

学校读者我要写书评

暂无评论

Typing noninterference for reactive programs

引用

JOURNAL OF LOGIC AND ALGEBRAIC programming 2007年第2期72卷 124-156页

作者： Matos, Ana Almeida Boudol, Gerard Castellani, Ilaria INRIA F-06902 Sophia Antipolis France

We study the security property of noninterference for a class of synchronous programs called reactive programs. We consider a core reactive language, obtained by extending the imperative language of Volpano, Smith and Irvine with a form of scheduled parallelism and with reactive primitives that manipulate broadcast signals. The definition of noninterference has to be tuned to the particular nature of reactive computations, which are regulated by a notion of instant. Moreover, a new form of covert channel may arise in reactive computations, called suspension leak. We give a formulation of noninterference based on bisimulation, as is now usual for concurrent languages. We then propose a type system to enforce this property in our language. Our type system is inspired by that introduced by Boudol and Castellani, and independently by Smith, for a parallel language with scheduling. We establish the soundness of our type system with respect to our new notion of noninterference. We finally show that this notion of noninterference refines in several aspects the standard one for imperative languages. (C) 2007 Elsevier Inc. All rights reserved.

关键词： reactive programming noninterference bisimulation type systems

来源：评论

学校读者我要写书评

暂无评论

LoRe: A programming Model for Verifiably Safe Local-first Software

引用

ACM TRANSACTIONS ON programming LANGUAGES AND SYSTEMS 2024年第1期46卷 1-26页

作者： Haas, Julian Mogk, Ragnar Yanakieva, Elena Bieniusa, Annette Mezini, Mira Tech Univ Darmstadt Dept Comp Sci D-64289 Darmstadt Germany Rheinland Pfalz Tech Univ Kaiserslautern Landau Dept Comp Sci D-67663 Kaiserslautern Germany

Local-first software manages and processes private data locally while still enabling collaboration between multiple parties connected via partially unreliable networks. Such software typically involves interactions with users and the execution environment (the outside world). The unpredictability of such interactions paired with their decentralized nature make reasoning about the correctness of local-first software a challenging endeavor. Yet, existing solutions to develop local-first software do not provide support for automated safety guarantees and instead expect developers to reason about concurrent interactions in an environment with unreliable network conditions. We propose LoRe, a programming model and compiler that automatically verifies developer-supplied safety properties for local-first applications. LoRe combines the declarative data flow of reactive programming with static analysis and verification techniques to precisely determine concurrent interactions that violate safety invariants and to selectively employ strong consistency through coordination where required. We propose a formalized proof principle and demonstrate how to automate the process in a prototype implementation that outputs verified executable code. Our evaluation shows that LoRe simplifies the development of safe local-first software when compared to state-of-the-art approaches and that verification times are acceptable.

关键词： Local-first software reactive programming invariants consistency automatic verification

来源：评论

学校读者我要写书评

暂无评论

reactive Caching for Composed Services Polling at the Speed of Push

引用

PROCEEDINGS OF THE ACM ON programming LANGUAGES-PACMPL 2018年第OOPSLA期2卷 1–28页

作者： Burckhardt, Sebastian Coppieters, Tim Microsoft Res Redmond WA 98052 USA Vrije Univ Brussel Brussels Belgium

Sometimes, service clients repeat requests in a polling loop in order to refresh their view. However, such polling may be slow to pick up changes, or may increase the load unacceptably, in particular for composed services that disperse over many components. We present an alternative reactive polling API and reactive caching algorithm that combines the conceptual simplicity of polling with the efficiency of push-based change propagation. A reactive cache contains a summary of a distributed read-only operation and maintains a connection to its dependencies so changes can be propagated automatically. We first formalize the setting using an abstract calculus for composed services. Then we present a fault-tolerant distributed algorithm for reactive caching that guarantees eventual consistency. Finally, we implement and evaluate our solution by extending the Orleans actor framework, and perform experiments on two benchmarks in a distributed cloud deployment. The results show that our solution provides superior performance compared to polling, at a latency that comes close to hand-written change notifications.

关键词： Services Distributed programming reactive programming Actor Model Virtual Actors

来源：评论

学校读者我要写书评

暂无评论

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案：

请选择收藏分类：

通借通还

建议与咨询 留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

时间限定

文献类型

馆藏选择

核心期刊

语言

文献类型

帮助

文字说明：

检索规则说明：

检索范例：

分类表

所选分类

限定检索结果

文献类型

馆藏范围

日期分布

学科分类号

主题

机构

作者

语言

请选择保存的检索档案： 新增检索档案 确定 取消

请选择收藏分类： 新增自定义分类 确定 取消

通借通还

建议与咨询留下您的常用邮箱和电话号码，以便我们向您反馈解决方案和替代方法

请选择保存的检索档案：

请选择收藏分类：