Type-Safe Prototype-Based Component Evolution

Zenger, Matthias

doi:10.1007/3-540-47993-7_20

Cited by 24 publications

(17 citation statements)

References 39 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Together with the rule that concrete class members always override abstract ones, this principle yields recursively pluggable components where component services do not have to be wired explicitly [50].…”

Section: Service-oriented Component Modelmentioning

confidence: 99%

Scalable component abstractions

Odersky

Zenger

2005

Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications

Self Cite

149

View full text Add to dashboard Cite

We identify three programming language abstractions for the construction of reusable components: abstract type members, explicit selftypes, and modular mixin composition. Together, these abstractions enable us to transform an arbitrary assembly of static program parts with hard references between them into a system of reusable components. The transformation maintains the structure of the original system. We demonstrate this approach in two case studies, a subject/observer framework and a compiler front-end.

show abstract

Section: Service-oriented Component Modelmentioning

confidence: 99%

Scalable component abstractions

Odersky

Zenger

2005

Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications

Self Cite

149

View full text Add to dashboard Cite

show abstract

“…Recently, there are several works on using type systems for certifying important security properties, such as performance safety, memory safety, control-flow safety [14], [6], [5]. In component software, typing has been studied in relation to integrating components such as type-safe composition [19] or type-safe evolution [13]. In this paper we explore the possibility of a type system which allows one to detect statically whether or not the number of simultaneously active instances of specific components exceeds the allowed number.…”

Section: Introductionmentioning

confidence: 99%

Guaranteeing Resource Bounds for Component Software

Truong

2005

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. Component software is software that has been assembled from various pieces of standardized, reusable computer programs, socalled components. Executing component software creates instances of these components. For several reasons, for example, limited resources and/or application requirements, it can be important to have control over the number of such instances. In the previous work [3], we have given an abstract component language and a type system which ensures that the number of simultaneously active instances of any component never exceeds a sharp bound expressed in the type. The language featured instantiation and reuse of components, as well as sequential composition, choice and scope. This work extends the previous one to include a parallel composition. Moreover, we improve on the operational semantics by using a small-step reduction relation. As a result, we can prove the soundness property of our static type system using the technique of Wright and Felleisen.

show abstract

“…In [32] linguistic abstractions for component-oriented programming are added on top of FJ: while this notion of component inspired our view of objects, in [32] components are distinct linguistic constructs from the notion of objects as class instances. Moreover, type safety in [32] is guaranteed only at the cost of a number of syntactic restrictions.…”

Section: Related Workmentioning

confidence: 99%

“…The basic idea is to adopt a generalized notion of object, which is inspired by the component-based programming [32]. Objects are intended as featherweight components which can be used in different compositions to modify their behavior based on dynamic conditions and independently from inheritance hierarchies.…”

Section: Introductionmentioning

confidence: 99%

Object reuse and behavior adaptation in Java-like languages

Bettini

Venneri

2011

Proceedings of the 9th International Conference on Principles and Practice of Programming in Java

View full text Add to dashboard Cite

Inheritance, which is a basic mechanism in mainstream objectoriented languages, introduces a strong coupling which limits modularity and code reuse. Furthermore, static class hierarchies cannot easily deal with unpredictable dynamic adaptations of the object behavior. In order to overcome these limitations, we propose new linguistic constructs for composing objects in a Java-like language. Objects are intended as featherweight components which can be used in multiple compositions, and object types specify not only the implemented functionalities, but also the required methods, which will be provided by other components during composition. Thus the language supports flexible object reuse and adaptation of the object behavior at run time. The static type discipline guarantees that method calls on well-typed object compositions are safe.

show abstract

Type-Safe Prototype-Based Component Evolution

Cited by 24 publications

References 39 publications

Scalable component abstractions

Scalable component abstractions

Guaranteeing Resource Bounds for Component Software

Object reuse and behavior adaptation in Java-like languages

Contact Info

Product

Resources

About