Syntax Of Programming Language Research Articles

Expanding the Scope of Statistical Computing: Training Statisticians to Be Software Engineers

Traditionally, statistical computing courses have taught the syntax of a particular programming language or specific statistical computation methods. Since Nolan and Temple Lang’s seminal paper, we have seen a greater emphasis on data wrangling, reproducible research, and visualization. This shift better prepares students for careers working with complex datasets and producing analyses for multiple audiences. But, we argue, statisticians are now often called upon to develop statistical software, not just analyses, such as R packages implementing new analysis methods or machine learning systems integrated into commercial products. This demands different skills. We describe a graduate course that we developed to meet this need by focusing on four themes: programming practices, software design, important algorithms and data structures, and essential tools and methods. Through code review and revision, and a semester-long software project, students practice all the skills of software engineering. The course allows students to expand their understanding of computing as applied to statistical problems while building expertise in the kind of software development that is increasingly the province of the working statistician. We see this as a model for the future evolution of the computing curriculum in statistics and data science.

Development of FRIMAN – Supporting Tool for Object Oriented Programming Teaching

Abstract The main goal of this contribution is to present the current developmental state of FRIMAN – the graphical development environment designed to support the teaching process of the object-oriented paradigm. FRIMAN project has two main purposes: 1. simplifying the understanding of the basics of the object-oriented programming for JAVA language beginners, 2. teaching students of applied informatics to collaborate in bigger project development. Therefore, an application called FRIMAN has been developed at the Faculty of Management Science and Informatics at the University of Žilina. This project is developed by students of Master degrees under the leaderships of experienced software developers. The suggested system consists of several modules. In this paper, we focus on the description of selected modules and their current functionality as well as description of future plans for this project and brief description of FRIMAN development process. Attention is paid to a module for class management and a graphical code editor, which enables the creation of method bodies using flow diagrams without the necessity of programming language syntax knowledge. Based on good evaluation by the development team preparing changes in the high school education process, the current application is planned to be applied in practice.

Pedagogy of teaching introductory text‐based programming in terms of computational thinking concepts and practices

AbstractIntroductionProgramming can be an intellectually satisfying skill and is definitely considered useful. However, problem‐solving with a computer involves much more than just learning programming language syntax. The theory and practice are interrelated in fascinating ways. Whether one thinks that the purpose of college or higher education is to prepare students for an occupation or to develop foundational knowledge with lifetime benefits (or both), computer science (CS) has become a fundamental part of 21st‐century life. Even students studying in areas other than CS are likely to have significant encounters with computational thinking (CT) later on in life.Motivation and ObjectivesColleges and universities offer the opportunity for students to take as many courses as they desire in coding, programming, and CS taught by faculty members from that discipline area. However, this approach alone is deemed insufficient for computer‐based problem‐solving and computer programming. Effective programming teaching pedagogy also requires organizational principles that can guide us in formulating the overall design of a programming science curriculum (CS). In particular, we need strategies that help us structure multiple paradigm‐based teaching curricula into manageable modules. This study aims to develop a framework for programming pedagogy.Research Methodology and MethodsA systematic literature review was conducted for identifying, evaluating, and interpreting relevant research to explore programming paradigms that could be incorporated for novice programmers, possible implementation strategies, and instructional methods for teaching text‐based programming, CT concepts, and practices.Results and FindingsThis paper's focus was on the pedagogical phenomenon of teaching programming considering the evolving paradigms, implementation strategies, and instructional methods and techniques through the lens of CT. Hence, a framework to design a learning path for pedagogical approaches that consist of CT concepts and practices within text‐based programming were proposed. The proposed framework is based on the assumption that “any ongoing research on computing pedagogy requires a review of what CT is, how it impacts on teaching and learning and its role within the pedagogy advocated.” The programming pedagogy framework consists of four fundamental components: programming paradigm, implementation strategy, instructional methods, and instructional techniques.

Automation of calculation of technical and operational parameters of a railway cargo terminal

Research is the automation of decision-making on the justification of the type of unloading section of the terminal for single-piece cargo — external or internal input of the railway track is rational according to the criterion of minimum total costs. The relevance of the research topic is associated with the widespread solution of this type of business problems in the modern conditions of the transport and warehouse market. Cargo terminals connect modes of transport and transform cargo flows, which determines both the key position of cargo terminals in modern supply chains, and the complexity of tasks to be solved in their design. For operational management of transport and logistics processes, it is necessary to quickly make business decisions, which can be provided by software implementation of a number of settlement procedures.Used dynamic and linear programming, syntax and tools of the Pascal ABC programming language, analytical, marketing, and project methods; materials of general access and official sites, own research.A software product for automating the calculation of technical and operational parameters of a railway cargo terminal is described. The program allows you to calculate a set of technical and economic parameters of the cargo terminal operation, in particular, the size of the annual car traffic, the required length of the railway unloading section, as well as annual operating (production) costs and capital costs for the construction of the car unloading section by options.The software product can be useful both in the educational process of secondary and higher education, and in practical business when making business decisions on planning the operation of a cargo terminal.

