{"id":{"repo_id":"cornell","oai_identifier":"oai:ecommons.cornell.edu:1813/3726"},"canonical_url":"https://search.ndltd.org/etd/cornell/oai:ecommons.cornell.edu:1813/3726","repository":{"repo_id":"cornell","name":"Cornell University","base_url":"https://ecommons.cornell.edu/server/oai/request"},"display":{"title":"Programming Languages for Scalable Software Extension and Composition","abstract":"Large software systems are often constructed by reusing existing code. This dissertation describes several approaches that address the limitations of existing code reuse mechanisms such as class inheritance. The Polyglot design pattern enables software systems to be extended in a scalable way: the code required to extend the system is proportional to the amount of new functionality provided. This design pattern has been used to implement an extensible compiler framework. Nested inheritance is an object-oriented programming language mechanism that supports scalable extensibility in a safer, more natural way than the design pattern approach. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection extends nested intersection to enable composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. Nested intersection is implemented in the language J&. The utility of J& is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features.","abstract_html":"Large software systems are often constructed by reusing existing code. This dissertation describes several approaches that address the limitations of existing code reuse mechanisms such as class inheritance. The Polyglot design pattern enables software systems to be extended in a scalable way: the code required to extend the system is proportional to the amount of new functionality provided. This design pattern has been used to implement an extensible compiler framework. Nested inheritance is an object-oriented programming language mechanism that supports scalable extensibility in a safer, more natural way than the design pattern approach. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection extends nested intersection to enable composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. Nested intersection is implemented in the language J&amp;. The utility of J&amp; is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features.","abstract_has_math":false,"creators":["Nystrom, Nathaniel J."],"institution":null,"degree_name":null,"degree_level":null,"degree_discipline":null,"degree_department":null,"school":null,"contributors":[],"advisors":[],"committee_chairs":[],"committee_members":[],"year":2006,"date_issued":"2006-11-06T21:03:54Z","date_published":"2006-11-06T21:03:54Z","updated_at":"2026-11-19T03:18:04Z","subjects":[],"languages":["en_US"],"rights":[],"rights_urls":[],"identifier_entries":[{"key":"dc:identifier.bibid","label":"Dc Identifier Bibid","values":["6475874"],"render_values":[{"text":"6475874","href":null,"code":true}]}],"person_identifier_entries":[]},"links":{"outbound_url":"https://hdl.handle.net/1813/3726","outbound_label":"Handle","outbound_source":"dc:identifier.uri","record_url":"https://hdl.handle.net/1813/3726","record_label":"Repository record","record_kind":"handle","record_source":"dc:identifier.uri","download_url":null,"download_label":null,"download_source":null,"access_status":null,"embargo_until":null,"access_note":null},"source_record":{"url":"https://ecommons.cornell.edu/server/oai/request?verb=GetRecord&metadataPrefix=dim&identifier=oai%3Aecommons.cornell.edu%3A1813%2F3726","prefix":"dim"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:creator","label":"Author","values":["Nystrom, Nathaniel J."]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date.accessioned","label":"Dc Date Accessioned","values":["2006-11-06T21:03:54Z"]},{"key":"dc:date.available","label":"Dc Date Available","values":["2006-11-06T21:03:54Z"]},{"key":"dc:date.issued","label":"Date","values":["2006-11-06T21:03:54Z"]},{"key":"dc:type","label":"Dc Type","values":["dissertation or thesis"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language.iso","label":"Language (ISO)","values":["en_US"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier.bibid","label":"Dc Identifier Bibid","values":["6475874"]},{"key":"dc:identifier.uri","label":"Identifier URI","values":["https://hdl.handle.net/1813/3726"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"cerif:openaire","label":"Cerif Openaire","values":["<Publication xmlns=\"https://www.openaire.eu/cerif-profile/1.1/\" id=\"e93a2509-9335-464c-b0f6-3f18a6ce2453\"> <Type xmlns=\"https://www.openaire.eu/cerif-profile/vocab/COAR_Publication_Types\">http://purl.org/coar/resource_type/c_1843</Type> <Language>en_US</Language> <Title>Programming Languages for Scalable Software Extension and Composition</Title> <PublishedIn> <Publication> </Publication> </PublishedIn> <PublicationDate>2006-11-06T21:03:54Z</PublicationDate> <Authors> <Author> <DisplayName>Nystrom, Nathaniel J.</DisplayName> <Affiliation> <OrgUnit> </OrgUnit> </Affiliation> </Author> </Authors> <Editors> </Editors> <Publishers> <Publisher> <OrgUnit /> </Publisher> </Publishers> <Abstract>Large software systems are often constructed by reusing existing code. This dissertation describes several approaches that address the limitations of existing code reuse mechanisms such as class inheritance. The Polyglot design pattern enables software systems to be extended in a scalable way: the code required to extend the system is proportional to the amount of new functionality provided. This design pattern has been used to implement an extensible compiler framework. Nested inheritance is an object-oriented programming language mechanism that supports scalable extensibility in a safer, more natural way than the design pattern approach. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection extends nested intersection to enable composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. Nested intersection is implemented in the language J&. The utility of J& is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features.</Abstract> <Access xmlns=\"http://purl.org/coar/access_right\" > </Access> </Publication>"]},{"key":"cris:virtual.author","label":"Cris Virtual Author","values":["Nystrom, Nathaniel J."]},{"key":"cris:virtualsource.collection","label":"Cris Virtualsource Collection","values":["5893a6ea-7af3-41d7-abc6-04bcd26ab5df"]},{"key":"dc:description.abstract","label":"Abstract","values":["Large software systems are often constructed by reusing existing code. This dissertation describes several approaches that address the limitations of existing code reuse mechanisms such as class inheritance. The Polyglot design pattern enables software systems to be extended in a scalable way: the code required to extend the system is proportional to the amount of new functionality provided. This design pattern has been used to implement an extensible compiler framework. Nested inheritance is an object-oriented programming language mechanism that supports scalable extensibility in a safer, more natural way than the design pattern approach. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection extends nested intersection to enable composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. Nested intersection is implemented in the language J&. The utility of J& is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features."]},{"key":"dc:description.collection","label":"Dc Description Collection","values":["Cornell Theses and Dissertations"]},{"key":"dc:format.extent","label":"Dc Format Extent","values":["1629140 bytes"]},{"key":"dc:format.mimetype","label":"Dc Format Mimetype","values":["application/pdf"]},{"key":"dc:title","label":"Title","values":["Programming Languages for Scalable Software Extension and Composition"]},{"key":"dspace:entity.type","label":"Dspace Entity Type","values":["Publication"]},{"key":"others:access_status","label":"Others Access Status","values":["open.access"]}]}],"canonical_facts":{"cerif:openaire":["<Publication xmlns=\"https://www.openaire.eu/cerif-profile/1.1/\" id=\"e93a2509-9335-464c-b0f6-3f18a6ce2453\"> <Type xmlns=\"https://www.openaire.eu/cerif-profile/vocab/COAR_Publication_Types\">http://purl.org/coar/resource_type/c_1843</Type> <Language>en_US</Language> <Title>Programming Languages for Scalable Software Extension and Composition</Title> <PublishedIn> <Publication> </Publication> </PublishedIn> <PublicationDate>2006-11-06T21:03:54Z</PublicationDate> <Authors> <Author> <DisplayName>Nystrom, Nathaniel J.</DisplayName> <Affiliation> <OrgUnit> </OrgUnit> </Affiliation> </Author> </Authors> <Editors> </Editors> <Publishers> <Publisher> <OrgUnit /> </Publisher> </Publishers> <Abstract>Large software systems are often constructed by reusing existing code. This dissertation describes several approaches that address the limitations of existing code reuse mechanisms such as class inheritance. The Polyglot design pattern enables software systems to be extended in a scalable way: the code required to extend the system is proportional to the amount of new functionality provided. This design pattern has been used to implement an extensible compiler framework. Nested inheritance is an object-oriented programming language mechanism that supports scalable extensibility in a safer, more natural way than the design pattern approach. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection extends nested intersection to enable composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. Nested intersection is implemented in the language J&. The utility of J& is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features.</Abstract> <Access xmlns=\"http://purl.org/coar/access_right\" > </Access> </Publication>"],"cris:virtual.author":["Nystrom, Nathaniel J."],"cris:virtualsource.collection":["5893a6ea-7af3-41d7-abc6-04bcd26ab5df"],"dc:creator":["Nystrom, Nathaniel J."],"dc:date.accessioned":["2006-11-06T21:03:54Z"],"dc:date.available":["2006-11-06T21:03:54Z"],"dc:date.issued":["2006-11-06T21:03:54Z"],"dc:description.abstract":["Large software systems are often constructed by reusing existing code. This dissertation describes several approaches that address the limitations of existing code reuse mechanisms such as class inheritance. The Polyglot design pattern enables software systems to be extended in a scalable way: the code required to extend the system is proportional to the amount of new functionality provided. This design pattern has been used to implement an extensible compiler framework. Nested inheritance is an object-oriented programming language mechanism that supports scalable extensibility in a safer, more natural way than the design pattern approach. Nested inheritance permits modular, type-safe extension of a package (including nested packages and classes), while preserving existing type relationships. Nested intersection extends nested intersection to enable composition and extension of two or more packages, combining their types and behavior while resolving conflicts with a relatively small amount of code. Nested intersection is implemented in the language J&. The utility of J& is demonstrated by using it to construct two composable, extensible frameworks: a compiler framework for Java, and a peer-to-peer networking system. Both frameworks support composition of extensions. For example, two compilers adding different, domain-specific features to Java can be composed to obtain a compiler for a language that supports both sets of features."],"dc:description.collection":["Cornell Theses and Dissertations"],"dc:format.extent":["1629140 bytes"],"dc:format.mimetype":["application/pdf"],"dc:identifier.bibid":["6475874"],"dc:identifier.uri":["https://hdl.handle.net/1813/3726"],"dc:language.iso":["en_US"],"dc:title":["Programming Languages for Scalable Software Extension and Composition"],"dc:type":["dissertation or thesis"],"dspace:entity.type":["Publication"],"others:access_status":["open.access"]},"updated_at":"2026-11-19T03:18:04Z"}