Type-based hot swapping of running modules

Research output: Contribution to conferencePaper

45 Citations (Scopus)

Abstract

While dynamic linking has become an integral part of the run-time execution of modern programming languages, there is increasing recognition of the need for support for hot swapping of running modules, particularly in long-lived server applications. The interesting challenge for such a facility is to allow the new module to change the types exported by the original module, while preserving type safety. This paper describes a type-based approach to hot swapping running modules. The approach is based on a reflective mechanism for dynamically adding type sharing constraints to the type system, realized by programmer-defined version adapters in the run-time.

Original languageEnglish (US)
Pages62-73
Number of pages12
StatePublished - Jan 1 2001
Event6th ACM SIGPLAN Internatinal Conference on Functional Programming (ICFP'01) - Florence, Italy
Duration: Sep 3 2001Sep 5 2001

Other

Other6th ACM SIGPLAN Internatinal Conference on Functional Programming (ICFP'01)
CountryItaly
CityFlorence
Period9/3/019/5/01

Fingerprint

Computer programming languages
Servers

Cite this

Duggan, D. (2001). Type-based hot swapping of running modules. 62-73. Paper presented at 6th ACM SIGPLAN Internatinal Conference on Functional Programming (ICFP'01), Florence, Italy.
Duggan, Dominic. / Type-based hot swapping of running modules. Paper presented at 6th ACM SIGPLAN Internatinal Conference on Functional Programming (ICFP'01), Florence, Italy.12 p.
@conference{ac8f950d5f8444bca3f931bd945ad3d1,
title = "Type-based hot swapping of running modules",
abstract = "While dynamic linking has become an integral part of the run-time execution of modern programming languages, there is increasing recognition of the need for support for hot swapping of running modules, particularly in long-lived server applications. The interesting challenge for such a facility is to allow the new module to change the types exported by the original module, while preserving type safety. This paper describes a type-based approach to hot swapping running modules. The approach is based on a reflective mechanism for dynamically adding type sharing constraints to the type system, realized by programmer-defined version adapters in the run-time.",
author = "Dominic Duggan",
year = "2001",
month = "1",
day = "1",
language = "English (US)",
pages = "62--73",
note = "6th ACM SIGPLAN Internatinal Conference on Functional Programming (ICFP'01) ; Conference date: 03-09-2001 Through 05-09-2001",

}

Duggan, D 2001, 'Type-based hot swapping of running modules' Paper presented at 6th ACM SIGPLAN Internatinal Conference on Functional Programming (ICFP'01), Florence, Italy, 9/3/01 - 9/5/01, pp. 62-73.

Type-based hot swapping of running modules. / Duggan, Dominic.

2001. 62-73 Paper presented at 6th ACM SIGPLAN Internatinal Conference on Functional Programming (ICFP'01), Florence, Italy.

Research output: Contribution to conferencePaper

TY - CONF

T1 - Type-based hot swapping of running modules

AU - Duggan, Dominic

PY - 2001/1/1

Y1 - 2001/1/1

N2 - While dynamic linking has become an integral part of the run-time execution of modern programming languages, there is increasing recognition of the need for support for hot swapping of running modules, particularly in long-lived server applications. The interesting challenge for such a facility is to allow the new module to change the types exported by the original module, while preserving type safety. This paper describes a type-based approach to hot swapping running modules. The approach is based on a reflective mechanism for dynamically adding type sharing constraints to the type system, realized by programmer-defined version adapters in the run-time.

AB - While dynamic linking has become an integral part of the run-time execution of modern programming languages, there is increasing recognition of the need for support for hot swapping of running modules, particularly in long-lived server applications. The interesting challenge for such a facility is to allow the new module to change the types exported by the original module, while preserving type safety. This paper describes a type-based approach to hot swapping running modules. The approach is based on a reflective mechanism for dynamically adding type sharing constraints to the type system, realized by programmer-defined version adapters in the run-time.

UR - http://www.scopus.com/inward/record.url?scp=0034777575&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=0034777575&partnerID=8YFLogxK

M3 - Paper

SP - 62

EP - 73

ER -

Duggan D. Type-based hot swapping of running modules. 2001. Paper presented at 6th ACM SIGPLAN Internatinal Conference on Functional Programming (ICFP'01), Florence, Italy.