Tutorial on programming language research

The 1990s saw a hugely productive interaction between database and programming language research. Ideas about type systems from programming languages played a central role in generalizing and adapting relational database systems to new data models. At the same time databases provided some of the best concrete examples of the application of concurrency theory and of the benefits of high-level optimization in functional programming languages. One of the driving ambitions behind this research was the idea that database access should be properly embedded in programming languages: one should not have to be bilingual in order to use a database from a programming language; and that goal has to some extent been realized. In the past fifteen years, new data models, both for data storage and for data exchange have appeared with depressing regularity and with each such model, the inevitable query language. Does programming language research have anything to contribute to these new languages? Should we take the time to to worry about embedding these models in conventional languages? Over the same period, some interesting new connections between databases and programming languages have emerged, notably in the areas of scientific databases, annotation and provenance. Will this provide new opportunities for cross-fertilization?

Over the past few years, Large Language Models of Code (Code LLMs) have started to have a significant impact on programming practice. Code LLMs are also emerging as building blocks for research in programming languages and software engineering. However, the quality of code produced by a Code LLM varies significantly by programming language. Code LLMs produce impressive results on high-resource programming languages that are well represented in their training data (e.g., Java, Python, or JavaScript), but struggle with low-resource languages that have limited training data available (e.g., OCaml, Racket, and several others). This paper presents an effective approach for boosting the performance of Code LLMs on low-resource languages using semi-synthetic data. Our approach, called M ulti PL-T, generates high-quality datasets for low-resource languages, which can then be used to fine-tune any pretrained Code LLM. M ulti PL-T translates training data from high-resource languages into training data for low-resource languages in the following way. 1) We use a Code LLM to synthesize unit tests for commented code from a high-resource source language, filtering out faulty tests and code with low test coverage. 2) We use a Code LLM to translate the code from the high-resource source language to a target low-resource language. This gives us a corpus of candidate training data in the target language, but many of these translations are wrong. 3) We use a lightweight compiler to compile the test cases generated in (1) from the source language to the target language, which allows us to filter our obviously wrong translations. The result is a training corpus in the target low-resource language where all items have been validated with test cases. We apply this approach to generate tens of thousands of new, validated training items for five low-resource languages: Julia, Lua, OCaml, R, and Racket, using Python as the source high-resource language. Furthermore, we use an open Code LLM (StarCoderBase) with open training data (The Stack), which allows us to decontaminate benchmarks, train models without violating licenses, and run experiments that could not otherwise be done. Using datasets generated with M ulti PL-T, we present fine-tuned versions of StarCoderBase and Code Llama for Julia, Lua, OCaml, R, and Racket that outperform other fine-tunes of these base models on the natural language to code task. We also present Racket fine-tunes for two very recent models, DeepSeek Coder and StarCoder2, to show that M ulti PL-T continues to outperform other fine-tuning approaches for low-resource languages. The M ulti PL-T approach is easy to apply to new languages, and is significantly more efficient and effective than alternatives such as training longer.

