Parallelism exploration in sequential algorithms via animation tool

Abstract

Different high performance techniques, such as profiling, tracing, and instrumentation, have been used to tune and enhance the performance of parallel applications. However, these techniques do not show how to explore the potential of parallelism in a given application. Animating and visualizing the execution process of a sequential algorithm provide a thorough understanding of its usage and functionality. In this work, an interactive web-based educational animation tool was developed to assist users in analyzing sequential algorithms to detect parallel regions regardless of the used parallel programming model. The tool simplifies algorithms’ learning, and helps students to analyze programs efficiently. Our statistical $t$ -test study on a sample of students showed a significant improvement in their perception of the mechanism and parallelism of applications and an increase in their willingness to learn algorithms and parallel programming.

Keywords

Algorithm animation educational tool parallel programming performance analysis sorting algorithms algorithms visualization

1. Introduction

Multicore architectures have significantly evolved in recent years. The traditional way of explaining the concepts of algorithm techniques and parallelism efficiently has become more complicated considering the rapid growth of parallel programming models. As a consequence, undergraduate students need new methods of analysis, design, and parallelism of algorithms to become more aware of the available parallel resources.

It has recently become easier to simplify the difficulty of understanding algorithms, due to the ability of visualization in modern software. The visual explanation of algorithms improve the process of teaching especially when detailed explanation is needed. Previous studies [1, 2] emphasized the difficulties of understanding the abstract concepts of programming for computer science students.

Animation added one more dimension to modern education, where the dynamic properties of an algorithm can be illustrated and explained. However, Naps et al. [3] argue that any animation technology must engage students in an active manner in order to be effective and reliable. Hundhausen et al. [4] concluded that the benefit of using animation and visualization in education depends on how students use algorithm visualization technology instead of what visualization shows them. In some cases, visualization of parallel algorithms can lead to further learning difficulties.

The major contributions of this paper can be explained as follows:

•
Develop an interactive web-based animation tool for different sorting algorithms while providing code tracing.
•
Employ the tool to analyze the behavior of these algorithms in order to detect the regions of code that can be parallelized.
•
Assess the effect of using our tool on students’ performance by conducting a statistical test on a sample of 200 students.
•
Provide a critical discussion of this work in contrast to the related work in the literature.

This paper is organized as follows. Section 2 discusses the related work. Section 3 describes how algorithms animation was integrated into a learning environment. Section 4 discusses the experiments and results. A comparison study was discussed in Section 5. Finally, Section 6 concludes our paper, and highlights the future work.
2. Literature review

Algorithm visualization has been used at different stages of university education with different perspectives and concepts. In this section, we partition the related systems into three main categories depending on methodology and concept of visualization.

2.1 Performance analysis tools

Instrumentation, profiling, and tracing are observation techniques that can be used to tune and improve the performance of parallel applications. Instrumentation can be done at different stages with different levels of accuracy and overheads. TAU (Tuning and Analysis Utilities) [5] and VALGRIND [6] tools employ instrumentation at different levels. TAU also supports profiling and tracing. Such techniques are dedicated to performance issues and are used to enhance parallelism, but they require sufficient understanding of parallel algorithms, parallel programming models, and optimization techniques.

2.2 Animation tools for parallel algorithms

Using animation and visualization to teach parallel algorithms was discussed in [7]. Three algorithms were only analyzed including the bitonic merge sort algorithm. It does not support code tracing and is dependent on one programming language. The tool Modeloo [8] gives students the ability to analyze parallel computations via graph representation. However, it does not provide any algorithm as an example and lacks code tracing, which is a critical feature for finding code bottlenecks. Rantakokko [9] animated few parallel sorting algorithms using the Polka package to facilitate learning. Only two algorithms are supported and code tracing is missing. VPMM (Visualization of Parallel Matrix Multiplication) [10] visualizes the parallel execution flow of matrix multiplication algorithms. Such tool does not allow users to try different input scenarios in order to check how algorithm execution might change or how parallelism can be detected. Grossman et al. [11] provides a unique approach to teach parallel programming from abstract parallel concepts to experiences with industry with auto-grader for parallel programming assignments. This tool lacks code tracing. Such tools explain how parallelism works, but they do not teach students how to parallelize a given code. In some cases, parallel algorithm animation and visualization can lead to further complications in understanding parallelism according to [4]. Such tools can be used more efficiently when users have a good background about parallel models and languages. On the contrary, our work covers sufficient variety of sorting algorithms implemented via different design techniques, while focusing on sequential behavior analysis as a crucial pre-step in parallelism.

