Object Types against Races

In this paper, we develop a novel notion of dependent information flow types. Dependent information flow types fit within the standard framework of dependent type theory, but, unlike usual dependent types, crucially allow the security level of a type, rather than just the structural data type itself, to depend on runtime values. Our dependent function and dependent sum information flow types provide a direct, natural and elegant way to express and enforce fine grained security policies on programs, including programs that manipulate structured data types in which the security level of a structure field may depend on values dynamically stored in other fields, still considered a challenge to security enforcement in software systems such as data-centric web-based applications. We base our development on the very general setting of a minimal lambda-calculus with references and collections. We illustrate its expressiveness, showing how secure operations on relevant scenarios can be modelled and analysed using our dependent information flow type system, which is also shown to be amenable to algorithmic type checking. Our main results include type-safety and non-interference theorems ensuring that well-typed programs do not violate prescribed security policies.

It is well known that class and type are two different concepts in object-oriented programming languages (OOPLs). However, in many popular OOPLs, classes are used as types. In this paper, we argue that the class-is-type principle is a major obstacle to software reuse, especially to object reuse. The concepts of the basic entities, i.e., objects, object classes, object types, and object kinds, in the type hierarchy of OOPLs are revisited. The notion of object reuse is defined and elaborated. In addition, we show that parameterized types and generic functions are better served by used kind-bounded quantification than universal quantification and other mechanisms.

