Unifying Algorithmic Performance: Insertion Sort Across Diverse Programming Paradigms

Aim/Background: Insertion Sort is widely taught in computer science, yet its practical runtime can vary substantially depending on the programming language and the structure of the input data. This study aims to provide a language-aware empirical comparison of Insertion Sort and to complement benchmark results with machine-learning–based runtime classification. Methods: Insertion Sort was implemented and evaluated in six languages (C, C++, Go, Java, PHP, and Python). Execution time was measured under a controlled hardware/software environment using identical datasets of three sizes (1,000; 10,000; and 100,000 elements) and four input patterns (ascending, descending, nearly sorted, and random). To interpret performance trends, supervised machine learning models were trained to classify runtime behavior into Fast, Moderate, and Slow categories, and a Relative Execution Time Ratio (RETR) metric was introduced to normalize runtimes against the fastest observed case. Results: Go achieved the best overall performance, followed by Java, while C and C++ produced mid-range results. Python and PHP were consistently the slowest, with the largest slowdowns observed for large and reverse-ordered inputs. For runtime classification, Random Forest outperformed XGBoost, achieving 93% accuracy compared with 87% for XGBoost. RETR enabled a clearer cross-language comparison by standardizing runtimes relative to the fastest baseline. Conclusion: Insertion Sort performance is strongly influenced by both programming language and input characteristics. Combining benchmarking with ML-based classification and normalized metrics (RETR) offers a more interpretable view of runtime behavior and supports better alignment of algorithm choices with language and data context in real-world applications.

In this chapter it will be shown that there can exist possible connections of Tsallis nonextensive definition of entropy (Tsallis, 1988) with the statistical analysis of simple insertion sort algorithm behaviour. This will be done basing on the connections between the idea of Turing machines (Turing, 1936) as a basis of considerations in computer science and especially in algorithmic processing and the proposal of non-equilibrium thermodynamics given by Constatino Tsallis (Tsallis, 1988; Tsallis, 2004) for indication of the possible existence of non-equilibrium states in the case of one sorting algorithm behaviour. Moreover, it will be also underlined that a some kind of paradigm change (Kuhn, 1962) is needed in the case of computer systems analysis because if one considers the computers as physical implementations of Turing machines should take into account that such implementations always need energy for their work (Strzalka, 2010) – Turing machine as a mathematical model of processing does not need energy. Because there is no (computer) machine that have the efficiency η = 100%, thus the problem of entropy production appears during their work. If we note that the process of sorting is also the introduction of order (obviously, according to a given appropriate relation) into the processed set (sometimes sorting is considered as an ordering (Knuth, 1997)), thus if one orders it must decrease the entropy in sorted set and increase it somewhere else (outside the Turing machine – in physical world outside its implementation). The connections mentioned above will be given basing on the analysis of insertion sorting, which behaviour for some cases can lead to the levels of entropy production that can be considered in terms of non-extensivity. The presented deliberations can be also related to the try of finding a new thermodymical basis for important part of authors' interest, i.e., the physics of computer processing.

This paper presents the study of implementation and performance in sorting process, using two different algorithms, namely Insertion Sort and Merge Sort. In the first stage, the two algorithms were implemented in C++ language to sort several numbers typed by a user. In the second stage, the source codes for those algorithms were modified to enable sorting randomly generated numbers with the amount as requested by the user. To find out how well they performed in sorting out the data, therefore in the last stage the two algorithms were tested to sort random numbers with predetermined amount ranges and the results were compared. From the experiments performed, merge sort algorithm had shown a better performance, particularly in a large number of data (> 10000). Insertion sort algorithm has the advantage in lower complexity algorithm, notably in the best case condition and since it does not use recursion routines in sorting process, hence it does not require as much storage space or memory as needed by merge sort algorithm.

The aim of this paper is to compare the complexity of three simple sort algorithm; selection sort algorithm, bubble sort algorithm, and insertion sort algorithm. The measurement of the complexity is based on control flow structure and time processing. The control flow structure is illustrated into flowgraph and measured by number of out-degree and number of in-degree. The algorithm is coded in C programming language. The sorting experiment uses four data sets: 100,000 random words, 50,000 random words, 100,000 random integer numbers, and 50,000 random integer numbers to measure the time processing. The result of the measurement explains that the bubble sort algorithm has the complexity more than others.

