Procedural Programming Languages Research Articles

Access to struct members and undefined behavior of C code

During software development, novice developers usually receive a lot of error messages and just warnings of various kinds. And if the code simply won't run when there are errors, then the program usually starts when there are various warnings. And here it is important to understand what consequences the presence of warnings of various kinds can lead to. This work aims to study the code's undefined behavior when working with struc-tures in the C programming language when issuing a corresponding compiler warn-ing about returning the address of a local or temporary variable. In the procedural programming language C, there is an ancestor of the OOP class — the structure struct, which encapsulates only the state of the entity. And the question arises — is it possible to work with separate components-fields of such a structure analogously to OOP languages? For research, a simple structure was taken, which contains information about the person's name, surname, and phone number. To access parts of the structure, pseudogetters were used — functions that returned a pointer to the corresponding part of the structure. The research was conducted in the Visual Studio 2019 environment under the control of the Windows 10 operating system when the default C language standard - MSVC and the more modern ISO standard C17 (2018) was selected in the project settings. As a result, a truly undefined behavior of the code was obtained, when the re-sult of the work of the code fragment (function call) depends on many factors: the length of the array, the standard of the C language, the position of a certain part in the structure. An attempt to conduct similar research under the control of the Linux Mint oper-ating system using the gcc compiler version 5.4 was unsuccessful. When compiling the code, a similar warning about returning the address of a local variable was also issued, as in the case of Visual Studio. But when the program was launched, it sim-ply crashed with a message about a segmentation error. Thus, both the Visual Studio 2019 compiler and the gcc compiler warned us about undefined code behavior. But this uncertain behavior was radically different for operating systems and compilers. If after gcc under the Linux OS, the code simply does not work at all and the program stops its work with a segmentation error mes-sage, then after Visual Studio under Windows, inexperienced developers with im-proper testing and verification of the code can miss the code that "does not always work", which can lead to unexpected results, not always pleasant, to say the least. And that's why software developers, especially beginners, should pay attention not only to compilation errors but also to warnings, even if the code works.

Representation of the program model using predicates

The object of research in this article is the process of modeling programs and their subsequent development. The purpose of this article is to develop a methodology for describing and building software models in the form of nondeterministic finite automat. To achieve this goal, a task was set to improve the method for describing such models using predicates based on the MODEL CHECKING technology. The result of this article is a method for describing and presenting program models directly according to the chosen algorithm using predicates. If the program algorithm is chosen and described correctly, the resulting model should also be correct. The model will be a non-deterministic state machine that will not require further checking, as provided by the MODEL CHECKING technology. Structurally, the model will represent a special database, the processing of which will allow turning the model into a program in any procedural programming language. When developing parallel programs that are widely used for control in aviation, land transport, military affairs, etc., two additional states of the automaton are introduced into the model, which take into account the features of such programs. Therefore, a state monitor is provided for access to shared resources and a state protocol to process parallel branches of the program. To describe the algorithm of the program, we propose to present it in the form of a connected sequence of certain actions using predicates with the use of extended temporal logic. This description covers both the logic of the program and its branches and the specific actions at each location of the program model. With the help of this methodology, a program model of a stack algorithm was developed, which is the main component for the future automated system of processing the description of program models. The program which was created according to this technology, is currently in the testing and verification stage. The sequence of processing steps of such a model is shown in the example of a floating-point constant translation program. This program is also created using this technology in the target language assembly, has been fully tested, and has shown its functionality. This description covers both the logic of the program with its branches and the specific actions at each location of the application model. Conclusions: with a correct description of the program algorithm, an adequate model of it is built, with the help of which the program itself is created in the target procedural programming language. Note that in the conditions of the rapid development of management and control automation systems in various spheres of human activity, research on the creation of reliable based on the description of their models is an urgent problem.004.414.23:510.637

Accuracy Comparison of Data Mining Methods for Internet Gaming Disorder Classification

