Search

The message-passing programming model is based on the abstraction of a parallel computer with a distributed address space where each processor has a local memory to which it has exclusive access, see Sect. 2.3.1. There is no global memory. Data exchange must be performed by message passing: to transfer data from the local memory of one processor \(A\) to the local memory of another processor \(B\), \(A\) must send a message containing the data to \(B\), and \(B\) must receive the data in a buffer in its local memory. To guarantee portability of programs, no assumptions on the topology of the interconnection network is made. Instead, it is assumed that each processor can send a message to any other processor.

The R package calculus implements C++-optimized functions for numerical and symbolic calculus, such as the Einstein summing convention, fast computation of the LeviCivita symbol and generalized Kronecker delta, Taylor series expansion, multivariate Hermite polynomials, high-order derivatives, ordinary differential equations, differential operators and numerical integration in arbitrary orthogonal coordinate systems. The library applies numerical methods when working with functions, or symbolic programming when working with characters or expressions. The package handles multivariate numerical calculus in arbitrary dimensions and coordinates. It implements the symbolic counterpart of the numerical methods whenever possible, without depending on external computer algebra systems. Except for Rcpp, the package has no strict dependencies in order to provide a stable self-contained toolbox that invites re-use.

Live coding-the real-time procedural creation of audiovisual works-suggests opportunities to extend hand-drawn animation; however, existing live coding systems are incompatible with manual animation workflows. Manual input is not a primary datatype in existing live coding languages and live coding tools require using symbolic programming environments. We theorize that by applying direct manipulation to the domain of live coding, we can enable animators to create expressive mappings between hand-drawn animations and audio effects in real time. We present Megafauna, a sketch-based system for audiovisual performance, informed by interviews with professional animators. Megafauna supports the integrated generation and control of hand-drawn animation and audio sequences by enabling animators to directly sketch mapping functions between animation frames and sound oscillators. We demonstrate the expressive potential of Megafauna by reproducing animated compositions from procedural and manual domains and show how the system supports manual expression and exploration in live performance.

Despite significant improvements in contemporary machine learning, symbolic methods currently outperform artificial neural networks on tasks that involve compositional reasoning, such as goal-directed planning and logical inference. This illustrates a computational explanatory gap between cognitive and neurocomputational algorithms that obscures the neurobiological mechanisms underlying cognition and impedes progress toward human-level artificial intelligence. Because of the strong relationship between cognition and working memory control, we suggest that the cognitive abilities of contemporary neural networks are limited by biologically-implausible working memory systems that rely on persistent activity maintenance and/or temporal nonlocality. Here we present NeuroLISP, an attractor neural network that can represent and execute programs written in the LISP programming language. Unlike previous approaches to high-level programming with neural networks, NeuroLISP features a temporally-local working memory based on itinerant attractor dynamics, top-down gating, and fast associative learning, and implements several high-level programming constructs such as compositional data structures, scoped variable binding, and the ability to manipulate and execute programmatic expressions in working memory (i.e., programs can be treated as data). Our computational experiments demonstrate the correctness of the NeuroLISP interpreter, and show that it can learn non-trivial programs that manipulate complex derived data structures (multiway trees), perform compositional string manipulation operations (PCFG SET task), and implement high-level symbolic AI algorithms (first-order unification). We conclude that NeuroLISP is an effective neurocognitive controller that can replace the symbolic components of hybrid models, and serves as a proof of concept for further development of high-level symbolic programming in neural networks.

The gap between informal functional specifications and the resulting implementation in the chosen programming language is notably a source of errors in embedded systems design. In this paper, we discuss a methodology and a software platform aimed at coping with this issue in programming resource-constrained wireless sensor network nodes (WSNs). Whereas the typical development model for the WSNs is based on cross compilation, the proposed approach supports high-level symbolic coding of abstract models and distributed applications, as well as their test and their execution, directly on the target hardware. As a working example, we discuss the application of our methodology to specify the functional behavior of a radio transceiver chip. The resulting executable specifications are augmented with automatically generated runtime verification code. Our approach is also compared to code development for two prominent WSN general-purpose operating systems.

After a Wireless Sensor Network (WSN) is deployed it is subject to significant variations of the quality of its radio links during its lifetime. Knowledge of the condition of the wireless links can be useful to optimize power consumption and increase the reliability of the network. However, resource-constrained nodes may not be able to spare the storage space for network monitoring code. Also, reprogramming deployed nodes can be costly or unfeasible. In this work, we show how an approach based on the exchange of symbolic executable code among nodes enables the assessment of the network status in terms of Packet Reception Rate (PRR) with no extra storage requirements on deployed networks. We also compare the predictions made through this estimate with the actual network behavior.

