Teaching Type Systems Implementation with Stella, an Extensible Statically Typed Programming Language

Despite a variety of programming languages adopted in open source (OS) projects, fork variation on some languages has been minimal and slow to be adopted, and there is little research as to why this is so. We therefore employed a K-nearest neighbours (KNN) technique to predict the fork visibility performance of a productive language from a pool of programming languages adopted in projects. In total, 38 showcase OS projects from 2012 to 2016 were downloaded from the GitHub website and categorized into different levels of programming language adoption clusters. Among 33 languages, JavaScript is one of the popular languages that adopted by community. It has been predicted the language chosen when fork visibility is high can increase project longevity as a highly visible language is likely to occur more often in projects with a significant number of interoperable programming languages and high language fork count. Conversely, a low fork language reduces longevity in projects with an insignificant number of interoperable programming languages and low fork count. Our results reveal the survival of a productive language is in response to high language visibility (large fork number) and high interoperability of multiple programming languages.

Programming languages play an important role in the development of computer science. Just imagine programming an expert system in machine language! Any revision would require an enormous additional coding effort. It has been clear for some time that complex programming tasks require powerful programming environments on the conceptual level of the user. Such environments support abstract tools for numeric and symbolic computation. This trend led to the development of high-level programming languages like LISP and other languages like PLANNER (Hewitt 1972), CONNIVER (Sussman and McDermott 1972), QA4 (Rulifson et al. 1973), QLISP (Reboh and Sacerdoti 1973), and Prolog (Colmerauer et al. 1972). These more powerful languages are often collectively known as Programming in the AI languages differs substantially from programming in more standard environments. Edward Feigenbaum has characterized this difference by noting that a given language may be plotted along the what-to-how spectrum. At the end of the spectrum, programs specify step by step precisely how the desired computation is to be carried out. In contrast, at the end of the spectrum, programs are required merely to specify what conditions the desired result must satisfy. The AI languages are usually nearer the end of the spectrum than the more standard languages. A computation within an AI language is taken as the process of proving a goal: the user provides a goal and the system tries to provide a proof, relying on a knowledge base and built-in proof mechanisms. Therefore these languages are also known. as goal-directed computation languages. Robert Kowalski's 1974 paper Predicate Logic as Programming Language introduced logic programming to the computing community as a technique for specifying goal-directed computations. Prior to Kowalski's 1974 paper, various research efforts during the late 1960s and early 1970s influenced the development of logic programming. Its theoretical foundations were established through research in automatic theorem proving dating back to the early 1960s. The first implementation of a logic programming system was described in Colmerauer et al. (1972). These developments occurred concurrently with, and partly in response to, the development of PLANNER (Hewitt 1972) and CONNIVER (Sussman and McDermott 1972) at M.I.T. This logic programming technique consists of formulating a set of rules and facts (collectively called clauses), each of which is a simple statement of some truth that one wishes to record in a knowledge base. A statement has the form

SUMMARYIn object programming languages, the Visitor design pattern allows separation of algorithms and data structures. When applying this pattern to tree‐like structures, programmers are always confronted with the difficulty of making their code evolve. One reason is that the code implementing the algorithm is interwound with the code implementing the traversal inside the visitor. When implementing algorithms such as data analyses or transformations, encoding the traversal directly into the algorithm turns out to be cumbersome as this type of algorithm only focuses on a small part of the data‐structure model (e.g., program optimization). Unfortunately, typed programming languages like Java do not offer simple solutions for expressing generic traversals. Rewrite‐based languages like ELAN or Stratego have introduced the notion of strategies to express both generic traversal and rule application control in a declarative way. Starting from this approach, our goal was to make the notion of strategic programming available in a widely used language such as Java and thus to offer generic traversals in typed Java structures. In this paper, we present the strategy language SL that provides programming support for strategies in Java. Copyright © 2012 John Wiley & Sons, Ltd.

We consider call-by-name, call-by-value, and lazy versions of PCF, and prove, using both syntactic and semantic means, that the operational equivalences of the base language are preserved when the language is extended with sum and product types, with polymorphic types, and with recursive types. These theorems show that the type systems of the extended languages are orthogonal to the type systems of the original languages.