2.3 Web-based animation tools for sequential algorithms

Some Web tools [12, 13] visualize the process of sorting algorithms. The user can interact with the tool to check how the process of sorting is virtually performed. ALGAE (Algorithm Animation Engine) [14] allows C $++$ or Java code to produce a simulated version of that code. Although these tools provide various animation and visualization features, they were not employed to explore parallelism or were statistically evaluated to test the impact of using them on users’ understanding. Marcelino et al. [15] developed a mobile tool that can be used to support initial stages of programming learning using a procedural approach. This approach converts user’s code to a flowchart, while displaying the values of variables at each step. However, it does not provide any kind of animation. Krushkov et al. [16] provides a tutoring system for programming. Some of these applications only cover numeric input data. In comparison, our work highlights the impact of animating sorting algorithms on learning parallelism, while covering different input data types. Some other systems [17, 18] provide two standpoints to analyze algorithms: one is artistic, and the other is more analytical aiming to explain algorithms step by step. These systems do not allow users to get engaged in code tracing or inputs modification. In contrast, our tool focuses on explaining how sorting algorithms work from a learning perspective by allowing users to trace code and modify inputs to check the impact on algorithm’s behavior.

In terms of simulation, Tuparov et al. [19, 20] developed an interactive simulation-based tool in an introductory programming course focusing on sorting algorithms. Their study showed an increase in students’ willingness and understanding. However, the main disadvantage of this work was the limited number of sorting algorithms. TRAKLA2 [21] is a framework, which was developed for building interactive algorithm simulation exercises. Exercises constructed in TRAKLA2 are viewed as learning objects in which students manipulate conceptual visualizations of data structures in order to simulate the working of given algorithms.

To recap, the main idea of our approach is to teach parallelism via animation of sequential algorithms. Our tool animates the execution process of a variety of sorting algorithms including both comparison and non-comparison based algorithms, in contrast with most of the current tools, which discuss comparison-based sorting algorithms only. Moreover, our tool allows users to get involved in the learning process by letting them trying different input cases. This makes students more engaged in the topic of algorithms and parallelism. More details are given later in the paper.

There are other tools and applications that have been developed and used in the context of algorithms. However, we tried to focus on the most relevant ones.

3. Integrating algorithm animation into a learning environment

The overall mechanism of our interactive animation tool is shown in Fig. 1. In the following, each component of our proposed system is explained in details.

Figure 1.

Framework of our animation tool.

Because of the importance of design in any Web application, we tried to create an attractive and flexible interface that provides a convenient way of interaction for students/instructors. In other words, user can easily access our application and choose the type of sorting he/she wants to explore. Our system responds by giving the user an animated way to learn how the chosen algorithm sorts the input data, while displaying the algorithm’s pseudo-code and observing the current variable values.

Our methodology was to develop a web-based tool that animates the execution of sequential sorting algorithms while tracing their pseudo-code and observing the current variable values. Our tool is based on a two-tier architecture, where we used Hyper Text Markup Langaue (HTML), Cascade Style Sheet (CSS) and Java-script to design the front-end environment, while using Personal Home Page (PHP) for implementing the back-end functions and methods. For animation, we used the canvas library for the process of moving objects on the screen, then we added the corresponding algorithm to the animation code to create a simulation environment.