Events and Sightings David Walden (bio) and Dag Spicer (bio) Fifty-Year Anniversaries in Norwegian Computing History Two fifty-year anniversaries in computing history were celebrated in Oslo in September 2017: the fifty-year anniversary of the creation of the Simula programming language, and the fifty-year anniversary of the founding of the Norsk Data computer company. Simula The Simula 67 programming language, first formally defined in 1967, was a step in a series of developments by Ole-Johan Dahl and Kristen Nygaard that began in the early 1960s.1 Dahl and Nygaard were given the 2001 IEEE John von Neumann Medal and the ACM 2001 A.M. Turing Award for their creation of Simula. A fifty-year anniversary celebration for Simula took place (in the “Simula Auditorium” in the “Ole-Johan Dahl Building”) at the University of Oslo on 27 September 2017. The celebration began with unveiling of a plaque from the IEEE History Committee’s Milestone program. The plaque reads: IEEE Milestone Object-oriented Programming, 1961–1967 Ole-Johan Dahl and Kristen Nygaard created the Simula programming languages in the 1960s at the Norwegian Computer Center, and in so doing introduced a new way of modeling and simulating complex tasks. Object-oriented programming is now dominant in systems development. It is an integral part of computer science curricula, as are languages built on object-oriented programming concepts, such as Smalltalk, C++, Java, and Python. September 2017 The nomination of this Milestone was from the IEEE Norway Section. The photo shows Section Vice-Chairman Kaveh Niayesh unveiling the plaque. The rest of the day consisted of presentations by several programming language researchers and developers: Oscar Nierstrasz (“Great Moments in the History of OOP”), Dave Thomas (“The Legacy of Simula 67”), and James Gosling (“Simula: A Personal Journey”), as well as a panel discussion chaired by Eric Jul (“Whither Programming Languages? Can We Still Celebrate Simula 50 Years from Now?”) with participation of the prior three speakers and Ole Lehrmann Madsen and Olaf Owe.2 Videos from the event are available.3 The previous afternoon, the Association of Simula Users (ASU) held a several-hour meeting at which there were six presentations and a wrap-up session. According to Boris Magnusson (ASU chairman 1982–83), the ASU has been in continuous existence since the early days of Simula 67, holding annual conferences and publishing a quarterly newsletter. However, in recent years the ASU activities “have slowly faded away, and the meeting in Oslo was intended as a last meeting and also a way to formally close down the Association.” Click for larger view View full resolution Photo 1. Photo credit: Harald Brombach/digi.no. Norsk Data On 16–17 September 2017, the fiftieth anniversary of the founding of Norsk Data was marked. In 1967 Lars Monrad-Krohn, Per Bjørge, and Rolf Skår left the Norwegian Defence Research Establishment (NDRE), where they had worked on the computer developments in “Siffergruppen” (the Digital Group), initiated and [End Page 93] led by Yngvar Lundh. They founded Norsk Data Elektronikk, where their first computer development was the Nord-1, building on work they had done in the Digital Group. Click for larger view View full resolution Photo 2. Veslemøy Østrem of Aftenposten interviewing Norsk Data founders Rolf Skår and Lars Monrad-Krohn. Photo credit: Ragnar Sturzel. The Nord-1was a minicomputer and competed well in Europe with minicomputers from the United States. With additional computers being developed over the years (arguably better hardware and software than some US competitors) and many high-profile or operation-critical installations, Norsk Data eventually became a high-flying company listed on the London as well as the NASDAQ stock exchanges, in addition to on the Norwegian exchange. With the personal computer revolution, Norsk Data went the way of almost all minicomputer manufacturers, eventually going out of business. For many of the eventual 4,500 employees of Norsk Data, their time with a company was one of the most exciting times of their professional careers, and the one-time employees of Norsk Data went on to populate a significant part of the developing Norwegian computing industry. The day of 18 September involved a five-hour...

The work of Fuzz has pioneered the use of functional programming languages wheretypes allow to reason about the sensitivity of programs. Fuzz and subsequentwork (e.g., DFuzz and Duet) use technical devices like linear types, modal types, and partial evaluation. These features usually require the design of a newprogramming language from scratch - a major task on its own! While thesefeatures are part of the classical toolbox of programming languages, they areoften rather obscure for non-programming language experts. In this work, weexplore a different direction. We propose the design of a library capable ofcalculating the sensitivity of programs. The library is built on a novel use ofpolymorphism to represent (and prove) the sensitivity of functions andthe use of type constraints and type-level natural numbers. We show how ourapproach can be used to reason about the sensitivity of classical examplesworking over vectors, such as sum, map, and sort - we leave reasoning aboutmore complex programs for future work. Our library, called DSencity, isimplemented with just 360 lines of Haskell code.

