94,201 research outputs found
An exercise in transformational programming: Backtracking and Branch-and-Bound
We present a formal derivation of program schemes that are usually called Backtracking programs and Branch-and-Bound programs. The derivation consists of a series of transformation steps, specifically algebraic manipulations, on the initial specification until the desired programs are obtained. The well-known notions of linear recursion and tail recursion are extended, for structures, to elementwise linear recursion and elementwise tail recursion; and a transformation between them is derived too
Building Efficient Query Engines in a High-Level Language
Abstraction without regret refers to the vision of using high-level
programming languages for systems development without experiencing a negative
impact on performance. A database system designed according to this vision
offers both increased productivity and high performance, instead of sacrificing
the former for the latter as is the case with existing, monolithic
implementations that are hard to maintain and extend. In this article, we
realize this vision in the domain of analytical query processing. We present
LegoBase, a query engine written in the high-level language Scala. The key
technique to regain efficiency is to apply generative programming: LegoBase
performs source-to-source compilation and optimizes the entire query engine by
converting the high-level Scala code to specialized, low-level C code. We show
how generative programming allows to easily implement a wide spectrum of
optimizations, such as introducing data partitioning or switching from a row to
a column data layout, which are difficult to achieve with existing low-level
query compilers that handle only queries. We demonstrate that sufficiently
powerful abstractions are essential for dealing with the complexity of the
optimization effort, shielding developers from compiler internals and
decoupling individual optimizations from each other. We evaluate our approach
with the TPC-H benchmark and show that: (a) With all optimizations enabled,
LegoBase significantly outperforms a commercial database and an existing query
compiler. (b) Programmers need to provide just a few hundred lines of
high-level code for implementing the optimizations, instead of complicated
low-level code that is required by existing query compilation approaches. (c)
The compilation overhead is low compared to the overall execution time, thus
making our approach usable in practice for compiling query engines
Runtime protection via dataïŹow flattening
Software running on an open architecture, such as the PC, is vulnerable to inspection and modiïŹcation. Since software may process valuable or sensitive information, many defenses against data analysis and modiïŹcation have been proposed. This paper complements existing work and focuses on hiding data location throughout program execution. To achieve this, we combine three techniques: (i) periodic reordering of the heap, (ii) migrating local variables from the stack to the heap and (iii) pointer scrambling. By essentialy flattening the dataflow graph of the program, the techniques serve to complicate static dataflow analysis and dynamic data tracking. Our methodology can be viewed as a data-oriented analogue of control-flow flattening techniques. Dataflow flattening is useful in practical scenarios like DRM, information-flow protection, and exploit resistance. Our prototype implementation compiles C programs into a binary for which every access to the heap is redirected through a memory management unit. Stack-based variables may be migrated to the heap, while pointer accesses and arithmetic may be scrambled and redirected. We evaluate our approach experimentally on the SPEC CPU2006 benchmark suit
A Linear Logic Programming Language for Concurrent Programming over Graph Structures
We have designed a new logic programming language called LM (Linear Meld) for
programming graph-based algorithms in a declarative fashion. Our language is
based on linear logic, an expressive logical system where logical facts can be
consumed. Because LM integrates both classical and linear logic, LM tends to be
more expressive than other logic programming languages. LM programs are
naturally concurrent because facts are partitioned by nodes of a graph data
structure. Computation is performed at the node level while communication
happens between connected nodes. In this paper, we present the syntax and
operational semantics of our language and illustrate its use through a number
of examples.Comment: ICLP 2014, TPLP 201
Quality-aware model-driven service engineering
Service engineering and service-oriented architecture as an integration and platform technology is a recent approach to software systems integration. Quality aspects
ranging from interoperability to maintainability to performance are of central importance for the integration of heterogeneous, distributed service-based systems. Architecture models can substantially influence quality attributes of the implemented software systems. Besides the benefits of explicit architectures on maintainability and reuse, architectural constraints such as styles, reference architectures and architectural patterns can influence observable software properties such as performance. Empirical performance evaluation is a process of measuring and evaluating the performance of implemented software. We present an approach for addressing the quality of services and service-based systems at the model-level in the context of model-driven service engineering. The focus on architecture-level models is a consequence of the black-box
character of services
Gainsharing: A Critical Review and a Future Research Agenda
This paper provides a critical review of the extensive literature on gainsharing. It examines the reasons for the fast growth in these programs in recent years and the major prototypes used in the past. Different theoretical formulations making predictions about the behavioral consequences and conditions mediating the success of these programs are discussed and the supporting empirical evidence is examined. The large number of a theoretical case studies and practitioner reports or gainsharing are also summarized and integrated. The article concludes with a suggested research agenda for the future
Networking in the food sector of regional economy
Purpose: The article aims to study the features and the directions of development of network interaction of subjects of the food sector in different regions of the economy. Design/Methodology/Approach: The use of different methodological approaches allowed us to formulate a holistic management concept for the development of a network of competences in the food sector of the regional economy. Findings: The study identified the subjects of such interaction, as well as features that allow them to unite into groups that form networks of competencies. Considering the food sector of the region's economy as a socio-economic system, noted its extreme structural complexity, which necessitates the development of special approaches to its management, or rather the need for structural management is presented. The format of such interaction is a network of competencies, representing a spatially localized socio-economic structure formed on the initiative of active subjects of the regional economy. Practical Implications: The results obtained can be used as a basis for designing a network form of development of the food sector of the region's economy, taking into account the nature of placement and interaction of participants, as well as allowing for effective use of their resource capabilities, experience and knowledge.
Originality/Value: In order to overcome the problems associated with the formation of network identity, network management competence is proposed to use a structured approach allowing them to make targeted decisions based on objective conditions and institutional nature.peer-reviewe
- âŠ