A Swiss Pocket Knife for Computability

This research is about operational- and complexity-oriented aspects of classical foundations of computability theory. The approach is to re-examine some classical theorems and constructions, but with new criteria for success that are natural from a programming language perspective. Three cornerstones of computability theory are the S-m-ntheorem; Turing's "universal machine"; and Kleene's second recursion theorem. In today's programming language parlance these are respectively partial evaluation, self-interpretation, and reflection. In retrospect it is fascinating that Kleene's 1938 proof is constructive; and in essence builds a self-reproducing program. Computability theory originated in the 1930s, long before the invention of computers and programs. Its emphasis was on delimiting the boundaries of computability. Some milestones include 1936 (Turing), 1938 (Kleene), 1967 (isomorphism of programming languages), 1985 (partial evaluation), 1989 (theory implementation), 1993 (efficient self-interpretation) and 2006 (term register machines). The "Swiss pocket knife" of the title is a programming language that allows efficient computer implementation of all three computability cornerstones, emphasising the third: Kleene's second recursion theorem. We describe experiments with a tree-based computational model aiming for both fast program generation and fast execution of the generated programs.Comment: In Proceedings Festschrift for Dave Schmidt, arXiv:1309.455

Formulas as Programs

We provide here a computational interpretation of first-order logic based on a constructive interpretation of satisfiability w.r.t. a fixed but arbitrary interpretation. In this approach the formulas themselves are programs. This contrasts with the so-called formulas as types approach in which the proofs of the formulas are typed terms that can be taken as programs. This view of computing is inspired by logic programming and constraint logic programming but differs from them in a number of crucial aspects. Formulas as programs is argued to yield a realistic approach to programming that has been realized in the implemented programming language ALMA-0 (Apt et al.) that combines the advantages of imperative and logic programming. The work here reported can also be used to reason about the correctness of non-recursive ALMA-0 programs that do not include destructive assignment.Comment: 34 pages, appears in: The Logic Programming Paradigm: a 25 Years Perspective, K.R. Apt, V. Marek, M. Truszczynski and D.S. Warren (eds), Springer-Verlag, Artificial Intelligence Serie

In the Age of Web: Typed Functional-First Programming Revisited

Most programming languages were designed before the age of web. This matters because the web changes many assumptions that typed functional language designers take for granted. For example, programs do not run in a closed world, but must instead interact with (changing and likely unreliable) services and data sources, communication is often asynchronous or event-driven, and programs need to interoperate with untyped environments. In this paper, we present how the F# language and libraries face the challenges posed by the web. Technically, this comprises using type providers for integration with external information sources and for integration with untyped programming environments, using lightweight meta-programming for targeting JavaScript and computation expressions for writing asynchronous code. In this inquiry, the holistic perspective is more important than each of the features in isolation. We use a practical case study as a starting point and look at how F# language and libraries approach the challenges posed by the web. The specific lessons learned are perhaps less interesting than our attempt to uncover hidden assumptions that no longer hold in the age of web.Comment: In Proceedings ML/OCaml 2014, arXiv:1512.0143

The role of concurrency in an evolutionary view of programming abstractions

In this paper we examine how concurrency has been embodied in mainstream programming languages. In particular, we rely on the evolutionary talking borrowed from biology to discuss major historical landmarks and crucial concepts that shaped the development of programming languages. We examine the general development process, occasionally deepening into some language, trying to uncover evolutionary lineages related to specific programming traits. We mainly focus on concurrency, discussing the different abstraction levels involved in present-day concurrent programming and emphasizing the fact that they correspond to different levels of explanation. We then comment on the role of theoretical research on the quest for suitable programming abstractions, recalling the importance of changing the working framework and the way of looking every so often. This paper is not meant to be a survey of modern mainstream programming languages: it would be very incomplete in that sense. It aims instead at pointing out a number of remarks and connect them under an evolutionary perspective, in order to grasp a unifying, but not simplistic, view of the programming languages development process

SCRATCH LANGUAGE OF PROGRAMMING VS ENGLISH LANGUAGE: COMPARING MATHEMATICAL AND LINGUISTIC FEATURES

This paper focuses on Scratch language of programming and traces its math and linguistic features. From a complex consideration about Scratch language programming in linguistic paradigm, focusing on structural, semantic and syntactic features and logic of its narration, this research attempts to clarify specifics of the language and correlate it with the English language features. Global integration of ideas and sciences underline the crucial importance of programming and language conglomerate. Human-computer interfaces, software systems, and development of various programming languages depend on well-balanced structure, shape, logic, and appearance of the actual code. Dynamic characteristics of the Scratch programming environment sustain the creation of interactive and media-rich projects. Ad expansion of Scratch for mediation of animated stories, music videos, science projects, tutorials, and other contents necessitates multifaceted analysis of this programming environment and evokes the interest of researching Scratch from the math and linguistic perspective as one possible projection on various aspects of the considered programming language

Task-driven programming pedagogy in the digital humanities

In this chapter, we advocate for a task-driven approach to teaching computer programming to students of the digital humanities (DH). Our perspective is grounded first in Birnbaum's (2014) plenary address to the University of Pittsburgh Faculty Senate (Birnbaum 2014), in which he argued that coding, like writing, should be taught across the liberal arts curriculum in domain-appropriate ways. This position argued that (1) coding is not an esoteric specialization to be taught solely by computer scientists, and that (2) coding might be taught most effectively in the context of different disciplines. Here, we present a method for embedding Digital Humanities education, and more specifically programming pedagogy, within the long-standing traditions of the Humanities and argue that this approach works most effectively when new learners have access to context-specific mentorship. Our second point of reference lies with oral-proficiency-oriented (OP) foreign language pedagogy. Within an OP model, the ability to communicate in a foreign language is a skill, and the primary goal for learners who seek to acquire that skill is not an academic understanding of the grammar of a language, but, instead, the ability to function successfully within realistic contextualized human interactions. Seen from this perspective, computer-programming curricula organized around the features of the programming language might be compared to older grammar-and-translation foreign-language pedagogies. What we advocate instead is that the ability to use a programming language (programming proficiency) is best acquired in the context of performing contextualized, discipline-conscious tasks that are meaningful to humanists, an approach that has parallels to OP language learning

Generic programming using Higher Kinded Data

This thesis describes datatype-generic programming, what it is, and how it is done in Scala. The thesis covers ways of thinking about datatype-generic programming and today's tools and libraries for datatype-generic programming in Scala and summarize how to use them. A new library called perspective for datatype-generic programming with higher kinded data is presented. How these libraries, including perspective, work together with sum types is be covered. Benchmarks are presented on both runtime and compile time performance of perspective and other libraries. perspective manages to keep up in performance with other libraries while offering faster code at the expense of longer compile time if a developer opts into this. Finally, an example language-integrated query library built on perspective is described.Masteroppgave i informatikkINF399MAMN-INFMAMN-PRO