Excessive access to online games by players can lead to addiction. Online game addiction can be detected through various ways including self-report questionnaires. Based on the value of the answers in the questionnaire a person can be categorized into groups, mild addiction, moderate addiction and severe addiction. Generally, this assessment calculation is done manually or through procedural programming languages. This is not efficient for processing more and more data, for that the mechine learning classification model is applied to solve the problem of program code repetition. This study compared the performance of three mechine learning methods against two different types of questionnaires, namely questionnaires with Likert scale and questionnaires with yes no type. The case study used in this study is online game addiction among high school students in Banda Aceh City, Indonesia. This research successfully proved that the algorithm ... It is better to use questionnaires with data types...., while algorithms....are better to use for questionnaires with types.....with the accuracy of the three algorithms are as follows. This study reveals the emergence of online game addiction, especially among high school students within Banda Aceh city. The results depicted that as many as 6% of high school students in the city of Banda Aceh indicated experiencing online game addiction based on their reports. Another objective of this research is to find the best accuracy between Naive Bayes and Support vector machine (SVM) in classifying the severity of the online game. It found that SVM accuracy was higher than Naive Bayes for the case of online game addiction level classification in high school students in Banda Aceh. This study provided baseline data for further research.

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.

Features of the method of teaching the For loop in Python language in secondary school

Today, in many educational institutions, the study of the Python programming language is included in the informatics curriculum. Possessing indisputable advantages, which are noted by both research educators and practicing teachers, the Python language has a number of features that students should pay attention to in order to prevent mistakes that they may make in the future when switching to other programming languages. This also applies to the study of cyclic constructions, in particular the For loop. The implementation of the For loop in the Python language is fundamentally different from the implementation of the loop with a parameter used in procedural programming languages that were studied earlier in the school curriculum (BASIC, Pascal, C/C++, etc.). Today, we have a situation where the method of learning a loop with a parameter cannot be applied to the For loop of the Python language. The article is devoted to the methods of studying this cyclic construction.

MSEMT: An Advanced Modelica Library for Power System Electromagnetic Transient Studies

Electromagnetic Transient (EMT) simulation tools are typically developed using conventional procedural programming languages. On the other hand, modern high-level and equation-based programming languages, such as Modelica, are currently available. Modelica allows formulating models that are easy to develop, maintain and understand by expressing what needs to be computed without stating how it should be computed. This paper presents a Modelica-based simulator for electromagnetic transients. It is demonstrated that this approach offers significant advantages for developing sophisticated models. Computational performance and accuracy are compared to a conventional EMT-type simulation tool.

Creating a General-Purpose Procedural Language for Programming in Kannada

Abstract: To build a general-purpose procedural programming language in Kannada and the corresponding header file that understands the language and pre-processes the code typed in Kannada into C++ programming language which can then be compiled by a C++ compiler and produce corresponding output in Kannada. The entire compilation of the language will be built in a single and Integrated Development Environment (IDE) i.e. Microsoft Visual Studio which can be downloaded by anyone and start learning to code in Kannada by including the header file. Any programming logic can be typed entirely in Kannada, the syntax is created such that it is similar to C-syntax. Any person knowing Kannada and with little effort on understanding the language’s syntax can start coding in Kannada without any prior knowledge in English or programming. This paper aims mainly at providing its users a programming experience in a regional language “Kannada”. The users can edit, complier and thus observe the results also in Kannada. The user has to abide by a set of syntactic rules and thus program accordingly for better results.

������� ����� � ������� ����� ��������� ����� ��������

The article considers the method for describing program modeling where predicates are used to create a model in the form of a nondeterministic finite automaton. A format of the description of predicates with the division of their semantic and conditional parts is offered in the paper. Arithmetic operators, parentheses, standard functions, as well as temporal logic operators U and N should be used to describe the content of the predicate. For the logical part of predicates, in addition to their logical functions, it is proposed to use relation operations, arithmetic operators, parentheses and standard functions. The formation of the description of each state of the pro-gram automaton model should be completed by dividing into different branches of the model. To describe the models of parallel programs, the following special states have been introduced: a state-monitor for the access of various processes to shared resources and a state-protocol for the description of independent parallel branches. The model is created in the process of its de-scription, so it does not require further verification. If the description of the model is performed correctly and the optimal algorithm of the future program is selected, such model will fully cor-respond to its description. Unlike MODEL CHECKING technology, which requires verification, it eliminates the need for model verification. The graph of the obtained model is processed by its sequential traversal on all branches with returns to the previous states and subsequent soft-ware implementation. Consecutive traversing should be performed for each branch of the model either to its final state or to the state that has already been processed during the traversal. Model processing includes transmission of the model description into an internal representation for subsequent conversion into a program in the target procedural programming language. In this case all actions in the substantive parts of the predicates, as well as the conditions of the branches in the process of transmission are converted into an internal representation of the pro-gram. This technology provides a direct conversion of the description of the program model in-to the program itself.

