Subrecursive programming languages II on program size

This paper was inspired by [FBW 94]. An arbitrary upper bound on the size of some program for the target function suffices for the learning of some program for this function. In [FBW 94] it was discovered that if “learning” is understood as “identification in the limit,” then in some programming languages it is possible to learn a program of size not exceeding the bound, while in some other programming languages this is not possible.We have studied three other learning types, namely, “finite identification,” “co-learning” and “confidence-learning.” These three types are very different. Co-learning with the considered additional information in the form “an arbitrary upper bound for the size of the minimal program” allows the learning of the class of all recursive functions. “Finite identification” does not allow this. “Confidence-learning” is strong enough to learn the class of all recursive functions even without the additional information. However, the results of our paper show exactly the opposite rating for the capabilities of learning programs not exceeding the size given by the bound.For finite identification it is still possible to identify small programs with additional information in some programming languages but not in all of them. For co-learning it is not possible in any programming language. These results contrast to the result in [FKS 94] showing that an arbitrary class of recursive functions is co-learnable if and only if it is identifiable in the limit. Finally, for confidence-learning it is in general not possible to identify small programs with additional information.KeywordsProgramming LanguageTarget FunctionRecursive FunctionInductive InferenceIdentification TypeThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In this thesis, we explore techniques for the development and verification of programs in a high-level, expressive, and safe programming language. Our programs can express problems over unbounded domains and over recursive and mutable data structures. We present an implementation language flexible enough to build interesting and useful systems. We mostly maintain a core shared language for the specifications and the implementation, with only a few extensions specific to expressing the specifications. Extensions of the core shared language include imperative features with state and side effects, which help when implementing efficient systems. Our language is a subset of the Scala programming language. Once verified, programs can be compiled and executed using the existing Scala tools. We present algorithms for verifying programs written in this language. We take a layer-based approach, where we reduce, at each step, the program to an equivalent program in a simpler language. We first purify functions by transforming away mutations into explicit return types in the functions' signatures. This step rewrites all mutations of data structures into cloning operations. We then translate local state into a purely functional code, hence eliminating all traces of imperative programming. The final language is a functional subset of Scala, on which we apply verification. We integrate our pipeline of translations into Leon, a verifier for Scala. We verify the core functional language by using an algorithm already developed inside Leon. The program is encoded into equivalent first-order logic formulas over a combination of theories and recursive functions. The formulas are eventually discharged to an external SMT solver. We extend this core language and the solving algorithm with support for both infinite-precision integers and bit-vectors. The algorithm takes into account the semantics gap between the two domains, and the programmer is ultimately responsible to use the proper type to represent the data. We build a reusable interface for SMT-LIB that enables us to swap solvers transparently in order to validate the formulas emitted by Leon. We experiment with writing solvers in Scala; they could offer both a better and safer integration with the rest of the system. We evaluate the cost of using a higher-order language to implement such solvers, traditionally written in C/C++. Finally, we experiment with the system by building fully working and verified applications. We rely on the intersection of many features including higher-order functions, mutable data structures, recursive functions, and nondeterministic environment dependencies, to build concise and verified applications.

A type theoretic programming language is introduced that is based on lambda calculus with coproducts, products and inductive types, and additionally allows the definition of recursive functions in the way that is common in most functional programming languages. A formal system is presented that checks whether such a definition is structurally recursive and a soundness theorem is shown for this system. Thus all functions passing this check are ensured to terminate on all inputs. For the moment only non-mutual recursive functions are considered.

This paper gives an overview of subrecursive hierarchy theory as it relates to computational complexity and applies some of the concepts to questions about the size of programs in subrecursive programming languages. The purpose is three-fold, to reveal in simple terms the workings of subrecursive hierarchies, to indicate new results in the area, and to point out ways that the fundamental ideas in hierarchy theory can lead to interesting questions about programming languages. A specific application yields new information about Blum's results on the size of programs and about the relationship between size and efficiency.

