Safe "Open-World" Designs in Java and GJ : Revised Version
Safe "Open-World" Designs in Java and GJ : Revised Version
Date
1999
Authors
Nissen, Marco
Weihe, Karsten
Editors
Journal ISSN
Electronic ISSN
ISBN
Bibliographical data
Publisher
Series
Konstanzer Schriften in Mathematik und Informatik; 66
URI (citable link)
International patent number
Link to the license
EU project number
Project
Open Access publication
Collections
Title in another language
Publication type
Preprint
Publication status
Published in
Abstract
By open-world design we mean that collaborating classes are so loosely coupled that changes in one class do not propagate to the other classes, and single classes can be isolated and integrated in other contexts. Of course, this is what maintainability and reusability is all about.
It is folklore knowledge that generic language features are helpful for the implementation of basic algorithms (such as sorting) and data structures (such as stacks). The insight is by far less common that genericity is generally useful to render the coupling of collaborating classes loose, yet still (statically) safe.
The intent of the paper is two-fold: first of all, we will have to lay out a base for fruitful discussions of this topic. It will turn out that the design goal "open world" is surprisingly ambitious even if we restrict our attention to a collaborative task as simple as attribute access. Second, we will try to demonstrate that in Java even an open-world design of mere attribute access can only be achieved if static safety is sacrificed, and that this conflict is unresolvable even if the attribute type is fixed.
In contrast, generic language features allow the combination of both goals. As a consequence, genericity should be viewed as a first-class design feature, because generic language features are preferably applied in many situations in which object-orientedness seems appropriate.
We chose Java as the base of the discussion because Java is commonly known and several advanced features of Java aim at a loose coupling of classes. On the other hand, the discussion of generic language features will be based on GJ, which is a generic extension of Java. In particular, the paper is intended to make a strong point in favor of generic extensions of Java.
It is folklore knowledge that generic language features are helpful for the implementation of basic algorithms (such as sorting) and data structures (such as stacks). The insight is by far less common that genericity is generally useful to render the coupling of collaborating classes loose, yet still (statically) safe.
The intent of the paper is two-fold: first of all, we will have to lay out a base for fruitful discussions of this topic. It will turn out that the design goal "open world" is surprisingly ambitious even if we restrict our attention to a collaborative task as simple as attribute access. Second, we will try to demonstrate that in Java even an open-world design of mere attribute access can only be achieved if static safety is sacrificed, and that this conflict is unresolvable even if the attribute type is fixed.
In contrast, generic language features allow the combination of both goals. As a consequence, genericity should be viewed as a first-class design feature, because generic language features are preferably applied in many situations in which object-orientedness seems appropriate.
We chose Java as the base of the discussion because Java is commonly known and several advanced features of Java aim at a loose coupling of classes. On the other hand, the discussion of generic language features will be based on GJ, which is a generic extension of Java. In particular, the paper is intended to make a strong point in favor of generic extensions of Java.
Summary in another language
Subject (DDC)
004 Computer Science
Keywords
Conference
Review
undefined / . - undefined, undefined. - (undefined; undefined)
Cite This
ISO 690
NISSEN, Marco, Karsten WEIHE, 1999. Safe "Open-World" Designs in Java and GJ : Revised VersionBibTex
@unpublished{Nissen1999OpenW-6405,
year={1999},
title={Safe "Open-World" Designs in Java and GJ : Revised Version},
author={Nissen, Marco and Weihe, Karsten}
}
RDF
<rdf:RDF
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:bibo="http://purl.org/ontology/bibo/"
xmlns:dspace="http://digital-repositories.org/ontologies/dspace/0.1.0#"
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:void="http://rdfs.org/ns/void#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#" >
<rdf:Description rdf:about="https://kops.uni-konstanz.de/server/rdf/resource/123456789/6405">
<dc:date rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">2011-03-24T16:12:29Z</dc:date>
<dspace:hasBitstream rdf:resource="https://kops.uni-konstanz.de/bitstream/123456789/6405/1/preprint_066_02.pdf"/>
<dc:creator>Weihe, Karsten</dc:creator>
<dc:format>application/pdf</dc:format>
<bibo:uri rdf:resource="http://kops.uni-konstanz.de/handle/123456789/6405"/>
<dspace:isPartOfCollection rdf:resource="https://kops.uni-konstanz.de/server/rdf/resource/123456789/36"/>
<dc:rights>terms-of-use</dc:rights>
<dcterms:available rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">2011-03-24T16:12:29Z</dcterms:available>
<void:sparqlEndpoint rdf:resource="http://localhost/fuseki/dspace/sparql"/>
<dcterms:title>Safe "Open-World" Designs in Java and GJ : Revised Version</dcterms:title>
<foaf:homepage rdf:resource="http://localhost:8080/"/>
<dc:language>eng</dc:language>
<dcterms:issued>1999</dcterms:issued>
<dc:contributor>Weihe, Karsten</dc:contributor>
<dcterms:rights rdf:resource="https://rightsstatements.org/page/InC/1.0/"/>
<dcterms:hasPart rdf:resource="https://kops.uni-konstanz.de/bitstream/123456789/6405/1/preprint_066_02.pdf"/>
<dc:contributor>Nissen, Marco</dc:contributor>
<dc:creator>Nissen, Marco</dc:creator>
<dcterms:abstract xml:lang="eng">By open-world design we mean that collaborating classes are so loosely coupled that changes in one class do not propagate to the other classes, and single classes can be isolated and integrated in other contexts. Of course, this is what maintainability and reusability is all about.<br /><br />It is folklore knowledge that generic language features are helpful for the implementation of basic algorithms (such as sorting) and data structures (such as stacks). The insight is by far less common that genericity is generally useful to render the coupling of collaborating classes loose, yet still (statically) safe.<br /><br />The intent of the paper is two-fold: first of all, we will have to lay out a base for fruitful discussions of this topic. It will turn out that the design goal "open world" is surprisingly ambitious even if we restrict our attention to a collaborative task as simple as attribute access. Second, we will try to demonstrate that in Java even an open-world design of mere attribute access can only be achieved if static safety is sacrificed, and that this conflict is unresolvable even if the attribute type is fixed.<br /><br />In contrast, generic language features allow the combination of both goals. As a consequence, genericity should be viewed as a first-class design feature, because generic language features are preferably applied in many situations in which object-orientedness seems appropriate.<br /><br />We chose Java as the base of the discussion because Java is commonly known and several advanced features of Java aim at a loose coupling of classes. On the other hand, the discussion of generic language features will be based on GJ, which is a generic extension of Java. In particular, the paper is intended to make a strong point in favor of generic extensions of Java.</dcterms:abstract>
<dcterms:isPartOf rdf:resource="https://kops.uni-konstanz.de/server/rdf/resource/123456789/36"/>
</rdf:Description>
</rdf:RDF>