We present a certified compiler from the simply-typed lambda calculus to assembly language. The compiler is certified in the sense that it comes with a machine-checked proof of semantics preservation, performed with the Coq proof assistant. The compiler and the terms of its several intermediate languages are given dependent types that guarantee that only well-typed programs are representable. Thus, type preservation for each compiler pass follows without any significant “proofs ” of the usual kind. Semantics preservation is proved based on denotational semantics assigned to the intermediate languages. We demonstrate how working with a type-preserving compiler enables type-directed proof search to discharge large parts of our proof obligations automatically. Categories and Subject Descriptors F.3.1 [Logics and meanings

A formal model of service-oriented dynamic object groups

Object-oriented design and programming are big topics—entire books are devoted solely to the process of object-oriented design or to using object-oriented programming in various languages and on various programming platforms. My focus in this book isn’t to teach the basics of object-oriented design or programming but rather to show how you may apply them to the creation of distributed. NET applications.KeywordsApplication ServerBusiness LogicBusiness ObjectMobile ObjectLogical LayerThese 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.

The square-rectangle problem is often cited as an illustration of pitfalls arising when using object-oriented programming (OOP). A number of solutions have been proposed, however, according to the author, none of them solve the problem satisfactorily, mainly because they tackle the problem from within the current OOP paradigm. This paper presents another solution stemming from object morphology (OM), a new object-oriented paradigm developed to model mutable phenomena. In the framework of OM the problem can be solved directly under the basic OM principle that an object may mutate not only with regard to its state, but also with regard to its type. The main contrast between the presented and the other solutions is that constraint violations caused by changes in an object's state are no longer necessarily considered errors; instead, they may be interpreted as triggers initiating a mutation of the object's type. The solution is demonstrated using Morpheus, a proof-of-concept implementation of OM in Scala.

Index refinements (or dependent types over a restricted domain) enable the expression of many desirable invariants that can be verified at compile time. We propose to incorporate a system of index refinements in a small, class-based, imperative, object-oriented language. While rooted in techniques formulated for dependently-typed functional languages, our type system is able to capture more than just value properties and pure computations. Index refinements, combined with a notion of pre- and post-type to track state, give programmers the ability to reason about effectful computations. Our type system distinguishes between two classes of objects, imposing an affine discipline to objects whose types are governed by indices, as opposed to conventional objects which can be freely shared. We have designed and implemented an expressive and decidable type system, which we illustrate through a number of examples.

In this paper we investigate the addition of first-class relationships to a prototypical object-oriented programming language (a “middleweight” fragment of Java). We provide language-level constructs to declare relationships between classes and to manipulate relationship instances. We allow relationships to have attributes and provide a novel notion of relationship inheritance. We formalize our language giving both the type system and operational semantics and prove certain key safety properties.KeywordsOperational SemanticType SoundnessMethod BodyRelationship InheritanceSubject ReductionThese 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.

Alltalk is an object-oriented programming and database system, based on Smalltalk, being developed at Eastman Kodak Company to support development of advanced information systems. It provides permanence to Smalltalk objects without adding a database sub-language, new language syntax, classes, or methods to Smalltalk. In this paper we describe problems we encountered in integrating Smalltalk with database management and discuss our solutions to these problems. We believe the problems we identify are of a general nature and would arise in augmenting most any object-oriented language with database support.KeywordsTransitive ClosureGarbage CollectionBuffer ManagementDatabase ObjectGarbage CollectorThese 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.

This paper introduces the individualized interdisciplinary learning resources based on scientific software, that usually serves for solving domain problems (optimization, simulation etc.). Integrating this type of software in learning process is a problem that we are solving by suggesting a new way to describe this software and introduce a framework that helps to form learning resource from it. We propose the concept of creating new advanced type of generative learning objects (GLOs) that changes not only structure of content presentation for different purposes (described by the contexts' parameters) but also it changes the way of learning and evaluating. The object-oriented programming (OOP) paradigm is used for combining concepts of GLO and learning objects (LO) based on information object to formulate our proposed approach. In this article we describe the principles of generating the interdisciplinary learning resource for a master program's learning course. Also we provide example of scientific software (transport schedule optimization) and show how it should be described for being used in learning process.

In [3] we defined the λ&-calculus, a simple extension of the typed λ-calculus to model typed object-oriented languages. To develop a formal study of type systems for object-oriented languages we define, in this paper, a meta-language based on λ& and we show by a practical example how to use it to prove properties of a language. To this purpose we define a toy object-oriented language and its type-checking algorithm; then we translate this toy language into our meta-language. The translation gives the semantics of the toy language and a theorem on the translation of well-typed programs proves the correction of the type-checker of the toy language.As an aside we also illustrate the expressivity of the λ&-based model by showing how to translate existing features like multiple inheritance and multiple dispatch, but also by integrating in the toy language new features directly suggested by the model, such as first-class messages, a generalization of the use of super and the use of explicit coercions.KeywordsMessage PassingOperational SemanticAtomic TypeInstance VariableDynamic BindingThese 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 an object oriented system, different types of objects may have one or more attributes in common. For example different types of objects in a library system might be loanable or catalogued. The first part of the paper introduces a distinction between object types and attribute types, showing that there are advantages in treating them as separate constructs of an object oriented programming language. Then generalized attribute types, (e.g. synchronized, journalized, protected) are discussed. It is shown how implementations involving a technique called bracket routines can lead to clearly modeled and cleanly implemented programs. It is then shown how the bracket technique can be effectively used to introduce protection and security concepts into a system. Among the clear advantages of this technique is that it results in better reusability of code.

The criterion of information-hiding wu originally developed for a otinctured approach in design. The advent of object-oriented design methodology and languages potentially allows the designer to implement information-hiding more effectively. In reality, however, building a program as a set of cooperating objects often results in a web of dependencies that makes an object-oriented program even more difficult to maintain than a traditional program. Two extensions of the concept of information-hiding are proposed: shared knowledge among object types and visibility of object types to other types. The first extension concentrates on the division of responsibilities among objects of different types. This form of information-hiding is related to the traditional concept of cohesion. The seccnd extension helps to organise object communications when an object of one type sends to an object of another type a message with an object of the third type as a parameter. This form of information-hiding is related to the criterion of coupling in traditional design. At a case study, a prototype model of an inventory control system written in C++ is discussed. Alternative design are compared. The use of proposed extensions is shown to be effective in elimination unnecessary complexity of design.

Previous work on type-theoretic foundations for object-oriented programming languages has mostly focused on applying or extending functional type theory to functional objects. This approach, while benefiting from a vast body of existing literature, has the disadvantage of dealing with state change either in a roundabout way or not at all, and completely side- stepping issues of concurrency. In particular, dynamic issues of non-uniform service availability and conformance to protocols are not addressed by functional types. We propose a new type framework that characterizes objects as regular (finite state) processes that provide guarantees of service along public channels. We also propose a new notion of subtyping for active objects, based on Brinksma's notion of extension , that extends Wegner and Zdonik's principle of substitutability to non-uniform service availability. Finally, we formalize what it means to satisfy a client's expectations, and we show how regular types can be used to tell when sequential or concurrent clients are satisfied.

Type information has many applications; it can e.g. be used in optimized compilation, termination analysis and error detection. However, logic programs are typically untyped. A well-typed program has the property that it behaves identically on well-typed goals with or without type checking. Hence the automatic inference of a well-typing is worthwhile. Existing inferences are either cheap and inaccurate, or accurate and expensive. By giving up the requirement that all calls to a predicate have types that are instances of a unique polymorphic type but instead allowing multiple polymorphic typings for the same predicate, we obtain a novel strongly-connected-component-based analysis that provides a good compromise between accuracy and computational cost.KeywordsLogic ProgramType SignatureType InformationRecursive CallType RuleThese 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.