Textual Programming Languages Research Articles

Design and Development of a Digital Personalized Learning Track: Bridging the Gap Between Textual and Visual Programming

Due to swift technological changes in society, programming tasks are proliferating in formal and informal education around the globe. However, challenges arise regarding the acquisition of programming skills. Many students are unequipped to develop programming skills due to limited instruction or background and therefore feel insecure when encountering programming in higher education. Some after-school initiatives focus on teaching younger students programming skills, however, not all students have the opportunity to attend. It can also be very challenging for teachers to teach programming—even more so due to significant differences in students’ knowledge and interests. To alleviate these challenges, we designed and developed a digital personalized learning (DPL) track for programming in the first grade of secondary education (12–14 year-old students) with a threefold purpose: (a) to encourage students bridging the gap between visual and more general-purpose textual programming languages (b) to meet differences in students’ programming knowledge by challenging them, albeit on their own pace, and subsequently (c) to support teachers in the delivery of programming education with relevant supportive learning materials. The design was tested by students and teachers, both of varying technical abilities. Assessments of the DPL-track were positive, with students identifying the tasks as challenging and the tools as motivating. Teachers praised the adaptivity, as well as the gradual transition from visual to textual programming. We present several suggestions for design improvement and dilemmas while reflecting on our design case.

Factors influencing Swedish grades 4–6 technology teachers’ choice of teaching and learning material in programming education

There is a recognized need to understand the current state of programming implementation in the Swedish compulsory school system. This study focused specifically on the implementation of programming in the school subject of technology for grades 4–6. In Sweden, the responsibility for choosing teaching and learning material lies with individual teachers. Recent studies have indicated the prevalence of visual programming languages (VPLs) in classrooms. However, no empirical research has specifically investigated why teachers select particular programming learning environments (PLEs) and the challenges they have overcome in this process. Therefore, this study aimed to explore the PLEs used by teachers and the factors influencing their choices. In addition, this study explored the role of pedagogical content knowledge (PCK) and the influence of systemic and situational amplifiers and filters in shaping the programming education landscape, highlighting the importance of understanding these factors for effective implementation. Semi-structured interviews were conducted with 14 experienced programming teachers in grades 4–6 to gather insights. The results revealed that VPLs, particularly Scratch, have been widely adopted, but the study also identified three textual programming languages being utilized. Furthermore, the findings indicate that teachers’ previous education plays a significant role in shaping their PLE preferences. This suggests that programming education in both professional development and preservice teacher training is crucial for effective implementation. By investigating PLE choices and the factors influencing them, this study contributes to a better understanding of the current landscape of programming education in Sweden’s compulsory school system.

Visual Low-Code Language for Orchestrating Large-Scale Distributed Computing

Distributed, large-scale computing is typically performed using textual general-purpose programming languages. This requires significant programming skills associated with the parallelisation and distribution of computations. In this paper, we present a visual (graphical) programming language called the Computation Application Language (CAL) to raise abstraction in distributed computing. CAL programs define computation workflows by visualising data flowing between computation units. The goal is to reduce the amount of traditional code needed and thus facilitate development even by non-professional programmers. The language follows the low-code paradigm, i.e. its implementation (the editor and the runtime system) is available online. We formalise the language by defining its syntax using a metamodel and specifying its semantics using a two-step approach. We define a translation of CAL into an intermediate language which is then defined using an operational approach. This formalisation was used to develop a programming and execution environment. The environment orchestrates computations by interpreting the intermediate language and managing the instantiation of computation modules using data tokens. We also present an explanatory case-study example that shows a practical application of the language.

PoST: A Process-Oriented Extension of the IEC 61131-3 Structured Text Language

This paper presents the core concepts for the poST language &#x2013; a process-oriented extension of the IEC 61131-3 Structured Text (ST) language which intends to provide a conceptual consistency of the PLC source code with technological description of the plant operating procedure. The poST can be seamlessly used as a textual programming language for complex PLC software in the context of IEC 61131-3 (<inline-formula> <tex-math notation="LaTeX">$3^{rd}$ </tex-math></inline-formula> Edition). The language combines the advantages of FSM-based programming with the conventional syntax of the ST language which would facilitate its adoption. The poST language assumes that a poST-program is a set of weakly connected concurrent processes, structurally and functionally corresponding to the technological description of the plant. Each process is specified by a sequential set of states. The states are specified by a set of the ST constructs, extended by TIMEOUT operation, SET STATE operation, and START / STOP / check state operations to communicate with other processes. The paper describes the basic syntax of the poST language, demonstrates the usage of the poST language by developing control software for an elevator, and compares the development in poST with pure Structured Text.

Exploring the first experiences of computer programming of older people with low levels of formal education: A participant observational case study

