Less-Java, more type safety: Type inference and static analysis in Less-Java

Less-Java is an object-oriented programming language whose primary goal is to help new programmers learn programming. Some of the features of Less-Java that might make it better for beginners are static typing, implicit typing, low verbosity, and built-in support for unit testing. The primary focus of this project is on improving type inference (especially with regards to object-oriented programming) and adding static analysis in the Less-Java compiler

Modular session types for objects

Session types allow communication protocols to be specified type-theoretically so that protocol implementations can be verified by static type checking. We extend previous work on session types for distributed object-oriented languages in three ways. (1) We attach a session type to a class definition, to specify the possible sequences of method calls. (2) We allow a session type (protocol) implementation to be modularized, i.e. partitioned into separately-callable methods. (3) We treat session-typed communication channels as objects, integrating their session types with the session types of classes. The result is an elegant unification of communication channels and their session types, distributed object-oriented programming, and a form of typestate supporting non-uniform objects, i.e. objects that dynamically change the set of available methods. We define syntax, operational se-mantics, a sound type system, and a sound and complete type checking algorithm for a small distributed class-based object-oriented language with structural subtyping. Static typing guarantees that both sequences of messages on channels, and sequences of method calls on objects, conform to type-theoretic specifications, thus ensuring type-safety. The language includes expected features of session types, such as delegation, and expected features of object-oriented programming, such as encapsulation of local state.Comment: Logical Methods in Computer Science (LMCS), International Federation for Computational Logic, 201

Less-java, more learning: Language design for introductory programming

Less-Java is a new procedural programming language with static, strong, and inferred typing, native unit testing, and support for basic object-oriented constructs. These features make programming in Less-Java more intuitive than traditional introductory languages, which will allow professors to dedicate more class time to overarching computer science concepts and less to syntax and language-specific quirks

Variables and parameters as references and containers

Most designers of object-based languages adopt a reference model of variables without explicit justification, despite its wide ranging consequences. This paper argues that the traditional container model of variables is more efficient than the reference model, nearly as flexible, and more appropriate to parallel and distributed systems. The topics addressed are object lifetime and its implications for storage management, dynamic typing and its implications for object representation, aliasing and its implications for interference between operations, parameter passing and its implications for communication, and sharing and its implications for contention. We present our experience with the container model in a prototype parallel language. Neither model is always better than the other, and the choice of model should not be left to default.Computing Reviews Categories and Subject Descriptors: D.3.2 [Programming Lan­guages]: Language Classifications — concurrent, distributed and parallel languages; object-oriented languages; D.3.3 [Programming Languages]: Language Constructs and Features — concurrent programming structures; data types and structures; dynamic storage management; procedures, func­tions, and subroutinesKeywords: object-based programming languages, reference variables, container variables, reference parameters, container parameters, variable lifetime, object lifetime, dynamic typing, static typing, dynamic allocation, static allocation, garbage collection, variable aliasing, parameter passing, communication, sharing, contention, parallelism, concurrency, distribution, Matroshka, Natash

Dynamically typed languages

Dynamically typed languages such as Python and Ruby have experienced a rapid grown in popularity in recent times. However, there is much confusion as to what makes these languages interesting relative to statically typed languages, and little knowledge of their rich history. In this chapter I explore the general topic of dynamically typed languages, how they differ from statically typed languages, their history, and their defining features

Transitioning from structural to nominal code with efficient gradual typing

Gradual typing is a principled means for mixing typed and untyped code. But typed and untyped code often exhibit different programming patterns. There is already substantial research investigating gradually giving types to code exhibiting typical untyped patterns, and some research investigating gradually removing types from code exhibiting typical typed patterns. This paper investigates how to extend these established gradual-typing concepts to give formal guarantees not only about how to change types as code evolves but also about how to change such programming patterns as well. In particular, we explore mixing untyped "structural" code with typed "nominal" code in an object-oriented language. But whereas previous work only allowed "nominal" objects to be treated as "structural" objects, we also allow "structural" objects to dynamically acquire certain nominal types, namely interfaces. We present a calculus that supports such "cross-paradigm" code migration and interoperation in a manner satisfying both the static and dynamic gradual guarantees, and demonstrate that the calculus can be implemented efficiently

Typechecking protocols with Mungo and StMungo: a session type toolchain for Java

Static typechecking is an important feature of many standard programming languages. However, static typing focuses on data rather than communication, and therefore does not help programmers correctly implement communication protocols in distributed systems. The theory of session types provides a basis for tackling this problem; we use it to develop two tools that support static typechecking of communication protocols in Java. The first tool, Mungo, extends Java with typestate definitions, which allow classes to be associated with state machines defining permitted sequences of method calls: for example, communication methods. The second tool, StMungo, takes a session type describing a communication protocol, and generates a typestate specification of the permitted sequences of messages in the protocol. Protocol implementations can be validated by Mungo against their typestate definitions and then compiled with a standard Java compiler. The result is a toolchain for static typechecking of communication protocols in Java. We formalise and prove soundness of the typestate inference system used by Mungo, and show that our toolchain can be used to typecheck a client for the standard Simple Mail Transfer Protocol (SMTP)

Data Structures and Data Types in Object-Oriented Databases

The possibility of finding a static type system for object-oriented programming languages was initiated by Cardelli [Car88, CW85] who showed that it is possible to express the polymorphic nature of functions such a