Programming language researchers often study real-world projects to see how language features have been adopted and are being used. Typically researchers choose a small number of projects to study, due to the immense challenges associated with finding, downloading, storing, processing, and querying large amounts of data. The Boa programming language and infrastructure was designed to solve these challenges and allow researchers to focus on simply asking the right questions. Boa provides a domain-specific language to abstract details of how to mine hundreds of thousands of projects and also abstracts how to efficiently query that data. We have previously used this platform to perform a large study of the adoption of Java's language features over time. In this demonstration, we will show you how we used Boa to quickly analyze billions of AST nodes and study the adoption of Java's language features.

The history of programming languages shows a continuous search for new composition mechanisms to find better ways for structuring increasingly complex software systems into modules that can be developed and reused independently. Composition mechanisms can address various forms of interactions, e.g., inheritance, delegation, aggregation, design patterns, contracts, explicit protocols, or domain-specific compositions. However, most languages adopt a fixed set of composition mechanisms, usually with explicit notation and predefined semantics. In case a language does not provide any mechanisms with the desired compositional behavior, programmers may need to write workarounds or introduce the new composition mechanism through macros, libraries, frameworks or language extensions. The FREECO workshop series intends to stimulate research in programming languages and software development by exploring the notion that languages should not offer a limited set of fixed composition mechanisms, but allow for flexibility, a wide variety of compositions, domain-specific and tailored compositions, or programmable compositions of various program artifacts. You can find more information about the FREECO workshop series at the workshop website located at: http://trese.ewi.utwente.nl/workshops/FREECO. These proceedings contain a selection of papers that were submitted for the [email protected]!2011 workshop that was held as part of the SPLASH/ONWARD conference in Portland, OR, October 23-27, 2011. The workshop was a fruitful and constructive day, which resulted in new insights, new inspiration, as well as a poster with the workshop results, which was presented at the plenary poster event the next day.

Probabilistic programming refers to the idea of using standard programming constructs for specifying probabilistic models from machine learning and statistics, and employing generic inference algorithms for answering various queries on these models, such as posterior inference and estimation of model evidence. Although this idea itself is not new and was, in fact, explored by several programming-language and statistics researchers in the early 2000, it is only in the last few years that probabilistic programming has gained a large amount of attention among researchers in machine learning and programming languages, and that expressive and efficient probabilistic programming systems (such as Anglican, Church, Figaro, Infer.net, PSI, PyMC, Stan, and Venture) started to appear and have been taken up by a nontrivial number of users. The primary goal of my talk is to introduce probabilistic programming to the CONCUR/QUEST/FORMATS audience. At the end of my talk, I want the audience to understand basic results and techniques in probabilistic programming and to feel that these results and techniques are relevant or at least related to what she or he studies, although they typically come from foreign research areas, such as machine learning and statistics. My talk will contain both technical materials and lessons that I learnt from my machine-learning colleagues in Oxford, who are developing a highly-expressive higher-order probabilistic programming language, called Anglican. It will also include my work on the denotational semantics of higher-order probabilistic programming languages and their inference algorithms, which are jointly pursued with colleagues in Cambridge, Edinburgh, Oxford and Tubingen.

The [lambda]-calculus provides a simple, well-established framework for research in functional programming languages that readily lends itself to the use offormal methods--that is, the use of mathematically sound techniques and supporting tools--to describe and verify properties of programming languages, as well. This is no coincidence. After all, the [lambda]-calculus formalizes the concept of effective computability, for all computable functions are definable in the untyped [lambda]-calculus, making it expressively equivalent torecursive functions. In software, the expressiveness of functional languages is considereda strength. Functional approaches to language design, however, needn't be limited to soft-ware. In hardware, the expressiveness of functional languages becomes a major obstacle to successful hardware synthesis, for the reason that such languages are usually capable of expressing general recursion. The presence of general recursion makes it possible to generate expressions that run forever, never producing a well-defined value. In this dissertation, we study two novel variants of the simply typed [lambda]-calculus, representing fragments of functional hardware description languages. The first variant extends the type system, using natural numbers representing time. This addition, though simple, is non-trivial. We prove that this calculus possesses bounded variants of type-safety and strong normalization. That is to say, we show that all well-typed expressions evaluate to values within a bound determined by the natural number index of their corresponding types. The second variant is a computational [lambda]-calculus that formalizes the core fragment of the hardware description language known as ReWire. We prove that the language has type-safety and is strongly normalizing -- the proof of strong normalizationis the first mechanized proof of its kind. We define an equational theory with respect to this language. This allows us to prove that the language has desirable security properties by construction. This work supports a full-edged, formal methodology for producing high assurance hardware.