Modern programming relies heavily on effects systems. In the context of the development of programming languages, two approaches to understanding effects are distinguished: the first recognizes an effect as a characteristic of a program that affects the execution environment, separating it from a simple calculation (that is, effects are not taken into account in the system of language types, which is typical for imperative programming languages); the second considers an effect as an aspect of program interpretation that affects the process of its interpretation (such effects are considered in the type system as higher-order types, and this approach is characteristic of functional programming). In industrial programming, the first approach is preferred because of its efficiency in rapid development and less complex concepts. However, this leads to the loss of the possibility of automatic analysis of effects using type systems and increases the difficulty of finding errors. Monads are a convenient tool for describing effects because they have a built-in computation composition operation and can sink values into the monadic environment. A direct contextual representation of effects can be useful for application developers because it reduces cognitive load from syntactic noise while preserving information about effects in data types. This representation also allows for cross-platform applications that can use both monadic and non-monadic effect systems. The paper describes the ergonomic programming language interface for working with monadic effects, which encapsulates the logic of computation and associated non-computational operations in the effect system monad, and describes the direct context encoding technique. The translation of the direct context encoding into the monadic form is implemented in the form of a Scala compiler plugin, which is available as an open source. The use of conditional effects compilation to organize cross-platform interfaces that combine different methods of implementing effects on different platforms is also discussed.

Visitor-based Attribute Grammars with Side Effect

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.

Existing approaches to object encapsulation either rely on ad hoc syntactic restrictions or require the use of specialised type systems. Syntactic restrictions are difficult to scale and to prove correct, while specialised type systems require extensive changes to programming languages. We demonstrate that confinement can be enforced cheaply in Featherweight Generic Java, with no essential change to the underlying language or type system. This result demonstrates that polymorphic type parameters can simultaneously act as ownership parameters and should facilitate the adoption of confinement and ownership type systems in general-purpose programming languages.

Properties that are needed in a language for programming computer vision tasks are described, and a new object-oriented programming language and data management system approach is suggested. An example from automatic pose estimation is used to illustrate the necessity for the properties in a language system, it is indicated where other languages and data management systems fail to provide these properties, and the type constructors used in the authors' system and features of the language semantics of their system are discussed.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Xtext is a framework for the development of languages, which also generates all the typical and recurrent artifacts for a fully-fledged IDE on top of Eclipse. The validation (e.g., checking the correctness of programs from the point of view of types) of languages developed in Xtext has to be implemented by the programmer writing Java code. In this paper we present XTypeS (Xtext TypeSystem), a DSL for writing the type system for an Xtext language. A type system definition in XTypeS is a set of rules which act on the elements of the AST of a program, which in Xtext is represented by an EMF model. Then, XTypeS will generate the corresponding Java code that can be used to implement the validation part for a language developed in Xtext. We describe the features of XTypeS by writing the type system of two languages implemented in Xtext: Featherweight Java and λ-calculus.

The progression from newborn to sophisticated language user in just a few short years is often described as wonderful and miraculous. What are the biological, cognitive, and social underpinnings of this miracle? What major language development milestones occur in infancy? What methodologies do researchers employ in studying this progression? Why do some become adept at multiple languages while others face a lifelong struggle with just one? What accounts for declines in language proficiency, and how might such declines be moderated? Despite an abundance of textbooks, specialized monographs, and a couple of academic handbooks, there has been no encyclopedic reference work in this area--until now. The Encyclopedia of Language Development covers the breadth of theory and research on language development from birth through adulthood, as well as their practical application. Features: This affordable A-to-Z reference includes 200 articles that address such topic areas as theories and research tradition; biological perspectives; cognitive perspectives; family, peer, and social influences; bilingualism; special populations and disorders; and more. All articles (signed and authored by key figures in the field) conclude with cross reference links and suggestions for further reading. Appendices include a Resource Guide with annotated lists of classic books and articles, journals, associations, and web sites; a Glossary of specialized terms; and a Chronology offering an overview and history of the field. A thematic Reader's Guide groups related articles by broad topic areas as one handy search feature on the e-Reference platform, which includes a comprehensive index of search terms. Available in both print and electronic formats, Encyclopedia of Language Development is a must-have reference for researchers and is ideal for library reference or circulating collections. Key Themes: Categories Effects of language on cognitive development Fundamentals, theories and models of language development Impairments of language development Language development in special populations Literacy and language development Mechanisms of language development Methods in language development research Prelinguistic communicative development Social effects in language acquisition Specific aspects of language development

