Type-Safe Prototype-Based Component Evolution

Component-based programming is currently carried out us- ing mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
1. Verfasser: Zenger, Matthias
Format: Web Resource
Sprache:eng
Online-Zugang:Volltext bestellen
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page
container_issue
container_start_page
container_title
container_volume
creator Zenger, Matthias
description Component-based programming is currently carried out us- ing mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the programming language level. We propose a simple prototype-based model for first-class components on top of a class-based object-oriented language. The model is formalized as an extension of Featherweight Java. Our calculus includes a minimal set of primitives to dynamically build, extend, and compose software components, while supporting features like explicit context dependen- cies, late composition, unanticipated component extensibility, and strong encapsulation. We present a type system for our calculus that ensures type-safe component definition, composition, and evolution.
doi_str_mv 10.1007/3-540-47993-7_20
format Web Resource
fullrecord <record><control><sourceid>epfl_F1K</sourceid><recordid>TN_cdi_epfl_infoscience_oai_infoscience_tind_io_64411</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>oai_infoscience_tind_io_64411</sourcerecordid><originalsourceid>FETCH-epfl_infoscience_oai_infoscience_tind_io_644113</originalsourceid><addsrcrecordid>eNqdy7EKwjAUQNEsDqLujvmBaGJSQ1dLxVGwewjtCzxI84KJgn8vgour0-UMl7Gtkjslpd1r0RgpjG1bLaw7yCUTwyuDuPkA_HqnSvXDky8w8Y7mTAlS5f2T4qMipTVbBB8LbL5dsebcD91FQA7RYQpURoQ0giOPP66YJofkjsYopf_93mQnQd8</addsrcrecordid><sourcetype>Institutional Repository</sourcetype><iscdi>true</iscdi><recordtype>web_resource</recordtype></control><display><type>web_resource</type><title>Type-Safe Prototype-Based Component Evolution</title><source>Infoscience: EPF Lausanne</source><creator>Zenger, Matthias</creator><creatorcontrib>Zenger, Matthias</creatorcontrib><description>Component-based programming is currently carried out us- ing mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the programming language level. We propose a simple prototype-based model for first-class components on top of a class-based object-oriented language. The model is formalized as an extension of Featherweight Java. Our calculus includes a minimal set of primitives to dynamically build, extend, and compose software components, while supporting features like explicit context dependen- cies, late composition, unanticipated component extensibility, and strong encapsulation. We present a type system for our calculus that ensures type-safe component definition, composition, and evolution.</description><identifier>DOI: 10.1007/3-540-47993-7_20</identifier><language>eng</language><publisher>Berlin, Heidelberg, Springer Berlin Heidelberg</publisher><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>315,780,27860</link.rule.ids><linktorsrc>$$Uhttp://infoscience.epfl.ch/record/64411$$EView_record_in_EPF_Lausanne$$FView_record_in_$$GEPF_Lausanne$$Hfree_for_read</linktorsrc></links><search><creatorcontrib>Zenger, Matthias</creatorcontrib><title>Type-Safe Prototype-Based Component Evolution</title><description>Component-based programming is currently carried out us- ing mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the programming language level. We propose a simple prototype-based model for first-class components on top of a class-based object-oriented language. The model is formalized as an extension of Featherweight Java. Our calculus includes a minimal set of primitives to dynamically build, extend, and compose software components, while supporting features like explicit context dependen- cies, late composition, unanticipated component extensibility, and strong encapsulation. We present a type system for our calculus that ensures type-safe component definition, composition, and evolution.</description><fulltext>true</fulltext><rsrctype>web_resource</rsrctype><recordtype>web_resource</recordtype><sourceid>F1K</sourceid><recordid>eNqdy7EKwjAUQNEsDqLujvmBaGJSQ1dLxVGwewjtCzxI84KJgn8vgour0-UMl7Gtkjslpd1r0RgpjG1bLaw7yCUTwyuDuPkA_HqnSvXDky8w8Y7mTAlS5f2T4qMipTVbBB8LbL5dsebcD91FQA7RYQpURoQ0giOPP66YJofkjsYopf_93mQnQd8</recordid><creator>Zenger, Matthias</creator><general>Berlin, Heidelberg, Springer Berlin Heidelberg</general><scope>F1K</scope></search><sort><title>Type-Safe Prototype-Based Component Evolution</title><author>Zenger, Matthias</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-epfl_infoscience_oai_infoscience_tind_io_644113</frbrgroupid><rsrctype>web_resources</rsrctype><prefilter>web_resources</prefilter><language>eng</language><toplevel>online_resources</toplevel><creatorcontrib>Zenger, Matthias</creatorcontrib><collection>Infoscience: EPF Lausanne</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Zenger, Matthias</au><format>book</format><genre>unknown</genre><ristype>GEN</ristype><btitle>Type-Safe Prototype-Based Component Evolution</btitle><abstract>Component-based programming is currently carried out us- ing mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the programming language level. We propose a simple prototype-based model for first-class components on top of a class-based object-oriented language. The model is formalized as an extension of Featherweight Java. Our calculus includes a minimal set of primitives to dynamically build, extend, and compose software components, while supporting features like explicit context dependen- cies, late composition, unanticipated component extensibility, and strong encapsulation. We present a type system for our calculus that ensures type-safe component definition, composition, and evolution.</abstract><pub>Berlin, Heidelberg, Springer Berlin Heidelberg</pub><doi>10.1007/3-540-47993-7_20</doi><oa>free_for_read</oa></addata></record>
fulltext fulltext_linktorsrc
identifier DOI: 10.1007/3-540-47993-7_20
ispartof
issn
language eng
recordid cdi_epfl_infoscience_oai_infoscience_tind_io_64411
source Infoscience: EPF Lausanne
title Type-Safe Prototype-Based Component Evolution
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-28T03%3A53%3A28IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-epfl_F1K&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=unknown&rft.btitle=Type-Safe%20Prototype-Based%20Component%20Evolution&rft.au=Zenger,%20Matthias&rft_id=info:doi/10.1007/3-540-47993-7_20&rft_dat=%3Cepfl_F1K%3Eoai_infoscience_tind_io_64411%3C/epfl_F1K%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true