Saleh M. Alnaeli

Towards a quality model of technical aspects for mobile learning services

Quality issues are commonly reported following the development of mobile learning applications. To evaluate and increase the chance of the successful development of new mobile learning products, the adoption of a complete and well-defined set of technical quality aspects for mobile learning development and their adoption in the education environment are proposed. This work describes a model that captures most abstract and generic technical aspects of mobile learning service quality, including availability, fast response times, flexibility, scalability, usability, maintainability, functionality, functionality, reliability, connectivity, performance, user interface and security. A set of technical quality aspects was developed following a literature study focussing on standards and guidelines for learning and mobile application software quality. The presented case studies point to a set of contextual technical quality factors that influence the choice of mobile learning application. The findings also indicate that there are causal relationships between learner satisfaction and the overall proposed model technical quality aspects. The model has a positive impact on overall learning process outcomes by evaluating the technical aspects while maintaining the quality of mobile learning delivered. The model components purportedly affect learning outcomes by assessing and improving the acceptability to stakeholders of the technical aspects of mobile learning. We propose a new model that captures most abstract and generic technical aspects of mobile learning.Four case studies were conducted with selected technical quality aspects in cumulative exercise.The case studies point to set of contextual technical quality factors influence mobile learning.The model evaluates technical aspects while maintaining delivered mobile learning quality.This effort is part of an Omani-funded research project investigating mobile learning in Oman.

Empirically Examining the Parallelizability of Open Source Software System

An empirical study is presented that examines the potential to automatically parallelism, using refactorings tools and/or compilers, 11 open source software. Static analysis methods are applied to each system to determine the number of for-loops and free-loops (i.e., loops that can be parallized). For each non-free loop the various inhibitors (to parallelization) are determined and counted. The results show that function calls within for-loops represent the vast majority of inhibitors and thus pose the greatest roadblock to adapt and re-engineer systems to better utilize parallelization. This is somewhat contradictory to the literature, which is focused primarily on the removal of data dependencies within loops. Additionally, the historical data of inhibitor counts for the set of systems is presented over a ten-year period. The data shows few of the systems examined are increasing the potential to parallelizable loops over time.

An empirical examination of the prevalence of inhibitors to the parallelizability of open source software systems

An empirical study is presented that examines the potential to parallelize general-purpose software systems. The study is conducted on 13 open source systems comprising over 14 MLOC. Each for-loop is statically analyzed to determine if it can be parallelized or not. A for-loop that can be parallelized is termed a free-loop. Free-loops can be easily parallelized using tools such as OpenMP. For the loops that cannot be parallelized, the various inhibitors to parallelization are determined and tabulated. The data shows that the most prevalent inhibitor by far, is functions called within for-loops that have side effects. This single inhibitor poses the greatest challenge in adapting and re-engineering systems to better utilize modern multi-core architectures. This fact is somewhat contradictory to the literature, which is primarily focused on the removal of data dependencies within loops. Results of this paper also show that function calls via function pointers and virtual methods have very little impact on the for-loop parallelization process. Historical data over a 10-year period of inhibitor counts for the set of systems studied is also presented. It shows that there is little change in the potential for parallelization of loops over time.

Middleware and multicore architecture: Challenges and potential enhancements from software engineering perspective

An empirical study that examines challenges middleware software systems have to take full advantages of multicore technology is presented. The study is conducted on 9 open source middleware systems containing over 3.39 million lines of code. Each system is analyzed and the inhibitors to parallelization are detected and presented. Additionally, some challenges in analyzing, adapting, and re-engineering middleware systems to better utilize modern multi-core architectures are determined including function side effects. Function side effects categorized based on their types and the complexity they pose in conducting inter-procedural static analysis. The data shows that the most prevalent inhibitor by far is functions called within for-loops that have side effects. Moreover, the study shows that parameters by reference and global variables modification are the most prevalent side effects that poses the greatest challenges in re-engineering middleware systems to improve their parallelizability to better utilize multi-core architectures. That is, conducting accurate program analysis with existing software engineering tools becomes exigent and impractical with those side effects. The study suggests some software engineering techniques (e.g., refactoring) that have the potential to improve the parallelizability of middleware systems.

Human Factors Considerations in Mobile Learning Management Systems

The rapid development in Internet and mobile technologies had an influence on education and learning processes that led to emergence of mobile learning as potential part of learning management system. Many individual learners and instructors, in some cases, entire education providers are gravitating towards the adoption of mobile learning through comprehensive learning management systems (LMS) for managing courses contents and enhancing learners’ education process. This research involves the development and validation of a survey that used to study 23 distinct Omani higher education providers empirically. A total sample of 806 university and higher college students and instructors participated in this study. A correlated six-factor Flexibility, Suitability, Enjoyment, Impact, Social and Economic were found to be as human influencing factors. Four different learning management systems Moodle, Blackboard, Schoology and Edmodo have been compared and evaluated in respect of the selected human factors. The effort is part of an Omani-funded research project investigating the development, adoption and dissemination of M-learning in Oman.