Scientific algorithms are designed and implemented in a variety of programming languages. Depending on the exact application, some languages are a better choice than others: some offer a productive environment while others focus on performance. Selecting a language is often difficult, with poor choices resulting in much higher development times. By implementing a case study algorithm in multiple programming languages, we compare their pros and cons. As a case study, we selected the trace transform, an image processing algorithm from the widely used class of integral transforms. We describe each implementation, including a highly optimized version for NVIDIA graphics processing units, and present a productivity overview and an in-depth performance analysis, from which we draw more generic conclusions. We have found that MATLAB is still the best choice overall, but Julia proves an interesting emerging choice. For realistic images, our compute unified device architecture (CUDA) implementation offers the best performance, albeit at a high development cost.

In many speech communities two or more varieties of the same language are used by some speakers under different conditions. Perhaps the most familiar example is the standard language and regional dialect as used, say, in Italian or Persian, where many speakers speak their local dialect at home or among family or friends of the same dialect area but use the standard language in communicating with speakers of other dialects or on public occasions. There are, however, quite different examples of the use of two varieties of a language in the same speech community. In Baghdad the Christian Arabs speak a ‘Christian Arabic’ dialect when talking among themselves but speak the general Baghdad dialect, ‘Muslim Arabic’, when talking in a mixed group. In recent years there has been a renewed interest in studying the development and characteristics of standardized languages (see especially Kloss, 1952, with its valuable introduction on standardization in general), and it is in following this line of interest that the present study seeks to examine carefully one particular kind of standardization where two varieties of a language exist side by side throughout the community, with each having a definite role to play. The term ‘diglossia’ is introduced here, modeled on the French diglossie, which has been applied to this situation, since there seems to be no word in regular use for this in English; other languages of Europe generally use the word for ‘bilingualism’ in this special sense as well. (The terms ‘language’, ‘dialect’, and ‘variety’ are used here without precise definition. It is hoped that they occur sufficiently in accordance with established usage to be unambiguous for the present purpose.

A limited form of dependent types, called Generalized Algebraic Data Types (GADTs), has recently been added to the list of Haskell extensions supported by the Glasgow Haskell Compiler. Despite not being full-fledged dependent types, GADTs still offer considerably enlarged scope for enforcing important code and data invariants statically. Moreover, GADTs offer the tantalizing possibility of writing more efficient programs since capturing invariants statically through the type system sometimes obviates entire layers of dynamic tests and associated data markup. This paper is a case study on the applications of GADTs in the context of Yampa, a domain-specific language for Functional Reactive Programming in the form of a self-optimizing, arrow-based Haskell combinator library. The paper has two aims. Firstly, to explore what kind of optimizations GADTs make possible in this context. Much of that should also be relevant for other domain-specific embedded language implementations, in particular arrow-based ones. Secondly, as the actual performance impact of the GADT-based optimizations is not obvious, to quantify this impact, both on tailored micro benchmarks, to establish the effectiveness of individual optimizations, and on two fairly large, realistic applications, to gauge the overall impact. The performance gains for the micro benchmarks are substantial. This implies that the Yampa API could be simplified as a number of "pre-composed" primitives that were there mainly for performance reasons are no longer needed. As to the applications, a worthwhile performance gain was obtained in one case whereas the performance was more or less unchanged in the other.

Developing programming languages is a difficult task that requires a lot of time, effort, and expertise. Reusable programming language components make this task easier, by allowing language designers to grab off-the-shelf components for common language features. Modern functional programming languages, however, lack support for reuse of definitions, and thus language components defined using algebraic data types and pattern matching functions cannot be reused without modifying or copying existing code. To improve the situation, we introduce CS, a functional meta-language for developing reusable programming language components, that features built-in support for extensible data types and functions, as well as effects and handlers. In CS, we can define language components using algebraic data types and pattern matching functions, such that we can compose language components into larger languages and define new interpretations for existing components without modifying existing definitions.