Computer programming is widely regarded as a key skill in the 21st century. Yet, and despite a growing aging population and interest in promoting computer programming for all, research on this topic with older people (60+) is scant in the Human-Computer Interaction literature. This paper presents a qualitative case study aimed to explore the first experiences of computer programming of a group of older active computer users with low levels of educational attainment (i.e., primary school / K-12). Over a 6-month period, we provided a hands-on introduction to several textual and visual programming languages and environments to (N = 29) older and adult people in three courses in an adult educational center. We reveal and explain relevant factors that shape, and help us understand, the participants’ computer programming learning experiences, including their motivations, difficulties, and identity, along with strategies that hindered and fostered empowerment. Implications for research and design are discussed.

Hybrid Java: The creation of a Hybrid Programming Environment

This article details the creation of a hybrid computer programming environment combining the power of the text-based Java language with the visual features of the Snap! language. It has been well documented that there exists a gap in the education of computing students in their mid-to-late teenage years, where perhaps visual programming languages are no longer suitable and textual programming languages may involve too steep of a learning curve. There is an increasing need for programming environments that combine the benefits of both languages into one.&#x0D; Snap! is a visual programming language which employs “blocks” to allow users to build programs, similar to the functionality offered by Scratch. One added benefit of Snap! is that it offers the ability to create one’s own blocks and extend the functionality of those blocks to create more complex and powerful programs. This will be utilised to create the Hybrid Java environment. The development of this tool will be detailed in the article, along with the motivation and use cases for it.&#x0D; Initial testing conducted will be discussed including one phase that gathered feedback from a pool of 174 first year Computer Science students. These participants were given instructions to work with the hybrid programming language and evaluate their experience of using it. The analysis of the findings along with future improvements to the language will also be presented.

Adding interactive visual syntax to textual code

Many programming problems call for turning geometrical thoughts into code: tables, hierarchical structures, nests of objects, trees, forests, graphs, and so on. Linear text does not do justice to such thoughts. But, it has been the dominant programming medium for the past and will remain so for the foreseeable future. This paper proposes a novel mechanism for conveniently extending textual programming languages with problem-specific visual syntax. It argues the necessity of this language feature, demonstrates the feasibility with a robust prototype, and sketches a design plan for adapting the idea to other languages.

Touch: A Textual Programming Language for Developing APPs of Insect Intelligent Building

Insect intelligent building (I2B) is a novel decentralized, flat-structured intelligent building platform with excellent flexibility and scalability. I2B allows users to develop applications that include control strategies for efficiently managing and controlling buildings. However, developing I2B APPs (applications) is considered a challenging and complex task due to the complex structural features and parallel computing models of the I2B platform. Existing studies have been shown to encounter difficulty in supporting a high degree of abstraction and in allowing users to define control scenarios in a concise and comprehensible way. This paper aims to facilitate the development of such applications and to reduce the programming difficulty. We propose Touch, a textual domain-specific language (DSL) that provides a high-level abstraction of I2B APPs. Specifically, we first establish the conceptual programming architecture of the I2B APP, making the application more intuitive by abstracting different levels of physical entities in I2B. Then, we present special language elements to effectively support the parallel computing model of the I2B platform and provide a formal definition of the concrete Touch syntax. We also implement supporting tools for Touch, including a development environment as well as target code generation. Finally, we present experimental results to demonstrate the effectiveness and efficiency of Touch.

A Building Block Method for Modeling and Small-Signal Stability Analysis of the Autonomous Microgrid Operation

The task of the whole microgrid state-space matrix creation is usually done in a preferred textual programming language, and it presents a complicated, time-consuming, and error-prone job for a researcher without good coding practices. To ease the modeling task, contribute to the adaptation of new microgrid structures, control algorithms, and devices, and to improve the flexibility of the model, a graphical element building block method is proposed in this paper. With the proposed approach model creation of the whole microgrid is reduced to the creation of the individual element state-space model that is linked with other elements in a logical way with a graphical connection. Elements are then grouped into meaningful wholes and encapsulated with the appropriate graphical user interface that enables easy parameter modification and model complexity change. More detailed DC/DC and DC/AC models of converters than those in the literature concerning microgrid stability are presented in this paper. Those converters are incorporated in a microgrid, whose model is created using the proposed approach in MATLAB/Simulink. The dynamic response examination of the model remains easy, just as with all Simulink models, while for the linear system analysis, a specialized toolbox is used.

Undergraduate Students' Brain Activity in Visual and Textual Programming.

