Abstract

Algorithms are a fundamental part of computer science education, with expressing and tracing forming key aspects of their study. Both pseudocode and code are used to express algorithms. Pseudocode helps abstract away specifics of the programming language when specifying an algorithm, but it can introduce ambiguities due to its informal nature and does not support a structured way to trace an algorithm. On the other hand, tracing a program provides a precise description but can conflate algorithmic logic with language-specific details, obscuring the inherent structure of an algorithm.

In this experience report, we propose employing the Mapcode framework for expressing and tracing algorithms. Mapcode represents an algorithm as a set of transformations between well-defined spaces, naturally producing execution traces that are independent of programming constructs. Unlike traditional notional machines, which model the execution of programs, Mapcode machines model the high-level execution of algorithms. Mapcode traces reflect underlying logic and are independent of programming-language-specific data and control structures like while loops.

We report preliminary findings from two classroom activities which explored the application of Mapcode to express and trace algorithms. In the first activity, third-year undergraduate students drew Mapcode Execution Diagrams to trace simple algorithms already specified in the Mapcode framework. We found that a majority of students were successful in constructing the diagrams. In the second activity, students in a Principles of Programming Languages course successfully defined algorithms from various paradigms (greedy, dynamic programming, sorting, etc.) as Mapcode machines and implemented them in Python and Racket.

Abstract

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.

We are interested in exploring pen-and-paper activities related to tracing control-flow. While the literature presents several tracing methodologies, existing pen-and-paper activities prioritise tracking the values of variables as they change throughout the program; control-flow is not adequately addressed.

To fill this gap, we propose a comprehensive suite of class activities around control-flow of programs and report our experience deploying it in a first-year university programming course. In these activities, students construct six hand-drawn artefacts representing the static and dynamic aspects of a program's control-flow.

We use a simplified subset of Python that includes sequential, conditional, iterative and (first-order) procedural control. We chose this subset to match the syllabus of the introduction to computer programming course of our university.

We report the results of a preliminary study conducted to explore the feasibility of constructing the artefacts. Most students correctly understood the structure of the artefacts. We also report what these artefacts revealed about students' misconceptions related to control-flow in programs. Students had difficulty identifying the destination of a procedure call and its return. A significant number of their misconceptions were related to transfer of control when encountering errors.

Abstract

A system and method for implementing an experiment remotely and determining an output using a computer-vision model is provided. The system includes an image capturing device, an experiment setup, a microcontroller, a user device, and a relay unit. The microcontroller (i) receives the input of the experiment from the image capturing device,(ii) extracts one or more frames from the input data,(iii) pre-process the one or more frames to obtain a binary image,(iv) obtain a closed curve around the binary image to locate the experiment,(v) determine the coordinates of the experiment to track the experiment in each frame,(vi) determine an output of the experiment from every two consecutive frames of the one or more frames, and (vii) optimize the determined output of the experiment using a linear regression model.

Abstract

When novice engineers (fresh or recent graduates with little industry experience) join a SaaS (Software-as-a-Service) product company, they are tasked with comprehending the product, especially
its behavior and dynamics. We believe that they can comprehend
more effectively if they know and understand the architecture patterns used in the product.
Are the current architecture pattern descriptions of high quality?
Do they fit the needs of novice engineers?
We evaluated the pattern descriptions of Model-View-Controller
(MVC) (a popular and important architecture pattern for cloud
systems) from a quality and fitment perspective and found gaps.
To address these gaps, we have built a System of Systems (SoS)
model of MVC that uses a transition systems vocabulary and a
set-theoretic notation. In the paper, we show that this SoS model
provides a rich set of information about the behavior and dynamics
of the MVC components and their interactions. The model bridges
the gaps in the MVC pattern description.
One of the contributions of the paper is to provide criteria to
evaluate the pattern descriptions for quality and fitment for novice
engineers. The paper proposes that we augment the benchmark
pattern description of MVC with an SoS model. The paper also
demonstrates a general approach to building SoS models for architecture patterns and recommends creating a catalog of SoS models
for SaaS architecture patterns. We believe such a catalog will significantly help novice engineers in comprehension and other software
engineering activities.

