Working effectively with large, existing software systems requires strong comprehension skills, yet most graduates enter the industry with little preparation for this challenge. We report early results from a pilot intervention integrated into a SaaS company's onboarding program: a five-session course introducing systems thinking and Labelled Transition System (LTS) modelling. Participants articulated their understanding of product behaviour using a structured template and completed matched pre- and post-assessments. Of 35 new hires, 31 provided paired records for analysis. Across the full cohort, gains were small and not statistically significant. However, participants below the median on the pre-test improved by 15 percentage points on average (statistically significant), while those above the median regressed slightly (not statistically significant). Course feedback indicated high engagement and perceived applicability. These results suggest that short, modelling-focused onboarding interventions can accelerate comprehension for less-prepared new hires. At the same time, they point to the need for differentiated pathways for stronger participants, and to the potential for companies to adopt such interventions at scale as a low-cost complement to existing onboarding.

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 it seldom supports 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 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.

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.

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.

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.

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.

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.

Developing control software for cyberphysical systems 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 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.

Software-as-a-Service (SaaS) product companies have brought in significant changes in how we build software from architecture and engineering process perspective. SaaS products are large, distributed software systems hosted in cloud and built using collaborating services (or micro-services). The software releases happen in days and weeks, necessitating an agile development process. Novice engineers (those who join the company fresh from college) need to become comfortable with complex systems and proficient in agile delivery with high quality, otherwise they fall behind in productivity. The paper posits that, to be successful at these SaaS product companies, the novice engineers need good modeling and design skills. While this has been for all software development, the changes driven by SaaS products have made this need more acute. Such skills will allow them to capture their feature behaviors (in context of their understanding of the larger product) in an implementation-independent manner and any knowledge gaps can be identified and bridged by their collaborators. We propose a modeling language that is easy for them to learn and use, and which has characteristics suitable for the kind of engineering work they need to do in their early years in a SaaS product company. This modeling language is based on the notion of Transition Systems. The paper demonstrates the usage and value of this language by creating a model for a real feature. The modeling language is quite general and transcends abstraction boundaries. We also present a modeling process that should be used with this language for better results. This is a short position paper that presents an idea about a new modeling language for a specific purpose (helping novice engineers design well at SaaS product companies). Validation studies for the language and the design process is a work in progress and the results will be shared in a full paper later.

The fixed control structure of deterministic algorithms renders their behavior traceable but not amenable to interactive exploration. In the accompanying poster, we illustrate how the runs of a transition system simulating a family of algorithms form the basis for interaction and exploration. A student interacting with a transition system controls its execution. They are running a system, not merely tracing an algorithm. The runs are easy and fun to construct as pen-and-paper based classroom activities or as interactive online simulations. We illustrate the versatility of this approach for a class of swap-based sorting algorithms and other related problems.

As software systems become increasingly complex, it is important that students develop software-is-system mindset. Our research aims to help engineers comprehend architecture patterns better using systems approach. We postulate that such an understanding is aided when we enhance pattern descriptions with a System of Systems (SoS) model of the pattern to better explicate the dynamics. We demonstrate this for Model-View-Controller (MVC) pattern, a common architecture pattern for interactive applications. Such an SoS model of the pattern can also be beneficial in the teaching-learning process in a software engineering classroom.

Modern software products are complex systems and are better comprehended when engineers can think of the software as a system. Systems Science suggests that learning about a complex system is aided by modeling. It stands to reason that if we can help novice engineers model the software products as systems, it should improve their comprehension. One way of learning through modeling is to use Transition Systems to build models that we proposed in a previous paper. This requires the engineers to learn the vocabulary of Transition Systems and a way to use it to model software systems. The question arises: is it difficult to learn and use transition systems vocabulary? We hypothesize that it is not, because its vocabulary is small, and it builds on the concepts learned in other courses like Theory of Computation and Discrete Mathematics - finite-state machines and set theory. To test this hypothesis, we designed a short intervention (one lecture and one project) in a software engineering course for two cohorts of students from two different environments. We taught them basic concepts of Transition Systems and how systems can be modelled using its vocabulary and evaluated their performance on a modeling project. We also administered a survey to evaluate their perception of the topic. Both the cohorts scored well on the project and reported agreement with ease of learning and use of Transition Systems when surveyed. Based on the knowledge demonstrated and the survey feedback, we conclude that it is not difficult for them to learn the vocabulary of Transition Systems and its use. This result gives confidence to start designing longer intervention to promote use of systems modeling and study their effectiveness with large software systems.

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.

Modeling software systems as transition systems can improve system comprehension for novice engineers and graduating students. However, this requires them to learn the vocabulary of transition systems and its use. We hypothesize that it is not hard for them to do so. To test this, we did a very short intervention in a software engineering course for two cohorts of students. Based on the transition systems knowledge demonstrated by the cohorts, we conclude that it is not hard for them to learn the vocabulary of transition system and its use. This result gives confidence to start designing longer intervention and study their effectiveness.