Based on our approach, we did not animate algorithm parallelism. What we did was animating the execution of sequential algorithms to assist in detecting regions of code that can be parallelized and teach students how to parallelize code accordingly. The building blocks of algorithm parallelism based on our approach can be explained in order as follows:

Use animation/visualization tool to assist in analyzing the execution of sequential algorithms.

Provide code tracing to visualize the behavior of algorithms in a timely manner.

Allow users to modify the input data to see how this affects the execution of algorithm.

Detect the regions of code that can be parallelized based on the previous steps.

Involve instructors to help students to parallelize sequential code.

Check the correctness of parallel code by comparing its output with the sequential one.

Optimize the performance of parallel code.

In this section, we elaborate on these steps by giving detailed explanation about the tool’s interface, features, code tracing, usage, instructor’s involvement, correctness of parallel code and its performance.

The home page of our tool is divided into separate frames reachable easily by the user. By clicking on the “ALGORITHMS” tab, the algorithms page, shown in Fig. 2, will be displayed. This page consists of six different algorithms.

Figure 2.

Sorting algorithms main page.

Each sorting algorithm page has an explanation paragraph that gives the user an overview of the algorithm. We also inserted a graphic multimedia element, as shown in Fig. 3 to give the user a visual explanation about the algorithm. There is also a written explanation in these multimedia pages about the given case. However, we just captured the visual explanation to save space. At the bottom of each page, we created a link, which transfers the user to the animation page.

Figure 3.

Multimedia pages of different algorithms. (a) Merge sort. (b) Insertion sort. (c) Bubble sort.

For the interface, we designed attractive simulation pages for each implemented algorithm. From a technical point of view, user can insert his own values or try the random numeric values given by the tool. After inserting the values and clicking on the “sort” button, the tool will start sorting the values according to the chosen algorithm. The tool gives the user a code tracker (pseudo-code) to make the process of understanding more efficient, while displaying the current variables values. The pseudo-code also describes the design paradigm used.

Instructor’s responsibility in term of parallelism is to explain the fundamentals of parallelism to students by linking the animation of execution and psuedo-code tracking from one side with parallelism exploration in algorithms from the other side. Dependencies among operations can easily be explained via animation. Critical regions and code bottlenecks can also be detected. This deep explanation of algorithm’s execution and behavior via animation can make the learning process of parallelism much easier. Checking the correctness of a written parallel code is done by comparing its output with the sequential output. Performance of parallel code can be improved by consulting instructors and trying different optimizations related to the given parallel programming model.

Figure 4.

Animation page of comparison-based algorithms (Ex: Quick sort).

Figure 4 demonstrates the simulation process of comparison-based algorithms, where we show Quick sort algorithm as an example. Each color assigned to the displayed bars has its own meaning depending on the used algorithm, and this is thoroughly explained in every algorithm page. The same animation format was used in all comparison-based sorting algorithms, demonstrated in our tool, that include bubble sort, selection sort, insertion sort, and merge sort. However, we developed another animation format for the non-comparison Radix sort algorithm, as shown in Fig. 5. We included this type of sorting to help instructors explain the difference between comparison-based and non-comparison based sorting algorithms to their students more attractively.

Figure 5.

Radix sorting animation page.

The tool also has an input/output page that can track a flat file containing unsorted data. The tool returns the values sorted. This page can track any value type (numeric, character, string, etc.) and produce a file with sorted data. The output file can be downloaded to the local directory of the user’s computer.

New algorithms can easily be added to our learning tool, as the simulation environment has already been developed. We first need to modify the home page to add the corresponding new algorithm. Second, we need to add a graphic multimedia element page to give the user a visual explanation about the new algorithm. For animation, we just need to add the corresponding algorithm to the existing animation code.

4. Experiments and results