Exploring college students’ conceptions of learning computer science: a draw-a-picture technique study

ABSTRACT Background and context Researchers have been looking into the complexity of computer science (CS) education and tried to apply rigorous and relevant educational research methods to understand and facilitate the learning experience of students. Objective The purpose of this study was to explore college students’ conceptions of learning CS to shed light on student learning activities, feelings, contexts, and beliefs about their learning. Method Draw-a-picture technique was used as an emerging research technique in CS education. Using a modified coding checklist, we analyzed the drawings into 9 categories with 50 sub-categories. Findings College students most frequently expressed computer programming as the learning activity by illustrating syntax and semantics of programming languages in the drawings. Problem-solving constructs like decomposition and abstraction were also recorded along with other tools like diagramming techniques. Gender and prior computer science experience were analyzed as moderators. Implications The results provide a baseline for future research on the topic and preliminary evidence in using the method to discern student learning conceptions in CS.

Exploring the intersection of algebraic and computational thinking

ABSTRACT This article investigates how the recent implementation of programming in school mathematics interacts with algebraic thinking and learning. Based on Duval’s theory of semiotic representations, we analyze in what ways syntax and semantics of programming languages are aligned with or divert from corresponding algebraic symbolism. Three examples of programming activities suggested for school mathematics are discussed in detail. We argue that although the semiotic representations of programming languages are similar to algebraic notation the meanings of several concepts in these two domains differ. In a learning perspective these differences must be taken into account, especially considering that students have to convert between registers with both overlapping and specific meanings.

ANALYSIS OF MECHANISMS AND EFFICIENCY OF SPECIALIZED LANGUAGES OF FUNCTIONAL PROGRAMMING

Purpose. The authors aim to determine the differences between functional programming languages, to identify the capabilities of the most popular languages by comparing and analyzing them. To identify the main features, it is necessary to consider their data structures, as well as the application scope. The authors also aim to analyze and compare examples from various fields of language application using metrics of the program texts complexity. Methodology. The five most popular specialized functional languages are selected: Erlang, Lisp, F #, Scala and Haskel. An overview of the official documentation was conducted to obtain information on the capabilities of each language; their data structures and the application scope were studied. The experimental research base is formed from texts of the existing open source software systems and matched by similar applications and equal volume of text. Comparative analysis of sample programs is performed using Halsted metrics, which are calculated using specially designed software. The analysis of the received quality assessments is done graphically. Findings. Software has been developed to obtain Halsted metrics for program input texts in functional programming languages such as Erlang, Lisp, F # and Scala. The complexity of the Haskel programming language syntax did not allow the use of metrics to evaluate the text, so only a documentation review was performed. Benchmarking shows the differences between languages and outlines their use. The examples of different volumes from such areas of application as system programming tasks, graphing, mathematical calculations, AI systems, web programming, etc. were compared. Originality. The authors first conducted a comparative analysis of specialized languages using text complexity metrics, which made it possible to establish that Lisp has the smallest vocabulary and code length, Scala text has the most structured form, and F # and Erlang are marked with extra verbosity. Practical value. The findings and measurements will help in selecting the most effective functional programming language for solving specific problems, taking into account differences in applications. The developed software allows making measurements for various program texts when developing and maintaining complex software systems.

Deep Reinforcement Learning for Syntactic Error Repair in Student Programs

Novice programmers often struggle with the formal syntax of programming languages. In the traditional classroom setting, they can make progress with the help of real time feedback from their instructors which is often impossible to get in the massive open online course (MOOC) setting. Syntactic error repair techniques have huge potential to assist them at scale. Towards this, we design a novel programming language correction framework amenable to reinforcement learning. The framework allows an agent to mimic human actions for text navigation and editing. We demonstrate that the agent can be trained through self-exploration directly from the raw input, that is, program text itself, without either supervision or any prior knowledge of the formal syntax of the programming language. We evaluate our technique on a publicly available dataset containing 6975 erroneous C programs with typographic errors, written by students during an introductory programming course. Our technique fixes 1699 (24.4%) programs completely and 1310 (18.8%) program partially, outperforming DeepFix, a state-of-the-art syntactic error repair technique, which uses a fully supervised neural machine translation approach.

