The ability of students to read, understand and explain code is tightly interlinked to their ability to trace. Multiple studies have shown that tracing helps students improve their comprehension of code. Analysis of the traces also provides insight into student misconceptions about program execution.

Dynamic control software reconfiguration for the Internet of Things (IoT) and cyber-physical systems (CPSs) is crucial for adaptable and efficient automation. This article presents a knowledge-driven architecture enabling dynamic device reconfiguration using the Web ontology language (OWL) and terse triple language (TTL) formats. Key components include a capability ontology, session-type information for sequencing and concurrent operations, and an integrated development environment (IDE) for automated control design. The capability ontology standardizes machine capabilities, facilitating device integration based on their capabilities, while session-type information ensures correct sequencing and synchronization of machine functions. The IDE platform supports dynamic reconfiguration by automating device selection, control strategy formulation, and system adjustments across diverse use cases. The architecture has been validated in real-world scenarios, including smart meeting rooms, warehouse automation, and energy management, showing a reduction in manual configuration time (up to 50%), development time (86% in some cases), and error rates (30%). Benchmarking results indicate faster code generation (40% improvement) and efficient component integration across different CPS environments. Challenges like computational complexity, scalability, and integration with existing systems highlight limitations. Future research will explore further optimizations and broader applicability to ensure low-latency, high-accuracy, and seamless integration in complex CPS. This work advances dynamic control software reconfiguration by providing a flexible solution that enhances CPS reliability and efficiency through a knowledge-driven approach.

Cyber-Physical Systems (CPS), robotics, the Internet of Things (IoT), and automotive systems are integral to modern technology. They are characterized by their safety criticality, accuracy, and real-time control requirements. Control software plays a crucial role in achieving these objectives by managing and coordinating the operations of various sub-systems. This article presents a novel Systematic Mapping Study (SMS) for control software engineering, analyzing 115 peer-reviewed papers. The study identifies, classifies, and maps existing solutions, providing a comprehensive and structured overview for practitioners and researchers. Our contributions include (1) a unique classification of literature into six research themes—engineering phases, engineering approaches, engineering paradigms, engineering artifacts, target application domains, and engineering concerns; (2) insights into the specificity of approaches to target technologies and phases; (3) the prominence of model-driven approaches for design and testing; (4) the lack of end-to-end engineering support in existing approaches; and (5) the emerging role of agile-based methods versus the dominance of waterfall-based methods. This article's significance lies in its thorough analysis and the high-level mapping of the solution space, offering new perspectives and a detailed roadmap for future research and innovation in control software engineering. The findings will guide advancements and best practices in the field, underscoring the article's impact.

This Full Paper in the Innovative Practice category begins by asking “can algorithms be thought of and taught as dynamical systems?” Our exploration of this idea — Algodynamics — is guided by a vision to achieve convergence between computing and engineering education. The engineering sciences share a common conceptual vocabulary originating in dynamical systems: state spaces, flows, actions, invariants, fixed points, convergence, etc. The goal of algodynamics is to build, ab initio, a framework for understanding and teaching algorithms using concepts from dynamics. This allows us to teach computing and algorithms as an engineering science. Engineers work with models. In algodynamics, models are expressed using transition systems rather than as pseudocode or programs. This allows a crisp representation of two important classes of computation: sequential algorithms as ‘discrete flows’ (iterative systems) and interactive applications as ‘action flows’ (transition systems). The focus of this paper is on the first of these classes, algorithms, but using ideas from the second, viz., transition systems. In this framework, algorithms emerge as convergent iterative systems. Due to their non-interactivity, iterative systems may be hard to understand. The student may trace through the algorithm, but to know how the parts of the algorithm work together requires ‘opening up’ the algorithm and situating it within the more general class of interactive systems. Doing so helps the student to understand the machinery of an algorithm in an incremental and modular way. The student interactively solves the algorithmic problem, experimenting with various strategies along the way. At each stage of the design, interactivity is traded for automation. We illustrate our approach by considering a classic example from sorting: Bubblesort. We first examine a solution based on fixed point iteration. Then we approach Bubblesort as a sequence of five interactive transition systems that culminate in the Bubblesort algorithm. This exercise reveals to the student design decisions and strategies that help understand why Bubblesort works. The successive refinement also pays off in terms of highly modular code whose primitives are elements of the transition system models.

With increasing computing power, capacity and internet connectivity, the ability to learn has crossed classroom boundaries in the form of online learning. The adoption rate and effectiveness of online learning continues to be an area of research. Collaborative and Cooperative (CoCo) learning involves a joint effort by students to understand and solve problems or tasks. Adoption of open source software has also increased with technology-aided collaboration and cooperation. Leveraging the practices of crowdsourced software development, we propose CoCo Learning approach for technical education using virtual labs. About 145 undergraduate engineering students from various institutes participated in our study for a period of one full semester. About 92% of the students conducted an average of 24 virtual experiments with this approach. Nearly 90% of the faculty from these institutes also confirmed that their students' understanding of courses has improved while delivering tangible software artifacts as outcomes.