We propose a methodology to verify applications developed following programming patterns inspired by natural language that interact with physical environments and run on resource-constrained interconnected devices. Natural language patterns allow for the reduction of intermediate abstraction layers to map physical domain concepts into executable code avoiding the recourse to ontologies, which would need to be shared, kept up to date, and synchronized across a set of devices. Moreover, the computational paradigm we use for effective distributed execution of symbolic code on resource-constrained devices encourages the adoption of such patterns. The methodology is supported by a rule-based system that permits runtime verification of Software Under Test (SUT) on board the target devices through automated oracle and test case generation. Moreover, verification extends from syntactic and semantic checks to the evaluation of the effects of SUT execution on target hardware. Additionally, by exploiting rules tying sensors and actuators to physical quantities, the effects of code execution on the physical environment can be verified. The system is also able to build test code to highlight software issues that may arise during repeated SUT execution on the target hardware.

It is highly recognized that difficulties involved in teaching programming in an introductory course, arise from the cognitive process complexity that is necessary for developing this ability. Previous studies on the best first programming language or the best first programming paradigm have been conducted. Even, the most appropriate integrated development environment (IDE) for novice programmers has been inquired, and the most appropriate problem solving strategy to teach to write computable solutions has been researched. From the investigation in a sample of Bogota universities, and from a holistic perspective, this paper presents an overview of the most common practices and difficulties in teaching these courses, providing important information to help diagnose possible weaknesses in the current process of teaching as well as providing some elements to consider in the design of new strategies, resources and planning criteria for these formative scenarios.

The availability of versatile and interconnected embedded devices makes it possible to build low-cost networks with a large number of nodes running even complex applications and protocols in a distributed manner. Common tools used for modeling and verification, such as simulators, present some limitations as application correctness is checked off-board and only focuses on source code. Execution in the real network is thus excluded from the early stages of design and verification. In this paper, a system for modeling and verification of symbolic distributed protocols running on embedded devices is introduced. The underlying methodology is rooted in a symbolic programming paradigm that makes it possible to model protocols with a high level of abstraction still permitting their execution on resource-constrained devices. The preliminary experimental results shown in this paper concern verification of a distributed averaging protocol in a simulated network at increasing number of nodes. The results support the feasibility of the approach to test distributed applications running on large networks of resource- constrained nodes.

Starting from the first investigations with strictly functional languages, reactive programming has been proposed as the programming paradigm for reactive applications. Over the years, researchers have enriched reactive languages with more powerful abstractions, embedded these abstractions into mainstream languages—including object-oriented languages—and applied reactive programming to several domains, such as GUIs, animations, Web applications, robotics, and sensor networks. However, an important assumption behind this line of research is that, beside other claimed advantages, reactive programming makes a wide class of otherwise cumbersome applications more comprehensible. This claim has never been evaluated. In this paper, we present the first empirical study that evaluates the effect of reactive programming on comprehension. The study involves 127 subjects and compares reactive programming to the traditional object-oriented style with the Observer design pattern. Our findings show that program comprehension is significantly enhanced by the reactive-programming paradigm—a result that suggests to further develop research in this field.

This is the second part of a two-part series that describes a pilot programming course in which high school students majoring in computer science were introduced to the visual, scenario-based programming language of live sequence charts. The main rationale for the course was that computer science students should be exposed to at least two very different programming paradigms and that LSCs, with their unique characteristics, can be a good vehicle for that. Part 1 (see the previous issue) focused on the pedagogic rationale of the pilot, on introducing LSC, and on the structure of the course. Part 2 centers on the evaluation of the pilot’s results.

Programming technique is one of the subjects at Vocational High School in Indonesia. This subject contains theory and application of programming utilizing Visual Programming. Students experience some difficulties to learn textual learning. Therefore, it is necessary to develop media as a tool to transfer learning materials. The objectives of this study are to determine the feasibility of learning media based on Visual Programming and to investigate the response of students who utilize the learning media. Learning media is firstly validated by experts before it is applied to students. This research implemented rating validation with fuzzy rating based on fuzzy inference system. Fuzzy benefits in translating a crisp form into the preference of linguistic variable form and reprocess into a crisp form as a value decision. The results revealed that fuzzy rating can be implemented to measure the feasibility of learning media and students' responses to the use of learning media.

