Specific Programming Language Research Articles

Improvement of the UCP method for estimating labor costs in the implementation of IT-projects

An important stage of planning in the implementation of IT-projects is the assessment of the complexity of software development. An accurate estimate of labor costs at the early stage of the project life cycle significantly affects the allocation of resources, time planning and budget costs. Therefore, regardless of the large number of methods used to estimate labor costs during the implementation of an IT-project, the task of increasing the accuracy of this predictive estimate is relevant. The paper examines in detail the possibilities of using the well-known method for estimating labor costs Use Case Points (UCP), which is based on the use of use cases. It belongs to algorithmic methods, which makes it quite reliable and predictable in use. It also allows you to take into account the functional requirements for the system, which is especially useful in the early stages of project implementation. In addition, UCP is not tied to specific technologies or programming languages, which indicates its universality and flexibility. The purpose of the study is to improve the UCP method of estimating labor costs necessary for the successful implementation of an IT-project, which will allow taking into account interval estimates of technical complexity factors and external factors that affect the estimation of the amount of software and, accordingly, the estimation of the project's labor intensity. To experimentally verify the operability and efficiency of the proposed modified UCP method, a dataset containing information on 71 real projects was used. The results of computer modeling and comparative analysis of the accuracy of estimates of labor costs for the implementation of the project obtained using the proposed and original UCP methods are given. The results of the experiments showed that the proposed modification of the UCP method allows obtaining more accurate predictive estimates of labor costs in the implementation of IT-projects, which can significantly affect the efficiency of planning and project management processes.

StructuredFuzzer: Fuzzing Structured Text-Based Control Logic Applications

Rigorous testing methods are essential for ensuring the security and reliability of industrial controller software. Fuzzing, a technique that automatically discovers software bugs, has also proven effective in finding software vulnerabilities. Unsurprisingly, fuzzing has been applied to a wide range of platforms, including programmable logic controllers (PLCs). However, current approaches, such as coverage-guided evolutionary fuzzing implemented in the popular fuzzer American Fuzzy Lop Plus Plus (AFL++), are often inadequate for finding logical errors and bugs in PLC control logic applications. They primarily target generic programming languages like C/C++, Java, and Python, and do not consider the unique characteristics and behaviors of PLCs, which are often programmed using specialized programming languages like Structured Text (ST). Furthermore, these fuzzers are ill suited to deal with complex input structures encapsulated in ST, as they are not specifically designed to generate appropriate input sequences. This renders the application of traditional fuzzing techniques less efficient on these platforms. To address this issue, this paper presents a fuzzing framework designed explicitly for PLC software to discover logic bugs in applications written in ST specified by the IEC 61131-3 standard. The proposed framework incorporates a custom-tailored PLC runtime and a fuzzer designed for the purpose. We demonstrate its effectiveness by fuzzing a collection of ST programs that were crafted for evaluation purposes. We compare the performance against a popular fuzzer, namely, AFL++. The proposed fuzzing framework demonstrated its capabilities in our experiments, successfully detecting logic bugs in the tested PLC control logic applications written in ST. On average, it was at least 83 times faster than AFL++, and in certain cases, for example, it was more than 23,000 times faster.

High-Level Language Translation Controlled by Dataflow

The article is devoted to the description of the developed method and tools for translating high-level programming languages into an abstract syntactic tree. The peculiarity of the technique is that it is based on the object-attribute (OA) architecture of a computing system belonging to the dataflow class. The syntactic tree synthesized by the translator is a frame-like dynamic structure. The methodology includes the format and methodology of syntactic tree synthesis, the method for describing the translation algorithm, and the specialized programming language (OA-language) for describing a translation algorithm.

A Comparative Analysis of Programming Language Preferences Among Computer Science and Non-Computer Science Students

In the face of the growing importance of programming skills across various fields, understanding student preferences for programming languages becomes crucial. This study delves into this very topic, examining which languages resonate most with computer science majors and students from non-computer science backgrounds. We don’t just identify the popular choices; we also explore the underlying reasons behind these preferences through surveys. The analysis reveals a fascinating interplay between factors like a student’s learning experience, their career aspirations, and even their interests, all of which influence their preference for specific programming languages. This newfound knowledge empowers us to refine programming education for a diverse student body, ensuring they’re well-equipped for the demands of the digital world. Our findings hold value for curriculum designers, educators, and industry professionals alike. By understanding the evolving demands and preferences of students, these stakeholders can craft more relevant and engaging programming education experiences. Ultimately, this fosters interdisciplinary collaboration in the digital age, a key element for success in today’s interconnected world. This research not only contributes to the growing body of knowledge on programming language preferences but also offers practical insights for the betterment of programming instruction and the promotion of collaboration across disciplines within the digital landscape.