Parallelism of any algorithm requires deep analysis of the sequential behavior of this algorithm. In this section, we show parallel implementations of two sorting algorithms that differ in terms of input data sensitivity, design paradigm, complexity, and parallelism (Loop/irregular). We used OpenMP [22, 23], which is a shared memory programming model, to illustrate our point. OpenMP parallel construct represents a parallel region where different threads in the team will share the work inside the region. Algorithm 4 represents the merge sort algorithm, which exhibits irregular behavior considering its recursive calls. Merge sort is insensitive to the input data, which means that its behavior and complexity do not change while changing its input data. Hence, even its parallel version does not change. OpenMP section construct can be used, where each structured block (recursive call) is executed once by one of the threads in the team.

On the other hand, Algorithm 4 represents the insertion sort algorithm, in which loop behavior is depicted. Insertion sort is sensitive to the input data, which means that its behavior and complexity do change while changing its input data. In contrast with merge sort, insertion sort requires the ordered clause to ensure that the iterations are executed in order, while the critical construct ensures that its structured block is executed by one thread only in the team. This implementation actually means that this code will be executed sequentially, regardless of the number of working threads. However, assuming that the given input data is sorted, the critical construct can be ignored, as the while statement will be always false. This indicates that an actual parallel version can be implemented to handle such case.

Therefore, developing a reliable animation tool that can visually describe the execution of sequential algorithms is definitely crucial for teaching fundamentals of exploring parallelism.

Parallel merge sort algorithm

mergesortMerge-Sort $A, p, r$

$p<r$ $q\leftarrow(p+r/2)$

#pragma omp parallel sections

{

#pragma omp section

$A, p, q$

#pragma omp section

$A,q+1,r$

}

Merge( $A, p, q, r$ )

Parallel insertion sort algorithmUnsorted Array A

Sorted Array A

#pragma omp parallel for ordered

$i\leftarrow 2$ $n$ $\text{key}\leftarrow A[j]$

$i\leftarrow j-1$

#pragma omp critical

$i>0$ and $A[i]>\text{key}$ $A[i+1]\leftarrow A[i]$ $i\leftarrow i-1$

$A[i+1]\leftarrow\text{key}$

4.1 Statistical $t$ -test

A study was conducted in the undergraduate course “Introduction to Algorithms” in the college of Information Technology at the Hashemite University in Jordan on a sample of 200 students during two different periods of time, where each period included 100 students. This sample included students in their second, third, or fourth academic year. The tool was available to students for self-learning as well as during face-to-face lectures and office hours. The instructor showed students how to obtain the best case, average case, and worst case complexity of each algorithm, while explaining the impact of these cases on algorithm’s parallelism.

$t$ -test [24] is one type of inferential statistics that can be used to determine whether there is a significant difference between the means of two groups.

To assess the effect of our tool on students’ achievement, we used a paired $t$ -test at 0.01 level to compare the performance of the same students in two written exams before and after using the tool. The first exam tests students’ ability in analyzing and designing algorithms (Exam A), while the second exam tests their ability in parallelizing algorithms (Exam B). A total of $n=$ 100 students have taken the exams. Their grades in Exam A before using the tool ranged between 0 and 15 ( $\mu\pm\sigma=7.13\pm 3.15$ ), while their grades in a similar exam covering the same topics with similar difficulty after using the tool ranged between 4 and 15 ( $\mu\pm\sigma=9.99\pm 2.44$ ), where $\mu$ is the mean and $\sigma$ is the standard deviation.

As Fig. 6a illustrated, the $t$ -test shows significant improvement in student’s performance after using the tool in comparison to their performance before using the tool ( $P<$ 0.01). Students’ grades in Exam B before using the tool ranged between 0 and 15 ( $\mu\pm\sigma=6.92\pm 3.38$ ), while their grades in a similar exam after using the tool ranged from 0 and 15 ( $\mu\pm\sigma=8.15\pm 3.58$ ). As shown in Fig. 6b, the $t$ -test revealed no significant mean differences between the grades of students before and after using the tool ( $P=$ 0.0138) in Exam B. Taking into consideration that the performance of some students may vary from one exam to another due to factors other than using or not using the tool, we used $t$ -test to compare between the total grades of students before and after using the tool. The total grades ranged between 3 and 30 ( $\mu\pm\sigma=14.03\pm 5.54$ ) before using the tool, while the total grades ranged between 5 and 29 ( $\mu\pm\sigma=18.14\pm 5.20$ ) after using the tool. As Fig. 6c suggests, the difference is statistically significant ( $P<$ 0.01). Thus, a significant improvement was achieved in students’ performance after using the tool.