The Design and Construction of an Ecosystem Simulation Workbench

Efforts to study ecosystems have been carried out by humans since ancient times in various ways or approaches. The approach of using a computer model and simulation nowadays is one of the increasingly possible alternatives, especially with the rapid advancement of information and communication technology. There are several ways to build computer models of an ecosystem to be used in simulations. Composite modeling is one method that can be used where several computer programs (main, sub-routines, functions, sub-programs) written using a procedural programming language, which as a whole are integrated into one final program that can be run on a computer. The approach in this research is different from what was explained earlier. Composite models are still used but each component of the model is kept separate which is not combined into one module when the simulation process of the ecosystem model is formed. Each module remains separate but will operate side by side and communicate with one another through an auxiliary module to allow conditions to work (Molenaar, 1998). This research was conducted to make a prototype of a composite computer simulation infrastructure model of an ecosystem. The outputs of this research proved that the approach seemed working well and able to be used as computer simulation infrastructure in studying various existing system start your abstract here.

Development of Procedural-Parametric Paradigm in the Language GO

The article presents a programming paradigm that defines a new style of program development called procedural-parametric programming (PPP). The paradigm is based on parametric polymorphism, which allows the procedures to accept and process variant data types without the algorithmic choice of alternatives within these procedures. In procedural programming languages, such types are described by unions (union in C, C++) or variant entries (in Pascal). Algorithmic processing of variants is carried out by means of conditional operators or switches. This approach is a development of procedural programming methods and acts as an alternative to object-oriented programming. The procedural-parametric paradigm of programming is an extension of the procedural approach. It makes possible to increase the capabilities of the latter by supporting data polymorphism. The application of the proposed approach will allow to increase the functional capabilities of the procedures without making any internal algorithmic changes. Procedural-parametric programming can be used both independently and in combination with other programming paradigms

Automatic Design and Optimization of Column Sequences and Column Stacking Using a Process Simulation Automation Server

Simulation–optimization is applied to determine nearly optimal process designs in column sequencing and stacking problems using a simulated annealing algorithm (SAA) in the client (MATLAB) and a single distillation column in the server (Aspen Plus). Each column in every sequence is optimized separately, and the total cost of each sequence is calculated. This method benefits from both the rigor of column modeling in a process simulator and the flexibility of implementing sequential procedures and derivative-free optimization in a procedural programming language. Using this method, a single column can be optimized within 6 min of computer time. Furthermore, when stacking rules and available utilities are specified, a nearly optimal heat-integrated distillation column sequence can be designed automatically. Results are illustrated using two case studies of column sequencing problems.

A methodology to infer and refactor an object‐oriented model from C applications

SummaryWhen analyzing legacy code, generating a high‐level model of an application during the reverse engineering process helps the developers understand how the application is structured and how the dependencies relate the different software entities. Within the context of procedural programming languages (such as C), the existing approaches to get a model of the code require documentation and/or implicit knowledge that stakeholders acquire during the software building. These approaches use the code itself to build a syntactic model where we see the different software artifacts, such as variables, functions, and modules. However, there is no supporting methodology to detect and analyze if there are relationships/dependencies between those artifacts, such as which variable in a module is declared using an abstract data type described in another one, or which are the functions that are using parameters typed with an abstract data type; or any design decision taken by original developers, such as how the developer has implemented functions in different modules. On the other hand, current developers use object‐oriented (OO) paradigm to implement not only business applications but also useful methodologies/tools that allow semiautomatic analysis of any application. We must remark the legacy procedural code still has worth and is working in several industries, and as any evolving code, the developers have to be able to perform maintenance tasks minimizing the limitations offered by the language. Based on useful properties that the OO paradigm (and their supporting analysis tools) provide, such as UML models, we propose M2K as a methodology to generate a high‐level model from legacy procedural code, mainly written in Ansi C. To understand how C‐based applications were implemented is not a new problem in software reengineering. However, our contribution is based on building an OO model and suggesting different refactorings that help the developer to improve it and to eventually guide a new implementation of the target application. Specifically, the methodology builds cohesive software entities mapped from procedural code and makes the coupling between C entities explicit in the high‐level model. The result of our methodology is a set of refactored class candidates: a structure that groups a set of variables and a set of functions obtained from the C applications. Based on the class candidate model, we propose refactorings based on OO design principles to improve the design of the application. The most relevant design improvements were obtained with algorithm abstraction by applying the strategy pattern, attributes/methods relocalization, variables types generalization, and removing/renaming methods/attributes. Besides a methodology and the supporting tool, we provide 14 case studies based on real projects implemented in C, and we showed how the results validate our proposal.