Eight computer science students, novice programmers, who were in the first semester of their studies, participated in a field study in order to explore potential differences in their brain activity during programming with a visual versus a textual programming language. The students were asked to develop two specific programs in both programming languages (a total of four tasks). Measurements of cerebral activity were performed by the electroencephalography (EEG) imaging method. According to data analysis, it appears that the type of programming language did not affect the students' brain activity.

Impact of used programming language for K-12 students' understanding of the loop concept

Block-based programming languages are becoming a favourite learning tool for programming novices while the traditional way of teaching programming mostly uses text-based programming languages. The purpose of this study was to compare the impact of used visual and textual programming languages on K-12 students' understanding of the loop concept. Participants were 312 elementary school students from 5th to 8th grade using visual programming language Scratch (n = 59), and textual programming languages Logo (n = 185) and Python (n = 68). Tests for all languages were equivalent, differing only in the used programming language. Results showed that students achieved statistically significant higher scores when using block-based programming language compared to students using textual programming languages. These results show that K-12 students need concrete experience to understand abstract concepts, as the loop concept, which Scratch as a block-based programming language provides.

Exploring brain activity and transforming knowledge in visual and textual programming using neuroeducation approaches.

Eight (8) computer science students, novice programmers, who were in the first semester of their studies, participated in a field study in order to explore potential differences in their brain activity during programming with a visual programming language versus a textual programming language. The eight students were asked to develop two specific programs in both programming languages (a total of four tasks). The order of these programs was determined, while the order of languages in which they worked differed between the students. Measurement of cerebral activity was performed by the electroencephalography (EEG) imaging method. According to the analysis of the data it appears that the type of programming language did not affect the students' brain activity. Also, six students needed more time to successfully develop the programs they were asked with the first programming language versus the second one, regardless of the type of programming language that was first. In addition, it appears that six students did not show reducing or increasing brain activity as they spent their time on tasks and at the same time did not show a reduction or increase in the time they needed to develop the programs. Finally, the students showed higher average brain activity in the development of the fourth task than the third, and six of them showed higher average brain activity when developing the first versus the second program, regardless of the programming language. The results can contribute to: a) highlighting the need for a diverse educational approach for students when engaging in program development and b) identifying appropriate learning paths to enhance student education in programming.

Visual augmentation of source code editors: A systematic mapping study

Source code written in textual programming languages is typically edited in integrated development environments (IDEs) or specialized code editors. These tools often display various visual items, such as icons, color highlights or more advanced graphical overlays directly in the main editable source code view. We call such visualizations source code editor augmentation.In this paper, we present a first systematic mapping study of source code editor augmentation tools and approaches. We manually reviewed the metadata of 5553 articles published during the last twenty years in two phases – keyword search and references search. The result is a list of 103 relevant articles and a taxonomy of source code editor augmentation tools with seven dimensions, which we used to categorize the resulting list of the surveyed articles.We also provide the definition of the term source code editor augmentation, along with a brief overview of historical development and augmentations available in current industrial IDEs.

An Analysis of the Difficulties of Elementary School Students in Python Programming Learning

Software education is spreading all over the world; programming education is being implemented in elementary schools in each country using block-programming language. The block programming language provides a novice environment for easy access, but lacks understanding and teaching all the concepts of programming. There seems to be a need for primary education using text-based programming language for elementary school students. However, the difficulties encountered by learners in typing grammars and commands in textual programming languages could not be completely ruled out. This study aims to investigate the difficulties of learners based on grammatical errors frequently encountered in elementary school students. As a result, the most frequent errors in elementary school students in Python programming were errors caused by missing parentheses, followed by incorrect operator use, assignment of variable values that did not fit the data type, incorrect control statement composition, missing quotes Respectively. This study implies that it provided the improved direction of programming education by identifying the difficulties of learners and presenting practical examples and guidance plans and finding appropriate teaching strategies for text type programming education.

Visual and textual programming languages: a systematic review of the literature

It is well documented, and has been the topic of much research, that Computer Science courses tend to have higher than average drop out rates at third level. This is a problem that needs to be addressed with urgency but also caution. The required number of Computer Science graduates is growing every year but the number of graduates is not meeting this demand and one way that this problem can be alleviated is to encourage students at an early age towards studying Computer Science courses. This paper presents a systematic literature review on the role of visual and textual programming languages when learning to program, particularly as a first programming language. The approach is systematic, in that a structured search of electronic resources has been conducted, and the results are presented and quantitatively analysed. This study will give insight into whether or not the current approaches to teaching young learners programming are viable, and examines what we can do to increase the interest and retention of these students as they progress through their education.

Low cost, high accuracy real-time simulation used for rapid prototyping and testing control algorithms on example of BLDC motor