A Systematic Literature Review on Teaching and Learning Introductory Programming in Higher Education

Contribution: This paper adds to the results of previous systematic literature reviews by addressing a more contemporary context of introductory programming. It proposes a categorization of introductory programming challenges, and highlights key issues for a research roadmap on introductory programming learning and teaching in higher education. Background: Despite the advances in methods and tools for teaching and learning introductory programming, dropout and failure rates are still high. Published surveys and reviews either cover papers only up to 2007, or focus on methods and tools for teaching introductory programming. Research Questions: 1) What previous skills and background knowledge are key for a novice student to learn programming? 2) What difficulties do novice students encounter in learning how to program? 3) What challenges do teachers encounter in teaching introductory programming? Methodology: Following a formal protocol, automatic and manual searches were performed for work from 2010 to 2016. Of 100 papers selected for data extraction, 89 were retained after quality assessment. Findings: The most frequently cited skills necessary for learning programming were related to problem solving and mathematical ability. Problem solving was also cited as a learning challenge, followed by motivation and engagement, and difficulties in learning the syntax of programming languages. The main teaching challenges concern the lack of appropriate methods and tools, as well as scaling and personalized teaching.

Multi-objective search-based software modularization: structural and non-structural features

Software modularization techniques are employed to understand a software system. The purpose of modularization is to decompose a software system from a source code into meaningful and understandable subsystems (modules). Since modularization of a software system is an NP-hard problem, the modularization quality obtained using evolutionary algorithms is more reasonable than greedy algorithms. All evolutionary algorithms presented for software modularization only consider structural features that are dependent on the syntax of programming languages. For most programming languages, does not exist a tool to extract structural features, so it is not possible to modularize them. To overcome this problem, this paper presents a new multi-objective fitness function, named MOF, which exploits the structural (such as calling dependency and inheritance dependency) and non-structural features (such as semantic contained in the code comments and identifier names), aiming to automatically guide optimization algorithms to find a good decomposition of software systems. To evaluate the performance of this objective function, three optimization strategies, namely global-based search, combining global and local search, and Estimation of Distribution (EoD), are adapted to optimize it. The results on Mozilla Firefox indicate that the proposed algorithm which is based on EoD along with the new MOF function outperforms the algorithms that use structural-based objective functions in guiding the optimization process, in finding more understandable modules.

Bridging Theory and Practice in Programming Lectures With Active Classroom Programmer

Contribution: Active classroom programmer (ACP) is a software tool that places minimal pressure on resources, and is shown to help improve student learning while also encouraging a high degree of engagement both during and outside of programming lectures. Background: Programming is difficult for students, largely due to the myriad of ever-advancing concepts. As students gradually become stronger programmers, both within a course and within their degree, they are constantly presented with new and challenging programming concepts regardless of their expertise. While laboratory sessions provide an excellent opportunity for students to independently practice, this does not help them in the programming process where expert scaffolding is desired. Intended outcomes: ACP is intended to engage students with active programming exercises and develop an inductive approach to learning, focusing on developing problem-solving skills. Application design: Students need guidance in the programming strategy rather than the syntax and peculiarities of the particular programming language. ACP allows students to program alongside instructors as new concepts are introduced. Findings: Experience from two concept-rich programming courses at different levels is presented, demonstrating students engaged with ACP both inside and outside lectures to deepen their understanding of the programming concepts.

Merlin: a language server for OCaml (experience report)

We report on the experience of developing Merlin, a language server for the OCaml programming language in development since 2013. Merlin is a daemon that connects to your favourite text editor and provides services that require a fine-grained understanding of the programming language syntax and static semantics: instant feedback on warnings and errors, autocompletion, "type of the code under the cursor", "go to definition", etc. Language servers need to handle incomplete and partially-incorrect programs, and try to be incremental to minimize recomputation after small editing actions. Merlin was built by carefully adapting the existing tools (the OCamllex lexer and Menhir parser generators) to better support incrementality, incompleteness and error handling. These extensions are elegant and general, as demonstrated by the interesting, unplanned uses that the OCaml community found for them. They could be adapted to other frontends -- in any language. Besides incrementality, we discuss the way Merlin communicates with editors, describe the design decisions that went into some demanding features and report on some of the non-apparent difficulties in building good editor support, emerging from expressive programming languages or frustrating tooling ecosystems. We expect this experience report to be of interest to authors of interactive language tooling for any programming language; many design choices may be reused, and some hard-won lessons can serve as warnings.

