Urban bus transit agencies need reliable, network-wide delay predictions to provide accurate arrival information to passengers and support real-time operational control. Accurate predictions help passengers plan their trips, reduce waiting time, and allow operations staff to adjust headways, dispatch additional vehicles, and manage disruptions. Although real-time feeds such as GTFS-RT are now widely available, most existing delay prediction systems handle only a few routes, rely on hand-crafted features, and offer little guidance on designing a scalable, reusable architecture. We present a city-scale prediction pipeline that combines multi-resolution feature engineering, dimensionality reduction, and deep learning. The framework systematically generates spatiotemporal features by exploring aggregation combinations over spatial regions (using hexagonal hierarchical indexing), routes, segments, and temporal patterns, then compresses them using Adaptive PCA while preserving 95 % of the variance. To avoid the “giant cluster” problem that occurs when dense urban areas fall into a single spatial region, we introduce a hybrid clustering method that combines geographic and network topology information to yield balanced route clusters and enable efficient distributed training. We compare five model architectures on six months of bus operations from the Société de transport de Montréal (STM) network in Montréal. A global LSTM with cluster-aware features achieves the best trade-off between accuracy and efficiency ( R 2 = 0 . 7121 at the elementary level), outperforming transformer models by 18 % to 43 % while using 275 × fewer parameters. LSTM’s compact architecture (31,000 parameters) effectively captures short-term temporal dependencies in the compressed feature space, making it more suitable than transformer models, which are overparameterized for this task. We also report multi-level evaluation at the elementary segment, segment, and trip level using walk-forward validation and latency analysis, showing that the proposed pipeline is suitable for real-time, city-scale deployment and can be reused for other networks with limited adaptation.

This paper presents a methodology and an associated platform for classifying and visualizing schedule deviations in public transit systems. Applied to the Montreal public transit network, the work offers two main contributions: (1) a methodology integrating real-time transit data processing (GTFS-RT), systematic/stochastic deviation classification, and multi-resolution spatial analysis using the Hexagonal Hierarchical Spatial Index (H3) system (Resolutions 9 and 10); (2) an interactive visualization platform employing KeplerGL, built upon this methodology, enabling dynamic exploration of spatio-temporal deviation patterns. The platform reveals significant schedule deviations across Montreal's network. While preliminary, the visualized patterns provide data-driven evidence to generate actionable hypotheses and guide further investigation for transit optimization and urban planning, particularly in identifying delay-prone areas and understanding spatial delay propagation.

Metropolitan cities heavily rely on Intelligent Transportation Systems (ITS) to enhance the overall well-being of their citizens. Despite the implementation of various policies and strategies aimed at improving the reliability and quality of public transportation services, transit authorities consistently face criticism from commuters. The main cause of dissatisfaction arises from deviations in scheduled bus arrival times, leading to either early or late arrivals that disrupt the schedules of commuters. These deviations can result in missed appointments, prolonged wait times at bus stops, and instances of being late for work. This paper provides a preliminary analysis of the public transit system in Montreal City, focusing on delays and deviations. It utilizes planned and real-time transit data to quantify, locate, and classify deviations as systematic (i.e., deviations that are accommodated in the schedules by the transit authority) or stochastic (unforeseen deviations, e.g., due to sudden road accidents). The paper also explores using machine learning models to predict stochastic delays.

UML is the standard in software modeling and enjoys widespread use across various domains. However, domains like cyber-physical systems necessitate developers to model across diverse domains. The diverse use of UML underscores the need for tools to be interoperable. Unfortunately, a significant limitation in many UML tools is their lack of robust interoperability, impeding their integration into industrial projects, including cyber-physical systems. This paper proposes an approach to address the interoperability challenges between UML tools. We implemented this approach within an existing tool, USE, improving its ability to interact seamlessly with five widely used UML tools.

