Following a discussion of various forms of set-theoretical foundations of category theory and the controversial question of whether category theory does or can provide an autonomous foundation of mathematics, this article concentrates on the question whether there is a foundation for “unlimited” or “naive” category theory. The author proposed four criteria for such some years ago. The article describes how much had previously been accomplished on one approach to meeting those criteria, then takes care of one important obstacle that had been met in that approach, and finally explains what remains to be done if one is to have a fully satisfactory solution.

This paper deals with the decidability of semigroup freeness. More precisely, thefreeness problem over a semigroup S is defined as: given a finite subsetX ⊆ S, decide whether each element ofS has at most one factorization over X. To date, thedecidabilities of the following two freeness problems have been closely examined. In 1953,Sardinas and Patterson proposed a now famous algorithm for the freeness problem over thefree monoids. In 1991, Klarner, Birget and Satterfield proved the undecidability of thefreeness problem over three-by-three integer matrices. Both results led to the publicationof many subsequent papers. The aim of the present paper is (i) to presentgeneral results about freeness problems, (ii) to study the decidabilityof freeness problems over various particular semigroups (special attention is devoted tomultiplicative matrix semigroups), and (iii) to propose precise,challenging open questions in order to promote the study of the topic.

Since Findler and Felleisen (Findler, R. B. & Felleisen, M. 2002) introduced higher-order contracts, many variants have been proposed. Broadly, these fall into two groups: some follow Findler and Felleisen (2002) in using latent contracts, purely dynamic checks that are transparent to the type system; others use manifest contracts, where refinement types record the most recent check that has been applied to each value. These two approaches are commonly assumed to be equivalent—different ways of implementing the same idea, one retaining a simple type system, and the other providing more static information. Our goal is to formalize and clarify this folklore understanding. Our work extends that of Gronski and Flanagan (Gronski, J. & Flanagan, C. 2007), who defined a latent calculus λC and a manifest calculus λH, gave a translation φ from λC to λH, and proved that if a λC term reduces to a constant, so does its φ-image. We enrich their account with a translation ψ from λH to λC and prove an analogous theorem. We then generalize the whole framework to dependent contracts, whose predicates can mention free variables. This extension is both pragmatically crucial, supporting a much more interesting range of contracts, and theoretically challenging. We define dependent versions of λH and two dialects (“lax” and “picky”) of λC, establish type soundness—a substantial result in itself, for λH — and extend φ and ψ accordingly. Surprisingly, the intuition that the latent and manifest systems are equivalent now breaks down: the extended translations preserve behavior in one direction, but in the other, sometimes yield terms that blame more.

Region-based memory management (RBMM) is a form of compile time memory management, well-known from the world of functional programming. In this paper we describe our work on implementing RBMM for the logic programming language Mercury. One interesting point about Mercury is that it is designed with strong type, mode, and determinism systems. These systems not only provide Mercury programmers with several direct software engineering benefits, such as self-documenting code and clear program logic, but also give language implementors a large amount of information that is useful for program analyses. In this work, we make use of this information to develop program analyses that determine the distribution of data into regions and transform Mercury programs by inserting into them the necessary region operations. We prove the correctness of our program analyses and transformation. To execute annotated programs, we have implemented runtime support that tackles the two main challenges posed by backtracking. First, backtracking can require regions removed during forward execution to be “resurrected”; and second, any memory allocated during computation that has been backtracked over must be recovered promptly without waiting for the regions involved to come to the end of their life. We describe in detail our solution of both these problems. We study in detail how our RBMM system performs on a selection of benchmark programs, including some well-known difficult cases for RBMM. Even with these difficult cases, our RBMM-enabled Mercury system obtains clearly faster runtimes for 15 out of 18 benchmarks compared to the base Mercury system with its Boehm runtime garbage collector, with an average runtime speedup of 24%, and an average reduction in memory requirements of 95%. In fact, our system achieves optimal memory consumption in some programs.

David L. Waltz died on March 22, 2012 after suffering from brain cancer.

Dave was a good friend to Natural Language Engineering, and provided some sage advice when Roberto Garigliano and I started working on the proposed journal in the early 1990s; he subsequently agreed to serve as a founding editorial board member.