A Rapid Control Prototyping and Hardware-in-the Loop Approach for Upper Limb Robotic Exoskeletons Control

In the last decade, robotic-mediated rehabilitation has emerged as a potential solution to improve repetitive task training. Each device in this field has a unique development history shaped by engineers’ expertise in specific programming languages or platforms. In this work we adopt an approach that tries to abstract from the final implementation with the aim to make control logic more shareable and understandable. The authors will present the outcomes of the application of a Rapid Control Prototyping strategy to an upper-limb robotic exoskeleton. A model-based design approach implemented on a real-time target machine is presented. This modern design approach was explored with several control strategies and was used to test the exoskeleton’s performances. The proposed method highlights how it is possible to develop the entire control architecture in a single programming environment.

ЗАСТОСУВАННЯ СИСТЕМНОГО ПІДХОДУ ПРИ ВИКОНАННІ ІТ-ПРОЕКТІВ

Abstract. Modern requirements for the profession of an IT specialist are determined not only by the ability to work with specific technologies or programming languages. Today, an IT specialist faces a deeper task - understanding the functioning of complex systems and having the skills to analyze and solve complex problems. System analysis is a key success factor in the field of information technology, contributing to a holistic approach to solving problems and tasks that arise before IT specialists. Demand for systems analysts is growing rapidly and they are becoming an integral part of the IT team. Keywords: integrated software tools, IT team, competitiveness, principles of system analysis, system analyst.

Specification and Description Language Models Automatic Execution in a High-Performance Environment

Specification and Description Language (SDL) is a language that can represent the behavior and structure of a model completely and unambiguously. It allows the creation of frameworks that can run a model without the need to code it in a specific programming language. This automatic process simplifies the key phases of model building: validation and verification. SDLPS is a simulator that enables the definition and execution of models using SDL. In this paper, we present a new library that enables the execution of SDL models defined on SDLPS infrastructure on a HPC platform, such as a supercomputer, thus significantly speeding up simulation runtime. Moreover, we apply the SDL language to a social science use case, thus opening a new avenue for facilitating the use of HPC power to new groups of users. The tools presented here have the potential to increase the robustness of modeling software by improving the documentation, verification, and validation of the models.

Fuzzing-based grammar learning from a minimal set of seed inputs

To be effective, a fuzzer needs to generate inputs that are well formed, so that they are not outright rejected by the Software Under Test (SUT) and can thus detect meaningful bugs. Grammar based fuzzers solve this problem, but they obviously require a grammar of the input language accepted by the SUT. Many times such grammar is unknown. Therefore, different black- and white-box algorithms have been proposed for learning them from SUTs. Black-box algorithms rely only on membership queries, but need access to carefully crafted well formed inputs in order to obtain good results. White-box algorithms require access to the source code and generally produce grammars with higher precision and recall, but at the expense of working only for specific programming languages and libraries. We propose a new algorithm and show through extensive experimentation that it can learn grammars from recursive descendent parsers with consistently high levels of both, recall and precision. Notably, this result was obtained starting with a couple of arbitrary seed inputs and includes evaluations with sophisticated languages such as Java Script Object Notation (JSON). Different to other state of the art white-box approaches, our method does not require sophisticated program analysis techniques such as dynamic tainting or symbolic execution. In fact, the experiments confirm that our method performs extremely well with just a (standard) generic Abstract Syntax Tree (AST) of the parsing program as input. The core of our method uses fuzzing techniques combined with fundamental theoretical results on grammar learning. Compared to other white-box approaches, ours is not tied to specific programming languages and tools, and thus can be easily ported. Regarding performance, we have shown that our algorithm works well in practice and that, under reasonable assumptions, its worst-case complexity is polynomial (with low exponents) w.r.t. time and space requirements.

A tool and a methodology to use macros for abstracting variations in code for different computational demands

Scientific software used on high-performance computing platforms is in a phase of transformation because of the combined increase in the heterogeneity and complexity of models and hardware platforms. Having separate implementations for different platforms can easily lead to combinatorial explosions; therefore, the computational science community has been looking for mechanisms to express code through abstractions that can be specialized for different platforms. Most existing approaches use template meta-programming in C++, and are, therefore language specific. We have developed a tool that uses customized expansion of macros to mimic some of C++ behaviour in other languages. It enables unification of any code variants that may be necessary to run efficiently on different target architectures and different computational environments through use of macros with multiple alternative definitions and ability to arbitrate on definition selection for expansion. Combined with two other tools, a custom runtime, and a user specified recipe translator, our custom macroprocessor becomes a part of an overall performance portability solution that does not depend on any specific programming language. We also use macros as code-shorthand that lets code snippets become building blocks that allow variations in control flow to explore performance options. We demonstrate use of macros in Flash-X, a multiphysics multicomponent code with many Fortran legacy components derived from an earlier community code FLASH.