Datalog is a carefully restricted logic programming language. What makes Datalog attractive is its declarative fixpoint semantics: Datalog queries consist of simple Horn clauses, yet Datalog solvers efficiently compute all derivable tuples even for recursive queries. However, as we argue in this paper, Datalog is ill-suited as a programming language and Datalog programs are hard to write and maintain. We propose a “new” frontend for Datalog: functional programming with sets called functional IncA. While programmers write recursive functions over algebraic data types and sets, we transparently translate all code to Datalog relations. However, we retain Datalog’s strengths: Functions that generate sets can encode arbitrary relations and mutually recursive functions have fixpoint semantics. We also ensure that the generated Datalog program terminates whenever the original functional program terminates, so that we can apply off-the-shelve bottom-up Datalog solvers. We demonstrate the versatility and ease of use of functional IncA by implementing a type checker, a program transformation, an interpreter of the untyped lambda calculus, two data-flow analyses, and clone detection of Java bytecode.

Open Source developers play fundamental determinant role in the life of any open source project. This paper investigates developer motivation in contributing tirelessly to an open source project. Open source Onions were investigated and the developer layer modeled and validated based on ten case studies from SourceForge. Validation was based on Delphi's four rounds of successive stages. Results show that 62% of the developers around an open source development project community are skilled programmers, and that Open source developers are largely motivated by web based development platforms with universal programming language such as Java and that Developers are mostly attracted to the GPL licensed software development project with high project publicity as could be tracked from the hit rate on the project website. Finally, the few Core developers (Project Administrators) of about 19% actually controls and oversees the affairs carried out by about 81% of many developers showing the prominence of Pareto80/20 Principle in Open Source Project development.

Foreword: Volume 7

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?

Recursive function theory studies functions that can be evaluated by an algorithm based on some computing model such as a Turing machine or computer program. These functions are called partial recursive (p.r.) and are defined on subsets of N, where N = {0, 1,... }, with values in N. (A good introduction to the theory may be found in [2].) This paper explains the Parameter Theorem, illustrates some unusual computer programs, and explains their connection to recursive function theory. Basing our computing model on a modern high level language, we can construct programs whose existence is known through more formal means. Our functions will operate on strings rather than numbers, however. There is no loss in generality since strings can be viewed as members of N, and vice-versa. From a practical aspect, this approach is somewhat more desirable since conventional programming languages often allow making use of long strings, but place more restrictive limits on the size of integers. We first pose a problem: Does there exist a program (written in some conventional programming language) which halts if and only if its input is identical to the program's text (i.e., source code)? For the remainder of this note X is the set of ASCII characters 'a,' 'b, +,' space, line feed, and so forth, needed to write programs in most programming languages. We denote by X * the set of all strings (finite sequences) over X. Let P1 be the set of all one variable partial recursive functions on X *. A function I belongs to P1 if and only if there is a subset of S of X* and some algorithm which computes 't by associating with each element of S a well-defined element of X *. Similarly, 't belongs to P2 if and only if there is a set S c X * X X *, and an algorithm for 't which associates with each element of S a well-defined element of X *. A partial recursive function I in P1 (or in P2) is recursive if the algorithm is defined on all of X * (or X * X X *). This is equivalent to saying that the algorithm which evaluates I always halts. Our computing model will be based on Adat; its high-level string-handling properties simplify later examples. For readability, however, we will express algorithms in a more familiar Pascal-like style. Readers familiar with either programming language should find forthcoming algorithms sufficiently clear. A formal presentation in Ada is given in the Appendix. A string of ASCII characters, such as in FIGURE 1, represents a function in our language which takes strings to strings. Of course, strings of ASCII characters such as The quick brown fox and %*!! represent nothing at all in our programming language. Let A1 be the set of all strings in X * representing functions in our language of one input STRING which outputs a STRING. Similarly let A2 be the set of all strings in

