Journal of Computer Languages最新文献

Design pattern for reusing immutable methods in object-oriented languages 面向对象语言中重用不可变方法的设计模式

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2026-01-20 DOI: 10.1016/j.cola.2026.101385

William Flageol , Yann-Gaël Guéhéneuc , Stefan Monnier , Mourad Badri

Programming concepts from functional programming have grown in popularity and have been introduced in object-oriented programming. Among these concepts, immutability is a core concept of functional programming, which brings advantages to software development. However, introducing immutability in object-oriented programming languages presents some challenges.

Problem:

One of these challenges, in the concept of inheritance, is overriding of non-destructive mutators. Mutators are necessary for updating data as a software is running. Non-destructive mutators are mutators on immutable objects, which return new objects instead of modifying the receiver. When inheriting non-destructive mutators, a naive implementation will yield code duplication and have code scalability issues.

Contribution:

We analyze an example of overriding non-destructive mutators, discuss the challenges, and propose a solution that takes the form of a new design pattern, inspired from the Factory Method pattern. We also discuss the advantages and limitations of this pattern, as well as implementations in eight languages (Clojure, Common Lisp, C#, Java, Kotlin, OCaml, Rust, and Scala). We finally identify and discuss the language features that mostly affect the implementation of this pattern, and present a language extension to Common Lisp to demonstrate the effects of those features on the implementation.

Conclusion:

Our proposed design pattern helps reduce the code duplication and improve the code scalability of a naive implementation of inherited non-destructive mutators. However, using a language which includes features for functional updating is required to completely remove the code scalability issues of the implementation. We conclude that object-oriented programming languages should consider adding functional updating to their language features to better support their new functional programming features.

函数式编程的编程概念越来越流行，并被引入到面向对象编程中。在这些概念中，不变性是函数式编程的核心概念，它给软件开发带来了优势。然而，在面向对象编程语言中引入不变性会带来一些挑战。问题：在继承的概念中，其中一个挑战是对非破坏性突变的重写。当软件运行时，mutator对于更新数据是必需的。非破坏性mutator是对不可变对象的mutator，它返回新对象而不修改接收者。当继承非破坏性变量时，幼稚的实现将产生代码重复，并存在代码可伸缩性问题。贡献：我们分析了一个覆盖非破坏性突变的示例，讨论了其中的挑战，并提出了一个解决方案，该解决方案采用了一种受工厂方法模式启发的新设计模式的形式。我们还讨论了这种模式的优点和局限性，以及在八种语言（Clojure、Common Lisp、c#、Java、Kotlin、OCaml、Rust和Scala）中的实现。最后，我们确定并讨论了主要影响该模式实现的语言特性，并给出了Common Lisp的语言扩展，以演示这些特性对实现的影响。结论：我们提出的设计模式有助于减少代码重复并提高继承的非破坏性突变的初始实现的代码可伸缩性。然而，使用包含功能更新特性的语言是完全消除实现的代码可伸缩性问题所必需的。我们的结论是，面向对象编程语言应该考虑在其语言特性中添加函数更新，以更好地支持新的函数式编程特性。

{"title":"Design pattern for reusing immutable methods in object-oriented languages","authors":"William Flageol , Yann-Gaël Guéhéneuc , Stefan Monnier , Mourad Badri","doi":"10.1016/j.cola.2026.101385","DOIUrl":"10.1016/j.cola.2026.101385","url":null,"abstract":"<div><div>Programming concepts from functional programming have grown in popularity and have been introduced in object-oriented programming. Among these concepts, immutability is a core concept of functional programming, which brings advantages to software development. However, introducing immutability in object-oriented programming languages presents some challenges.</div></div><div><h3>Problem:</h3><div>One of these challenges, in the concept of inheritance, is overriding of non-destructive mutators. Mutators are necessary for updating data as a software is running. Non-destructive mutators are mutators on immutable objects, which return new objects instead of modifying the receiver. When inheriting non-destructive mutators, a naive implementation will yield code duplication and have code scalability issues.</div></div><div><h3>Contribution:</h3><div>We analyze an example of overriding non-destructive mutators, discuss the challenges, and propose a solution that takes the form of a new design pattern, inspired from the Factory Method pattern. We also discuss the advantages and limitations of this pattern, as well as implementations in eight languages (Clojure, Common Lisp, C#, Java, Kotlin, OCaml, Rust, and Scala). We finally identify and discuss the language features that mostly affect the implementation of this pattern, and present a language extension to Common Lisp to demonstrate the effects of those features on the implementation.</div></div><div><h3>Conclusion:</h3><div>Our proposed design pattern helps reduce the code duplication and improve the code scalability of a naive implementation of inherited non-destructive mutators. However, using a language which includes features for functional updating is required to completely remove the code scalability issues of the implementation. We conclude that object-oriented programming languages should consider adding functional updating to their language features to better support their new functional programming features.</div></div>","PeriodicalId":48552,"journal":{"name":"Journal of Computer Languages","volume":"86 ","pages":"Article 101385"},"PeriodicalIF":1.8,"publicationDate":"2026-01-20","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"146038068","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":3,"RegionCategory":"计算机科学","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 0

Assessing Python’s suitability for airborne safety-critical systems under DO-178C guidelines 根据DO-178C指南评估Python对机载安全关键系统的适用性

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-12-27 DOI: 10.1016/j.cola.2025.101383

Mohammad Mari, Lian Wen

Python is a widely adopted programming language celebrated for its ease of use, dynamic typing, and strong community support. Despite these advantages, Python presents challenges when considered for safety-critical applications, notably those in airborne systems. Concerns arise from performance limitations, limited compile-time checking, and dynamic features that may impact reliability in environments where failures can have severe consequences. Airborne systems, with their stringent safety requirements, provide a context in which these challenges can be critically examined.

This study evaluates Python’s alignment with the objectives defined in DO-178C (Software Considerations in Airborne Systems and Equipment Certification). By analyzing Python’s core characteristics against these rigorous standards, we highlight potential compliance gaps and practical challenges that may hinder its use in safety-critical contexts.

In addition, we perform a comparative analysis between Python and Rust—a modern systems programming language noted for its safety guarantees and performance. Rust was selected not as a replacement for established baselines such as Ada, C, and C++, but as a complementary point of comparison illustrating how a newer, safety-oriented compiled language contrasts with Python’s interpreted model. Our findings indicate that Python lacks compile-time error checking, exhibits delayed signal handling, and has limited optimization capabilities, which together may affect its performance and reliability. Potential enhancements such as Just-In-Time (JIT) compilation, advanced static analysis, and robust type-checking tools are recommended to mitigate these issues. Overall, our study emphasizes both the strengths and limitations of Python and suggests pathways to improve its viability for safety-critical use.

Python是一种被广泛采用的编程语言，以其易于使用、动态类型和强大的社区支持而闻名。尽管有这些优势，Python在考虑安全关键应用程序时仍面临挑战，特别是在机载系统中。问题来自于性能限制、有限的编译时检查和动态特性，这些特性可能会影响环境中的可靠性，在这些环境中，故障可能会产生严重的后果。机载系统具有严格的安全要求，为这些挑战提供了一个可以严格审查的环境。本研究评估了Python与DO-178C（机载系统和设备认证中的软件考虑）中定义的目标的一致性。通过对照这些严格的标准分析Python的核心特征，我们强调了可能阻碍其在安全关键环境中使用的潜在遵从性差距和实际挑战。此外，我们还对Python和rust（一种以安全保证和性能著称的现代系统编程语言）进行了比较分析。选择Rust并不是为了替代Ada、C和c++等已建立的基准，而是作为一个互补的比较点，说明一种新的、面向安全的编译语言与Python的解释模型之间的对比。我们的研究结果表明，Python缺乏编译时错误检查，表现出延迟的信号处理，并且优化能力有限，这些都可能影响其性能和可靠性。建议使用即时（JIT）编译、高级静态分析和健壮的类型检查工具等潜在增强功能来缓解这些问题。总的来说，我们的研究强调了Python的优势和局限性，并提出了提高其安全关键应用可行性的途径。

{"title":"Assessing Python’s suitability for airborne safety-critical systems under DO-178C guidelines","authors":"Mohammad Mari, Lian Wen","doi":"10.1016/j.cola.2025.101383","DOIUrl":"10.1016/j.cola.2025.101383","url":null,"abstract":"<div><div>Python is a widely adopted programming language celebrated for its ease of use, dynamic typing, and strong community support. Despite these advantages, Python presents challenges when considered for safety-critical applications, notably those in airborne systems. Concerns arise from performance limitations, limited compile-time checking, and dynamic features that may impact reliability in environments where failures can have severe consequences. Airborne systems, with their stringent safety requirements, provide a context in which these challenges can be critically examined.</div><div>This study evaluates Python’s alignment with the objectives defined in DO-178C (Software Considerations in Airborne Systems and Equipment Certification). By analyzing Python’s core characteristics against these rigorous standards, we highlight potential compliance gaps and practical challenges that may hinder its use in safety-critical contexts.</div><div>In addition, we perform a comparative analysis between Python and Rust—a modern systems programming language noted for its safety guarantees and performance. Rust was selected not as a replacement for established baselines such as Ada, C, and C++, but as a complementary point of comparison illustrating how a newer, safety-oriented compiled language contrasts with Python’s interpreted model. Our findings indicate that Python lacks compile-time error checking, exhibits delayed signal handling, and has limited optimization capabilities, which together may affect its performance and reliability. Potential enhancements such as Just-In-Time (JIT) compilation, advanced static analysis, and robust type-checking tools are recommended to mitigate these issues. Overall, our study emphasizes both the strengths and limitations of Python and suggests pathways to improve its viability for safety-critical use.</div></div>","PeriodicalId":48552,"journal":{"name":"Journal of Computer Languages","volume":"86 ","pages":"Article 101383"},"PeriodicalIF":1.8,"publicationDate":"2025-12-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"145884600","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":3,"RegionCategory":"计算机科学","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 0

Teaching introductory programming in top universities: A global study of languages, paradigms, assessment, and AI 在顶尖大学教授编程入门：语言、范式、评估和人工智能的全球研究

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-12-24 DOI: 10.1016/j.cola.2025.101384

João Pedro Gomes , Redney Monteiro , André Silva Moreira , Vítor Mendonça , Anabela Pinho , Carlos R. Cunha

This study examines the first two introductory computer science courses (CS1 and CS2) at the world's top universities, focusing on the choice of programming languages and paradigms, assessment types and weights, and policies regarding student use of AI tools. Data were compiled from 150 programming courses across 83 institutions ranked in the Shanghai 2023 Global Ranking of Academic Subjects for Computer Science & Engineering. The analysis reveals that the prevailing languages are Python in CS1 (32.5 %) and Java in CS2 (56.7 %). Typical transitions from CS1 to CS2 involve moving from Python or C to Java. There are some regional preferences: Asian institutions favor lower-level languages like C and C++, whereas European universities explore functional programming languages like Haskell. Regarding programming paradigms, CS1 emphasizes imperative approaches, sometimes introducing object-oriented concepts later in the course, while CS2 consolidates object-oriented programming. However, some CS1 courses adopt a functional paradigm. Course assessments are typically divided into several categories, with a preference for exams and various types of continuous assessments. However, there is also significant use of projects, quizzes, and labs. Examinations usually have the highest weight in the final grade. Course-level policies on students' use of generative AI tools reveal very different approaches, from complete prohibition to active encouragement. These findings offer valuable insights into how leading universities approach programming education in a multidimensional view that includes languages, paradigms, assessments, and AI tools policies.

本研究考察了世界顶尖大学的前两门计算机科学入门课程（CS1和CS2），重点关注编程语言和范式的选择、评估类型和权重，以及学生使用人工智能工具的政策。数据来自入选《上海2023全球计算机科学与工程学科排名》的83所院校的150门编程课程。分析显示，CS1中的Python（32.5%）和CS2中的Java（56.7%）是主流语言。从CS1到CS2的典型转换包括从Python或C迁移到Java。有一些地区的偏好：亚洲的大学倾向于C和c++等低级语言，而欧洲的大学则倾向于Haskell等函数式编程语言。在编程范式方面，CS1强调命令式方法，有时在课程后期引入面向对象的概念，而CS2则巩固面向对象的编程。然而，一些CS1课程采用功能范式。课程评估通常分为几个类别，优先考虑考试和各种类型的连续评估。然而，也有大量的项目、测验和实验。考试通常在期末成绩中占有最高的权重。课程层面对学生使用生成式人工智能工具的政策揭示了截然不同的方法，从完全禁止到积极鼓励。这些发现为一流大学如何从多维角度（包括语言、范式、评估和人工智能工具政策）进行编程教育提供了有价值的见解。

{"title":"Teaching introductory programming in top universities: A global study of languages, paradigms, assessment, and AI","authors":"João Pedro Gomes , Redney Monteiro , André Silva Moreira , Vítor Mendonça , Anabela Pinho , Carlos R. Cunha","doi":"10.1016/j.cola.2025.101384","DOIUrl":"10.1016/j.cola.2025.101384","url":null,"abstract":"<div><div>This study examines the first two introductory computer science courses (CS1 and CS2) at the world's top universities, focusing on the choice of programming languages and paradigms, assessment types and weights, and policies regarding student use of AI tools. Data were compiled from 150 programming courses across 83 institutions ranked in the Shanghai 2023 Global Ranking of Academic Subjects for Computer Science & Engineering. The analysis reveals that the prevailing languages are Python in CS1 (32.5 %) and Java in CS2 (56.7 %). Typical transitions from CS1 to CS2 involve moving from Python or C to Java. There are some regional preferences: Asian institutions favor lower-level languages like C and C++, whereas European universities explore functional programming languages like Haskell. Regarding programming paradigms, CS1 emphasizes imperative approaches, sometimes introducing object-oriented concepts later in the course, while CS2 consolidates object-oriented programming. However, some CS1 courses adopt a functional paradigm. Course assessments are typically divided into several categories, with a preference for exams and various types of continuous assessments. However, there is also significant use of projects, quizzes, and labs. Examinations usually have the highest weight in the final grade. Course-level policies on students' use of generative AI tools reveal very different approaches, from complete prohibition to active encouragement. These findings offer valuable insights into how leading universities approach programming education in a multidimensional view that includes languages, paradigms, assessments, and AI tools policies.</div></div>","PeriodicalId":48552,"journal":{"name":"Journal of Computer Languages","volume":"86 ","pages":"Article 101384"},"PeriodicalIF":1.8,"publicationDate":"2025-12-24","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"145925531","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":3,"RegionCategory":"计算机科学","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 0

Efficient indexing and querying spatial-keyword data in main memory 高效索引和查询主存中的空间关键字数据

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-12-15 DOI: 10.1016/j.cola.2025.101382

Raúl García-Muñoz , Francisco García-García , Antonio Corral , Michael Vassilakopoulos

The increasing use of GPS-enabled mobile devices and the popularity of location-based services have fueled demand for spatial keyword (SK) queries, which fuse a geographic location with descriptive text. To meet this demand, this paper proposes an improved in-memory IR-tree structure for efficiently storing and querying spatio-textual data. The research details the structure’s design and implementation, alongside efficient in-memory query algorithms, a novel algorithm for the spatio-textual similarity join query. Exhaustive experiments with real-world datasets demonstrate that the proposed in-memory IR-tree and its algorithms offer excellent performance, significantly accelerating the processing of all tested SK queries.

支持gps的移动设备的使用越来越多，以及基于位置的服务的普及，推动了对空间关键字（SK）查询的需求，这种查询将地理位置与描述性文本融合在一起。为了满足这一需求，本文提出了一种改进的内存ir树结构，用于高效地存储和查询空间文本数据。该研究详细介绍了结构的设计和实现，以及高效的内存查询算法，一种用于空间-文本相似连接查询的新算法。对真实数据集的详尽实验表明，所提出的内存ir树及其算法提供了出色的性能，显著加快了所有测试SK查询的处理速度。

引用次数: 0

GeckoGraph: A visual language for polymorphic types GeckoGraph：多态类型的可视化语言

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-12-04 DOI: 10.1016/j.cola.2025.101381

Shuai Fu, Tim Dwyer, Peter J. Stuckey, John C. Grundy

Polymorphic type is an important feature in most strongly typed programming languages. They allow functions to be written in a way that can be used with different data types, while still enforcing the relationship and constraints between the values. However, programmers often find polymorphic types difficult to use and understand, and tend to reason in terms of concrete types. We propose GeckoGraph, a graphical notation for types. GeckoGraph aims to complement traditional text-based type notation by making reading, understanding, and comparing types easier. We conducted a large-scale user study comparing GeckoGraph to text-based type notation. To our knowledge, this is the largest controlled user study on functional programming ever conducted. The results show no overall significant differences in task completion time or success rate. However, we observed a modest improvement in success rate among beginner participants. For the most challenging task, GeckoGraph improved success rates by 14.5% for beginners and 11.2% for less experienced users. These findings suggest that GeckoGraph has potential as a teaching and learning aid for polymorphic type systems.

多态类型是大多数强类型编程语言的一个重要特征。它们允许以可用于不同数据类型的方式编写函数，同时仍然强制值之间的关系和约束。然而，程序员经常发现多态类型难以使用和理解，并且倾向于根据具体类型进行推理。我们提出GeckoGraph，一种类型的图形符号。GeckoGraph旨在通过简化类型的阅读、理解和比较来补充传统的基于文本的类型表示法。我们对GeckoGraph和基于文本的类型表示法进行了大规模的用户研究。据我们所知，这是迄今为止对函数式编程进行的最大的受控用户研究。结果显示，在任务完成时间或成功率方面，总体上没有显著差异。然而，我们观察到初学者的成功率有适度的提高。对于最具挑战性的任务，GeckoGraph将初学者的成功率提高了14.5%，将经验不足的用户的成功率提高了11.2%。这些发现表明GeckoGraph有潜力作为多态类型系统的教学辅助工具。

{"title":"GeckoGraph: A visual language for polymorphic types","authors":"Shuai Fu, Tim Dwyer, Peter J. Stuckey, John C. Grundy","doi":"10.1016/j.cola.2025.101381","DOIUrl":"10.1016/j.cola.2025.101381","url":null,"abstract":"<div><div>Polymorphic type is an important feature in most strongly typed programming languages. They allow functions to be written in a way that can be used with different data types, while still enforcing the relationship and constraints between the values. However, programmers often find polymorphic types difficult to use and understand, and tend to reason in terms of concrete types. We propose GeckoGraph, a graphical notation for types. GeckoGraph aims to complement traditional text-based type notation by making reading, understanding, and comparing types easier. We conducted a large-scale user study comparing GeckoGraph to text-based type notation. To our knowledge, this is the largest controlled user study on functional programming ever conducted. The results show no overall significant differences in task completion time or success rate. However, we observed a modest improvement in success rate among beginner participants. For the most challenging task, GeckoGraph improved success rates by 14.5% for beginners and 11.2% for less experienced users. These findings suggest that GeckoGraph has potential as a teaching and learning aid for polymorphic type systems.</div></div>","PeriodicalId":48552,"journal":{"name":"Journal of Computer Languages","volume":"86 ","pages":"Article 101381"},"PeriodicalIF":1.8,"publicationDate":"2025-12-04","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"145738156","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":3,"RegionCategory":"计算机科学","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 0

Software design smells prediction using machine learning with evolutionary and structural metrics of source code 软件设计使用带有源代码进化和结构度量的机器学习进行气味预测

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-11-29 DOI: 10.1016/j.cola.2025.101373

Kapil Sharma, Jitender Kumar Chhabra

Software design smells refer to structural abnormalities in a software system that negatively impact maintainability and evolution. Prior research relies on structural metrics for software smell prediction and did not consider the evolutionary aspect. This paper proposes an evolutionary and structural metrics-based method for predicting design smells. A dataset has been curated using multiple versions of Java projects. The proposed method uses ensemble classifiers for classification of design smells, and findings show that adding evolutionary features with structural makes predictions more accurate. In all the design smells, both evolutionary and structural metrics together work better than using structural metrics alone.

软件设计气味指的是软件系统中对可维护性和进化产生负面影响的结构异常。先前的研究依赖于软件气味预测的结构度量，而没有考虑进化方面。本文提出了一种基于进化和结构度量的设计气味预测方法。使用多个版本的Java项目来管理数据集。该方法使用集成分类器对设计气味进行分类，结果表明，在结构中加入进化特征可以使预测更加准确。在所有的设计气味中，进化和结构指标结合起来比单独使用结构指标效果更好。

引用次数: 0

Fast topology density map 快速拓扑密度图

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-11-01 DOI: 10.1016/j.cola.2025.101371

Zhicheng Hu , Agus Hasan , Ricardo da Silva Torres

Density map visualizations have been successfully employed in various applications, particularly in the context of urban data analysis. Their computation, however, often relies on costly algorithms that hamper its practical usage. This paper introduces the Fast Topology Density Map (Fast TDM), a new algorithm that integrates graph- and image-based label propagation strategies for efficiently computing density maps based on spatiotemporal data. Fast TDM utilizes the Image-Foresting Transform (IFT) to partition the 2D space based on a given seed pixel set, enabling the computation of an Euclidean distance transform that leads to the creation of cost, label, and density maps simultaneously. Experiments considered different practical scenarios involving the computation and visualization of topology density maps on diverse topologies in terms of complexity, size, and temporal evolution. Experimental results show a significant reduction in computation time when topology density maps are computed using Fast TDM, achieving three times faster performance compared to recently proposed baselines. In addition, qualitative visualization analysis is performed, based on similarities and differences between the computed output maps with those produced by the baselines. Fast TDM can effectively replace counterparts, as it provides expedited computations with similar visual results in most cases.

密度图可视化已成功地应用于各种应用，特别是在城市数据分析方面。然而，他们的计算往往依赖于昂贵的算法，这阻碍了其实际应用。本文介绍了快速拓扑密度图（Fast TDM）算法，该算法集成了基于图和图像的标签传播策略，可以有效地计算基于时空数据的密度图。快速TDM利用图像森林变换（IFT）根据给定的种子像素集划分二维空间，从而实现欧几里得距离变换的计算，从而同时创建成本、标签和密度图。实验考虑了不同的实际场景，包括拓扑密度图在不同拓扑上的计算和可视化，包括复杂性、大小和时间演化。实验结果表明，当使用Fast TDM计算拓扑密度图时，计算时间显着减少，与最近提出的基线相比，性能提高了三倍。此外，根据计算输出图与基线生成的图之间的异同，进行定性的可视化分析。快速TDM可以有效地取代对等项，因为它在大多数情况下提供了具有类似视觉结果的快速计算。

{"title":"Fast topology density map","authors":"Zhicheng Hu , Agus Hasan , Ricardo da Silva Torres","doi":"10.1016/j.cola.2025.101371","DOIUrl":"10.1016/j.cola.2025.101371","url":null,"abstract":"<div><div>Density map visualizations have been successfully employed in various applications, particularly in the context of urban data analysis. Their computation, however, often relies on costly algorithms that hamper its practical usage. This paper introduces the Fast Topology Density Map (Fast TDM), a new algorithm that integrates graph- and image-based label propagation strategies for efficiently computing density maps based on spatiotemporal data. Fast TDM utilizes the Image-Foresting Transform (IFT) to partition the 2D space based on a given seed pixel set, enabling the computation of an Euclidean distance transform that leads to the creation of cost, label, and density maps simultaneously. Experiments considered different practical scenarios involving the computation and visualization of topology density maps on diverse topologies in terms of complexity, size, and temporal evolution. Experimental results show a significant reduction in computation time when topology density maps are computed using Fast TDM, achieving three times faster performance compared to recently proposed baselines. In addition, qualitative visualization analysis is performed, based on similarities and differences between the computed output maps with those produced by the baselines. Fast TDM can effectively replace counterparts, as it provides expedited computations with similar visual results in most cases.</div></div>","PeriodicalId":48552,"journal":{"name":"Journal of Computer Languages","volume":"85 ","pages":"Article 101371"},"PeriodicalIF":1.8,"publicationDate":"2025-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"145519579","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":3,"RegionCategory":"计算机科学","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 0

Netskip—A novel architecture for consistent multiplayer videogame state netskip -一个新颖的架构，用于一致的多人视频游戏状态

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-11-01 DOI: 10.1016/j.cola.2025.101370

Francesco Bertolotti, Walter Cazzola, Luca Favalli, Dario Ostuni, Leonardo Secco

In the past decades, video games have experienced a remarkable surge in popularity, making the gaming industry a multi-billion-dollar business. Simultaneously, game development has expanded beyond AAA publishers, with independent developers achieving impressive success. Today’s users are highly aware of quality standards and expect a reliable experience, especially in multiplayer games. However, traditional architectures, peer-to-peer and client–server, present complementary limitations, either from a user experience perspective (e.g., stability, latency, disconnection handling) or from a business perspective (e.g., deployment, maintenance, and scalability costs). In this work, we propose a novel architecture—dubbed netskip—that bridges the gap between peer-to-peer and client–server models by combining their strengths. The netskip architecture eliminates single points of failure and reduces deployment costs by removing the need for replicated servers, while still supporting disconnections, reconnections, and temporary network partitions. It manages game state in multiplayer settings using conflict-free replicated data types, and we formally prove that the netskip architecture ensures eventual consistency among nodes. Finally, we show through an empirical study using real video game traces that the netskip architecture delivers performance comparable to peer-to-peer and client–server architectures.

在过去的几十年里，电子游戏经历了惊人的普及，使游戏产业成为数十亿美元的生意。与此同时，游戏开发已经超越了AAA级发行商，独立开发者取得了令人印象深刻的成功。今天的用户非常重视质量标准，并期待可靠的体验，尤其是在多人游戏中。然而，从用户体验角度（例如，稳定性、延迟、断开连接处理）或从业务角度（例如，部署、维护和可伸缩性成本）来看，传统的点对点架构和客户机-服务器都存在互补的局限性。在这项工作中，我们提出了一种被称为netskip的新架构，它通过结合点对点模型和客户端-服务器模型的优势，弥合了两者之间的差距。netskip架构消除了单点故障，并通过不需要复制服务器来降低部署成本，同时仍然支持断开、重新连接和临时网络分区。它使用无冲突的复制数据类型来管理多人设置中的游戏状态，并且我们正式证明了netskip架构确保了节点之间的最终一致性。最后，我们通过使用真实视频游戏跟踪的实证研究表明，netskip架构提供的性能可与点对点和客户端-服务器架构相媲美。

{"title":"Netskip—A novel architecture for consistent multiplayer videogame state","authors":"Francesco Bertolotti, Walter Cazzola, Luca Favalli, Dario Ostuni, Leonardo Secco","doi":"10.1016/j.cola.2025.101370","DOIUrl":"10.1016/j.cola.2025.101370","url":null,"abstract":"<div><div>In the past decades, video games have experienced a remarkable surge in popularity, making the gaming industry a multi-billion-dollar business. Simultaneously, game development has expanded beyond AAA publishers, with independent developers achieving impressive success. Today’s users are highly aware of quality standards and expect a reliable experience, especially in multiplayer games. However, traditional architectures, peer-to-peer and client–server, present complementary limitations, either from a user experience perspective (e.g., stability, latency, disconnection handling) or from a business perspective (e.g., deployment, maintenance, and scalability costs). In this work, we propose a novel architecture—dubbed <em>netskip</em>—that bridges the gap between peer-to-peer and client–server models by combining their strengths. The <em>netskip</em> architecture eliminates single points of failure and reduces deployment costs by removing the need for replicated servers, while still supporting disconnections, reconnections, and temporary network partitions. It manages game state in multiplayer settings using conflict-free replicated data types, and we formally prove that the <em>netskip</em> architecture ensures eventual consistency among nodes. Finally, we show through an empirical study using real video game traces that the <em>netskip</em> architecture delivers performance comparable to peer-to-peer and client–server architectures.</div></div>","PeriodicalId":48552,"journal":{"name":"Journal of Computer Languages","volume":"85 ","pages":"Article 101370"},"PeriodicalIF":1.8,"publicationDate":"2025-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"145416095","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":3,"RegionCategory":"计算机科学","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 0

Lua and lunar re-entry: Experiences with Lua for modelling and simulation of high-speed aerodynamics Lua和月球再入：用Lua进行高速空气动力学建模和仿真的经验

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-11-01 DOI: 10.1016/j.cola.2025.101356

Rowan J. Gollan, Peter A. Jacobs

We describe our 15＋ years of experience using Lua as part of the development toolkit for a physics-based simulation code, Eilmer. The code is specialised for the simulation of gas motions at high-speeds and the use of Lua aids to manage complexity and provide flexibility. We discuss our uses of Lua including: user-programmable input configuration, user-defined run-time customisation, for data description, and as a scripting layer to D language code. The paper presents both user and developer perspectives and experiences. We conclude with some lessons learnt about using Lua in the context of a physics-based simulation code, and close with a recommendation that the inclusion of Lua in our toolkit has been a net positive and fruitful decision.

我们描述了我们使用Lua作为基于物理的模拟代码开发工具包的一部分的15年以上的经验，Eilmer。该代码专门用于模拟高速气体运动，并使用Lua辅助来管理复杂性并提供灵活性。我们讨论了我们对Lua的使用，包括：用户可编程输入配置，用户自定义运行时定制，用于数据描述，以及作为D语言代码的脚本层。本文介绍了用户和开发人员的观点和经验。我们总结了一些关于在基于物理的模拟代码环境中使用Lua的经验教训，并建议将Lua包含在我们的工具包中是一个积极而富有成效的决定。

引用次数: 0

Goliath and the Cognitive Load Theory 歌利亚和认知负荷理论

IF 1.8 3区计算机科学 Q3 COMPUTER SCIENCE, SOFTWARE ENGINEERING

Journal of Computer Languages

Pub Date : 2025-11-01 DOI: 10.1016/j.cola.2025.101372

Tiago Carvalho Freitas , Alvaro Costa Neto , Maria João Varanda Pereira , Pedro Rangel Henriques

A successful teaching effort is usually dependant on several factors. From the right environment, to a precisely worded exercise statement, it rests on the teacher’s shoulders the concoction of the most effective learning assets to their students. A significant part of this process lies on practise: students commonly solidify their knowledge by solving exercises. Creating new programming exercises, specially in high-demand environments such as large classrooms, is a repetitive and error-prone process, specially when stacked with other typical affairs that educators are required to attend to. Goliath, one of the two main contributions of this article, is a template-based, Artificial Intelligence (AI) supported exercise generator, that aims to facilitate the creation of exercise repositories. By using a Domain-Specific Language (DSL) to define exercise templates, combined with the automatic generation of different exercise types, educators can use Goliath’s features to improve their exercise repositories, both in size and variety. This systematic approach allows for greater control and automatisation than using a Large Language Model (LLM) directly, as the exercises’ main components can be pre-defined and pre-configured via their templates. Goliath, which is available online for free access, has been tested and its usability assessed. Combined with these functionalities, the content of the exercises themselves, the manner in which they are presented, and how they are rated for difficulty should also be considered in high regard when designing programming exercises. The Cognitive Load Theory (CLT) provides a conceptual foundation to understand problem-solving mechanisms that are commonly found in several aspects and situations of daily life, such as solving programming exercises. This foundation has been explored and systematically structured to construct the second main contribution of this article: guides to create exercise templates in Goliath founded on the Cognitive Load Theory, aiming to improve both teaching and learning computer programming.

成功的教学工作通常取决于几个因素。从合适的环境，到措辞精确的练习说明，教师的肩上肩负着为学生提供最有效的学习资产的重任。这个过程的一个重要部分在于实践：学生通常通过解决问题来巩固他们的知识。创建新的编程练习是一个重复且容易出错的过程，特别是在要求高的环境中，如大型教室，特别是当教育者需要参加其他典型的事务时。Goliath是本文的两个主要贡献之一，它是一个基于模板的、人工智能（AI）支持的练习生成器，旨在促进练习存储库的创建。通过使用领域特定语言（DSL）来定义练习模板，结合不同练习类型的自动生成，教育者可以使用Goliath的功能来改进他们的练习存储库，无论是在大小还是种类上。与直接使用大型语言模型（LLM）相比，这种系统的方法允许更好的控制和自动化，因为练习的主要组件可以通过它们的模板预先定义和预先配置。歌利亚可以在网上免费使用，它已经经过了测试和可用性评估。结合这些功能，在设计编程练习时，练习本身的内容、呈现的方式以及它们的难度等级也应该被高度考虑。认知负荷理论（CLT）为理解在日常生活的几个方面和情况中常见的问题解决机制提供了一个概念基础，例如解决编程练习。这个基础已经被探索和系统地结构化，以构建本文的第二个主要贡献：基于认知负荷理论的歌利亚中创建练习模板的指南，旨在改善计算机编程的教学和学习。

{"title":"Goliath and the Cognitive Load Theory","authors":"Tiago Carvalho Freitas , Alvaro Costa Neto , Maria João Varanda Pereira , Pedro Rangel Henriques","doi":"10.1016/j.cola.2025.101372","DOIUrl":"10.1016/j.cola.2025.101372","url":null,"abstract":"<div><div>A successful teaching effort is usually dependant on several factors. From the right environment, to a precisely worded exercise statement, it rests on the teacher’s shoulders the concoction of the most effective learning assets to their students. A significant part of this process lies on practise: students commonly solidify their knowledge by solving exercises. Creating new programming exercises, specially in high-demand environments such as large classrooms, is a repetitive and error-prone process, specially when stacked with other typical affairs that educators are required to attend to. Goliath, one of the two main contributions of this article, is a template-based, Artificial Intelligence (AI) supported exercise generator, that aims to facilitate the creation of exercise repositories. By using a Domain-Specific Language (DSL) to define exercise templates, combined with the automatic generation of different exercise types, educators can use Goliath’s features to improve their exercise repositories, both in size and variety. This systematic approach allows for greater control and automatisation than using a Large Language Model (LLM) directly, as the exercises’ main components can be pre-defined and pre-configured via their templates. Goliath, which is available online for free access, has been tested and its usability assessed. Combined with these functionalities, the content of the exercises themselves, the manner in which they are presented, and how they are rated for difficulty should also be considered in high regard when designing programming exercises. The Cognitive Load Theory (CLT) provides a conceptual foundation to understand problem-solving mechanisms that are commonly found in several aspects and situations of daily life, such as solving programming exercises. This foundation has been explored and systematically structured to construct the second main contribution of this article: guides to create exercise templates in Goliath founded on the Cognitive Load Theory, aiming to improve both teaching and learning computer programming.</div></div>","PeriodicalId":48552,"journal":{"name":"Journal of Computer Languages","volume":"85 ","pages":"Article 101372"},"PeriodicalIF":1.8,"publicationDate":"2025-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"145465922","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":3,"RegionCategory":"计算机科学","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}

引用次数: 0