Figure 6.

A paired $t$ -test boxplot diagram represents the difference between the performance of the same students before and after using the tool in Exam A, Exam B, and total of both exams respectively. (a) Exam A. (b) Exam B. (c) Total grade.

Figure 7.

An unpaired $t$ -test boxplot diagram represents the difference between the performance of different students before and after using the tool in Exam A, Exam B, and total of both exams respectively. (a) Exam A. (b) Exam B. (c) Total grade.

To further investigate the impact of our tool in improving students’ performance, A new set of students ( $n=100$ ) were asked to take similar exams covering the same topics with similar difficulty, but this time after using the tool only. Unpaired $t$ -test was then used to compare between performance of the first set of students before using the tool, and the second set of students after using the tool. The new students’ grades ranged between 4 and 15 ( $\mu\pm\sigma=10.03\pm 2.83$ ) in Exam A, and ranged between 3 and 15 ( $\mu\pm\sigma=8.09\pm 2.58$ ) in Exam B. Their total grades ranged between 8 and 30 ( $\mu\pm\sigma=18.12\pm 5.15$ ). As shown in Fig. 7, all tests show that the difference is statistically significant ( $P<$ 0.01).

4.2 Interesting findings

Beside the promising improvements in students’ grades as verified by our statistical study, students were impressed by the use of our interactive tool. The most interesting part was the ability to observe the potential parallelism in each algorithm and its behavior, while modifying input data. Students were able to understand the impact of changing input data on algorithms’ complexity and parallelism. Students also started to program these algorithms more easily using Java or C $++$ . Visualizing algorithms also helped students to understand the different design paradigms used to implement the covered algorithms and how these paradigms can be adopted to solve other programming problems. The percentage of students participating in discussions during lectures has also increased.

5. Discussion

There have been many previous studies targeting animation, visualization, and performance analysis of sequential/parallel algorithms in the context of academia as well as industry. In this comparative study, we mainly focused on the most recent and related systems that have been used in the context of education. In this work, we proposed 8 different implementation and performance metrics as explained in Table 1. These metrics highlight the usage of these systems/tools and compare them to our work as shown in Table 2.

Table 1
Our proposed performance and implementation metrics

Metric	Definition
Type of system/tool	It shows whether the tool is for animation, visualization or performance analysis and whether it targets parallel or sequential algorithms or both.
User engagement	It shows whether the user can interact with the tool and modify algorithms’ inputs to check the impact on the output.
Dependent/ independent	It indicates whether the tool requires a previous knowledge of any specific programming language(s) such as C $++$ , Java, etc. (dependent) or not.
Covered algorithms	It shows what algorithms are targeted by the tool.
Educational tool	It shows whether the tool was mainly developed to assist students in a related undergraduate/graduate course (yes) or was developed as a multi-purpose tool that targets a broader range of users.
Input types	It shows the input types accepted by the tool to be processed by the covered algorithms.
Code tracing	It shows whether the tool allows users to trace the values of the variables during execution of algorithms or not.
Statistical analysis	It shows whether the performance of users was statistically analyzed before and after using the tool/system to check its effectiveness.

According to previous studies such as [10, 7], visualization of parallel computations in algorithms is very hard to explain. In most cases, it may complicate the process of education. Hence, systems, targeting parallel algorithms, such as [7, 8, 9] among others require some sort of knowledge about parallel programming models and how to use them for writing parallel code. This indicates that such systems do not teach students how to parallelize a sequential code. Many other tools have targeted sequential algorithms. However, they were either limited in terms of covered algorithms [19, 20], missing code tracing [21, 18, 11], depending on specific programming language/model [25, 11, 14], lacking user engagement [6, 19, 18], or limited in terms of input types [12, 13]. Moreover, most of the existing educational systems do not statistically analyze the performance of students before and after using the tool to validate the usage of these systems.