POSSIBILITIES OF DIAGNOSING THE LEVEL OF DEVELOPMENT OF STUDENTS' COMPUTATIONAL THINKING AND THE INFLUENCE OF ALTERNATIVE METHODS OF TEACHING MATHEMATICS ON THEIR RESULTS

The testing of students' computational thinking and the development of standardized tools for this testing is one of the most debated issues in the practical integration of computational thinking development. Thus, for more than a decade, there have been initiatives aimed at identifying the algorithmic, programming, and information thinking skills of primary and secondary school students. The research, the progress, and results of which are the subject of the communication of this paper, has been our contribution to the development of testing tools that would allow for the widespread testing of the level of students' computational thinking, and that are not focused on the use of a specific programming language. As part of it, we were also able to identify a possible link between alternative methods of teaching mathematics, such as the Hejny method, and the deeper development of computational thinking in primary school pupils.

MetaTPTrans: A Meta Learning Approach for Multilingual Code Representation Learning

Representation learning of source code is essential for applying machine learning to software engineering tasks. Learning code representation from a multilingual source code dataset has been shown to be more effective than learning from single-language datasets separately, since more training data from multilingual dataset improves the model's ability to extract language-agnostic information from source code. However, existing multilingual training overlooks the language-specific information which is crucial for modeling source code across different programming languages, while only focusing on learning a unified model with shared parameters among different languages for language-agnostic information modeling. To address this problem, we propose MetaTPTrans, a meta learning approach for multilingual code representation learning. MetaTPTrans generates different parameters for the feature extractor according to the specific programming language type of the input code snippet, enabling the model to learn both language-agnostic and language-specific information with dynamic parameters in the feature extractor. We conduct experiments on the code summarization and code completion tasks to verify the effectiveness of our approach. The results demonstrate the superiority of our approach with significant improvements on state-of-the-art baselines.

A Scalable AI Training Platform for Remote Sensing Data

Abstract. We present a platform to support the AI development lifecycle with focus on large data like remote sensing.We target developers who are not allowed to use existing commercial cloud platforms for legal reasons or data compliance. The flexible implementation of our platform enables a deployment on classic server infrastructures as well as on internal clouds. Our goals of scalable and resource-efficient execution, independence from specific AI frameworks and programming languages, as well as reproducibility of results are met through a workflow-based calculation combined with the tool Data Version Control. The capabilities of the platform are demonstrated by training an AI-based forest type classification.

Smart contracts software metrics: A first study.

Smart contracts (SC) are software programs that reside and run over a blockchain. The code can be written in different languages with the common purpose of implementing various kinds of transactions onto the hosting blockchain. They are ruled by the blockchain infrastructure with the intent to automatically implement the typical conditions of traditional contracts. Programs must satisfy context-dependent constraints which are quite different from traditional software code. In particular, since the bytecode is uploaded in the hosting blockchain, the size, computational resources, interaction between different parts of the program are all limited. This is true even if the specific programming languages implement more or less the same constructs as that of traditional languages: there is not the same freedom as in normal software development. The working hypothesis used in this article is that Smart Contract specific constraints should be captured by specific software metrics (that may differ from traditional software metrics). We tested this hypothesis on 85K Smart Contracts written in Solidity and uploaded on the Ethereum blockchain. We analyzed Smart Contracts from two repositories "Etherscan" and "Smart Corpus" and we computed the statistics of a set of software metrics related to Smart Contracts and compared them to the metrics extracted from more traditional software projects. Our results show that generally, Smart Contract metrics have more restricted ranges than the corresponding metrics in traditional software systems. Some of the stylized facts, like power law in the tail of the distribution of some metrics, are only approximate but the lines of code follow a log-normal distribution which reminds us of the same behaviour already found in traditional software systems.

Method of generating ORM models software code based on relational database schemes

