Daniel von Dincklage
Research Areas
Authored Publications
Sort By
Uncanny Valleys in Declarative Language Design
Mark S. Miller
Vuk Ercegovac
Brian Chin
SNAPL 2017, Summit on Advances in Programming Languages (to appear)
Preview abstract
When people write programs in conventional programming languages, they over-specify how to solve the problem they have in mind. Over-specification prevents the language's implementation from making many optimization decisions, leaving programmers with this burden. In more declarative languages, programmers over-specify less, enabling the implementation to make more choices for them. As these decisions improve, programmers shift more attention from implementation to their real problems. This process easily overshoots. When under-specified programs almost always work well enough, programmers rarely need to think about implementation details. As their understanding of implementation choices atrophies, the controls provided so they can override these decisions become obscure.
Our declarative language project, Yedalog, is in the midst of this dilemma. The improvements in question make our users more productive, so we cannot simply retreat back towards over-specification. To proceed forward instead, we must meet some of the expectations we prematurely provoked, and our implementation's behavior must help users learn expectations more aligned with our intended semantics.
These are general issues. Discussing their concrete manifestation in Yedalog should help other declarative systems that come to face these issues.
View details
Yedalog: Exploring Knowledge at Scale
Brian Chin
Vuk Ercegovac
Peter Hawkins
Mark S. Miller
Franz Och
Chris Olston
Fernando Pereira
1st Summit on Advances in Programming Languages (SNAPL 2015), Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik, Dagstuhl, Germany, pp. 63-78
Preview abstract
With huge progress on data processing frameworks, human programmers are frequently the bottleneck when analyzing large repositories of data. We introduce Yedalog, a declarative programming language that allows programmers to mix data-parallel pipelines and computation seamlessly in a single language. By contrast, most existing tools for data-parallel computation embed a sublanguage of data-parallel pipelines in a general-purpose language, or vice versa. Yedalog extends Datalog, incorporating not only computational features from logic programming, but also features for working with data structured as nested records. Yedalog programs can run both on a single machine, and distributed across a cluster in batch and interactive modes, allowing programmers to mix different modes of execution easily.
View details
Preview abstract
Modern object-oriented languages have complex features that cause
programmers to overspecify their programs. This overspecification
hinders automatic optimizers, since they must preserve the
overspecified semantics. If an optimizer knew which semantics the
programmer intended, it could do a better job.
Making a programmer clarify his intentions by placing assumptions
into the program is rarely practical. This is because the programmer
does not know which parts of the programs' overspecified semantics
hinder the optimizer. Therefore, the programmer has to guess
which assumption to add. Since the programmer can add many
different assumptions to a large program, he will need to place
many such assumptions before he guesses right and helps the optimizer.
We present IOpt, a practical optimizer that uses a
specification of the programmers' intended semantics to enable
additional optimizations. That way, our optimizer can significantly
improve the performance of a program. We present case studies in which
we use IOpt to speed up two programs by over 50%.
To make specifying the intended semantics practical, IOpt
communicates with the programmer. IOpt identifies which
assumptions the programmer textit{should} place, and where he should
place them. IOpt ranks each assumption by (i) the likelyhood that
the assumption conforms to the programmers' intended semantics and
(ii) how much the assumption will help IOpt improve the programs'
performance. IOpt proposes ranked assumptions to the programmer,
who just picks those that conform to his intended semantics. With
this approach, IOpt keeps the programmers' specification burden
low. Our case studies show that the programmer just needs to add a few
assumptions to realize the 50% speedup.
View details