Nowadays, when algorithms are combined with programming languages, great technological works are emerging. Examples of these works continue to differentiate and increase in military and police systems, agricultural applications, image processing applications, data engineering field, language processing works, and cyber security applications. With the differentiation of the areas of use of algorithms, the programming languages used on these platforms are also changing. Python is an object-oriented and functional modern programming language. It is ideal for beginners due to its readability and ease of use. C# is a simple, modern, object-oriented, and type-safe programming language that combines the high productivity of application development languages with the raw power of C and C++. The Java programming language, on the other hand, shares many features that are common to most programming languages used today. Since it is designed with the structures of C and C++, where their languages are similar, the language is familiar to C and C++ programmers (Lerdorf, 2002; Hejlsberg, 2003; Arnold, 2005; Deitel, 2004; Kelly, 2016; Gavrilović, 2018; Pala, 2019; Chollet, 2021; Chen, 2023).

This thesis proposes a novel way of performing type checking, whose results are incremental, depending on the provided local information. This new way of type checking is called co-contextual, where all context information of expressions, methods, classes, etc., is removed. Instead, we introduce corresponding structures using requirements. Standard type systems are translated to the co-contextual ones systematically using dualism as technique. Type systems play an important role to prevent execution errors from occurring during runtime. They are used to check programs statically for potential errors. Programs are type checked against a given set of rules. Depending on these rules programs are well-typed or not. The set of these rules is called typing rules. Each type rule associates types to the constructs of a program given a certain context. There can be different forms of contexts, depending on the features of the typed programming language. Functional languages use a typing context of variables and their types; object-oriented (OO) languages use additional class tables. Class tables are used for example to ensure that method and class declarations are well-typed. Type checking is performed top-down. While traversing the syntax tree of a program, typing contexts are extended with information on the expressions and their types. In case of OO, class tables are extended with clauses from class declarations, including the class members, i.e., fields, methods, or constructors. Contexts are passed through the nodes of the syntax tree in order to coordinate type checking between them. Therefore, while traversing the syntax tree top-down, the type checker creates dependencies between otherwise independent subexpressions. This way, it inhibits incrementalization and parallelization of type checking. That is, a change to a node of the syntax tree would require to redo the type check of the whole syntax tree. In this thesis a novel formulation of type systems is proposed, in order to remove dependencies between subexpressions. We propose a co-contextual formulation of typing rules that depends only on the local program constructs, e.g., expressions, methods, classes. The co-contextual typing rules have as conclusion a type and sets of requirements. That is, contexts and class tables are replaced by the dual concept of context and class table requirements. In addition, operations on contexts and class tables are replaced by new dual operations on requirements. The co-contextual type checker traverses a syntax tree bottom-up and merges context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. We derive co-contextual type checkers for functional and OO languages. As a representative of functional languages we consider PCF and extensions of it: records, parametric polymorphism, structural subtyping and let-polymorphism. Also, we investigate featherweight java (FJ) as the basis of OO languages and extensions of it: method overloading and generics. We build a1 co-contextual type checker for FJ enabling key features of OO languages: subtype polymorphism, nominal typing and implementation inheritance. The dualism between the co-contextual and contextual type systems preserves the correctness of the contextual calculus. That is, we prove the correctness of the co-contextual calculus via the equivalence between contextual type rules and their co-contextual formulations. We implemented an incremental type checker for PCF along with a performance evaluation showing that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly. Regarding FJ, we implemented a co-contextual type checker with incrementalization and compared its performance against javac on a number of realistic programs. Our performance evaluation shows significant speedups for the co-contextual type checker with incrementalization in comparison to javac.