AbstractThis article presents the simulation of a BLDC motor and its closed control system in FPGA. The simulation is based on a mathematical model of the motor, including the electromagnetic torque, phase currents, back electromotive force, etc. In order to ensure calculation precision, the equations describing the motor were solved using a floating point representation of real numbers, and a small step of numerical calculations of 1 μs was assumed. The time step selection methodology has been discussed in detail. The motor model was executed with the use of Textual Programming Languages (with HDL codes).

Pragmatic model transformations for refactoring in Scilab/Xcos

Model-Based Development has become an industry wide standard paradigm. As an open source alternative, Scilab/Xcos is being widely employed as a hybrid dynamic systems modeling tool. With the increasing efficiency in implementation using graphical model development and code generation, the modeling and simulation community is struggling with assuring quality as well as maintainability and extendibility. Refactoring is defined as an evolutionary modernization activity where, most of the time, the structure of the artifact is changed to alter its quality characteristics, while keeping its behavior unchanged. It has been widely established as a technique for textual programming languages to improve the code structure and quality. While refactoring is also regarded as one of the key practices of model engineering, the methodologies and approaches for model refactoring are still under development. Architecture-Driven Modernization (ADM) has been introduced by the software engineering community as a model-based approach to software modernization, in which the implicit information that lies in software artifacts is extracted to models and model transformations are applied for modernization tasks. Regarding refactoring as a low level modernization task, the practices from ADM are adaptable. Accordingly, this paper proposes a model-based approach for model refactoring in order to come up with more efficient and effective model refactoring methodology that is accessible and extendable by modelers. Like other graphical modeling tools, Scilab/Xcos also possesses a formalized model specification conforming to its implicit metamodel. Rather than proposing another metamodel for knowledge extraction, this pragmatic approach proposes to conduct in place model-to-model transformations for refactoring employing the Scilab/Xcos model specification. To construct a structured model-based approach, the implicit Scilab/Xcos metamodel is explicitly presented utilizing ECORE as a meta-metamodel. Then a practical model transformation approach is established based on Scilab scripting. A Scilab toolset is provided to the modeler for in-place model-to-model transformations. Using a sample case study, it is demonstrated that proposed model transformation functions in Scilab provide a valuable refactoring tool.

Design and implementation of a remote lab for teaching programming and robotics

Abstract: In this document we describe the development of a remote lab and two user interfaces for teaching programming and fundamentals of robotics using Arduino boards. One of the interfaces uses visual language to make the experience more attractive for those who are beginning their studies. The second interface provides an environment similar to the original Arduino’s one for those users who have some background to use textual programming language. In addition, we present an usability evaluation of the application using visual programming language to obtain a broad feedback mainly in terms of target audience’s acceptance and suggestions for improvements. The environment is still an ongoing work, but it is suitable for courses and workshops, especially for institutions with limited resources.

A domain specific language for spatial simulation scenarios

This article describes DSL3S, a domain specific modelling language for Spatial Simulation in the field of Geographic Information Systems (GIS). Techniques such as cellular automata and agent-based modelling have long been used to capture and simulate the temporal dynamics of spatial information. Tools commonly employed to implement spatial simulation models include code libraries and pre-compiled models; the former require advanced programming skills while the latter impose relevant constraints on application scope. Previous attempts to produce domain specific languages in the field have invariably resulted in new textual programming languages (e.g. SELES, NetLogo, Ocelet) that are platform specific and in some cases with weak GIS support and interoperability. DSL3S synthesises relevant concepts of spatial simulation in a UML profile, that allows the design of simulation models through the arrangement of graphical elements. An implementation of this language is also presented, that relies on Model Driven Development (MDD) tools distributed with the Eclipse IDE. This includes a code generation infrastructure, that produces ready to run simulations from DSL3S models, supported by the MASON simulation tool-kit. Finally, DSL3S models for three simple and classical simulations allows to better illustrate and discuss the usage of the language.

A General Framework for FPGA-Based Real-Time Emulation of Electrical Machines for HIL Applications

Hardware-in-the-loop (HIL) technology is increasingly becoming the preferred, reliable, and cost-effective alternative in a virtual scenario for tedious, time-consuming, and expensive tests on real devices. This paper presents a digital hardware emulation of commonly used electrical machines for HIL simulation on the field-programmable gate arrays (FPGAs) in a general framework. This paper provides a useful and comprehensive comparison between floating- and fixed-point arithmetic for hardware implementation, and addresses the differences of deeply pipelined and highly paralleled realization schemes, and the contribution of schematic and textual programming language methods for design configuration of electrical machine models. The hardware implementation by these approaches is evaluated in terms of real-time step size, accuracy, and hardware resource consumption. Finally, an experimentally measured electrical machine behavior is employed to demonstrate the effectiveness of the emulated electrical machine.