Abstract

Remote labs are a groundbreaking development in the education industry, providing students with access to laboratory education anytime, anywhere. However, most remote labs are costly and difficult to scale, especially in developing countries. With this as a motivation, this paper proposes a new remote labs (RLabs) solution that includes two use case experiments: Vanishing Rod and Focal Length. The hardware experiments are built at a low-cost by retrofitting Internet of Things (IoT) components. They are also made portable by designing miniaturised and modular setups. The software architecture designed as part of the solution seamlessly supports the scalability of the experiments, offering compatibility with a wide range of hardware devices and IoT platforms. Additionally, it can live-stream remote experiments without needing dedicated server space for the stream. The software architecture also includes an automation suite that periodically checks the status of the experiments using computer vision (CV). The software architecture is further assessed for its latency and performance. RLabs is qualitatively evaluated against seven non-functional attributes - affordability, portability, scalability, compatibility, maintainability, usability, and universality. Finally, user feedback was collected from a group of students, and the scores indicate a positive response to the students' learning and the platform's usability.

Abstract

Controller synthesis is pivotal in automating control system design from formal specifications
and enhancing industrial system verification and optimization processes. This paper critically
evaluates LTL-based controller synthesis, highlighting significant gaps in tool support that hinder its
widespread adoption in the industry. Despite substantial theoretical progress, an apparent disparity
persists between academic research outcomes and the robust, practical tools demanded by industry.
Through a comprehensive evaluation, this study reveals mismatches between industrial requirements
and the capabilities of current open-source tools. The findings emphasize underexplored challenges
and propose future research directions and strategies for practical integration. This work aims to
bridge the gap by advocating for enhanced tool support, enabling solutions that align with industrial
standards and fostering the broader application of controller synthesis across various sectors.

Abstract

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 paper 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 (i) a unique classification of literature into six research themes--engineering phases,
engineering approaches, engineering paradigms, engineering artefacts, target application domains, and
engineering concerns; (ii) insights into the specificity of approaches to target technologies and phases; (iii) the
prominence of model-driven approaches for design and testing; (iv) the lack of end-to-end engineering support
in existing approaches; and (v) the emerging role of agile-based methods versus the dominance of waterfallbased methods. This paper'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
paper's impact.

Abstract

Dynamic control software reconfiguration for the
Internet of Things (IoT) and cyber-physical systems (CPS) is crucial for adaptable and efficient automation. This paper 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 knowledgedriven approach.

Abstract

Developing control software for Cyber-Physical Systems (CPS) and
industrial automation faces challenges like hardware integration, real-time
responsiveness, and high reliability. Traditional environments often lack
domain-specific knowledge, leading to inefficiencies. This paper introduces the
Knowledge-aided Integrated Development Environment (K-IDE), which integrates
domain knowledge into the software lifecycle, improving efficiency, consistency,
and maintainability. K-IDE uses domain-specific languages (DSLs) and knowledge
graphs to automate design and code generation. Key findings show that K-IDE
significantly reduces development time and errors compared to traditional IDEs,
proving effective in robotics and industrial automation. K-IDE bridges the gap
between abstract designs and concrete implementations, offering a robust
solution for modern control software development.

Abstract

Remote Labs refer to an end-to-end system, including hardware and software built to access scientific equipment and resources remotely. The software platform built for such purposes needs to be robust enough to handle the communication of inputs and outputs between the client and the hardware nodes with minimal latency and simultaneously provide a seamless user experience. This paper highlights the importance of scalability in Remote Labs and presents multi-user multiplexing as a solution, to essentially provide users with concurrent access to the hardware node for experiments which can generate outputs instantaneously. The paper discusses the inefficiency of existing web-based Remote Labs with 4-layered architectures and proposes the use of WebSocket with a 3-layer software architecture to enhance user experience, accelerate input-output communication and implement multi-user multiplexing. To showcase the effectiveness of the proposed architecture over existing implementations using Blynk IoT platform as the middleware, a comprehensive communication pipeline was developed from scratch to perform Kirchhoff's Voltage Law (KVL) experiment remotely.