Delimited continuations are the meanings of delimited evaluation contexts in programming languages. We show they offer a uniform view of many scenarios that arise in systems programming, such as a request for a system service, an event handler for input/output, a snapshot of a process, a file system being read and updated, and a Web page. Explicitly recognizing these uses of delimited continuations helps us design a system of concurrent, isolated transactions where desirable features such as snapshots, undo, copy-on-write, reconciliation, and interposition fall out by default. It also lets us take advantage of efficient implementation techniques from programming-language research. The Zipper File System prototypes these ideas.

Traditionally, the interface between a programming language and a database has either been through a set of relatively low-level subroutine calls, or it has required some form of embedding of one language in another. Recently, the necessity of integrating database and programming language techniques has received some long-overdue recognition. In response, a number of attempts have been made to construct programming languages with completely integrated database management systems. These languages, which we term database programming languages , are the subject of this review. The design of these languages is still in its infancy, and the purpose of writing this review is to identify the areas in which further research is required. In particular, we focus on the problems of providing a uniform type system and mechanisms for data to persist. Of particular importance in solving these problems are issues of polymorphism, type inheritance, object identity, and the choice of structures to represent sets of similar values. Our conclusion is that there are areas of programming language research—modules, polymorphism, persistence, and inheritance—that must be developed and applied to achieve the goal of a useful and consistent database programming language. Other research areas of equal importance, such as implementation, transaction handling, and concurrency, are not examined here in any detail.

Data exchange between different computer-aided design (CAD) systems is a major problem inhibiting information integration in collaborative engineering environments. Existing CAD data format standards such as STEP and IGES enable geometric data exchange. However, they ignore construction history, features, constraints, and other parametric-based CAD data. As a result, they are inadequate for supporting modification, extension and other important higher-level functionality when accessing an imported CAD model from another CAD system. Achieving such higher-level functionality therefore often requires a time-consuming, error-prone, tedious process of manually recreating the model in the target CAD system. Based on techniques adapted from programming language research, this paper presents an approach to exchanging parametric data between CAD systems using formally-defined conversion semantics. We have demonstrated the utility of our approach by developing a prototype implementation that automates the conversion of 2D sketches between two popular CAD systems: Pro/ENGINEER and SolidWorks. We present examples showing that our approach is able to accurately convert parametric CAD data even in cases where models were constructed using operations from the source CAD system that have no direct counterpart in the target CAD system. Although the case study focuses on 2D interoperability, our approach provides formal foundations for supporting 3D and semantic interoperability between CAD systems.

The last decade and a half of Nico Habermann's research career focused on software engineering, and in particular on software development environments. His earlier work was oriented more towards operating systems and programming language research. We take this opportunity to look back at his research, putting it in a larger perspective, identifying some general themes that characterize his contributions to software engineering in particular, and to computer science in general. >

The last decade and a half of Nico Habermann's research career focused on software engineering, and in particular on software development environments. His earlier work was oriented more towards operating systems and programming language research. We take this opportunity to look back at his research, putting it in a larger perspective, identifying some general themes that characterize his contributions to software engineering in particular, and to computer science in general. >

Generic recursive lens combinators and their calculation laws

Recent workshops have explored commonality among the points of view of AL, DBMS and programming language researchers. On the surface, it would appear that DBMS researchers are building smarter data base systems and that AL researchers are building expert systems containing a knowledge base. However, it appears that there is minimal commonality to the points of view expressed by these communities. Therefore, the author is dubious of any significant cross fertilisation. He illustrates a few differences in points of view in the two communities by 3 examples.