This paper presents a knowledge-driven approach for automated synthesis of controllers in three different use-cases. The approach addresses the engineering challenge posed by Industrie 4.0, which requires fast, reliable, and flexible integration of multiple heterogeneous hardware and software components. Manual design approaches are not scalable for large systems due to their complexity. The proposed approach captures resource-capability knowledge and uses a reasoning-based synthesis mechanism to compose a controller design for a plant goal. The approach uses domain-specific languages (DSLs) to describe the components, their interfaces, and capabilities. The generated control designs are executable codes that implement the control strategy. The proposed approach reduces the average engineering time by 70% and generates on an average 60% of the executable code in each use-case. The approach uses a knowledge repository to store resource-capability knowledge and enables rapid prototyping and iterative design. The proposed approach provides a promising solution to automate the synthesis of controllers in different use-cases with multiple heterogeneous hardware and software components satisfaction.

One of the key challenges for a novice engineer in a product company is to comprehend the product sufficiently and quickly. It can take anywhere from six months to several years for them to attain mastery but they need to start delivering results much before. SaaS (Software-as-a-Service) products have sophisticated system architecture which adds to the time and effort of understanding them. On the other hand, time available to new hires for product understanding continues to be short and getting shorter, given the pressure to deliver more in less time. Constructivist theory views learning as a personal process in which the learner constructs new knowledge for themselves. Building and refining a mental model is the key way in which they learn, similar to how the brain operates. This paper presents an approach to improve system comprehension process by using a system model that a) acts as a transitional object to aid and refine the mental model of the learner, and b) captures the current understanding of the dynamics of the software system in a way that can be reasoned with and simulated. We have adapted discrete systems modeling techniques and used a transition system as a lightweight modeling language. Such a model can be used by novice engineers during their product ramp-up phase to build a model of the software system that captures their knowledge of the system and aid their mental model. The paper also presents a learning approach in which the learners create and refine these models iteratively using the available and newly uncovered knowledge about the software system. We hypothesize that by leveraging this modeling language and approach, novice engineers can reduce the time it takes them to achieve desired proficiency level of system comprehension. This paper presents early ideas on this language and approach.

An engineer in a product company is expected to design a good solution to a computing problem (Design skill) and articulate the solution well (Expression skill). We expect an industry-ready student (final year student or a fresh campus hire) as well to demonstrate both these skills when working on simple problems assigned to them. This paper reports on the results when we tested a cohort of participants (N=16) for these two skills. We created two participant groups from two different tiers of college, one from a Tier 1 college (who were taking an advanced elective course), and another from Tier 2 colleges (who had been hired for internship in a SaaS product company). We gave them a simple design problem and evaluated the quality of their design and expression. Design quality was evaluated along three design principles of Abstraction, Decomposition, and Precision (adapted from the Software Engineering Book of Knowledge). Expression quality was evaluated using criteria we developed for our study that is based on the diversity and density of the expressions used in the articulation. We found the students lacking in design and expression skills. Specifically, a) they struggled with abstraction as a design principle, b) they did not use enough modes of expressions to articulate their design, and c) they did not use enough formal notations (UML, equations, relations, etc.). We also found significant difference in the performance between the two participant groups.

Remote Triggered Labs (RTL) are helpful for students to work on laboratory experiments virtually anytime, anywhere. Such setups can facilitate distance learning and are helpful during pandemics. In this paper, the use of Computer Vision (CV) is demonstrated for RTL experiments. For this, a use-case of the Conservation of Mechanical Energy experiment is considered. A CV-based approach is used to estimate an object's velocity whose setup primarily consists of a microprocessor, a camera and infrared (IR) sensors. The experiment is recorded, and various CV techniques are employed to estimate the object's velocity. This paper also compares a CV-based and an IR sensor-based approach to estimate the object's velocity. Linear regression applied to the CV-based implementation resulted in an optimal mean-squared error (MSE), nearly 10 times better than IR-based implementation.

The annual ACM Innovations in Software Engineering Conference (ISEC) held its 14th edition online during 25–27th February, 2021. Since 2019, the conference has included a PhD symposium. The aim of the symposium is to offer PhD scholars in early stages of their research work a platform to present their work and also to get feedback from the audience. This report from the symposium co-chairs briefly summarises the effort involved in organising the symposium and a brief summary of the papers presented at the symposium.

Online education has witnessed a spike during the COVID-19 pandemic[1], due to which it is important to be performance efficient and serve the content in a reasonable time. In this case study of Virtual Labs, an e-learning platform we analyse and propose a set of approaches which helps in improving the website's performance. Virtual Labs is an e-learning website for virtual experiments in topics on science and engineering. These experiments are in the form of static webpages. This paper delineates the steps we followed to improve the performance of the static e-learning website. It shares insights into some of the concepts which can help improve the website performance.