A]C#

Abstract— Aim/Background This study aims to systematically evaluate the practical runtime performance of the Insertion Sort algorithm across six widely used programming languages: C, C++, Go, Java, PHP, and Python. While Insertion Sort’s theoretical time complexity is well established, real-world execution performance may differ significantly due to variations in language paradigms, compilation strategies, and runtime environments. The research focuses on identifying how language-specific characteristics influence actual execution time. Methods The Insertion Sort algorithm was implemented uniformly in all six languages using a shared pseudocode to ensure consistency. Experiments were conducted under controlled conditions using input sizes of 1K, 10K, and 100K elements. Each dataset was tested with four different data arrangements: ascending, descending, nearly sorted, and random. Runtime measurements were collected and compared. Additionally, a Relative Execution Time Ratio (RETR) metric was introduced to provide a normalized and quantitative comparison of performance across languages. Results The experimental findings show clear performance differences among the programming languages. Go demonstrated the fastest runtimes across most scenarios, benefiting from its efficient compiled execution model. Java performed second-best, leveraging just-in-time (JIT) compilation and runtime optimizations. C and C++ showed moderate performance, influenced by compiler optimization levels and memory management mechanisms. PHP and Python exhibited significantly slower execution times, particularly for large and poorly ordered datasets, mainly due to interpreter overhead and runtime inefficiencies. The RETR metric effectively highlighted these relative performance gaps. Conclusion The study confirms that programming language choice significantly impacts real-world algorithm performance, even for well-understood algorithms like Insertion Sort. Compiled languages with efficient runtime optimizations generally outperform interpreted languages, especially for larger datasets. These results emphasize the importance of selecting appropriate programming languages for performance-critical applications and aligning algorithm implementation with both data characteristics and execution environments.

Exception handling mechanisms have been introduced into programming languages in an effort to help deal with runtime irregularities. These mechanisms aim to improve code reliability by providing constructs for sectioning code into exception scopes (e.g. Java try blocks) and exception handlers (e.g. Java catch blocks). Whilst exception handling mechanisms have been the focus of much research over the past years, empirical studies have only focused on characterising exception handling code of Java and C# programs. There exists little empirical evidence on how exception handling mechanisms are used to develop software with other programming languages. Moreover, to date there exists no empirical study which has examined the structure of exception scopes across software projects. We address these shortcomings by examining the commonalities and differences of both exception scopes and handlers implemented with a wider range of languages. To this end, we analysed 50 software projects, containing code developed in C++, JavaScript, PHP, Java and C#. More than 9 million lines of code and over 20,000 exceptional code blocks were analysed. Our findings revealed significant differences in the frequency, structure and length of exception scopes and exception handlers across languages. This finding suggests that certain exception handling mechanisms are less explored by programmers using certain programming languages. However, regardless of language, exception handlers remained simplistic and in general only ever one handler was associated with each scope. Finally, our analysis confirms the existing belief that developers often pay little attention to developing exception scoping and handling behaviour.

In this paper, a multi-body system dynamics problem is considered as a complex system modeling and computation problem. A parallel programming model and its execution environment are designed to reduce model complexity and to improve computational speed. In this architecture, the problem is divided into two levels: 1. Find a parallel mathematical algorithm to describe the behavior of this multi-body system. 2. Build a unified programming language that could leverage many different pieces of computational resources, such as symbolic computing, and numerical libraries. To tackle the first level, Space-Time Finite Element Method (FEM) is applied. The Space-Time FEM formats of Newton-Euler formula is given, as well as its constraint formula. This algorithm has avoided the loop operation during the time field solving. To tackle the second level, a network-based functional programming language - Object Computing Network (OCN) is designed. OCN is inspired by Object-Process Methodology (OPM). In OCN, every computation behavior is treated as a function, which is constructed by a three element set: {Var, Rule. Condition}. Three basic patterns - Branching, Synchronizing, Merging are given in OCN to prove the flexibility of OCN. An communication interface is designed in OCN to connect different programming languages together. Two multi-body system dynamics computing models - Semi-discretization method and Space-Time discretization method - are constructed with OCN, and a significant contrast in task parallelization is shown by different OCN models.

Global programming language is a special instrument, which will initially be created to solve the problem of code translation between programming languages. It will allow users to conveniently and error-free translate code from one language to another. Therefore, its grammar will be developed based on the condition of maximum convenience of unification of source texts of programs implemented in different paradigms. Also Global programming language has a lot of advantages. It is a universal entry point for learning programming. All programs can be run on any device by translating the source code into a language supported by a particular device. There is no need to choose one programming language to implement the entire project. It becomes possible to write various blocks of code in the most convenient languages and then automatically translate result into a single target language.

