A library to modularly control asynchronous executions

Hiroaki Fukuda, Paul Leger

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

3 Citations (Scopus)

Abstract

Asynchronous programming style has been widely adopted for a variety of reasons one such being the rise of Web applications. Using non-blocking operations is a major approach to enforcing asynchronous programming. A non-blocking operation requires decomposing a module that consists of a set of blocking operations into more than two modules, in turn, leading to a variety of challenges such as callback spaghetti and callback hell. This paper presents SyncAS, a library specification to address these two problems. This library specification follows the ECMAScript standard; indeed, we provide a prototype implementation for ActionScript3. SyncAS proposes a novel approach that enables programmers to virtually block a program execution and restart it at arbitrary points of the program, instead of waiting for a callback execution. As a result, programmers do not need to decompose a module even if nonblocking operations are adopted. SyncAS uses aspect-oriented programming to control the program execution in an oblivious manner.

Original languageEnglish
Title of host publicationProceedings of the ACM Symposium on Applied Computing
PublisherAssociation for Computing Machinery
Pages1648-1650
Number of pages3
Volume13-17-April-2015
ISBN (Print)9781450331968
DOIs
Publication statusPublished - 2015 Apr 13
Event30th Annual ACM Symposium on Applied Computing, SAC 2015 - Salamanca, Spain
Duration: 2015 Apr 132015 Apr 17

Other

Other30th Annual ACM Symposium on Applied Computing, SAC 2015
CountrySpain
CitySalamanca
Period15/4/1315/4/17

Fingerprint

Aspect oriented programming
Specifications

Keywords

  • Aspect-oriented programming
  • Asynchronous programming
  • Modularity
  • Virtual block

ASJC Scopus subject areas

  • Software

Cite this

Fukuda, H., & Leger, P. (2015). A library to modularly control asynchronous executions. In Proceedings of the ACM Symposium on Applied Computing (Vol. 13-17-April-2015, pp. 1648-1650). Association for Computing Machinery. https://doi.org/10.1145/2695664.2696034

A library to modularly control asynchronous executions. / Fukuda, Hiroaki; Leger, Paul.

Proceedings of the ACM Symposium on Applied Computing. Vol. 13-17-April-2015 Association for Computing Machinery, 2015. p. 1648-1650.

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

Fukuda, H & Leger, P 2015, A library to modularly control asynchronous executions. in Proceedings of the ACM Symposium on Applied Computing. vol. 13-17-April-2015, Association for Computing Machinery, pp. 1648-1650, 30th Annual ACM Symposium on Applied Computing, SAC 2015, Salamanca, Spain, 15/4/13. https://doi.org/10.1145/2695664.2696034
Fukuda H, Leger P. A library to modularly control asynchronous executions. In Proceedings of the ACM Symposium on Applied Computing. Vol. 13-17-April-2015. Association for Computing Machinery. 2015. p. 1648-1650 https://doi.org/10.1145/2695664.2696034
Fukuda, Hiroaki ; Leger, Paul. / A library to modularly control asynchronous executions. Proceedings of the ACM Symposium on Applied Computing. Vol. 13-17-April-2015 Association for Computing Machinery, 2015. pp. 1648-1650
@inproceedings{32db9d054db04bcd8da7dc6237847f76,
title = "A library to modularly control asynchronous executions",
abstract = "Asynchronous programming style has been widely adopted for a variety of reasons one such being the rise of Web applications. Using non-blocking operations is a major approach to enforcing asynchronous programming. A non-blocking operation requires decomposing a module that consists of a set of blocking operations into more than two modules, in turn, leading to a variety of challenges such as callback spaghetti and callback hell. This paper presents SyncAS, a library specification to address these two problems. This library specification follows the ECMAScript standard; indeed, we provide a prototype implementation for ActionScript3. SyncAS proposes a novel approach that enables programmers to virtually block a program execution and restart it at arbitrary points of the program, instead of waiting for a callback execution. As a result, programmers do not need to decompose a module even if nonblocking operations are adopted. SyncAS uses aspect-oriented programming to control the program execution in an oblivious manner.",
keywords = "Aspect-oriented programming, Asynchronous programming, Modularity, Virtual block",
author = "Hiroaki Fukuda and Paul Leger",
year = "2015",
month = "4",
day = "13",
doi = "10.1145/2695664.2696034",
language = "English",
isbn = "9781450331968",
volume = "13-17-April-2015",
pages = "1648--1650",
booktitle = "Proceedings of the ACM Symposium on Applied Computing",
publisher = "Association for Computing Machinery",

}

TY - GEN

T1 - A library to modularly control asynchronous executions

AU - Fukuda, Hiroaki

AU - Leger, Paul

PY - 2015/4/13

Y1 - 2015/4/13

N2 - Asynchronous programming style has been widely adopted for a variety of reasons one such being the rise of Web applications. Using non-blocking operations is a major approach to enforcing asynchronous programming. A non-blocking operation requires decomposing a module that consists of a set of blocking operations into more than two modules, in turn, leading to a variety of challenges such as callback spaghetti and callback hell. This paper presents SyncAS, a library specification to address these two problems. This library specification follows the ECMAScript standard; indeed, we provide a prototype implementation for ActionScript3. SyncAS proposes a novel approach that enables programmers to virtually block a program execution and restart it at arbitrary points of the program, instead of waiting for a callback execution. As a result, programmers do not need to decompose a module even if nonblocking operations are adopted. SyncAS uses aspect-oriented programming to control the program execution in an oblivious manner.

AB - Asynchronous programming style has been widely adopted for a variety of reasons one such being the rise of Web applications. Using non-blocking operations is a major approach to enforcing asynchronous programming. A non-blocking operation requires decomposing a module that consists of a set of blocking operations into more than two modules, in turn, leading to a variety of challenges such as callback spaghetti and callback hell. This paper presents SyncAS, a library specification to address these two problems. This library specification follows the ECMAScript standard; indeed, we provide a prototype implementation for ActionScript3. SyncAS proposes a novel approach that enables programmers to virtually block a program execution and restart it at arbitrary points of the program, instead of waiting for a callback execution. As a result, programmers do not need to decompose a module even if nonblocking operations are adopted. SyncAS uses aspect-oriented programming to control the program execution in an oblivious manner.

KW - Aspect-oriented programming

KW - Asynchronous programming

KW - Modularity

KW - Virtual block

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

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

U2 - 10.1145/2695664.2696034

DO - 10.1145/2695664.2696034

M3 - Conference contribution

AN - SCOPUS:84955442213

SN - 9781450331968

VL - 13-17-April-2015

SP - 1648

EP - 1650

BT - Proceedings of the ACM Symposium on Applied Computing

PB - Association for Computing Machinery

ER -