OpenMP tasks: Asynchronous programming made easy

Author(s):  
E. Pascolo ◽  
S. Salon ◽  
D. Melaku Canu ◽  
C. Solidoro ◽  
Carlo Cavazzoni ◽  
...  
Author(s):  
Tran Thanh Luong ◽  
Le My Canh

JavaScript has become more and more popular in recent years because its wealthy features as being dynamic, interpreted and object-oriented with first-class functions. Furthermore, JavaScript is designed with event-driven and I/O non-blocking model that boosts the performance of overall application especially in the case of Node.js. To take advantage of these characteristics, many design patterns that implement asynchronous programming for JavaScript were proposed. However, choosing a right pattern and implementing a good asynchronous source code is a challenge and thus easily lead into less robust application and low quality source code. Extended from our previous works on exception handling code smells in JavaScript and exception handling code smells in JavaScript asynchronous programming with promise, this research aims at studying the impact of three JavaScript asynchronous programming patterns on quality of source code and application.


2010 ◽  
pp. 595-626
Author(s):  
Daniel M. Solis

Author(s):  
Hiroaki Fukuda ◽  
Paul Leger

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.


Author(s):  
Holger Schwichtenberg

2015 ◽  
Vol 50 (6) ◽  
pp. 154-164 ◽  
Author(s):  
Pantazis Deligiannis ◽  
Alastair F. Donaldson ◽  
Jeroen Ketema ◽  
Akash Lal ◽  
Paul Thomson

Sign in / Sign up

Export Citation Format

Share Document