This paper describes a technique for implementing the part of a compiler that processes the semantics of a programming language. It presents a concise, easy to understand notation for describing this semantic processing. The notation utilizes semantic charts which are similar to the separable transition diagrams [Conway63, Barnard75] that are used to define the syntax of programming languages. The charts describe semantic processing in terms of a set of operations that manipulate a small number of special-purpose data structures. They form a variable-free programming language, which accesses data via a set of operations organized into mechanisms to manage the associated data structure. These mechanisms can be modelled (and thus formalized) using abstract data types.

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.

The design and test of error control encoding and decoding mod ules for simulating data communications systems is described. Generic application library modules for the Interactive Commu nications Systems Simulation Module (ICSSM) were developed for block and convolutional codes using the programming lan guage FORTRAN. The end user specifies a system for simulation study by linking various communications, signal processing and error control modules. In developing the encoding and decoding modules, a top-down approach resulted in a heirarchy of subroutines and function calls. This approach simplified the validation task and allowed easier upgrades and maintenance. Some of the design trade-offs for both the block code and convolutional code modules are viewed. It was found that modest use of storage can be traded for execution time. Various computations and operations can be efficiently accomplished with table look-up when using a high-level language such as FORTRAN. A simple communication system using these modules was studied. The error behavior was as expected. The key problems identified in this development were systems issues; primarily, module initialization and synchronization.

BACKGROUND Secondary use of clinical data offers the unprecedented opportunity to rapidly conduct large-scale research and improve patient care. However, incomplete understanding of data quality requirements for a study often causes significant delays in executing analyses and validating results. While multi-institutional networks have developed general data quality programs, they are closely tied to network characteristics and do not address many study-specific requirements. In turn, most investigators conduct per-study exploratory analyses, but these efforts are typically ad hoc and partially reported, which can hinder reproducible science and delay advances in patient care. OBJECTIVE The objectives of this study were to develop a comprehensive yet extensible model that guides study-specific data quality assessment (SSDQA) and to construct reusable data quality modules, based on the model, that can be widely disseminated and adopted. METHODS We reviewed current literature and studies, interviewed experts, and convened a group of scientists 14 times over 24 months to develop a strategy for effective and generalizable SSDQA. From this we built a model that provides guidance for improved SSDQA design and implementation, identifying reusable components and software development best practices. We created a set of executable data quality modules addressing multiple check requirements, packaged for dissemination using the R programming language. Modules include tabular output as well as high density data displays to improve the feasibility of more complete SSDQA. RESULTS The data quality model integrates theoretical principles of data quality testing with pragmatic considerations of application to clinical data. Eighteen data quality modules were specified, incorporating a wide range of theory-based check categories and practice-based check types. The nine specifications covering most common SSDQA requirements were developed as reusable software packages. Study-specific user decisions for application of a module include: (a) target data element(s), (b) single- or multi- source analyses, (c) exploratory output or statistical anomaly detection; and (d) longitudinal or cross-sectional analyses. Consistent visualizations of results are provided across multiple checks, and tabular results are available for archiving or further computation. We demonstrate that application of SSDQA modules to a cohort of pediatric patients diagnosed with sickle cell disease drawn from a multisite clinical research network produces informative results about data characteristics that may create analytic risk. CONCLUSIONS The study-specific data quality model builds on current practice, providing guidance for more complete and sound assessments. Reusable modules implementing model guidance can be readily deployed in large networks or smaller consortia, and provide detailed reporting of study-specific data quality in reproducible form. The flexibility allows investigators to tailor checks to their study requirements while retaining consistency of DQA methods. This approach fosters collaboration to identify data quality issues that can inform decisions about study design, as well as provide important context bearing on adoption of results.

This paper describes our experience in modeling two significant parallel applications: ARC2D, a 2-dimensional Euler solver; and, Xtrid, a tridiagonal linear solver. Both of these models were expressed in BDL (Behavior Description language) and simulated on an iPSC/860 Hypercube modeled using Axe (Abstract eXecution Environment). BDL models consist of abstract communicating objects: blocks of sequential code are modeled by single RUN statements; all communication operations in the original code are mirrored by corresponding BDL operations in the model. Our ARC2D model was built by first profiling the program to locate the significant loops and then timing the basic blocks within those loops. Simulated completion times were (except in one case) within 8% of measured execution times. Lengthy simulations were necessary for predicting the performance of large-scale runs. For Xtrid, only the loops surrounding communications were modeled; other loops were absorbed into large sequential blocks whose complexity was estimated using statistical regression. This approach yielded a much smaller model whose computation and communication complexities were clearly manifest. Analysis of complexity allowed rapid prediction of large-scale performance without lengthy simulations! Analytically predicted speed-ups were within 7% of those predicted by simulation. Simulated completion times were within 5% of measured execution times. The second approach provides a more effective methodology for simulation-based performance-tuning.