Towards Zero-Overhead Disambiguation of Deep Priority Conflicts

**Context** Context-free grammars are widely used for language prototyping and implementation. They allow formalizing the syntax of domain-specific or general-purpose programming languages concisely and declaratively. However, the natural and concise way of writing a context-free grammar is often ambiguous. Therefore, grammar formalisms support extensions in the form of *declarative disambiguation rules* to specify operator precedence and associativity, solving ambiguities that are caused by the subset of the grammar that corresponds to expressions. **Inquiry** Implementing support for declarative disambiguation within a parser typically comes with one or more of the following limitations in practice: a lack of parsing performance, or a lack of modularity (i.e., disallowing the composition of grammar fragments of potentially different languages). The latter subject is generally addressed by scannerless generalized parsers. We aim to equip scannerless generalized parsers with novel disambiguation methods that are inherently performant, without compromising the concerns of modularity and language composition. **Approach** In this paper, we present a novel low-overhead implementation technique for disambiguating deep associativity and priority conflicts in scannerless generalized parsers with lightweight data-dependency. **Knowledge** Ambiguities with respect to operator precedence and associativity arise from combining the various operators of a language. While *shallow conflicts* can be resolved efficiently by one-level tree patterns, *deep conflicts* require more elaborate techniques, because they can occur arbitrarily nested in a tree. Current state-of-the-art approaches to solving deep priority conflicts come with a severe performance overhead. **Grounding** We evaluated our new approach against state-of-the-art declarative disambiguation mechanisms. By parsing a corpus of popular open-source repositories written in Java and OCaml, we found that our approach yields speedups of up to 1.73x over a grammar rewriting technique when parsing programs with deep priority conflicts--with a modest overhead of 1-2 % when parsing programs without deep conflicts. **Importance** A recent empirical study shows that deep priority conflicts are indeed wide-spread in real-world programs. The study shows that in a corpus of popular OCaml projects on Github, up to 17 % of the source files contain deep priority conflicts. However, there is no solution in the literature that addresses efficient disambiguation of deep priority conflicts, with support for modular and composable syntax definitions.

Pedagogical Significance of Natural Language Programming in Introductory Programming

Learning programming is hard for novice students. Complicated syntax and semantic of programming languages and lack of previous knowledge are the contributing factors behind the hardness of programming. Natural programming language allows to program in a natural language and thereby ease the programming. In this paper, it is ascertained whether natural programming language is fruitful in learning the elementary programming concepts and supportive in preparing students for introductory programming courses. The discussion included in this paper can be used to design supportive programming languages and formulating effective courses and learning material to ameliorate performance of students’ in learning of introductory programming environments.

Writing In-Code Comments to Self-Explain in Computational Science and Engineering Education

This article presents two case studies aimed at exploring the use of self-explanations in the context of computational science and engineering (CSE) education. The self-explanations were elicited as students’ in-code comments of a set of worked-examples, and the cases involved two different approaches to CSE education: glass box and black box. The glass-box approach corresponds to a programming course for materials science and engineering students that focuses on introducing programming concepts while solving disciplinary problems. The black-box approach involves the introduction of Python-based computational tools within a thermodynamics course to represent disciplinary phenomena. Two semesters of data collection for each case study allowed us to identify the effect of using in-code comments as a self-explanation strategy on students’ engagement with the worked-examples and students’ perceptions of these activities within each context. The results suggest that the use of in-code comments as a self-explanation strategy increased students’ awareness of the worked-examples while engaging with them. The students’ perceived uses of the in-code commenting activities include: understanding the example, making a connection between the programming code and the disciplinary problem, and becoming familiar with the programming language syntax, among others.

Parsing Expression Grammars with Unordered Choices

Parsing expression grammars (PEGs) were formalized by Ford in 2004, and have several pragmatic operators (such as ordered choice and unlimited lookahead) for better expressing modern programming language syntax. In addition, PEGs can be parsed in a linear time by using recursive-descent parsing and memoization. In this way, PEGs have a lot of positive aspects. On the other hand, it is known that ordered choices defy intuition. They may cause bugs. This is due to a priority of an ordered choice. To avoid this, unordered choices are required. In this paper, we define a parsing expression grammar with unordered choices (PEGwUC), an extension of a PEG with unordered choices. By the extension, it is expected that a PEGwUC includes both a PEG and a context-free grammar (CFG), and this allows us to write a grammar more intuitively. Furthermore, we show an algorithm for parsing a PEGwUC. The algorithm runs in a linear time when a PEGwUC does not include unordered choice and in a cubic time in worst-case running time.