Abstract. Problem. Databases and data stores are an important part of any system, regardless of the field of application. It is at this level that all system information is stored, such as a list of online store products, user personal data, system configuration parameters, etc. In addition, they allow to structure information in the desired format. Although the use of databases is associated with obvious advantages, it has some disadvantages, in particular the process of designing them and integrating their software code is labor-intensive and time-consuming. This problem is usually attempted to be circumvented by using ORM libraries, which provide a convenient programming interface for performing basic queries. But the process of setting up an ORM library including developing ORM models still takes a lot of time. Goal. The purpose of the work is to develop an algorithm for the automatic generation of software code for ORM models based on the selected ORM library and the data scheme presented in the form of a configuration file. To achieve the goal, it is necessary to establish the optimal representation of the data scheme in text format, to determine the structure of the data configuration scheme and to describe all stages of the generation of software code for ORM models. Methodology. System approach, analysis of existing methods of visual design, formats of text representation of configuration data and methods of configuration data storing. Results. The developed method for software code generation for the selected ORM library based on the scheme of the relational database provides the user with the opportunity to obtain a qualitatively designed software code with minimal time expenditure. Originality. The developed method implements a unique approach which allows to create program code for various ORM libraries, supports the syntax and features of a specific programming language, and provides work with data schemas from various relational databases. Practical value. Developed generation algorithm can be used as part of the software in which the automated process of preparing the data schema in the appropriate text formatted form will be implemented. As a result, such a web-application will represent a platform for working with the data layer for IT professionals.

A Stochastic Simulator of a Multi-Component Distillation Tower Built as an Excel Macro

Dynamic process simulation is widely used in teaching controller design, as it allows foreseeing the performance of different control configurations and controller tunings. Currently, most college-level controller design exercises that are based on simulation consider deterministic perturbations (i.e. steps or ramps). In real life however, processes are more likely to face fluctuating, random disturbances, so the use of stochastic simulation in controller tuning exercises would provide students with an experience closer to their future professional practice than that provided by deterministic simulation. However, public institutions attempting to use dynamic, stochastic simulators in teaching, are hindered by the need of buying licenses of simulation packages or specialized programming languages (such as Matlab), as there aren´t any dynamic, stochastic simulators available as downloadable freeware. This paper shows a dynamic, stochastic simulator with a friendly interface of a distillation tower, developed as an Excel macro. This simulator has the advantage that it can be used at no cost to educational institutions since Excel is almost universally known and used by college faculties.

Correlation between increased maternal body mass index and pregnancy complications.

Obesity in pregnancy carries significant maternal and fetal risk. The aim of this study was to investigate the effect of maternal body mass index on pregnancy outcomes. The study retrospectively reviewed the clinical outcome of 485 pregnant women who delivered at the Department of Obstetrics and Gynecology, Clinical Centre of Vojvodina, Novi Sad, during the period of three years (2018-2020) and compared them against the body mass index (BMI). Correlation coefficient was calculated for BMI and seven pregnancy complications (hypertensive syndrome, preeclampsia, gestational diabetes mellitus, intrauterine growth restriction, premature rupture of membranes, mode of delivery and postpartum hemorrhage). The collected data were presented in the form of median values and relative numbers (the measure of variability). The implementation of the simulation model and its verification were carried out using a specialized programming language, Python. Statistical models were created where the Chi-square and p-value were as determined for every observed outcome. The average age of the subjects was 35.79 years and average BMI 29.28 kg/m2. A statistically significant correlation was found between the BMI and arterial hypertension, gestational diabetes mellitus, preeclampsia and cesarean section. The correlations between the body mass index and postpartum hemorrhage, intrauterine growth restriction and premature rupture of membranes were not statistically significant. As high BMI correlates with a number of negative outcomes in pregnancy, weight control before and during pregnancy and proper antenatal and intranatal care are necessary to achieve a favorable pregnancy outcome.

An Analysis of the Usage of Various Programming Languages to Classify Whether they are Relevant, Extinct, or on the Verge of Extinction

The first modern high level general purpose programming languages appeared over seventy years ago. Since then, with the exponential increase in the usage of different types of computer software and developments in computer hardware, numerous high level programming languages have been created for various purposes, with each language having its own relative advantages and disadvantages. Usually, specific general purpose high level programming languages are appropriate for specific applications or problems because of the nature of capabilities of the languages such as efficiency, memory consumption, expressiveness, availability of compilers, and tools etc. Newer languages incorporate significant functionalities of older languages which may serve as an “inspiration” for it while introducing new features and functionalities. However, the creation of newer programming languages does not necessarily mean the obsolescence of older languages because of factors such as programming effort, familiarity, and popularity. However, their usage for newer and upcoming applications may eventually decrease and familiarity and popularity might consequently fade away with it. In this paper, we take a look at 38 different programming languages that have been invented and identify the least used programming languages to provide an overall estimate of the least used programming languages in today’s time and the programming languages on the verge of death