Integrated design of ORC process and working fluid using PC-SAFT and Modelica

Organic Rankine Cycles (ORC) use low-temperature heat to generate electrical power. To use the full potential of a heat source, the ORC has to be tailored to the specific application. Tailoring a cycle means an integrated design of both process and working fluid. This integrated design leads to complex mixed-integer nonlinear program (MINLP) optimization problems. To avoid this complexity, working fluid candidates are commonly preselected using heuristic guidelines; subsequently, the process is optimized for the set of preselected working fluids. However, the preselection can fail, leading to suboptimal solutions.An approach for integrated design of ORC process and working fluid is the Continuous-Molecular Targeting–Computer-aided Molecular Design (CoMT-CAMD) approach. CoMT-CAMD employs the physically-based Perturbed-chain Statistical Associating Fluid Theory (PC-SAFT) equation of state as thermodynamic model of the working fluid. In PC-SAFT, each working fluid is described by a set of pure component parameters. In a first step, the so-called CoMT step, the discrete pure component parameters are relaxed resulting in a hypothetical optimal working fluid and the corresponding optimal process. In a second step, real working fluids with similar properties are identified using Computer-aided Molecular Design and a second-order Taylor approximation of the objective function around the hypothetical optimum. So far, the process models in CoMT-CAMD were implemented in a procedural programming language, which hinders the reusability, the use for more complex processes and dynamic simulations.In this work, we integrate CoMT-CAMD into the object-oriented modelling language Modelica. For this purpose, Modelica is directly linked to PC-SAFT. Thereby, already existing model libraries for Modelica can be used to model the ORC process. The resulting design approach is applied to the integrated design of an ORC process and working fluid for a geothermal power station.

Is cloned code really stable?

