João Costa Seco

A Basic Model of Typed Components

This paper studies specific language level abstractions for component-based programming. We propose a simple model which captures some basic ingredients--like explicit context dependence, dynamic binding and subtype polymorphism, late (dynamic) composition, and avoidance of inheritance in favor of object composition -- that several authors have defended to be central to black-box object-oriented component programming styles. The model is expressed by a core imperative typed calculus, in which components are first-class entities, and whose basic constructs enable the composition, scripting, instantiation and definition of atomic components. Some motivating programming examples are presented, and the operational semantics is shown to enjoy a type-safety property. We also discuss an extension to the Java language aimed at supporting the proposed model, and some implementation issues.

The conversation calculus: a model of service-oriented computation

We present a process-calculus model for expressing and analyzing service-based systems. Our approach addresses central features of the service-oriented computational model such as distribution, process delegation, communication and context sensitiveness, and loose coupling. Distinguishing aspects of our model are the notion of conversation context, the adoption of a context sensitive, message-passing-based communication, and of a simple yet expressive mechanism for handling exceptional behavior. We instantiate our model by extending a fragment of the π-calculus, illustrate its expressiveness by means of many examples, and study its basic behavioral theory; in particular, we establish that bisimilarity is a congruence.

The type discipline of behavioral separation

We introduce the concept of behavioral separation as a general principle for disciplining interference in higher-order imperative concurrent programs, and present a type-based approach that systematically develops the concept in the context of an ML-like language extended with concurrency and synchronization primitives. Behavioral separation builds on notions originally introduced for behavioral type systems and separation logics, but shifts the focus from the separation of static program state properties towards the separation of dynamic usage behaviors of runtime values. Behavioral separation types specify how values may be safely used by client code, and can enforce fine-grained interference control disciplines while preserving compositionality, information hiding, and flexibility. We illustrate how our type system, even if based on a small set of general primitives, is already able to tackle fairly challenging program idioms, involving aliasing at various types, concurrency with first-class threads, manipulation of linked data structures, behavioral borrowing, and invariant-based separation.

Type-based access control in data-centric systems

Data-centric multi-user systems, such as web applications, require flexible yet fine-grained data security mechanisms. Such mechanisms are usually enforced by a specially crafted security layer, which adds extra complexity and often leads to error prone coding, easily causing severe security breaches. In this paper, we introduce a programming language approach for enforcing access control policies to data in data-centric programs by static typing. Our development is based on the general concept of refinement type, but extended so as to address realistic and challenging scenarios of permission-based data security, in which policies dynamically depend on the database state, and flexible combinations of column- and row-level protection of data are necessary. We state and prove soundness and safety of our type system, stating that well-typed programs never break the declared data access control policies.

Subtyping first-class polymorphic components

We present a statically typed, class-based object oriented language where classes are first class polymorphic values. A main contribution of this work is the design of a type system that combines first class polymorphic values with structural equirecursive types and admits a subtyping algorithm which is arguably much simpler than existing alternatives. Our development is modular and can be easily instantiated for either a Kernel-Fun or a

A common data manipulation language for nested data in heterogeneous environments

F_{\leq}^{\top}

Capability-based localization of distributed and heterogeneous queries

style of subtyping discipline.

Concurrent typed intermediate language

One key aspect of data-centric applications is the manipu- lation of persistent data repositories, which is moving fast from querying a centralized relational database to the ad- hoc combination of constellations of data sources. Query languages are being typefuly integrated in host, general purpose, languages in order to increase reasoning and optimizing capabilities of interpreters and compilers. However, not much is being done to integrate and orches- trate different and separate sources of data. We present a common data manipulation language, that abstracts the nature and localization of the data-sources. We define its semantics and a type directed compilation, query optimization, and query orchestration mechanism to be used in development tools for heterogeneous environments. We provide type safety and language integration. Our approach is also suitable for an interactive query construction environment by rich user interfaces that pro- vide immediate feedback on data manipulation operations. This approach is currently the base for the data layer of a development platform for mobile and web applications.

Profiling of real-world web applications

One key aspect of data-centric applications is the manipulation of data stored in persistent repositories, which is moving fast from querying a centralized relational database to the ad-hoc combination of constellations of data sources. The extension of general purpose languages with query operations is increasingly popular, as a tool to improve reasoning and optimizing capabilities of interpreters and compilers. However, not much is being done to integrate and orchestrate different and separate sources of data. We present a data manipulation language that abstracts the nature and location of data-sources. We define its semantics and a type directed query localization mechanism to be used in development tools for heterogeneous environments to efficiently compile them into native queries. We introduce a localization procedure based on rewriting of query expressions that is confluent, terminating and provides the maximum mapping between site capabilities and the structure of the query. We provide formal type safety results that support the sound distribution of query fragments over remote sites. Our approach is also suitable for an interactive query construction environment by rich user interfaces that provide immediate feedback on data manipulation operations. This approach is currently the base for the data layer of a development platform for mobile and web applications.

Systems, methods, and apparatus for model-based security control

Typed assembly languages have been designed to ensure safety on low-level code, avoiding the dynamic loading of erroneous code, generated by unreliable compilers, thus compromising the correct behavior of virtual machines and processors. Among the most challenging errors to detect are errors related to concurrent behaviors and thread synchronization. We present a typed intermediate language for a stack-based virtual machine, comprising a primitive object model and native support for concurrency. By using primitives to deal with concurrency, we establish a more abstract level where it is possible to represent and enforce a linear discipline on thread values, and pave the way for more sophisticated type based aliasing and concurrency analyses.