Programming Language Elements Research Articles

BIOPLAG: An Approach to Detect Programming Plagiarism.

This paper creates an approach to the automatic detection of plagiarism in programming by combining the interdisciplinary knowledge from bioinformatics with techniques such as: tokens of programming language elements, tokens mapping in synthetic biological sequence, and alignment of biological sequences. This solution, named BIOPLAG, contemplates different levels of modifications in source code, and its functioning depends on concepts of computer science as well. Through the realization of three experiments with students and programmers, a total of 168 real examples of plagiarism evaluated the implementation of BIOPLAG with the usage of 336 source codes in C language divided into seven scenarios. The evaluation process compared to other tools known as references in the literature: MOSS and JPLAG. The evaluative metrics used are precision, recall, and fmeasure. As a result, BIOPLAG showed to be the best in four and equal in three out of seven test scenarios. Its average score on the metrics in the evaluation process was 0.95 against MOSS with 0.83 and JPAG with 0.87.

Predicting unstable software benchmarks using static source code features

Software benchmarks are only as good as the performance measurements they yield. Unstable benchmarks show high variability among repeated measurements, which causes uncertainty about the actual performance and complicates reliable change assessment. However, if a benchmark is stable or unstable only becomes evident after it has been executed and its results are available. In this paper, we introduce a machine-learning-based approach to predict a benchmark’s stability without having to execute it. Our approach relies on 58 statically-computed source code features, extracted for benchmark code and code called by a benchmark, related to (1) meta information, e.g., lines of code (LOC), (2) programming language elements, e.g., conditionals or loops, and (3) potentially performance-impacting standard library calls, e.g., file and network input/output (I/O). To assess our approach’s effectiveness, we perform a large-scale experiment on 4,461 Go benchmarks coming from 230 open-source software (OSS) projects. First, we assess the prediction performance of our machine learning models using 11 binary classification algorithms. We find that Random Forest performs best with good prediction performance from 0.79 to 0.90, and 0.43 to 0.68, in terms of AUC and MCC, respectively. Second, we perform feature importance analyses for individual features and feature categories. We find that 7 features related to meta-information, slice usage, nested loops, and synchronization application programming interfaces (APIs) are individually important for good predictions; and that the combination of all features of the called source code is paramount for our model, while the combination of features of the benchmark itself is less important. Our results show that although benchmark stability is affected by more than just the source code, we can effectively utilize machine learning models to predict whether a benchmark will be stable or not ahead of execution. This enables spending precious testing time on reliable benchmarks, supporting developers to identify unstable benchmarks during development, allowing unstable benchmarks to be repeated more often, estimating stability in scenarios where repeated benchmark execution is infeasible or impossible, and warning developers if new benchmarks or existing benchmarks executed in new environments will be unstable.

Implementing the template method pattern in genetic programming for improved time series prediction

Modularity is an ongoing focus in genetic programming research. Enhanced modularity can accelerate solution convergence and increase human understanding and knowledge gained from evolved programs. Prior advances in modularity research have addressed programming language elements such as functions, modules, and recursion. This paper proposes improving modularity by considering non-language elements, specifically software design patterns. A new genetic programming technique implementing the template method pattern is described. This technique was tested and compared to existing genetic programming approaches in the prediction of nonlinear time series subject to abrupt changes in the underlying data generation process. Such series are often seen in areas such as finance and meteorology and have proved challenging for genetic programming to model and predict. Experimental results demonstrate the potential for incorporating additional software design patterns into genetic programming and applying these techniques to additional problem domains.

A Syntax and Semantics of a Language for Operational Procedures

The aim of this paper is to present shortly syntax and semantics of a language to program operational procedures. This formal language is a unified suite of symbols, meanings, and codes used on the basis of conventional rules. Symbols have to be related to meanings and to be shared: operational, mathematical, and graphical symbols shown are preferred but are not mandatory. Parise program allows to express concepts and procedures, to make analysis of formal connections and bonds between components of the electrical power system. It allows to provide information and give instructions for the execution of certain operations following correct procedures. The programming language elements may be used in an interactive programming environment.

Programming language elements for correctness proofs

Formal methods are not used widely in industrial software development, because the overhead of formally proving program properties is generally not acceptable. In this paper we present an ongoing r...

Evaluation of subsetting programming language elements in a novice's programming environment

In this paper, we evaluate the effects of applying programming language subsets to the programming environment used by novice (CS1) students in a closed-laboratory setting, as well as reducing the complexity of the user interface for the environment. Our goal in this effort was to assess if such interface and application-level changes adversely impact the student or hinder the later migration to a traditional professional-strength programming environment.We focus on the comparison of the quantitative data captured from the closed-laboratory sessions (assignment grades, number of syntax / semantic errors, and the number of compilation / execution attempts) involving subjects that used a new programming environment featuring a less complex interface in two forms: one lacking support of language subsets, and one supporting the application of language subsets.We found that while using the environment supporting the application of language subsets, there was no difference in the compilation-attempt rate, the number of errors did not increase, and student grades were equivalent between the experiment groups. Additionally, following a migration to the professional environment from the simplified environment, student grades were equivalent to those that had used the professional environment throughout the experiment. Student reaction to the experimental environment was very positive, especially related to the removal of unused tools and project management features.

A safe variant of the unsafe integer arithmetic of Java™

AbstractComputers are finite machines and, therefore, the arithmetic operations in a programming language are different from their mathematical counterparts. These restrictions seem not to have been, in general, fully appreciated in programming languages and in computer science textbooks. One example is the programming language Java, which makes it difficult to warn the user in cases in which arithmetic operations produce incorrect results. In this paper we look at integer arithmetic in Java and develop a safe variant of the arithmetic operations in Java. The design of the safe variant of $+$, $-_{\rm un}$, $-_{\rm bin}$, $*$, $/$ and $**$ for the types byte, short, int and long reveals a number of deficiencies of Java in integer arithmetic, floating point arithmetic and program structure. Some of these deficiencies are also present in other contemporary programming languages. The paper therefore ends with some proposals for the design of the arithmetic elements of programming languages. Copyright © 2002 John Wiley & Sons, Ltd.

Adventures in PASCAL—the academy approach

A new curriculum was designed for the computer science major at the Air Force Academy with the initial majors course being Elements of Programming Languages (CS359). The course consists of four major blocks: detailed concepts of PASCAL; examination of elements of programming languages; examination of FORTRAN77 and COBOL; and student comparative reports on other contemporary languages. The initial block about PASCAL in this course is unique in concept and approach; and is the focus of this paper. The underlying basis for the approach taken is that PASCAL is an extremely small language; therefore, very easy to master. Once a student has mastered a programming language it is easy to compare other languages against the 'mastered' language. Also, it is much easier for the student to learn new programming languages once one is mastered. The approach we used in this course is what makes it fairly unique.

Relations as programming language elements

Relations as programming language elements