Digital nations have become dependent on computer applications. One of the most important part of literacy in today’s digital and connected word are the basics of computer applications development and usage, but also algorithmic thinking. Programmers, developers, analysts are very wanted resource in business, administration and educational organizations. Job portals contain a lot of well-paid job offers for developers, data scientists, knowledge engineers or robotic process automation developers. Still more and more specialists in these areas are needed not only by IT market but also other sectors of the economy. Therefore, schools and universities introduce many courses concerning process modeling, developing, programming and customizing applications used in management, finance, logistics or engineering. Programming seems to be quite difficult to learn, therefore several educational programming environments and the new easier languages like visual programming languages were developed, so that more people, not necessarily specialists, could create new IT tools and speed up development of the information society.The aim of the article is to present the role of visual programming languages like Scratch in encouraging university students to create algorithms and start programming. The paper presents the characteristic of Scratch visual programming language, the framework of VBA programming course with elements of Scratch. It contains also students’ opinions about learning the basics of programming with visual programming language. In the main part of the article the author presents the results of the survey that was at conducted at the beginning of 2019 on a group of Polish Master’s students (n=119) The author’s observation and students’ opinions allow to conclude that Scratch is very easy to access and to use. It makes introduction to programming more enjoyable, helps to concentrate on the problem, solution structure, and the flow of the process. Scratch platform is not an ideal tool, however it allows for faster introduction of new elements of programming languages such as variables, loops, code blocks, objects. Finally, visual programming languages thanks to its easiness and quickly visible final effect (working application) encourages students to self-development in the field of computer programming. Performed research indicates also that business students notice the benefits of knowing basics of programing, they would like to attend basic programing classes. Students acquire knowledge and skills mainly performing instructions received from the teacher (86%) and watching video tutorials. The comparative analysis showed also some differences between various groups of students. Therefore, tools like Scratch can be successfully used to develop IT courses for non-majors. Many advantages make Scratch useful in introductory programming courses prepared for business students that frequently had no prior experience in the area of IT applications development.

Image processing operations may be performed in either the spatial domain or the frequency domain. Spatial domain image processing is attractive because it avoids the mathematical transformations required by frequency domain processing is computationally more efficient and is more intuitive. Historically spatial processing has been done by traversing the image in strict raster-scan fashion (left-to-right top-to-bottom a paradigm encouraged by the syntax of traditional Fortran-like programming languages. Cellular logic is a different way of thinking about spatial processing in which images are modified h defining a set of logical operations to be performed on small groups of pixels neighboring any general pixel in the image. The same operations are then performed on every pixel in the image all at once there is no implied ordering in the processing ofthe pixels. This means that cellular logic has a natural parallelism making it easy to implement on parallel computers. Cellular logic is also efficient even on single-processor machines. since pixels are processed in machine-word sized groups. Another interesting property of cellular logic is that it is Turing-complete: in other words it has the same computational power as any programming language in general so that arbitrarily complex operations may be constructed from a small number of simple logical primitives. In addition the bit-block transfer instruction (bitbit) offers a convenient means of implementing cellular logic functions in software. As its name implies bitbit transfers© (1991) COPYRIGHT SPIE--The International Society for Optical Engineering. Downloading of the abstract is permitted for personal use only.

JRAF: A Julia package for computation of relativistic molecular auxiliary functions

CombiLog is a logic programming language that uses a small set of basic operators to build larger structures. Although the programs are built strictly through composition, the resulting code is often difficult to read and understand. Empirical studies on program creation both with visual programming language and traditional programming indicate that visual approaches may outperform traditional approaches to programming. Thus, CombiLog could gain largely from a visual interface to support the development process. With a visual interface the resulting system can be regarded as a declarative visual logic programming language, ViColl.

The next generation of engineering environments will consist of two principal components: a toolset and a framework. Tools are automated mechanisms, such as editors and compilers. which aid in the development and maintenance of systems. A framework provides a common set of object management and user interface services that support the integration of tools to automate a large slice of the lifecycle. We have designed an object-oriented framework and implemented it using the Ada' programming language. It currently runs under \ax/VMS2 and sun-33. This paper presents an overview of the framework and its underlqing concepts for integrated project support. LVe also describe future plans for extending our framework's functionalitj.

This paper relies on the resource-oriented architecture (ROA) to propose a middleware that shares resources (sensors, actuators and services) of one or more robots through the TCP/IP network, providing greater efficiency in the development of software applications for robotics. The proposed middleware consists of a set of web services that provides access to representational state of resources through simple and high-level interfaces to implement a software architecture for autonomous robots. The benefits of the proposed approach are manifold: i) full abstraction of complexity and heterogeneity of robotic devices through web services and uniform interfaces, ii) scalability and independence of the operating system and programming language, iii) secure control of resources for local or remote applications through the TCP/IP network, iv) the adoption of the Resource Description Framework (RDF), XML language and HTTP protocol, and v) dynamic configuration of the connections between services at runtime. The middleware was developed using the Linux operating system (Ubuntu), with some applications built as proofs of concept for the Android operating system. The architecture specification and the open source implementation of the proposed middleware are detailed in this article, as well as applications for robot remote control via wireless networks, voice command functionality, and obstacle detection and avoidance.