On the prevalence of indirect function calls in middleware software systems

An empirical study investigating the pervasiveness and distribution of indirect function calls via function pointers and virtual methods in middleware software systems is presented. The study encompasses a broad gamut of software systems that range from high-performance, distributed real-time embedded systems, to fully-featured professional 3D game engines; comprising in aggregate nearly five million lines of code and nine software systems. The systems were inter-procedurally statically examined to determine the distribution of function pointers and virtual method calls; function pointers were further segregated by type and complexity. Results indicate that function pointers are typically utilized in situations that make static analysis costly and impractical to conduct. A five-year analysis of archived data shows an increase in the usage of both calls using function pointers and virtual methods over the lifetime of open-source middleware systems, thus posing additional obstacles for inter-procedural analysis.

A study on the usage of unsafe functions in gcc compared to mobile software systems

A case study is presented that empirically analyzes the use of known unsafe functions in gcc, a well-known general purpose software system, along with their distribution over a 5-year period from, 2012 through 2016. The 5-year history of gcc studied is comprised of a total of over 26 million lines of code. gcc was statically analyzed with the use of srcML and a tool created by one of the authors. A count of each unsafe function type present in each year of the system was recorded, along with a count of safe replacement functions, and their distributions analyzed. The results were compared to findings from a previous study on networking and mobile systems. The results show free, strcmp, strlen, and memcpy to be the most prevalent unsafe functions used among the years of gcc studied. This information can help developers by showing where they should direct their attention when refactoring their system to improve security, and thereby improve the systems robustness, reliability, and overall quality. By focusing on the most prevalent unsafe functions, developers can plan their refactoring process to be more effective. The fact that unsafe functions are still being used despite there being safer alternatives shows a need for new security standards, better education about security and security issues, and supervision of programmers to ensure they follow those standards.

On the evolution of mobile computing software systems and C/C++ vulnerable code: Empirical investigation

A study is presented that examines the distribution and the usage of some unsafe functions that are known to cause security vulnerabilities in 15 software systems, written in C/C++. The systems are commonly used for mobile computing, and they comprise almost six million lines of code. A tool that uses a static analysis approach is applied to each system, and the number of calls to unsafe functions is determined and tabulated. The results show that vulnerable functions such as strcmp, strlen, and memcpy represent the vast majority of used unsafe functions that are banned by many companies (e.g., Microsoft) in the studied systems. This fact can help software trainers better design and plan training courses and materials on secure coding practices for software developers. Additionally, findings can help software engineers to conduct more effective refactoring processes that help to clean software systems from vulnerable code, and focus primarily on the removal of vulnerable code with higher usage for better outcomes. The historical data for a number of systems, subset, is presented over a five-year period. The data shows that few of the systems examined are increasing the number of unsafe function calls over time. This is somewhat contradictory to the literature, which claims that the use of vulnerable functions is decreasing in software systems. This fact demands that more attention and effort from software engineering and mobile computing communities be put towards addressing this phenomenon.

Parallelization in software systems used in wireless sensor networks and Internet of Things: Case study: Middleware systems

In the Internet of Things (IoT) architecture, middleware is the component that creates a bridge between the heterogeneous sensor nodes and the software applications. One aspect among many others that determine the efficiency, performance, and functionality of middleware is parallelizability. Parallelizability refers to how ready the software is to utilize multicore architecture. The problem in general has been studied recently. This paper presents a study that examines the middleware software systems that have been widely used in IoT and wireless sensor network (WSN) applications. The examination gives us an idea of how well the software takes advantage of the hardwares multicore technology. The study is conducted on the source code of three open source middleware systems containing 1.07 million lines of code and almost 5k files. Each system is analyzed and the inhibitors to parallelization are detected and presented. The most prevalent inhibitors are pointed out to show the developers of IoT middleware systems what they should focus on when refactoring and improving their products. A historical trend over the last five years concerning the presence of inhibitors in the source code is also presented. The study suggests some techniques for refactoring the source code to improve the parallelizability of the systems as well.

Vulnerable C/C++ code usage in IoT software systems

An empirical study that examines the usage of known vulnerable statements in software systems developed in C/C++ and used for IoT is presented. The study is conducted on 3 open source systems comprising more than one million lines of code and containing almost 5K files. Static analysis methods are applied to each system to determine the number of unsafe commands known among research communities to cause potential risks and security concerns, thereby decreasing a systems robustness and quality (i.e., strcpy, strcmp, and strlen). Some of those statements are banned by some companies (e.g., Microsoft). These commands are not supposed to be used in new code and should be removed from legacy code over time as recommended by new C/C++ language standards. Additionally, each system is analyzed and the distribution of the known unsafe commands is presented. Historical trends in the usage of the unsafe commands are presented to show how the studied systems evolved over time with respect to the vulnerable code. The results show that the most prevalent unsafe command used across all systems is memcpy, followed by strlen.