Table 2

Comparison study

Category	Tool	Type	User eng	Dependent/ independent	Covered algorithms	Edu tool	Input types	Code tracing	Statistical analysis
Performance	TAU [5]	Instrumentation, profiling, tracing	No	Dependent	Any supported programming language code	No	Unlimited	No	No
	VALGRIND [6]	Instrumentation,	No	Dependent	Any supported programming language code	No	Unlimited	No	No
Parallel	Naps et al. [7]	Windows-based, web-based visualization	Yes	Dependent	Three sorting algorithms	Yes	Numeric	No	No
	Modeloo [8]	Graph-based representation	Yes	Dependent	None	Yes	Not specified	No	No
	Rantakokko [9]	Parallel animation	Yes	Independent	Bucket and quick sort	Yes	Numeric	No	Yes
	VPMM [10]	Parallel visualization	No	Dependent	Matrix multiplication	Yes	Numeric	No	No
	Grossman et al. [11]	Parallel env and auto grader	Yes	Dependent	Any supported code	Yes	All	No	Yes
Sequential	Tuparov et al. [19]	Sequential simulation	No	Dependent	4 Sorting algorithms, binary search	Yes	Numeric	No	yes
	TRAKLA2 [21]	Sequential simulation	Yes	Independent	Sorting, searching, hashing, and other data-structure algorithm	Yes	Not specified	No	No
	Visualgo [12]	Web-based animation	Yes	Independent	Different data-structure algorithms	Yes	Numeric	Yes	No
	usfca [13]	Web-based animation	Yes	Independent	Different data-structure algorithms	Yes	Numeric	Yes	No
	AlgaE [14]	Web-based animation	Yes	Dependent	Different data-structure algorithms	Yes	Numeric	Yes	No
	Sorting [18]	Web-based animation	No	Independent	Sorting algorithms	Yes	Numeric	No	No
	Danner et al. [25]	Visualization, debugging tool sequential, parallel	Yes	Dependent	Any supported code	Yes	Numeric	Yes	No
	Our work	Web-based animation	Yes	Independent	Comparison and non-comparison sorting algorithms	Yes	All	Yes	Yes

In contrast, our solution is a web-based tool built using a two-tier architecture. It depends on facilitating the learning process of algorithms’ behavior via animation code to create a convenient simulation and visualization environment. Our tool explains the sequential behavior of algorithms in order to help students to parallelize these algorithms regardless of any specific parallel programming model. It eases instructors’ job to teach students how to find the bottlenecks of algorithms in order to parallelize them as a next step. Our tool covers both comparison-based and non-comparison based sorting algorithms while

allowing students to modify different input types of an algorithm to change its behavior. Our tools allows students to trace the code while visualizing its behavior. Last but not least, our work provided a statistical study that analyzed the impact of using our tool on the academic performance of students.

6. Conclusions and future work

This paper presented our experiences in developing a learning tool for teaching the concepts of analyzing, designing, and parallelizing algorithms. The tool provides an interactive environment for students to learn different programming concepts through animation and visualization of sorting algorithms. The tool meets the requirements of distance learning. It provides an animated demonstration of the execution process of different sequential algorithms that vary in terms of parallelism potential, usage, design paradigm, running time complexity, and difficulty of understanding. The tool is compatible with different Web browsers and can handle different input data types. Our statistical study, which was conducted on a sufficient number of students, showed that animation of algorithms can be of great assistance for students’ understanding of parallel programming fundamentals. Our tool also showed that instructors can efficiently teach the fundamentals of parallelism through visualizing the execution process of sequential algorithms.

We aim to integrate a mechanism in our tool to detect potentials of parallelism. This mechanism will firstly depend on detecting dependency conflicts among loop iterations at runtime. Later, we plan to handle irregular parallelism potentials.