Static-type systems are a major topic in programming language research and the software industry because they should reduce the development time and increase the code quality. Additionally, they are predicted to decrease the number of defects in a code due to early error detection. However, only a few empirical experiments exist on the potential benefits of static-type systems in programming activities. This paper describes an experiment that tests whether static-type systems help developers create solutions for certain programming tasks. The results indicate that although the existence of a static-type system has no positive impact when subjects code a program from scratch, it does allow more errors in program debugging to be fixed.

This paper presents an experiment in which visual programming environments have been used in programming courses aiming at helping students to acquire the competencies of a course on object-oriented programming. This paper is centered on the analysis of the acceptance by the students of this type of environment, as well as its effect on the motivation of the students. The results obtained show differences in their answers according to the two possible characteristics of the students analyzed: their gender and the fact of being or not a newcomer.

In the past, computer programming was perceived as a task only carried out by computer scientists; in the 21st century, however, computer programming is viewed as a critical and necessary skill that everyone should learn. In order to improve teaching of problem-solving abilities in a computing environment, extensive research is being done on teaching–learning methods, types of teaching software, the educational environment, and related tools. This paper, based on diverse experimental results, proposes an environment where elementary students can easily learn and practice computer programming. The proposed robot game environment used a tangible programming tool with which students can easily create robot programs, without learning syntax, and then validate their programming results; it can also provide various game activities to incite students’ interest. Observation of elementary school students placed in the robot game environment confirmed the tool’s usability and entertainment aspects, and students’ attitudes toward programming and their understanding of programming concepts improved.

While modern parallel computing systems provide high performance resources, utilizing them to the highest extent requires advanced programming expertise. Programming for parallel computing systems is much more difficult than programming for sequential systems. OpenMP is an extension of C++ programming language that enables to express parallelism using compiler directives. While OpenMP alleviates parallel programming by reducing the lines of code that the programmer needs to write, deciding how and when to use these compiler directives is up to the programmer. Novice programmers may make mistakes that may lead to performance degradation or unexpected program behavior. Cognitive computing has shown impressive results in various domains, such as health or marketing. In this paper, we describe the use of IBM Watson cognitive system for education of novice parallel programmers. Using the dialogue service of the IBM Watson we have developed a solution that assists the programmer in avoiding common OpenMP mistakes. To evaluate our approach we have conducted a survey with a number of novice parallel programmers at the Linnaeus University, and obtained encouraging results with respect to usefulness of our approach. (C) 2017 The Authors. Published by Elsevier B.V. Bibliographically approved by Viveka Svensson

This paper summarizes the experience of teaching an introductory course to programming by using a correctness by construction approach at Innopolis University, Russian Federation. In this paper we claim that division in beginner and advanced groups improves the learning outcomes, present the discussion and the data that support the claim.

Smart environments demand novel paradigms offering easy configuration, programming and deployment of pervasive applications. To this purpose, different solutions have been proposed ranging from visual paradigms based on mashups to formal languages. However, most of the paradigms proposed in the literature require further external tools to turn application description code into an executable program before the deployment on target devices. Source code generation, runtime upgrades and recovery, and online debugging and inspection are often cumbersome in these programming environments. In this work we describe a methodology for real-time and on-line programming in smart environments that is compact and efficient enough to run on resource-constrained devices. The pillar of the proposed approach is real-time exchange of executable symbolic code in heterogeneous networks. The methodology is supported by an inference engine that is able to generate symbolic code starting from knowledge about hardware devices and their placement in the environment, and about the application domain. Interoperability with existing smart applications and Internet of Things (IoT) deployments is reached through a symbolic Transmission Control Protocol (TCP) client, and Message Queue Telemetry Transport (MQTT) client.

Simplifying programming, deployment, and configuration of heterogeneous networked IoT devices requires networking, hardware, representation of knowledge and concepts, design and programming skills. In fact, IoT applications are mostly built by adopting different existing paradigms and technologies on a case-by-case basis. As a result, programming tools hinder adaptability and interoperability of applications with their rigidity. In this paper, we propose a rule-based system that configures and programs IoT devices automatically. The rule base holds formal specifications about hardware platforms, networking protocols, physical world concepts, and applications. Provided with a high-level application goal, the proposed system generates and delivers symbolic application code to the operating devices, which are then able to run it without any further translation. The tool also supports automatic configuration of IoT heterogeneous entities. Based on hardware specifications in the knowledge base, the system outputs the best configuration, i.e. the best way for connecting sensors and actuators to a specific board for a given purpose.

