Theory of mind refers to the attribution of mental states that humans ascribe to other humans or objects (such as computer-based systems). Recently, the attribution of mental states has been investigated toward Artificial Intelligence (AI) as a basic manner to capture people's engagement toward it, and people's perception about AI social skills and AI capabilities. In line with this idea, mental state attribution can be used as an indirect measure of students' understanding of AI functioning, and in particular of the kind of interactions students may have with AI systems. Too often is the case of people using generative AI systems in ways that exceed their actual ways of functioning. In our study, children of age in the range 9-12 were involved in one-shot unplugged activities concerning data and models. The unplugged activities were not aimed at teaching the theory of Machine Learning, but rather they were designed so as to provide awareness on some basic mechanisms and help developing a correct use of tools that are becoming more and more present in everyday life. This paper introduces the activities and reports the results that were achieved.

Information representation is a key concept in informatics, that involves representing real-world problems through symbolic encoding of data that can be automatically processed. Despite that, the presence and role of this concept in curricula, learning materials, and activities, is much less significant w.r.t. other informatics areas, as programming (coding) or algorithms. In this experience report we present a learning unit we designed, consisting of five two-hour lessons, that aims at introducing pupils to the fundamental concepts around information representation, and that we piloted in five fourth-grade classes. We also present and reflect upon the feedback asked of teachers, after the learning unit was concluded in their classes.

Artificial Intelligence is undoubtedly becoming pervasive in everyday life of everyone. In this setting, developing correct AI conception since childhood is not only a need to be addressed in educational curricula, but is also a children right. Accordingly, several initiatives at national and international levels aim at promoting AI and emerging technology literacy, supported also by a proliferation in the literature of learning courses covering a variety of topics, learning objectives and targeted ages. Schools are therefore pushed to introduce innovative activities for children in their curricula. In this paper, we report the results of a case study where we tested the contribution of an AI block-based course in developing computational thinking, and human and AI minds understanding in fifth and sixth grade children.

This experience report presents a participatory process that involved primary school teachers and computer science education researchers. The objective of the process was to co-design a learning module to teach iteration to second graders using a visual programming environment and based on the Use-Modify-Create methodology. The co-designed learning module was piloted with three second-grade classes. We experienced that sharing and reconciling the different perspectives of researchers and teachers was doubly effective. On the one hand, it improved the quality of the resulting learning module; on the other hand, it constituted a very significant professional development opportunity for both teachers and researchers. We describe the co-designed learning module, discuss the most significant hinges in the process that led to such a product, and reflect on the lessons learned.

In a project partially supported by research grant PANN20_00690 to Italy's CINI National Lab "Informatica e Scuola", we compared the effectiveness of two alternative instructional methods applied to scaffold the learning of iterations for children at grades 2-3. Eight university groups across the Country collaboratively run the project in two successive rounds throughout the year 2022. Teachers' feedback collected across the two rounds helped fine-tune the deployment of the interventions. The experiment results show that the two alternative interventions have measurable outcome differences in the short term.

Our Computer science k-12 education research group the educational toy company Quercetti have been collaborating together to design and manufacture toys that help stimulate and consolidate so-called computational thinking. This approach has been inspired by methods already consolidated in the literature and widespread worldwide such as the Bebras tasks and CS-Unplugged. This paper describes two of these smart toys, their design process, some evaluation’s results, and finally feedback and reviews from buyers. The main activities proposed by these toys leverage visual coding through small colored physical items (e.g., pegs and balls) to deliver the unplugged activities to young users.

This paper introduces an experiment and the first results of a research on computer programming education using process mining methods. A web-based tutorial addresses the topic of agent-based modeling by introducing a guided exercise with NetLogo, a widely used tool for modeling natural and social phenomena. A goal of the project is to analyze the goodness of the learning process, also through appropriate tests placed between the pages and at the end of the tutorial. Actual data extracted on student behavior (e.g., length of time spent on different parts of each web page, movements on the page, mouse position and mouse clicks) are examined using process discovery technique. Special attention is given to the return of student learning outcomes through visualization. Our solution includes heatmaps and direct-follow graphs of the real processes. Initial results are encouraging on the possibility of improving the assessment of learning processes by relying on techniques from the discipline of process mining, as shown by the case of web-based behaviour tracking data.