Footnotes

Acknowledgments

The authors would like to thank the Hashemite University for providing the required resources.

Author’s Bios

Ahmad Qawasmeh is a native of Jordan where he studied Computer Engineering. He obtained his MS degree in Computer Science in 2010 and completed his PhD on performance analysis support for HPC applications in Computer Science from the University of Houston, USA in 2015. His research interests include parallel and high performance computing, performance analysis tools, and machine learning. He joined the Hashemite University, Jordan in 2016 as an assistant professor in the Department of Computer Science.

Salah Taamneh is currently an Assistant Professor at the Department of Computer Science and Applications, Hashemite University, Zarqa, Jordan. He received the B.S. degree in computer science from Jordan University of Science and Technology, Irbid, Jordan, in 2005, the M.S. degree in computer science from Prairie View A& M University, Prairie View, Texas, in 2011 and the Ph.D. degree in computer science from University of Houston, Houston, Texas, USA, in 2016. He. His current research interests include parallel and distributed computing, machine learning and human- computer interaction.

	Ashraf H. Aljammal is currently an Associate Professor at the Department of Computer Science and Applications, The Hashemite University, Zarqa, Jordan. He received the B.S. degree in computer science from Albalqa’ Applied University, Al-Salt, Jordan, in 2006, the master’s degree from Universiti Sains Malaysia, USM, Malaysia, in 2007, and the PhD degree from Universiti Sains Malaysia, USM, Malaysia, in 2011. His research interests include network security, cyber security, network monitoring and cloud computing Security.
	Nabhan Hamadneh received the BSc. and MSc. degrees, from Irbid Uni. and Al-balqa’a Applied Uni. from JORDAN in 2003 and 2005, respectively. He also received his Ph.D. from Murdoch University in 2012, Australia. He worked as an IT teacher in the period 2004–2008 with the Jordanian Ministry of Education and a university lecturer from 2013 until 2021 in the Department of Computer Science at the Hashemite University. His research interest is in networking especially TCP congestion control strategies and some other topics in ICT.
	Mustafa BaniKhalaf is currently Assistant Professor in the Computer Science Department, Yarmouk University. He received his BSc. In computer information system from The Hashemite University in 2006. He also received his MSc. In computer science from Jordan University of Science and Technology in 2009. In 2010, he was granted a PhD studentship (Merit Competition-Award) from the School of Computing, Edinburgh Napier University, and was awarded his PhD in 2013. He has been working on the area of group communications, mobile and vehicular ad hoc networks and high-performance networks. His research has been supported by Scottish overseas research students award scheme and Edinburgh Napier University.
	Mohammad Kharasheh, Associate Professor., joins Hashemite University as an Assistant Professor in the Department of Computer Information System in the Prince al Hussein bin Abdullah II faculty of IT. He received his BSc. in Computer Science from Al-Yarmouk University and his MSc Master degree in Computer Science, Faculty of Computer and Information Technology, Jordan University of Science and Technology, Irbid- Jordan (2007). His research interests include Database Management Systems, In-Memory Representation of XML Documents, Succinct Data Structure, Artificial Intelligence Applications and Machine Learning in addition to Health Informatics.

References

Areias

C.M.

Mendes

A.J.

and Gomes

A.J.

, Learning to program with ProGuide, in: International Conference on Engineering Education, Coimbra, Portugal, 2007, pp. 1–6.

Rößling

, A family of tools for supporting the learning of programming, Algorithms 3 (2010), 168–182.

Naps

T.L.

Rößling

Almstrum

Dann

Fleischer

Hundhausen

Korhonen

Malmi

McNally

and Rodger

, Exploring the role of visualization and engagement in computer science education, in: Working Group Reports from ITiCSE on Innovation and Technology in Computer Science Education, Aarhus, Denmark, 2002, pp. 131–152.

Hundhausen

C.D.

Douglas

S.A.

and Stasko

J.T.