The rapid growth of the Internet of Things (IoT) and its applications requires high computational efficiency, low-cost, and low-power solutions for various IoT devices. These include a wide range of microcontrollers that are used to collect, process, and transmit IoT data. ESP32 is a microcontroller with built-in wireless connectivity, suitable for various IoT applications. The ESP32 chip is gaining more popularity, both in academia and in the developer community, supported by a number of software libraries and programming languages. While low- and middle-level languages, such as C/C++ and Rust, are believed to be the most efficient, TinyGo and MicroPython are more developer-friendly low-complexity languages, suitable for beginners and allowing more rapid coding. This paper evaluates the efficiency of the available ESP32 programming languages, namely C/C++, MicroPython, Rust, and TinyGo, by comparing their execution performance. Several popular data and signal processing algorithms were implemented in these languages, and their execution times were compared: Fast Fourier Transform (FFT), Cyclic Redundancy Check (CRC), Secure Hash Algorithm (SHA), Infinite Impulse Response (IIR), and Finite Impulse Response (FIR) filters. The results show that the C/C++ implementations were fastest in most cases, closely followed by TinyGo and Rust, while MicroPython programs were many times slower than implementations in other programming languages. Therefore, the C/C++, TinyGo, and Rust languages are more suitable when execution and response time are the key factors, while Python can be used for less strict system requirements, enabling a faster and less complicated development process.

In ultra-low power era, one of the most effective ways of reducing power consumption is to lower supply voltage level. When programs execute on processors, voltage fluctuations can occur due to sudden changes in current draw between successive instructions. Such voltage fluctuations can reduce the voltage levels below acceptable levels and cause unreliable operation in microprocessors. Voltage droops due to di/dt effects have been studied in the past, however no prior work studies the effect of compiler optimizations on voltage droops. Past work has studied the impact of compiler optimizations on performance and power, but not reliability. In this paper, we analyze voltage droops with different compiler optimization levels. We also report corresponding performance, power and energy results to put the results into perspective. No clear trends could be observed regarding the effect of compiler optimizations on voltage droops. We conclude that dynamic voltage noise mitigation is necessary because we cannot guarantee voltage noise reduction with static compiler optimization.

A model is a simplification of a reality, an abstraction, which neglects all of the irrelevant aspects of a software and focuses on the ones which define the software. Through modeling, we can visualize the software in a way which is understandable from both computers and people. Unified Modeling Language (UML) is a language, which stands in a higher level of abstraction than any programming language and through it, we can build software models from the simplest to the most complicated ones. However, even though through UML we are able to design software’s and to generate a considerable amount of code, still we need to write tons of lines of code in a certain object – oriented language. In order to be totally independent from the execution environment and to focus entirely in business logic as what really defines a software we need to go further. To achieve this goal, the executable UML and state machines concept is introduced. “An executable UML model is one with a behavioral specification detailed enough that it can effectively be run as a program” (Seidewitz, 2011). Through executable model a higher programmer productivity could be achieved and the system is not affected by the year after year change in development technologies, which require that the system to be upgraded each time there are changes in run-time environments. On the other hand, through state machines we are able to simulate the execution of a program through the model. Thus we can develop information systems using techniques which stand in a higher level of abstraction and platform independence that can be translated in whichever specific platform of implementation.

Mobile operating systems like Android failed to provide sufficient protection on personal data, and privacy leakage becomes a major concern. To understand the security risks and privacy leakage, analysts have to carry out data-flow analysis. In 2014, Android upgraded with a fundamentally new design known as Android RunTime (ART) environment in Android 5.0. ART adopts ahead-of-time compilation strategy and replaces previous virtual-machine-based Dalvik. Unfortunately, many data-flow analysis systems like TaintDroid were designed for the legacy Dalvik environment. This makes data-flow analysis of new apps and malware infeasible. We design a multi-level information-flow tracking system for the new Android system called TaintART. TaintART employs a multi-level taint analysis technique to minimize the taint tag storage. Therefore, taint tags can be stored in processor registers to provide efficient taint propagation operations. We also customize the ART compiler to maximize performance gains of the ahead-of-time compilation optimizations. Based on the general design of TaintART, we also implement a multi-level privacy enforcement to prevent sensitive data leakage. We demonstrate that TaintART only incurs less than 15% overheads on a CPU-bound microbenchmark and negligible overhead on built-in or third-party applications. Compared to legacy Dalvik environment in Android 4.4, TaintART achieves about 99.7% faster performance for Java runtime benchmark.