Clone has emerged as a controversial term in software engineering research and practice. The impact of clones is of great importance from software maintenance perspectives. Stability is a well investigated term in assessing the impacts of clones on software maintenance. If code clones appear to exhibit a higher instability (i.e., higher change-proneness) than non-cloned code, then we can expect that code clones require higher maintenance effort and cost than non-cloned code. A number of studies have been done on the comparative stability of cloned and non-cloned code. However, these studies could not come to a consensus. While some studies show that code clones are more stable than non-cloned code, the other studies provide empirical evidence of higher instability of code clones. The possible reasons behind these contradictory findings are that different studies investigated different aspects of stability using different clone detection tools on different subject systems using different experimental setups. Also, the subject systems were not of wide varieties. Emphasizing these issues (with several others mentioned in the motivation) we have conducted a comprehensive empirical study where we have - (i) implemented and investigated seven existing methodologies that explored different aspects of stability, (ii) used two clone detection tools (NiCad and CCFinderX) to implement each of these seven methodologies, and (iii) investigated the stability of three types (Type-1, Type-2, Type-3) of clones. Our investigation on 12 diverse subject systems covering three programming languages (Java, C, C#) with a list of 8 stability assessment metrics suggest that (i) cloned code is often more unstable (change-prone) than non-cloned code in the maintenance phase, (ii) both Type 1 and Type 3 clones appear to exhibit higher instability than Type 2 clones, (iii) clones in Java and C programming languages are more change-prone than the clones in C#, and (iv) changes to the clones in procedural programming languages seem to be more dispersed than the changes to the clones in object oriented languages. We also systematically replicated the original studies with their original settings and found mostly equivalent results as of the original studies. We believe that our findings are important for prioritizing code clones from management perspectives.

A formalization of programs in first-order logic with a discrete linear order

We consider the problem of representing and reasoning about computer programs, and propose a translation from a core procedural iterative programming language to first-order logic with quantification over the domain of natural numbers that includes the usual successor function and the “less than” linear order, essentially a first-order logic with a discrete linear order. Unlike Hoare's logic, our approach does not rely on loop invariants. Unlike the typical temporal logic specification of a program, our translation does not require a transition system model of the program, and is compositional on the structures of the program. Some non-trivial examples are given to show the effectiveness of our translation for proving properties of programs.

Simulation Methods of Computer Networks

A computer network can be considered as a system of mass service, in which as applications are moved information frames. Receiving the information frame, working station may use the received data for transfer to the end user. The resulting information frame is the same portion of data or signal, which is necessary for the organization distributed computing.The article describes the methods of simulation processes for transfer data in computer networks, methods of traffic analysis computer network and the procedure of selection of the optimal configuration topology computer network for the distributed computing.Considered modeling techniques can be used when building a computer network models using specialized software, or they can be implemented as a program, written in procedural or object-oriented programming language.

Simulation methods of computer networks

A computer network can be considered as a system of mass service, in which as applications are moved information frames. Receiving the information frame, working station may use the received data for transfer to the end user. The resulting information frame is the same portion of data or signal, which is necessary for the organization distributed computing. The article describes the methods of simulation processes for transfer data in computer networks, methods of traffic analysis computer network and the procedure of selection of the optimal configuration topology computer network for the distributed computing. Considered modeling techniques can be used when building a computer network models using specialized software, or they can be implemented as a program, written in procedural or object-oriented programming language.

A Survey of Object Oriented JavaScript Language

Many of the programmers move towards object oriented programming languages due to its reusability nature, whereas in procedural programming languages reusability is not allowed, which may contribute to the high cost of development. Most of web browsers make use of JavaScript as a user interactive program that is a client side program due to its active nature. In the client side programming it is practiced to enable user interaction, control browser activities and alters the content changes made by user dynamically. On the server side programming language, it is used for desktop and mobile application growth. JavaScript is mainly applied for maturation of object oriented web application development because of its supportability of inheritance via prototyping and also properties and methods. In this work the various object oriented concepts are discussed. The methods and operation supported by the object oriented JavaScript language is likewise talked about. Its nature of operating methods, type refinement of JavaScript language, various access control mechanisms over JavaScript language is discussed. The enabling of transaction control over JavaScript language is also elaborated.

POUŽITÍ GENETICKÝCH ALGORITMŮ PRO ANALÝZU NÁVŠTĚVNOSTI WWW PORTÁLU

The article proposes a new method suitable for advanced analysis of web portal visits. This is part of retrieving information and knowledge from web usage data (web usage mining). Such information is necessary in order to gain better insight into visitor’s needs and generally consumer behaviour. By le­ve­ra­ging this information a company can optimize the organization of its internet presentations and offer a better end-user experience. The proposed approach is using Grammatical evolution which is computational method based on genetic algorithms. Grammatical evolution is using a context-free grammar in order to generate the solution in arbitrary reusable form. This allows us to describe visitors’ behaviour in different manners depending on desired further processing. In this article we use description with a procedural programming language. Web server access log files are used as source data.The extraction of behaviour patterns can currently be solved using statistical analysis – specifically sequential analysis based methods. Our objective is to develop an alternative algorithm.The article further describes the basic algorithms of two-level grammatical evolution; this involves basic Grammatical Evolution and Differential Evolution, which forms the second phase of the computation. Grammatical evolution is used to generate the basic structure of the solution – in form of a part of application code. Differential evolution is used to find optimal parameters for this solution – the specific pages visited by a random visitor. The grammar used to conduct experiments is described along with explanations of the links to the actual implementation of the algorithm. Furthermore the fitness function is described and reasons which yield to its’ current shape. Finally the process of analyzing and filtering the raw input data is described as it is vital part in obtaining reasonable results.

A domain-specific language for building self-optimizing AST interpreters

Self-optimizing AST interpreters dynamically adapt to the provided input for faster execution. This adaptation includes initial tests of the input, changes to AST nodes, and insertion of guards that ensure assumptions still hold. Such specialization and speculation is essential for the performance of dynamic programming languages such as JavaScript. In traditional procedural and objectoriented programming languages it can be tedious to write selfoptimizing AST interpreters, as those languages fail to provide constructs that would specifically support that. This paper introduces a declarative domain-specific language (DSL) that greatly simplifies writing self-optimizing AST interpreters. The DSL supports specialization of operations based on types of the input and other properties. It can then use these specializations directly or chain them to represent the operation with the minimum amount of code possible. The DSL significantly reduces the complexity of expressing specializations for those interpreters. We use it in our high-performance implementation of JavaScript, where 274 language operations have an average of about 4 and a maximum of 190 specializations. In addition, the DSL is used in implementations of Ruby, Python, R, and Smalltalk.