Understanding the syntactic rule usage in java

Abstract Context: Syntax is fundamental to any programming language: syntax defines valid programs. In the 1970s, computer scientists rigorously and empirically studied programming languages to guide and inform language design. Since then, language design has been artistic, driven by the aesthetic concerns and intuitions of language architects. Despite recent studies on small sets of selected language features, we lack a comprehensive, quantitative, empirical analysis of how modern, real-world source code exercises the syntax of its programming language. Objective: This study aims to understand how programming language syntax is employed in actual development and explore their potential applications based on the results of syntax usage analysis. Method: We present our results on the first such study on Java, a modern, mature, and widely-used programming language. Our corpus contains over 5000 open-source Java projects, totalling 150 million source lines of code (SLoC). We study both independent (i.e. applications of a single syntax rule) and dependent (i.e. applications of multiple syntax rules) rule usage, and quantify their impact over time and project size. Results: Our study provides detailed quantitative information and yields insight, particularly (i) confirming the conventional wisdom that the usage of syntax rules is Zipfian; (ii) showing that the adoption of new rules and their impact on the usage of pre-existing rules vary significantly over time; and (iii) showing that rule usage is highly contextual. Conclusions: Our findings suggest potential applications across language design, code suggestion and completion, automatic syntactic sugaring, and language restriction.

Syntax and operational semantics of a probabilistic programming language with scopes

Dzhafarov and Kujala (2015) have introduced a contextual probability theory called Contextuality-by-Default (C-b-D) which is based on three principles. The first of these principles states that each random variable should be automatically labelled by all conditions under which it is recorded. The aim of this article is to relate this principle to block structured computer programming languages where variables are declared local to a construct called a “scope”. Scopes are syntactic constructs which correspond to the notion of condition used by C-b-D. In this way a variable declared in two scopes can be safely overloaded meaning that they can have the same label but preserve two distinct identities without the need to label each variable in each condition as advocated by C-b-D. By means of examples, the notion of a probabilistic program, or P-program, is introduced which is based on scopes. The semantics of P-programs will be illustrated using the well known relational database language SQL which provides an efficient and understandable operational semantics. A core issue addressed is how to construct a single probabilistic model from the various interim probability distributions returned by each syntactic scope. For this purpose, a probabilistic variant of the natural join operator of relational algebra is used to “glue” together interim distributions into a single distribution. More generally, this article attempts to connect contextuality with probabilistic programming by means of relational database theory.

Learners Programming Language a Helping System for Introductory Programming Courses

Programming is the core of computer science and due to this momentousness a special care is taken in designing the curriculum of programming courses. A substantial work has been conducted on the definition of programming courses, yet the introductory programming courses are still facing high attrition, low retention and lack of motivation. This paper introduced a tiny pre-programming language called LPL (Learners Programming Language) as a ZPL (Zeroth Programming Language) to illuminate novice students about elementary concepts of introductory programming before introducing the first imperative programming course. The overall objective and design philosophy of LPL is based on a hypothesis that the soft introduction of a simple and paradigm specific textual programming can increase the motivation level of novice students and reduce the congenital complexities and hardness of the first programming course and eventually improve the retention rate and may be fruitful in reducing the dropout/failure level. LPL also generates the equivalent high level programs from user source program and eventually very fruitful in understanding the syntax of introductory programming languages. To overcome the inherent complexities of unusual and rigid syntax of introductory programming languages, the LPL provide elementary programming concepts in the form of algorithmic and plain natural language based computational statements. The initial results obtained after the introduction of LPL are very encouraging in motivating novice students and improving the retention rate.

A Declarative Extension of Parsing Expression Grammars for Recognizing Most Programming Languages

Parsing Expression Grammars are a popular foundation for describing syntax. Unfortunately, several syntax of programming languages are still hard to recognize with pure PEGs. Notorious cases appears: typedef-defined names in C/C++, indentation-based code layout in Python, and HERE document in many scripting languages. To recognize such PEG-hard syntax, we have addressed a declarative extension to PEGs. The "declarative" extension means no programmed semantic actions, which are traditionally used to realize the extended parsing behavior. Nez is our extended PEG language, including symbol tables and conditional parsing. This paper demonstrates that the use of Nez Extensions can realize many practical programming languages, such as C, C\#, Ruby, and Python, which involve PEG-hard syntax.