, A meta-study of algorithm visualization effectiveness, Journal of Visual Languages & Computing 13 (2002), 259–290.

Shende

S.S.

and Malony

A.D.

, The TAU parallel performance system, The International Journal of High Performance Computing Applications 20 (2006), 287–311.

Nethercote

and Seward

, Valgrind: A framework for heavyweight dynamic binary instrumentation, ACM Sigplan notices 42 (2007), 89–100.

Naps

T.L.

and Chan

E.E.

, Using visualization to teach parallel algorithms, in: The Proceedings of the Thirtieth SIGCSE Technical Symposium on Computer Science Education, New Orleans Louisiana, USA, 1999, pp. 232–236.

Vitaliy

Mohamad

Z.J.

Nikolay

Vladimir

and Vladislava

, Modeloo – the tool for teaching parallel computations, Advanced Science Letters 21 (2015), 2243–2246.

Rantakokko

, Algorithm visualization through animation and role plays, in: Program Visualization Workshop, Coventry, UK, 2004, pp. 76–81.

10.

Desai

Kulkarni

Vasant

Varalakshmi

and Mohamed

, VPMM: Visualization of parallel matrix multiplication algorithms, Journal of Computing Sciences in Colleges 33 (2017), 24–31.

11.

Grossman

Aziz

Chi

Tibrewal

Imam

and Sarkar

, Pedagogy and tools for teaching parallel computing at the sophomore undergraduate level, Journal of Parallel and Distributed Computing 105 (2017), 18–30.

12.

visualgo.com, Algorithm visualisation, 2017, Accessed: 01-01-2017.

13.

University of San Francisco, Sorting visualization, Comparison sorting algorithm, Accessed: 13-11-2016.

14.

Steven Zeil

, AlgAE (Algorithm Animation Engine), (2011), Accessed: 13-11-2016.

15.

Marcelino

Mihaylov

and Mendes

, H-SICAS, a handheld algorithm animation and simulation tool to support initial programming learning, in: 38th Annual Frontiers in Education Conference, Saratoga Springs, NY, USA, 2008, T4A-7.

16.

Krushkov

Krushkova

Atanasov

and Krushkova

, A computer-based tutoring system for programming, in: Proceedings of the Thirty Ninth Spring Conference of the Union of Bulgarian Mathematicians, Albena, Bulgaria, 2010, pp. 354–358.

17.

Cortesi

, Sorting algorithm visualisation, 2016. http://sortvis.org.

18.

Zapponi

, Sorting, 2014. http://sorting.at.

19.

Tuparov

Tuparova

and Jordanov

, Teaching sorting and searching algorithms through simulation-based learning objects in an introductory programming course, Procedia-Social and Behavioral Sciences 116 (2014), 2962–2966.

20.

Tuparov

Tuparova

and Tsarnakova

, Using interactive simulation-based learning objects in introductory course of programming, Procedia-Social and Behavioral Sciences 46 (2012), 2276–2280.

21.

Malmi

Karavirta

Korhonen

Nikander

Seppälä

and Silvasti

, Visual algorithm simulation exercise system with automatic assessment: TRAKLA2, Informatics in Education 3 (2004), 267–267.

22.

Qawasmeh

Malik

Chapman

Huck

and Malony

, Open source task profiling by extending the openmp runtime api, in: 9th International Workshop on OpenMP, Canberra, Australia, 2013, pp. 186–199.

23.

Qawasmeh

Malik

A.M.

and Chapman

B.M.

, OpenMP task scheduling analysis via OpenMP runtime API and tool visualization, in: IPDPSW, Phoenix, AZ, USA, 2014, pp. 1049–1058.

24.

Kim

T.K.

, T test as a parametric statistic, Korean Journal of Anesthesiology 68 (2015), 540–540.

25.

Danner

Newhall

and Webb

K.C.

, Paravis: A library for visualizing and debugging parallel applications, in: 2019 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW), Rio de Janeiro, Brazil, 2019, pp. 326–333.