Archface4COP: Architectural interface for context-oriented programming

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

Context-awareness plays an important role in developing flexible and evolvable applications such as self-* systems (e.g., self-adaptive, self-healing, and self-management systems). However, it is not easy to design and implement such a context-aware system, because its software architecture is dynamically changed. That is, software components constituting a system and their connection structure can be dynamically changed. As a result, it is hard to check whether or not a design model is correctly implemented and its context-dependent behavior is faithful to the design. To deal with this problem, we introduce Archface4COP, an architectural interface mechanism for COP (Context-Oriented Programming). Archface4COP exposes architectural points shared between UML-based design models and code written in COP languages. Architectural points represent COP-specific events such as layer in, layer out, layered message send, and layered message receive. These points are important to represent an abstract structure of software architecture focusing on context-awareness. We can verify whether or not a design model and its code can co-evolve each other by checking an Archface4COP interface.

Original languageEnglish
Title of host publicationProceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013
DOIs
Publication statusPublished - Aug 30 2013
Event5th International Workshop on Context-Oriented Programming, COP 2013 - Montpellier, France
Duration: Jul 2 2013Jul 2 2013

Other

Other5th International Workshop on Context-Oriented Programming, COP 2013
CountryFrance
CityMontpellier
Period7/2/137/2/13

Fingerprint

Software architecture
Computer programming languages

All Science Journal Classification (ASJC) codes

  • Software

Cite this

Ubayashi, N., Di, A., & Kamei, Y. (2013). Archface4COP: Architectural interface for context-oriented programming. In Proceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013 [2489794] https://doi.org/10.1145/2489793.2489794

Archface4COP : Architectural interface for context-oriented programming. / Ubayashi, Naoyasu; Di, Ai; Kamei, Yasutaka.

Proceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013. 2013. 2489794.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Ubayashi, N, Di, A & Kamei, Y 2013, Archface4COP: Architectural interface for context-oriented programming. in Proceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013., 2489794, 5th International Workshop on Context-Oriented Programming, COP 2013, Montpellier, France, 7/2/13. https://doi.org/10.1145/2489793.2489794
Ubayashi N, Di A, Kamei Y. Archface4COP: Architectural interface for context-oriented programming. In Proceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013. 2013. 2489794 https://doi.org/10.1145/2489793.2489794
Ubayashi, Naoyasu ; Di, Ai ; Kamei, Yasutaka. / Archface4COP : Architectural interface for context-oriented programming. Proceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013. 2013.
@inproceedings{be3daf2763ce44b2a825f9518f8b6138,
title = "Archface4COP: Architectural interface for context-oriented programming",
abstract = "Context-awareness plays an important role in developing flexible and evolvable applications such as self-* systems (e.g., self-adaptive, self-healing, and self-management systems). However, it is not easy to design and implement such a context-aware system, because its software architecture is dynamically changed. That is, software components constituting a system and their connection structure can be dynamically changed. As a result, it is hard to check whether or not a design model is correctly implemented and its context-dependent behavior is faithful to the design. To deal with this problem, we introduce Archface4COP, an architectural interface mechanism for COP (Context-Oriented Programming). Archface4COP exposes architectural points shared between UML-based design models and code written in COP languages. Architectural points represent COP-specific events such as layer in, layer out, layered message send, and layered message receive. These points are important to represent an abstract structure of software architecture focusing on context-awareness. We can verify whether or not a design model and its code can co-evolve each other by checking an Archface4COP interface.",
author = "Naoyasu Ubayashi and Ai Di and Yasutaka Kamei",
year = "2013",
month = "8",
day = "30",
doi = "10.1145/2489793.2489794",
language = "English",
isbn = "9781450320405",
booktitle = "Proceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013",

}

TY - GEN

T1 - Archface4COP

T2 - Architectural interface for context-oriented programming

AU - Ubayashi, Naoyasu

AU - Di, Ai

AU - Kamei, Yasutaka

PY - 2013/8/30

Y1 - 2013/8/30

N2 - Context-awareness plays an important role in developing flexible and evolvable applications such as self-* systems (e.g., self-adaptive, self-healing, and self-management systems). However, it is not easy to design and implement such a context-aware system, because its software architecture is dynamically changed. That is, software components constituting a system and their connection structure can be dynamically changed. As a result, it is hard to check whether or not a design model is correctly implemented and its context-dependent behavior is faithful to the design. To deal with this problem, we introduce Archface4COP, an architectural interface mechanism for COP (Context-Oriented Programming). Archface4COP exposes architectural points shared between UML-based design models and code written in COP languages. Architectural points represent COP-specific events such as layer in, layer out, layered message send, and layered message receive. These points are important to represent an abstract structure of software architecture focusing on context-awareness. We can verify whether or not a design model and its code can co-evolve each other by checking an Archface4COP interface.

AB - Context-awareness plays an important role in developing flexible and evolvable applications such as self-* systems (e.g., self-adaptive, self-healing, and self-management systems). However, it is not easy to design and implement such a context-aware system, because its software architecture is dynamically changed. That is, software components constituting a system and their connection structure can be dynamically changed. As a result, it is hard to check whether or not a design model is correctly implemented and its context-dependent behavior is faithful to the design. To deal with this problem, we introduce Archface4COP, an architectural interface mechanism for COP (Context-Oriented Programming). Archface4COP exposes architectural points shared between UML-based design models and code written in COP languages. Architectural points represent COP-specific events such as layer in, layer out, layered message send, and layered message receive. These points are important to represent an abstract structure of software architecture focusing on context-awareness. We can verify whether or not a design model and its code can co-evolve each other by checking an Archface4COP interface.

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

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

U2 - 10.1145/2489793.2489794

DO - 10.1145/2489793.2489794

M3 - Conference contribution

AN - SCOPUS:84882981323

SN - 9781450320405

BT - Proceedings of the 5th International Workshop on Context-Oriented Programming, COP 2013

ER -