Model checking is now a standard technology for verifying large and complex systems. While there are a range of tools and techniques to verify various properties of a system under consideration, in this work, we restrict our attention to safety checking procedures using explicit state space generation. The necessary hardware resources required in this approach depends on the model complexity and the resulting state transition graph that gets generated. This cannot be estimated apriori. For reasonably realistic models, the available main memory in even high end servers may not be sufficient. Hence, we have to use distributed safety verification approaches on a cluster of nodes. However, the problem of estimating the minimum number of nodes in the cluster for the verification procedure to complete successfully remains unsolved. In this paper, we propose a dynamically scalable model checker using an actor based architecture. Using the proposed approach, an end user can invoke a model checker hosted on a cloud platform in a push button fashion. Our safety verification procedures automatically expands the cluster by requesting more virtual machines from the cloud provider. Finally, the user gets to pay only for the hardware resources he rented for the duration of the verification procedure. We refer to this as Model Checking as Service. We approach this problem by proposing an asynchronous algorithm for safety checking in actor framework. The actor based approach allows for scaling the resources on a need basis and redistributes the work load transparently through state migration. We tested our approach by developing a distributed version of SpinJA model checker using Akka actor framework. We conducted our experiments on Google Cloud Engine (GCE) platform wherein we scale our resources automatically using the GCE API. On large models such as anderson.8 from BEEM benchmark suite, our approach reduced the model checking cost in dollars by 8.6x while reducing the wall clock time to complete the safety checking procedure 5.5x times.

Domain Specific Modeling Languages (DSML) significantly improve productivity in designing Computer Based System (CBS), by enabling them to be modeled at higher levels of abstraction. It is common for large and complex systems with distributed teams, to use DSMLs, to express and communicate designs of such systems uniformly, using a common language. DSMLs enable domain experts, with no or minimal software development background, to model solutions, using the language and terminologies used in their respective domains. Although, there are already a number of DSMLs available for modeling CBSs, their need is felt strongly across multiple domains, which still are not well supported with DSMLs. Developing a new DSML, however, is non trivial, as it requires (a) significant knowledge about the domain for which the DSML needs to be developed, as well as (b) skills to create new languages. In the current practice, DSMLs are developed by experts, who have substantial understanding of the domain of interest and strong background in computer science. One of the many challenges in the development of DSMLs, is the collection of domain knowledge and its utilization, based on which the abstract syntax, the backbone of the DSML is defined. There is a clear gap in the current state of art and practice, with respect to overcoming this challenge. We propose a methodology, which makes it easier for people with different backgrounds such as domain experts, solution architects, to contribute towards defining the abstract syntax of the DSML. The methodology outlines a set of steps to systematically capture knowledge about the domain of interest, and use that to arrive at the abstract syntax of the DSML. The key contribution of our work is in abstracting a CBS from a domain into a Domain Specific Machine, embodied in domain specific concepts. The methodology outlines, how the Domain Specific Machine, when coupled with guidelines from current practices of developing DSMLs, results in the definition of the abstract syntax of the intended DSML. We discuss our methodology in detail, in this paper.

The Virtual Labs project (vlabs) is a country wide effort to provide access to internet and browser based virtual laboratories to science and engineering college students in India. There are currently over 800 experiments packaged in 70 vlabs in more than ten science and engineering disciplines. More than five hundred workshops on these virtual labs have been conducted and the experiments have been used over 2 million times. Vlabs are an important Government initiative in higher learning in engineering in India. This paper examines virtual labs from a usability perspective, focusing on vlabs. Usability of user-interface elements (technical usability) as well as how they aid learning (pedagogical usability) has been considered. We adapt Nielsen's technical usability heuristics and Nokelainen's pedagogical usability criteria to virtual labs and evaluate the usability of the top three most used vlabs. We construct checklists for each of these criteria and evaluate the vlabs against this checklist. Our analysis reveals a lack of usability focus in lab design. Lab design and implementation guidelines seem to be deficient in covering key usability criteria. We make suggestions on how to quickly improve the usability of these labs.

Virtual Labs allow performance of experiments without real world instrumentation needs. Most of these virtual experiments are simulation based and developed using proprietary or Open Source simulation, Adobe Flash, and other client side software. The procedural steps involved in conducting these experiments are hardwired and require software modification for enhancements or alignment to the course structure. We propose a model based approach that eases development of virtual experiments without dependency on software programmers for any changes. We demonstrate our model driven based approach on Chemical Sciences labs of Virtual Labs, a Government of India initiative. With our model driven based approach, the effort for new experiment development or FOSS conversion of existing experiments that were using outdated technologies is less than a person day as compared to more than a person month.