Companies must be able to demonstrate that their way of doing business is compliant with relevant rules and regulations. However, the law often has open texture; it is generic and needs to be interpreted before it can be applied in a specific case. Entrepreneurs generally lack the expertise to engage in the regulatory conversations that make up this interpretation process. In particular for the application domain of technological startups, this leads to legal risks. This research seeks to develop a robust module for legal interpretation. We apply informal logic to bridge the gap between the principles of interpretation in legal theory with the legal rules that determine compliance of business processes. Accordingly, interpretive arguments characterized by argument schemes are applied to business models represented by value modeling (VDML). The specific outcome of the argumentation process (if any) is then summarized into a compliance pattern, in a context-problem-solution format. A case study from copyright law, about an internet television company, shows that the approach is able to express the legal arguments of the case, but is also understandable for the target audience.

We consider a calculus for multiparty sessions enriched with security levels for messages. We propose a monitored semantics for this calculus, which blocks the execution of processes as soon as they attempt to leak information. We illustrate the use of this semantics with various examples, and show that the induced safety property is compositional and that it is strictly included between a typability property and a security property proposed for an extended calculus in previous work.

This article proposes a global escape mechanism which can handle unexpected or unwanted conditions changing the default execution of distributed communicational flows, preserving compatibility of the multiparty conversations. Our escape is realized by a collection of asynchronous local exceptions which can be thrown at any stage of the communication and to any subsets of participants in a multiparty session. This flexibility enables to model complex exceptions such as criss-crossing global interactions and error handling for distributed cooperating threads. Guided by multiparty session types, our semantics is proven to provide a termination algorithm for global escapes. Our type system guarantees further safety and liveness properties, such as progress within the session and atomicity of escapes with respect to the subset of involved participants.

Guaranteeing that the parties of a network application respect a given protocol is a crucial issue.Session typesoffer a method for abstracting and validating structured communication sequences (sessions).Object-oriented programmingis an established paradigm for large scale applications.Union types, which behave as the least common supertypes of a set of classes, allow the implementation of unrelated classes with similar interfaces without additional programming. We have previously developed an integration of the features above into a class-based core language for building network applications, and this successfully amalgamated sessions and methods so that data can be exchanged flexibly according to communication protocols (session types). The first aim of the work reported in this paper is to provide a full proof of the type safety property for that core language by renewing syntax, typing and semantics. In this way, static typechecking guarantees that after a session has started, computation cannot get stuck on a communication deadlock. The second aim is to define a constraint-based type system that reconstructs the appropriate session types of session declarations instead of assuming that session types are explicitly given by the programmer. Such an algorithm can save programming work, and automatically presents an abstract view of the communications of the sessions.

This paper proposes a global escape mechanism which can handle unexpected or unwanted conditions changing the default execution of distributed communicational flows, preserving compatibility of the multiparty conversations. Our escape is realised by a collection of asynchronous local exceptions which can be thrown at any stage of the communication and to any subsets of participants in a multiparty session. This flexibility enables to model complex exceptions such as criss-crossing global interactions and fault tolerance for distributed cooperating threads. Guided by multiparty session types, our semantics automatically provides an efficient termination algorithm for global escapes with low complexity of exception messages.

Dynamic trait replacement is a programming language feature for changing the objects' behavior at runtime by replacing some of the objects' methods. In previous work on dynamic trait replacement for JAVA-like languages, the object's methods that may be replaced must correspond exactly to a named trait used in the object's class definition. In this paper we propose the notion of replaceable: a programming language feature that decouples trait replacement operation code and class declaration code, thus making it possible refactoring classes and/or performing unanticipated trait replacement operations without invalidating existing code.

Double dispatch is the ability to dynamically select a method not only according to the run-time type of the receiver (single dispatch), but also according to the run-time type of the argument. This mechanism unleashes the power of dynamic binding in object-oriented languages, so enhancing re-usability and separation of responsibilities. However, many mainstream languages, such as, e.g., C++ and Java, do not provide it, resorting only to single dispatch. In this paper we propose an extension of C++ (also applicable to other object-oriented languages) that enables double dispatch as a language feature. This yields dynamic overloading and covariant specialization of methods. We define a translation from the new constructs to standard C++ and we present the preprocessor implementing this translation, called doublecpp. The translated code enjoys static type safety and implements the semantics of double dispatch by using only standard mechanisms of static overloading and dynamic binding, with minimal impact on the performance of the program. Copyright © 2006 John Wiley & Sons, Ltd.