In this article, we give an overview of the answer set programming paradigm, explain its strengths, and illustrate its main features in terms of examples and an application problem.

We describe the formulation and implementation of the Eilmer4 compressible-flow solver as well as discuss the features of the D programming language that we have found useful for writing scientific software. An example of use is provided to show the features of the user-input scripting and the performance of the main simulation code when run in parallel with block-marching.

The backward-chaining inference strategy of Prolog is inefficient for a number of problems. The article proposes Contralog: a Prolog-conform, forward-chaining language and an inference engine that is implemented as a preprocessor-compiler to Prolog. The target model is Prolog, which ensures mutual switching from Contralog to Prolog and back. The Contralog compiler is implemented using Prolog's de facto standardized macro expansion capability. The article goes into details regarding the target model. We introduce first a simple application example for Contralog. Then the next section shows how a recursive definition of some problems is executed by their Contralog definition automatically in a dynamic programming way. Two examples, the well-known matrix chain multiplication problem and the Warshall algorithm are shown here. After this, the inferential target model of Prolog/Contralog programs is introduced, and the possibility for implementing the ReALIS natural language parsing technology is described relying heavily on Contralog's forward chaining inference engine. Finally the article also discusses some practical questions of Contralog program development.

There is still no pedagogy to teach programming that stands out significantly from others and no consensus on what is the best way for learning programming. There is still a need to develop new teaching methods for learning in introductory programming courses. This paper presents a pedagogic approach in support of creativity in programming and the results of a successful case study, where the teacher facilitates the learning of programming patterns by means of students' involvement in game creation. The results show an improvement in motivation and learning introductory programming, when we combine programming patterns with games using concrete materials.

In this study, the effective elastic constants of several 2D and 3D frame-like periodic cellular solids with different unit-cell topologies are analytically derived using the homogenization method based on equivalent strain energy. The analytical expressions of strain energy of a unit cell under different strain modes are determined using a generic symbolic object-oriented finite element (FE) program written in MATLAB. The obtained analytical expressions of the strain energy are then used to symbolically compute the effective elastic constants that include Young’s moduli, Poisson’s ratios, and shear moduli. The obtained analytical effective elastic constants are numerically verified using results from an ordinary numerical FE program. The obtained closed-form effective elastic constants are also compared with some existing solutions from the literature. This study demonstrates that symbolic computation platforms can be properly used to provide efficient methodologies for finding useful analytical solutions of mechanical problems. Without the symbolic object-oriented FE program in this study, elaborate and tedious analytical analysis has to be manually performed for each different unit cell. The symbolic object-oriented FE program provides analytical analysis of unit cells that is accurate and fast. The object-oriented programming technique allows the symbolic FE program in this study to be efficiently implemented.

$\kappa $ -labs is a research project exploring the possibilities of the logic programming paradigm in bot behavior programming for first-person shooter (FPS) games. The focus of previous work was to make Prolog a usable tool for bot programming and a baseline for further extensions. This paper presents one such extension, which makes it possible to script tactics of the entire team of bots. The algorithm was tested by bot-to-bot computer tests and by running surveys among human players who volunteered to take part in the research. The results of the both tests are presented in this paper. The extension itself demonstrates the flexibility of the framework. Although the proposed method for defining team behaviors relies solely on the knowledge of the bot’s designer, alternative approaches, which use rules that are obtained by computational techniques, can also be developed. Such approaches are also being investigated as part of the $\kappa$ -labs project.

An educational programming language (EPL) allows a novice programmer to program quickly and easily by reducing the difficulty of programming in terms of programming education. The selection of a programming language, considering the students' cognitive level and the purpose of learning programming, is regarded as a key factor to increase the effectiveness of programming education. In this study, we derived the EPL selection criteria for pre-introductory computer science using the Delphi method of a 20-expert panels. Also, we selected RUR-PLE, a Python based programming learning environment, based on EPL selection criteria chosen through the Delphi method and applied the selected EPL to 26 students (20 males and 6 females) who participate in programming class to verify its usability. The objective of this study is to improve the possibility of selecting an appropriate EPL for novice programmers, considering the students' characteristics and the transition of programming knowledge from the EPL to a general-purpose programming language.