Ontologies have emerged as a common way of representing knowledge.Recently, people with minimal domain background or ontology engineering are developing ontologies, leading to a corpus of informal and under-evaluated ontologies.Existing ontology evaluation approaches require rigorous application of formal methods and knowledge of domain experts that can be cumbersome or tedious.We propose a lightweight approach for evaluating sufficiency of ontologies based on Natural Language Processing techniques.The approach consists of verifying the extent of coverage of concepts and relationships of ontologies against words in domain corpus.As a case study, we applied our approach to evaluate sufficiency of ontology in two example domains -Education (Curriculum) and Security (Phishing).We show that our approach yields promising results, is less effort intensive and is comparable with existing evaluation methods.

Software is finding place in deeply embedded systems to large scale distributed systems of cloud service providers such as Amazon and Google. Due to the concurrent and distributed nature of this software, it is hard to test for correctness of such systems in a foolproof manner. Explicit state model checking is an approach in which we build a model of the system and specify the properties it should hold. Then we construct a state transition system from the model and check if it satisfies the specified properties. There are two kinds of properties of interest: safety and liveness. In this paper, we focus our attention on safety verification, which involves checking if the states that are generated in the transition system satisfy some predicate formulae specified in the form of assertions. The main problem here is that the number of states in the transition system grows exponentially with the number of bits required to store the state of a model at any given point time. So the available main memory even in a server class machine is not sufficient to model check non-trivial practical models. One approach to address this problem is by using resources from a distributed collection of machines. In this paper, we adopt this approach, by proposing a distributed safety property verification algorithm using the vertex centric programming model.

The laboratory is an indispensable component of learning in engineering education. In this paper, we examine the impact of Advanced VLSI Virtual Lab, which is a part of the Government of India's suite of Virtual Labs, in improving the understanding and learning of students at a small sized university in India. The Advanced VLSI Virtual Lab includes ten simulated interactive experiments in the area of design and application development. Over a hundred Virtual Labs have been proposed and built, but, so far, few have been subject to systematic investigation of their effectiveness in helping the student learn. Our work is one of the first efforts to statistically study the effectiveness of the Virtual Lab. To this end, we designed and conducted pre- and post-tests, and feedback surveys on the lab. The tests and the survey, on analysis, reveal that the lab is effective in enhancing student learning. Our results are encouraging to several teachers in India who are in the midst of using Virtual Labs at their colleges.

In this paper, we present the construction and architecture of SangeetKosh: an open platform for studying North Indian or Hindustani Classical Music (HCM) on the web. This platform works on a three faceted architecture - to provide musical experiments, quizzes and drills, to host and find repositories of music, to semantically link and annotate pre-existing musical content on the web using open linked data methods. We describe the ways in which this application caters to the cultural and social problems of music students of HCM. This application is also structured to be sensitive to local context, with easy ways to translate into local languages, and make the platform accessible to a larger demographic. We present user experiments through case studies and pre and post tests to display how users are benefited by the application.

When a user learns to use a new device, her understanding of it evolves. A progressive comparison of the evolving user models towards the device target model, for analysing learning, involves determining the behavioral proximity between them. To quantify the gap between a user model and a target model, we introduce an edit distance metric for measuring their behavioral proximity using a bisimulation-based equivalence relation. We define edit distance to be the minimum number of edges and states with incident edges required to be deleted from and/or added to a user model to make it bisimilar to the target model. We propose an algorithm to compute edit distance between two models and employ the heuristic procedure on experimental data for computing edit distance between target and user models. The data is organised into two experiments depending on the device the user interacted with: (a) a simple device resembling a vending machine and (b) a close to real-world vehicle transmission model. The results validate our proposed metric as edit distance converges with progressive user learning, increases for erroneous learning, and remains unchanged indicating no learning.

This paper provides an overview of a program synthesis system for a class of quantum chemistry computations. These computations are expressible as a set of tensor contractions and arise in electronic structure modeling. The input to the system is a a high-level specification of the computation, from which the system can synthesize high-performance parallel code tailored to the characteristics of the target architecture. Several components of the synthesis system are described, focusing on performance optimization issues that they address.

Summary form only given. We address the problem of efficient out-of-core code generation for a special class of imperfectly nested loops encoding tensor contractions. These loops operate on arrays too large to fit in physical memory. The problem involves determining optimal tiling and placement of disk I/O statements. This entails a search in an explosively large parameter space. We formulate the problem as a nonlinear optimization problem and use a discrete constraint solver to generate optimized out-of-core code. Measurements on sequential and parallel versions of the generated code demonstrate the effectiveness of the proposed approach.

Distributed software component architectures provide promising approach to the problem of building large scale, scientific Grid applications [18]. Communication in these component architectures is based on Remote Method Invocation (RMI) protocols that allow one software component to invoke the functionality of another. Examples include Java remote method invocation (Java RMI)[25] and the new Simple Object Access Protocol (SOAP) [15]. SOAP has the advantage that many programming languages and component frameworks can support it. This paper describes experiments showing that SOAP by itself is not efficient enough for large scale scientific applications. However, when it is embedded in multi-protocol RMI framework, SOAP can be effectively used as a universal control protocol, that can be swapped out by faster, more special purpose protocols when large data transfer speeds are needed.