23,325 research outputs found
Coherence compilation: applying AIED techniques to the reuse of educational resources
The HomeWork project is building an exemplar system to provide individualised experiences for individual and groups of children aged 6-7 years, their parents, teachers and classmates at school. It employs an existing set of broadcast video media and associated resources that tackle both numeracy and literacy at Key Stage 1. The system employs a learner model and a pedagogical model to identify what resource is best used with an individual child or group of children collaboratively at a particular learning point and at a particular location. The Coherence Compiler is that component of the system which is designed to impose an overall narrative coherence on the materials that any particular child is exposed to. This paper presents a high level vision of the design of the Coherence Compiler and sets its design within the overall framework of the HomeWork project and its learner and pedagogical models
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
Enabling High-Level Application Development for the Internet of Things
Application development in the Internet of Things (IoT) is challenging
because it involves dealing with a wide range of related issues such as lack of
separation of concerns, and lack of high-level of abstractions to address both
the large scale and heterogeneity. Moreover, stakeholders involved in the
application development have to address issues that can be attributed to
different life-cycles phases. when developing applications. First, the
application logic has to be analyzed and then separated into a set of
distributed tasks for an underlying network. Then, the tasks have to be
implemented for the specific hardware. Apart from handling these issues, they
have to deal with other aspects of life-cycle such as changes in application
requirements and deployed devices. Several approaches have been proposed in the
closely related fields of wireless sensor network, ubiquitous and pervasive
computing, and software engineering in general to address the above challenges.
However, existing approaches only cover limited subsets of the above mentioned
challenges when applied to the IoT. This paper proposes an integrated approach
for addressing the above mentioned challenges. The main contributions of this
paper are: (1) a development methodology that separates IoT application
development into different concerns and provides a conceptual framework to
develop an application, (2) a development framework that implements the
development methodology to support actions of stakeholders. The development
framework provides a set of modeling languages to specify each development
concern and abstracts the scale and heterogeneity related complexity. It
integrates code generation, task-mapping, and linking techniques to provide
automation. Code generation supports the application development phase by
producing a programming framework that allows stakeholders to focus on the
application logic, while our mapping and linking techniques together support
the deployment phase by producing device-specific code to result in a
distributed system collaboratively hosted by individual devices. Our evaluation
based on two realistic scenarios shows that the use of our approach improves
the productivity of stakeholders involved in the application development
Proceedings of the 3rd Workshop on Domain-Specific Language Design and Implementation (DSLDI 2015)
The goal of the DSLDI workshop is to bring together researchers and
practitioners interested in sharing ideas on how DSLs should be designed,
implemented, supported by tools, and applied in realistic application contexts.
We are both interested in discovering how already known domains such as graph
processing or machine learning can be best supported by DSLs, but also in
exploring new domains that could be targeted by DSLs. More generally, we are
interested in building a community that can drive forward the development of
modern DSLs. These informal post-proceedings contain the submitted talk
abstracts to the 3rd DSLDI workshop (DSLDI'15), and a summary of the panel
discussion on Language Composition
Chaotic Compilation for Encrypted Computing: Obfuscation but Not in Name
An `obfuscation' for encrypted computing is quantified exactly here, leading
to an argument that security against polynomial-time attacks has been achieved
for user data via the deliberately `chaotic' compilation required for security
properties in that environment. Encrypted computing is the emerging science and
technology of processors that take encrypted inputs to encrypted outputs via
encrypted intermediate values (at nearly conventional speeds). The aim is to
make user data in general-purpose computing secure against the operator and
operating system as potential adversaries. A stumbling block has always been
that memory addresses are data and good encryption means the encrypted value
varies randomly, and that makes hitting any target in memory problematic
without address decryption, yet decryption anywhere on the memory path would
open up many easily exploitable vulnerabilities. This paper `solves (chaotic)
compilation' for processors without address decryption, covering all of ANSI C
while satisfying the required security properties and opening up the field for
the standard software tool-chain and infrastructure. That produces the argument
referred to above, which may also hold without encryption.Comment: 31 pages. Version update adds "Chaotic" in title and throughout
paper, and recasts abstract and Intro and other sections of the text for
better access by cryptologists. To the same end it introduces the polynomial
time defense argument explicitly in the final section, having now set that
denouement out in the abstract and intr
- …