Execution orders in parallel programs are governed by non-determinism and can vary substantially across different executions even on the same input. Thus, a highly non-deterministic program can exhibit rare execution orders never observed during testing. It is desirable to reduce non-determinism to suppress corner case behavior in production cycle (making the execution robust or bug-free) and increase non-determinism for reproducing bugs in the development cycle. Performance-wise different optimization levels (e.g. from O0 to O3) are enabled during development , however, non-determinism-wise, developers have no way to select right compiler optimization level in order to increase non-determinism for debugging or to decrease it for robustness. The major source of non-determinism is the underlying execution model, primarily determined by the processor architecture and the operating system (OS). Architectural artifacts such as cache misses and TLB misses characterize and shape the non-determinism. In this work, we seek to capture such sources of non-determinism through an architectural model based on hardware performance counters and use the model for predicting the appropriate compiler optimization level for generating a robust parallel program, which has minimal non-determinism in production. As a side effect, the generated model also allows maximizing non-determinism for debugging purposes. We demonstrate our technique on the PARSEC benchmark suite, and among other results show that the generated robust program decreases non-deterministic behavior up to 66.48%, and as a practical measure we also show that a known race condition plus randomly injected ones are rendered benign in the robust parallel program generated by our framework.

WebAssembly (WASM) has emerged as a promising compilation target for languages traditionally not executed on the web and enable the cross-platform deployment of high-performance applications. While its general use cases have been well studied, the performance implications of executing Machine Learning (ML) workloads via WASM across different programming languages and runtime environments remain relatively unexplored. This paper presents a systematic evaluation of two representative ML models, K-Means and Logistic Regression, implemented in Python, Rust, and C++ and compiled to WASM. These models are executed in two distinct environments: a web browser and the WebAssembly System Interface (WASI), and their execution time and accuracy is compared against each programming language across both environments. This study aims to provide insight into the trade-offs and practical considerations involved in deploying ML workloads using WebAssembly across different language ecosystems and runtime configurations.

Jackal is a fine-grained distributed shared memory implementation of the Java programming language. Jackal implements Java's memory model and allows multithreaded Java programs to run unmodified on distributed-memory systems.This paper focuses on Jackal's runtime system, which implements a multiple-writer, home-based consistency protocol. Protocol actions are triggered by software access checks that Jackal's compiler inserts before object and array references. We describe optimizations for Jackal's runtime system, which mainly consist of discovering opportunities to dispense with flushing of cached data. We give performance results for different runtime optimizations, and compare their impact with the impact of one compiler optimization. We find that our runtime optimizations are necessary for good Jackal performance, but only in conjunction with the Jackal compiler optimizations described in [24]. As a yardstick, we compare the performance of Java applications run on Jackal with the performance of equivalent applications that use a fast implementation of Java's Remote Method Invocation (RMI) instead of shared memory.

While in the past the primary goal to optimize software was the run time optimization, nowadays there is a growing awareness of the need to reduce energy consumption. Additionally, a growing number of developers wish to become more energy-aware when programming and feel a lack of tools and the knowledge to do so. In this paper we define a ranking of energy efficiency in programming languages. We consider a set of computing problems implemented in ten well-known programming languages, and monitored the energy consumed when executing each language. Our preliminary results show that although the fastest languages tend to be the lowest consuming ones, there are other interesting cases where slower languages are more energy efficient than faster ones.

Aspect-Oriented Programming (AOP) is a programming paradigm that implements crosscutting concerns in a modular way. People have witnessed the prosperity of AOP languages for Java and C++, such as AspectJ and AspectC++, which has propelled AOP to become an important programming paradigm with many interesting application scenarios, e.g., runtime verification. In contrast, the AOP languages for C are still poor and lack compiler support. In this paper, we design a new general-purpose and expressive aspect-oriented C programming language, namely Aclang, and implement a compiler for it, which brings fully-fledged AOP support into the C domain. We have evaluated the effectiveness and performance of our compiler against two state-of-the-art tools, ACC and AspectC++. In terms of effectiveness, Aclang outperforms ACC and AspectC++. In terms of performance, Aclang outperforms ACC in execution time and outperforms AspectC++ in both execution time and memory consumption.

Measuring the energy spent by a software application is a problem that can be solved by having the proper hardware or software instruments. However, not always such tools are available or the provide resolution cannot fit the needs of the user, for instance when measuring a very small piece of code. This problem is particularly relevant on mobile software products, as they are developed to be executed in an environment limited in energy resources. Mobile software engineers should take special consideration on the energy consumption when designing and implementing an application. In this paper, we propose that the energy consumed by a unit of code can be approximated by the execution time. Using software benchmarks run with different data loads, we measured the execution time required to complete the job, and using a software tool to measure the energy spent during the execution of the benchmark, with the objective of finding a relationship among them. We observed that, regardless of the software benchmark, the data load injected and the programming language, of implementation the ratio between the execution time and the energy consumption remains consistent, opening the opportunity to develop techniques to approximate the energy consumption of mobile software based on execution time measurements.

A surprisingly simple Lua compiler—Extended version