This thesis presents a refinement calculus for transforming highly abstract specifications into programs written in a functional programming language. Refinement calculi allow the derivation of a program from a formal specification by a sequence of correctness-preserving transformation steps. Most refinement calculi target imperative programming languages. Functional programming languages are often more expressive than imperative programming languages. This expressive power leads to a reduced gap between the concepts used to express a problem (as a specification) and the concepts used to express its solution (as a program). Thus, a refinement calculus which targets a functional programming language can lead to a simpler development process which produces a final product more quickly. We build a refinement calculus for functional programs by adding specification constructs to a functional language and examining transformations over the resulting language.This thesis complements other work in the area in two major ways. Firstly, we investigate the addition of truly-nondeterministic, rather than underdetermined, choice constructs to a functional language. These constructs allow specifications which are more abstract and which admit more implementations. Secondly, most refinement calculi for functional programs add erratic choice constructs to a functional language. We investigate the addition of both demonic and angelic nondeterminism to a functional language. Demonic and erratic choice are similar: given a number of alternatives, they choose any one. In contrast, given a number of alternatives angelic choice always makes the correct choice, if one exists. Angelic choice is difficult to reason about, but allows the concise specification of powerful parallel constructs.

I will discuss the design of Ct, an API for nested data parallel programming in C++. Ct uses meta-programming and functional language ideas to essentially embed a pure functional programming language in impure and unsafe languages, like C++. I will discuss the evolution of the design into functional programming ideas, how this was received in the corporate world, and how we plan to proliferate the technology in the next year.Ct is a deterministic parallel programming model integrating the nested data parallelism ideas of Blelloch and bulk synchronous processing ideas of Valiant. That is, data races are not possible in Ct. Moreover, performance in Ct is relatively predictable. At its inception, Ct was conceived as a simple library implementation behind C++ template magic. However, performance issues quickly forced us to consider some form of compilation. Using template programming was highly undesirable for this purpose as it would have been difficult and overly specific to C++ idiosyncrasies. Moreover, once compilation for performance was considered, we began to consider a language semantics that would enable powerful optimizations like calculational fusion, synchronization barrier elimination, and so on. The end result of this deliberation is an API that exposes a value-oriented, purely functional vector processing language. Additional benefits of this approach are numerous, including the important ability to co-exist within legacy threading programming models (because of the data isolation inherent in the model). We will show how the model applies to a wide range of important (at least by cycle count) applications. Ct targets both shipping multi-core architectures from Intel as well as future announced architectures.The corporate reception to this approach has (pleasantly) surprised us. In the desktop and high-performance computing space, where C, C++, Java, and Fortran are the only programming models people talk about, we have made serious inroads into advocating advanced programming language technologies. The desperate need for productive, scalable, and safe programming languages for multi-core architectures has provided an opening for functional, type-safe languages. We will discuss the struggles of multi-core manufacturers (i.e. Intel) and their software vendors that have created this opening.For Intel, Ct heralds its first serious effort to champion a technology that borrows functional programming technologies from the research community. Though it is a compromise that accommodates the pure in the impure and safe in the unsafe, this is an important opportunity to demonstrate the power of functional programming to the unconverted. We plan to share the technology selectively with partners and collaborators, and will have a fully functional and parallelizing implementation by year's end. At CUFP, we will be prepared to discuss our long term plans in detail.

Falafel, a functional programming language with first-class arrays, is being developed at the University of Saskatchewan. It is an experimental vehicle for work in language definition and implementation. This paper discusses some of the fundamental design decisions that underlie the language and its implementations. Falafel has drawn ideas from array-based programming languages (APL [Iverson] and Nial [Jenkins]_[More]), functional programming languages (Miranda™ [Turner] and Haskell [Haskell]), and dataflow programming languages (Id [Nikhil]_and Sisal [Sisal]). This paper discusses the nature of Falafel’s value space, the structure of arrays, the role of strong polymorphic typing, the use of lazy evaluation, and a means of partial definition of arrays. A full definition of Falafel is to be published separately.

The flexibility of a robot system comes from its ability to be programmed. How the robot is programmed is a main concern of all robot users. A good mechanical arm can be underutilized if it is too difficult to program. The introduction of the Universal Robot Controller™ (URC) has made the possibility of a standard, easy to use, robot programming language a reality. The URC is an open‐architecture, PC‐based robot controller. It will work with virtually any robot and gives the user increased flexibility and capabilities over the standard OEM controllers. The URC uses Windows NT as its operating system. The URC is the ideal platform for a universal robot programming language, RobotScript. It allows one robot language to run all robots in a factory.