To succeed with the development of modern software, organizations must have the agility to adapt faster to constantly evolving environments to deliver more reliable and optimized solutions that can be adapted to the needs and environments of their stakeholders including users, customers, business, development, and IT. However, stakeholders do not have sufficient automated support for global decision making, considering the increasing variability of the solution space, the frequent lack of explicit representation of its associated variability and decision points, and the uncertainty of the impact of decisions on stakeholders and the solution space. This leads to an ad-hoc decision making process that is slow, error-prone, and often favors local knowledge over global, organization-wide objectives. The Multi-Plane Models and Data (MP-MODA) framework explicitly represents and manages variability, impacts, and decision points. It enables automation and tool support in aid of a multi-criteria decision making process involving different stakeholders within a feedback-driven software development process where feedback cycles aim to reduce uncertainty. We present the conceptual structure of the framework, discuss its potential benefits, and enumerate key challenges related to tool supported automation and analysis within MP-MODA.

Abstract Context Tangled commits are changes to software that address multiple concerns at once. For researchers interested in bugs, tangled commits mean that they actually study not only bugs, but also other concerns irrelevant for the study of bugs. Objective We want to improve our understanding of the prevalence of tangling and the types of changes that are tangled within bug fixing commits. Methods We use a crowd sourcing approach for manual labeling to validate which changes contribute to bug fixes for each line in bug fixing commits. Each line is labeled by four participants. If at least three participants agree on the same label, we have consensus. Results We estimate that between 17% and 32% of all changes in bug fixing commits modify the source code to fix the underlying problem. However, when we only consider changes to the production code files this ratio increases to 66% to 87%. We find that about 11% of lines are hard to label leading to active disagreements between participants. Due to confirmed tangling and the uncertainty in our data, we estimate that 3% to 47% of data is noisy without manual untangling, depending on the use case. Conclusion Tangled commits have a high prevalence in bug fixes and can lead to a large amount of noise in the data. Prior research indicates that this noise may alter results. As researchers, we should be skeptics and assume that unvalidated data is likely very noisy, until proven otherwise.

Recently, Computer Science (CS) education has experienced a renewed interest, driven by the demand in the fast-changing job market. This renewed interest created an uptick of enrollment in computer science courses. Increased number of students search for information about CS courses and professors. Often times, students turn to a professor's profile on online sites, e.g. RateMyProfessor.com (RMP), to read feedback and assessments made by other students. Student Evaluations of Teaching (SETs), conducted online or on paper, are widely used to assess and improve the teaching quality of professors, and to provide critical assessment of the teaching material and content. This paper studies the role of race and gender of computer science professors on their teaching evaluation by analyzing the publicly available data of over 39,000 CS professors on RateMyProfessor. We found that women are generally rated lower then men in overall teaching quality. They are also perceived lower in personality-related student feedback ratings, i.e. they perceived less humorous, and less inspirational. We also found that Asian professors are perceived to be tough graders and lecture heavy. They are also perceived to be more difficult in general.

Learning how to model the structural properties of a problem domain or an object-oriented design in the form of a class diagram is an essential learning task in many software engineering courses. Since the grading of models is a time-consuming activity, automated grading approaches have been developed to assist the instructor by speeding up the grading process, as well as ensuring consistency and fairness for large classrooms. This paper empirically evaluates the efficacy of one such automated grading approach when applied in two real world settings: a beginner undergraduate class of 103 students required to create an object-oriented design model, and an advanced undergraduate class of 89 students elaborating a domain model. The results of the experiment highlight a) the need to adapt the grading strategy and strictness to the level of the students and the grading style of the instructor, and b) the importance of considering multiple solution variants when grading. Modifications to the grading algorithm are proposed and validated experimentally.

Extension is a common term used in model-driven engineering. However, it is expressed in different ways by different modeling languages. A class diagram modeler uses extension to mean inheriting from a class. An aspect modeler extends a base with an aspect. Despite the different ways the term is being expressed, it generally refers to adding/changing structure/behaviour of a model in some way. We observe that model extensions vary in several ways. For example, in some cases, such as in use case diagram extensions, the extended model (base model) is information complete, meaning that it requires no further information in order for it to be useful. In other languages, the base model is not useful on its own and must be completed with an extension. Extensions also vary in terms of granularity, e.g., inheritance between two classes is an extension at a low level of granularity (between two elements, i.e., classes, of the same class diagram) compared to extension between two models. This paper presents a feature model for extensions in modeling languages. We discuss how extensions vary in terms of granularity, the completeness of the base model, whether or not the extension model requires to specify matching information, and the changes the composed model does to the base. Using this feature model, we explore extensions in several popular modeling languages and report our findings.

