"Datafun: a functional query language" by Michael Arntzenius

Datafun is a new language exploring the question: What's the simplest way to bring our general-purpose languages closer to our database query languages?
At its core, a lot of programming is data munging. Yet our general-purpose programming languages don't make this easy for us. We have to decide in advance how to arrange our data, whether we want it in memory or on disk, what operations we want to be efficient, and so on. Databases are powerful tools for solving these issues, but they involve separating our data from our general programming tools.
Yet the walls separating database theory from programming language theory are quite thin. With the right design choices, we can dissolve them entirely. Purity and totality, for example, let us apply many standard database query optimizations to a functional language. Techniques like materialized view maintenance, Datalog's seminaive evaluation, and incremental computation are just different sides of the same coin.
This talk will use Datafun as a jumping off point to explore these and other ideas at the intersection of databases and programming languages.
Michael Arntzenius
UNIVERSITY OF BIRMINGHAM
Michael Arntzenius researches the theory, design, and implementation of programming languages. He's interested in types, monotonicity, logic, concurrency and distributed systems; but most of all in simplicity. He's convinced there is still low-hanging fruit left to be plucked in the orchards of language design, if you look in the right places.

[@abdulshabazz8597]

The Derivative of a Fixed Point computes what has changed between iterations . So The Derivative is the Irreducible Residue that is left from the previous iteration. And the last and final iteration results in an Irreducible Residue that is itself irreducible . These in essence remind me of Euclidean primes, which satisfy the same characteristics.

[@davidpiepgrass743]

So... the first 15 minutes reinvents C# 3.0 (2007) using list comprehensions in place of LINQ.
In the second 15 minutes, I don't know what "!y" is supposed to mean, but it looks like something that could be implemented as a macro in a language with LISP-style macros. For example, in Enhanced C# one could write a macro that recognizes "fix" such that the ancestor set is generated by something like
fix Set ancestor = parent |
from (x, y) in parent
from (y, z) in ancestor
select (x, z);
Set parent = .... // Set type from Loyc.Collections
Since macros run arbitrary code at compile-time, the macro could optimize the query at compile-time. Or using ordinary C#, one could write a `fix(ancestor => ...)` function whose argument is an expression tree, which optimizes the query at run-time. In either case, `fix` could be implemented based on the discussion in the last part of this video.
So we don't actually need to invent a new programming language in order to obtain a programming language that supports new functionality. And even if you decide you need a new programming language, you don't necessarily need to invent a syntax for it ( see loyc.net/les )

[@freshhawk]

He's giving the background, explaining the history of the stuff that lead to LINQ/list comprehensions/etc in the first section.

[@clementdato6328]

Where is the “general purpose programming is functional programming” coming from?
For me, functional programming is imperative programming.