SyncAS: A Virtual Block Approach to Tame Asynchronous Programming

Hiroaki Fukuda, Paul Leger

Research output: Contribution to journalArticle

Abstract

Asynchronous programming has been widely adopted in domains such as Web development. This programming style usually uses callback methods, non-blocking operations, allowing high responsive user interactions even if an application works without multi-threading. However, this style requires the uncoupling of a module into two sub-modules at least, which are not intuitively connected by a callback method. The separation of modules spurs the birth of other issues: callback spaghetti and callback hell. This paper proposes a virtual block approach to address the previous two issues. This approach enables a programmer to virtually block a program execution and restart it at arbitrary points in the program. As a result, programmers do not need to uncouple a module even if non-blocking operations are adopted; therefore, callback dependencies disappear. Using aspect-oriented programming, this approach uses aspects to control the execution of a program in an oblivious manner. As a consequence, programmers do not need to be concerned whether pieces of code use blocking or non-blocking operations. We implement a proof-of-concept for this approach, called SyncAS, for ActionScript3. In addition, we apply our proposal to a toy application and conduct experiments to show its modular application, flexibility, and performance.

Original languageEnglish
Pages (from-to)887-907
Number of pages21
JournalInternational Journal of Software Engineering and Knowledge Engineering
Volume25
Issue number5
DOIs
Publication statusPublished - 2015 Jun 30

Fingerprint

Aspect oriented programming
Experiments

Keywords

  • aspect-oriented programming
  • asynchronous programming
  • SyncAS
  • virtual block

ASJC Scopus subject areas

  • Software
  • Artificial Intelligence
  • Computer Graphics and Computer-Aided Design
  • Computer Networks and Communications

Cite this

SyncAS : A Virtual Block Approach to Tame Asynchronous Programming. / Fukuda, Hiroaki; Leger, Paul.

In: International Journal of Software Engineering and Knowledge Engineering, Vol. 25, No. 5, 30.06.2015, p. 887-907.

Research output: Contribution to journalArticle

@article{346870fa86764531b4735f859ea686ac,
title = "SyncAS: A Virtual Block Approach to Tame Asynchronous Programming",
abstract = "Asynchronous programming has been widely adopted in domains such as Web development. This programming style usually uses callback methods, non-blocking operations, allowing high responsive user interactions even if an application works without multi-threading. However, this style requires the uncoupling of a module into two sub-modules at least, which are not intuitively connected by a callback method. The separation of modules spurs the birth of other issues: callback spaghetti and callback hell. This paper proposes a virtual block approach to address the previous two issues. This approach enables a programmer to virtually block a program execution and restart it at arbitrary points in the program. As a result, programmers do not need to uncouple a module even if non-blocking operations are adopted; therefore, callback dependencies disappear. Using aspect-oriented programming, this approach uses aspects to control the execution of a program in an oblivious manner. As a consequence, programmers do not need to be concerned whether pieces of code use blocking or non-blocking operations. We implement a proof-of-concept for this approach, called SyncAS, for ActionScript3. In addition, we apply our proposal to a toy application and conduct experiments to show its modular application, flexibility, and performance.",
keywords = "aspect-oriented programming, asynchronous programming, SyncAS, virtual block",
author = "Hiroaki Fukuda and Paul Leger",
year = "2015",
month = "6",
day = "30",
doi = "10.1142/S0218194015400252",
language = "English",
volume = "25",
pages = "887--907",
journal = "International Journal of Software Engineering and Knowledge Engineering",
issn = "0218-1940",
publisher = "World Scientific Publishing Co. Pte Ltd",
number = "5",

}

TY - JOUR

T1 - SyncAS

T2 - A Virtual Block Approach to Tame Asynchronous Programming

AU - Fukuda, Hiroaki

AU - Leger, Paul

PY - 2015/6/30

Y1 - 2015/6/30

N2 - Asynchronous programming has been widely adopted in domains such as Web development. This programming style usually uses callback methods, non-blocking operations, allowing high responsive user interactions even if an application works without multi-threading. However, this style requires the uncoupling of a module into two sub-modules at least, which are not intuitively connected by a callback method. The separation of modules spurs the birth of other issues: callback spaghetti and callback hell. This paper proposes a virtual block approach to address the previous two issues. This approach enables a programmer to virtually block a program execution and restart it at arbitrary points in the program. As a result, programmers do not need to uncouple a module even if non-blocking operations are adopted; therefore, callback dependencies disappear. Using aspect-oriented programming, this approach uses aspects to control the execution of a program in an oblivious manner. As a consequence, programmers do not need to be concerned whether pieces of code use blocking or non-blocking operations. We implement a proof-of-concept for this approach, called SyncAS, for ActionScript3. In addition, we apply our proposal to a toy application and conduct experiments to show its modular application, flexibility, and performance.

AB - Asynchronous programming has been widely adopted in domains such as Web development. This programming style usually uses callback methods, non-blocking operations, allowing high responsive user interactions even if an application works without multi-threading. However, this style requires the uncoupling of a module into two sub-modules at least, which are not intuitively connected by a callback method. The separation of modules spurs the birth of other issues: callback spaghetti and callback hell. This paper proposes a virtual block approach to address the previous two issues. This approach enables a programmer to virtually block a program execution and restart it at arbitrary points in the program. As a result, programmers do not need to uncouple a module even if non-blocking operations are adopted; therefore, callback dependencies disappear. Using aspect-oriented programming, this approach uses aspects to control the execution of a program in an oblivious manner. As a consequence, programmers do not need to be concerned whether pieces of code use blocking or non-blocking operations. We implement a proof-of-concept for this approach, called SyncAS, for ActionScript3. In addition, we apply our proposal to a toy application and conduct experiments to show its modular application, flexibility, and performance.

KW - aspect-oriented programming

KW - asynchronous programming

KW - SyncAS

KW - virtual block

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

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

U2 - 10.1142/S0218194015400252

DO - 10.1142/S0218194015400252

M3 - Article

AN - SCOPUS:84942592497

VL - 25

SP - 887

EP - 907

JO - International Journal of Software Engineering and Knowledge Engineering

JF - International Journal of Software Engineering and Knowledge Engineering

SN - 0218-1940

IS - 5

ER -