Self-assembly is the process whereby relatively simple components autonomously combine to form more complex objects. Nature exhibits self-assembly to form everything from microscopic crystals to living cells to galaxies. With a desire to both form increasingly sophisticated products and to understand the basic components of living systems, scientists have developed and studied artificial self-assembling systems. One such framework is the Tile Assembly Model introduced by Erik Winfree in 1998. In this model, simple two-dimensional square ‘tiles’ are designed so that they self-assemble into desired shapes. The work in this thesis consists of a series of results which build toward the future goal of designing an abstracted, highlevel programming language for designing the molecular components of self-assembling systems which can perform powerful computations and form into intricate structures. The first two sets of results demonstrate self-assembling systems which perform infinite series of computations that characterize computably enumerable and decidable languages, and exhibit tools for algorithmically generating the necessary sets of tiles. In the next chapter, methods for generating tile sets which self-assemble into complicated shapes, namely a class of discrete self-similar fractal structures, are presented. Next, a software package for graphically designing tile sets, simulating their self-assembly, and debugging designed systems is discussed. Finally, a high-level programming language which abstracts much of the complexity and tedium of designing such systems, while preventing many of the common errors, is presented. The summation of this body of work presents a broad coverage of the spectrum of desired outputs from artificial self-assembling systems and a progression in the sophistication of tools used to design them. By creating a broader and deeper set of modular tools for designing xii self-assembling systems, we hope to increase the complexity which is attainable. These tools provide a solid foundation for future work in both the Tile Assembly Model and explorations into more advanced models.

In recent years, there has been tremendous progress in automated synthesis techniques that are able to automatically generate code based on some intent expressed by the programmer. A major challenge for the adoption of synthesis remains in having the programmer communicate their intent. When the expressed intent is coarse-grained (for example, restriction on the expected type of an expression), the synthesizer often produces a long list of results for the programmer to choose from, shifting the heavy-lifting to the user. An alternative approach, successfully used in end-user synthesis is programming by example (PBE), where the user leverages examples to interactively and iteratively refine the intent. However, using only examples is not expressive enough for programmers, who can observe the generated program and refine the intent by directly relating to parts of the generated program. We present a novel approach to interacting with a synthesizer using a granular interaction model. Our approach employs a rich interaction model where (i) the synthesizer decorates a candidate program with debug information that assists in understanding the program and identifying good or bad parts, and (ii) the user is allowed to provide feedback not only on the expected output of a program, but also on the underlying program itself. That is, when the user identifies a program as (partially) correct or incorrect, they can also explicitly indicate the good or bad parts, to allow the synthesizer to accept or discard parts of the program instead of discarding the program as a whole. We show the value of our approach in a controlled user study. Our study shows that participants have strong preference to using granular feedback instead of examples, and are able to provide granular feedback much faster.

Python State Estimation and Modeling Library, pystemlib, is a library that implements Bayesian State Estimation theory for modeling and tracking target objects. This library was developed to overcome the limitations associated with licensed programming languages as well as imperative and numerical matrix-based programming styles that were used in previously developed libraries. pystemlib incorporates object-oriented, functional, and symbolic programming to develop accurate and easy-to-use tracking filters and models. This library is also capable of mapping state estimation results onto the geographical areas to which they correspond. Future work on this library will include optimizing the algorithms for speed and extending the library to incorporate multi-target tracking, data fusion, and image and video processing.

Difficulties in learning programming are a constant concern in engineering courses. In many research studies involving the learning programming must of the solutions presented, from the beginning of the first programming languages, was to apply different type of problems analysis. Literature relating to the understanding of nature of learning programming skills has been focused explicitly on the teaching methodology and few of them focus on abilities, characteristics and knowledge acquired over the life cycle of learning programming in each student. Most of the students enrolled in engineering courses, where programming is a crucial competence, never had the opportunity to develop skills of computational thinking. In this paper, we focus our work on the learning programming developing and applying a set of exercises where students with more difficulties can express and develop their skills in computational thinking. In order to understand some programming students difficulties we have create a set of exercises, and apply it to a pre-programming course, that allows teachers to understand how students analyse and comprehend aspects such as visualization, spatial interpretation and physical manipulation. This paper also reports on results obtained from a class experiment where Memory Transfer Language was used by students to learn programming. All the exercises must be resolved without any type of technology, designed as a ne-course (no electronic course) for learning programming.