Specification of the Procedural Programming Language

A simple procedural programming language is considered, each program of which can input integer values, process them and output new integer values as result. A program is a block with description of local integer variables and procedures and a list of statements. The language has data processing statements: assignment, input, output, conditional, loop, procedure call and block. Main purpose of the block is to enter local data (integer variables and procedures) that are used in the body of the block – a list of operators. The scope of the name of the local data described in the block is the text of the block except for nested blocks, where this name is redefined. A mechanism of automatic memory allocation for variables entered in the block is also associated with the block. Memory for local variables is allocated when entering a block, and freed when exiting a block. A block containing only a list of statements is valid. The procedure has a name, list of formal parameters, and a body – a statement (most often a block). Formal parameters are applied only in its body. A procedure is calculated by the procedure call statement, whose actual parameters are only variables. Parameters are passed by reference (pass-by-reference).A formal specification of a programming language is a description of its syntax and semantics. A concrete syntax, finite set of rules, singles out syntactically correct sequences of symbols of the alphabet of language. To describe the semantics of a language, as a rule, abstract syntax is used, adding contextual conditions to it. The task of semantics is to introduce the denotations (“meanings”) of the basic constructions of language and semantic functions that build the denotations of complex syntactic constructions based on the denotations of their components, including the program.The article provides a specification of a procedural programming language that uses the extended Backus-Naur form to describe a concrete syntax, and the tools of the functional language Haskell to describe other parts. Abstract syntax is defined by the types Program, Proc, Stmt, Expr and Op. Additional contextual conditions are predicates that use information about program data. Most of the context conditions are related to the correct use of data in the program. The leading predicate that checks the context conditions of the program pr is iswfProgram pr.The language denotations are based on the Work type. The value of this type – a tuple (inp, stg, out) models the environment in which the language program is executed: inp - input data, stg – memory containing variable values, out – resulting data. The semantics of main constructions procedure, statement and expression are functions of the type Work -> Work or Work -> Integer. The semantics of the program is a function of the type [Integer] -> [Integer]. Semantic functions build these denotations according to syntactic constructions, which are described by abstract syntax – Proc, Stmt, Expr, Program types. The semantics of the program (Program) pr is built by function iProgram pr.All functions: contextual conditions, denotations and semantic functions are pure functions. Using Haskell tools, a function called parsePLL is built, which connects concrete and abstract syntax. It is shown how by combining the functions parsePLL, iswfProgram and iProgram you can get a procedural language – a pure function with the name interpret.

Analysis of a column with variable, arbitrary shaped cross section, including initial imperfections, geometric and material nonlinearity

In this paper, we propose a general method for solving structural mechanics problems by developing a “functional model”. It is implemented by defining the required geometrical and physical relationships in their general form via analytical and numerical functions. For that purpose, a special programming language Calcpad is used. The obtained data structure is processed by a core engine, which generates the computer code, required for the solution. This model can be used for calculation of different partial cases, after specifying the specific input functions and parameters. In this way, the need for developing a different procedure for each separate case is eliminated. The proposed method is applied for the analysis of a column with variable, arbitrary shaped cross section, accounting for initial imperfections, geometric and material nonlinearity.

NewBee: Context-Free Grammar (CFG) of a New Programming Language for Novice Programmers

Learning programming and using programming languages are the essential aspects of computer science education. Students use programming languages to write their programs. These computer programs (students or practitioners written) make computers artificially intelligent and perform the tasks needed by the users. Without these programs, the computer may be visioned as a pointless machine. As the premise of writing programs is situated with specific programming languages, enormous efforts have been made to develop and create programming languages. However, each programming language is domain-specific and has its nuances, syntax and semantics, with specific pros and cons. These language-specific details, including syntax and semantics, are significant hurdles for novice programmers. Also, the instructors of introductory programming courses find these language specificities as the biggest hurdle in students learning, where more focus is on syntax than logic development and actual implementation of the program. Considering the conceptual difficulty of programming languages and novice students’ struggles with the language syntax, this paper describes the design and development of a Context-Free Grammar (CFG) of a programming language for the novice, newcomers and students who do not have computer science as their major. Due to its syntax proximity to daily conversations, this paper hypothesizes that this language will be easy to use and understand by novice programmers. This paper systematically designed the language by identifying themes from various existing programming languages (e.g., C, Python). Additionally, this paper surveyed computer science experts from industry and academia, where experts self-reported their satisfaction with the newly designed language. The results indicate that 93% of the experts reported satisfaction with the NewBee for novice, newcomer and non-Computer Science (CS) major students.