This paper proposes an Agile Concern-Driven Development (Agile CDD) process, a software development process that uses concerns as its primary artifact and applies agile practices. Whereas classical Model-Driven Engineering (MDE) methodologies focus on models that are built from scratch with little support for reuse, Agile CDD is a reuse-focused development process in which an application is built incrementally by repeatedly reusing other existing concerns. In Agile CDD, a modeler would use a modelling language that is appropriate for the current development phase and for the problem domain. Model transformations would then be applied to produce the initial set of models for the next phase. The process will continue until an execute model is produced. In each phase, the modeller should consult a repository of reusable concerns to identify and reuse concerns. Changing requirements are welcome and incomplete implementations are moved to the next iteration by delaying design decisions.

Like any other software artifact, models evolve and need to be versioned. In the last few years, dedicated support for model versioning has been proposed to improve the default text-based versioning that version control systems offer. However, there is still the need to comprehend model differences in terms of the semantics of the modeling language. For this purpose, we propose a comprehensive approach that considers both abstract and concrete syntax, to express model differences in terms of the domain-specific language (DSL) used and define domain-specific semantics for specific difference patterns. The approach is based on the automatic extension of the DSL to enable the representation of changes, on the definition of rules to capture recurrent domain-specific difference patterns, and on the automatic adaptation of the graphical concrete syntax to visualize the differences. We present a prototype tool support and discuss its application on versioned models created by third parties.

Summary Concern‐oriented reuse (CORE) proposes the concern as a new unit of model‐based reuse encapsulating software artefacts pertaining to a domain of interest that span multiple development phases and levels of abstraction. With CORE, a concern encapsulates multiple reusable features, while allowing its generic models to be customized to problem‐specific contexts. We report on our experience of designing a family of crisis management systems (CMS) with the help of reusable concern libraries. The collected metrics show a considerable amount of reuse in our CMS design. The study provides encouraging evidence that CORE's vision to create large‐scale, generic and reusable entities that are expressed with the most appropriate modelling formalisms at the right level of abstraction is feasible. We present our experience in the design of the CMS and elaborate on the advantages as well as the efforts required to adopt CORE in an industrial setting. Copyright © 2016 John Wiley & Sons, Ltd.

Concern-Oriented Reuse (CORE) proposes a new way of structuring model-driven software development, where models of the system are modularized by domains of abstraction within units of reuse called concerns. Within a CORE concern, models are further decomposed and modularized by features. This paper extends CORE with a technique that enables developers of high-level concerns to reuse lower-level concerns without unnecessarily committing to a specific feature selection. The developer can select the functionality that is minimally needed to continue development, and reexpose relevant alternative lower-level features of the reused concern in the reusing concern's interface. This effectively delays decision making about alternative functionality until the higher-level reuse context, where more detailed requirements are known and further decisions can be made. The paper describes the algorithms for composing the variation (i.e., feature and impact models), customization, and usage interfaces of a concern, as well as the concern's realization models and finally an entire concern hierarchy, as is necessary to support delayed decision making in CORE.

Tracking the progress of a project is often done through imprecise manually gathered information, like progress reports, or through automatic metrics such as Lines Of Code (LOC). Such metrics are too coarse-grained and too imprecise to capture all facets of a project. In this paper, we mine the code changes in the source code repository and study the concept of time dependence of code changes. Using this concept, we can track the progress of a software project as the progress of a building. We can examine how changes build on each other over time and determine the impact of these changes on the quality of a project. In particular, we study whether new changes are built just-in-time or if they build on older, stable code. Through a case study on two large open source projects (PostgreSQL and FreeBSD), we show that time dependence varies across projects and throughout the lifetime of each project. We also show that there is a high linear correlation between building on new code and the occurrence of bugs.