@courseproject{debate2rescue-ise2526,
    abstract = {Debate2Rescue is a multi-agent simulation for the dynamic allocation of scarce resources in disaster-response scenarios. When multiple emergencies require the same resource—such as a medical helicopter or heavy machinery—autonomous rescuer agents negotiate by exchanging structured logical arguments rather than numerical bids. The project investigates how argumentation-based negotiation can support transparent and context-sensitive decisions in situations where fixed priority metrics are insufficient. The system combines BDI agents implemented in Jason/AgentSpeak, logic-based argument evaluation through tuProlog and Arg2P, and a custom Java-based discrete spatial simulator. Rescuer agents perceive the environment, maintain beliefs about emergencies, formulate rescue intentions, and justify their resource requests. A dispatcher coordinates task assignments, while the argumentation engine evaluates conflicts and determines the prevailing request according to domain-specific rules. A dedicated communication protocol introduces performatives such as {{code language="none"}}ARGUE{{/code}}, {{code language="none"}}ATTACK{{/code}}, {{code language="none"}}CONCEDE{{/code}}, and {{code language="none"}}REJECT{{/code}}. The resulting prototype will provide a visual or command-line monitor and structured event logs, making both spatial coordination and the reasoning behind every resource-allocation decision observable and explainable.},
    apice = {Debate2Rescue},
    author = {Amadori, Nicolas and Mazzi, Riccardo and Nanni, Denise},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = oct,
    sort = {simulation},
    supervisor = {Omicini, Andrea},
    title = {Debate2Rescue},
    type = {Standard Project},
    url = {https://github.com/NicolasAmadori/Debate2Rescue},
    year = 2026
}
@courseproject{gridsim-ds2526,
    abstract = {GridSim-Distribuited simulates a small electrical grid — houses, solar panels, batteries and the cables connecting them — as a genuinely distributed, tick-driven system rather than as a single-process program. On the backend, every grid entity and every running simulation is an independent, event-sourced Apache Pekko actor: cluster sharding gives each one a stable identity regardless of which node currently hosts it, and Pekko Persistence lets it recover its exact state by replaying its event log. Because that log is kept in a Redis store shared by every backend node, rather than inside the node that hosts the actor, a simulation survives not only an actor restart but also the crash of a whole node, resuming on a surviving one. Each simulated tick is a scatter/gather exchange between a simulation’s orchestrating actor and its entities, guarded by a timeout; a timed-out tick is retried with exponential backoff, the retry is idempotent with respect to the at-least-once delivery a distributed system has to assume, and a run of repeated failures is reported to clients as a degraded status rather than silently retried forever. A Split Brain Resolver, configured with a keep-majority strategy, gives the cluster a deterministic response to a network partition. A separate ScalaFX desktop client, structured with an MVVM architecture, drives the simulation’s lifecycle through a synchronous HTTP API and observes its progress through Protobuf-encoded telemetry published over Apache Kafka, a channel that lets several GUI instances watch the same simulation at once without the backend tracking who is listening. Grid topologies are authored through a small internal Scala DSL with accumulating validation, from which the system’s four built-in scenario presets are built. This report documents the requirements, architecture, implementation and validation of the system.},
    apice = {GridSim},
    author = {Matteo Bambini and Nardini, Michele},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = nov,
    sort = {simulation},
    supervisor = {Matteini, Mattia},
    title = {Grid Sim},
    type = {Simulation Project},
    url = {https://github.com/michelenardini99/GridSim-Distribuited},
    year = 2026
}
@courseproject{fallsgame-ds2425,
    abstract = {This report presents the "Falls Game" project, realized for the "Distributed Systems" course at the University of Bologna. The project is a multiplayer game inspired by one of the levels of Fall Guys: players compete in a multi-layered arena where the platforms disappear beneath their feet, and the last one standing wins. The game is written in Python with the Ursina engine. The main focus of the project is the networking. The matchmaking mode relies on a matchmaking server that creates a separate game process for each match, while in the peer-to-peer mode there is no server: all the players run the same program and one of them, the host, also acts as the authority of the match (a peer-to-peer architecture with a host). Both modes are played on a local network; hosting the matchmaking server on a cloud service is left as future work. In both modes an authoritative host or server decides the state of the match and the clients only send their positions and requests. The system uses TCP for the operations that must be reliable (matchmaking and joining) and UDP for the real-time game traffic, and it uses Redis to keep track of the matches in progress. It also tolerates failures: a player who loses the connection can rejoin the match, and a peer-to-peer match survives the loss of its host thanks to an automatic host migration.},
    apice = {FallsGame},
    author = {Guo, Jiahao},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = nov,
    sort = {game},
    supervisor = {Ciatto, Giovanni and Matteini, Mattia},
    title = {Falls Game},
    type = {Game Project},
    url = {https://github.com/schwein69/Falls-Game},
    year = 2026
}
@courseproject{kafkarabbitmq2026-ds2526,
    abstract = {The goal of this project is to analyze and compare Apache Kafka and RabbitMQ within the context of modern event-driven distributed systems. The project focuses on asynchronous communication, distributed messaging, scalability, reliability, and fault tolerance. Theoretical analysis will be supported by a lightweight experimental environment for practical validation and observation of distributed-system behaviours.},
    apice = {KafkaRabbitmq2026},
    author = {Pulighe, Mara},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = oct,
    sort = {technology},
    supervisor = {Omicini, Andrea and Matteini, Mattia},
    title = {Event-Driven Architectures in Distributed Systems: A Comparative Study of Apache Kafka and RabbitMQ},
    type = {Technology Project},
    url = {https://github.com/mara-pulighe/KafkaRabbitmq2026},
    year = 2026
}
@courseproject{realtimeincidentmanagementdashboard-ds2526,
    abstract = {This project presents a distributed real-time incident management dashboard designed for collaborative ticket resolution in operational environments. The system enables multiple operators to simultaneously interact with a shared pool of incidents through a web-based dashboard. The architecture follows a three-tier pattern: a Vue.js 3 single-page application serves as the presentation layer, an Express.js API with Socket.IO handles real-time communication and business logic, while a MongoDB Replica Set ensures persistent strongly-consistent state and Redis provides distributed coordination. Key distributed systems patterns implemented include: (i) Redis-based distributed locking and Lua scripts for check-then-act operations, preventing race conditions during ticket assignment; (ii) optimistic locking via document versioning in MongoDB to avoid lost updates during concurrent modifications; (iii) leader election using Redis TTL keys for exclusive execution of background tasks (automatic escalation of stale incidents); (iv) event-driven synchronization of all connected clients without polling, combining MongoDB Change Streams for incident updates with Redis Pub/Sub (via the Socket.IO adapter) for lock and presence events. The entire system is containerized and orchestrated via Kubernetes (validated via Minikube), featuring a 3-node MongoDB StatefulSet for data persistence and failover, Horizontal Pod Autoscaler for the API tier (3--10 replicas), and an Ingress with session affinity.},
    apice = {RealTimeIncidentManagementDashboard},
    author = {Martini, Alessandro},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = oct,
    sort = {classic},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Real-Time Incident Management Dashboard},
    type = {Standard Project},
    url = {https://github.com/AlleMartins/Distributed_Systems_Project},
    year = 2026
}
@courseproject{donkeykongrush-ds2425,
    abstract = {This report presents the "Donkey Kong: Rush" project, realized for the "Distributed System" course at the University of Bologna. The project involves the development of a 2D multiplayer platform video game inspired by the classic Donkey Kong . The system is designed around an Entity-Component-System (ECS) architecture written in Java, utilizing JavaFX for rendering. The main focus of the project is the implementation of smooth multiplayer gameplay. The solution combines the host's authority over the deterministic environment with a reactive handling of local inputs, guaranteeing an experience free of blocking lag for the players.},
    apice = {DonkeyKongRush},
    author = {Foschi, Giacomo and Terenzi, Mirco},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = oct,
    sort = {game},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Donkey Kong: Rush},
    type = {Game Project},
    url = {https://github.com/mircoterenzi/donkey-kong},
    year = 2026
}
@courseproject{wizardcardgame-ds2526,
    abstract = {This project details the evolution of a local, single-player "Wizard" card game into a distributed, real-time multiplayer web application designed for 3 to 6 players. The system transitions the game into a modern distributed application utilizing a Next.js web frontend and a reactive, event-driven Scala 3 backend built on Eclipse Vert.x. Built around Hexagonal Architecture and CQRS principles, the backend completely isolates core game rules from external transport mechanisms and infrastructural concerns. To support distributed gameplay across geographically dispersed users, Redis serves as the Single Source of Truth. It provides fast key-value state persistence, Pub/Sub channels for real-time event broadcasting, and Redis Streams with Consumer Groups to distribute AI bot tasks across dedicated worker instances. Real-time client interactions combine HTTP REST APIs for upstream commands with WebSockets for bidirectional event streaming and in-game chat.},
    apice = {WizardCardGame},
    author = {Mazzoni, Alex and Graziotin, Nicola and Marcatelli, Francesco},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = oct,
    sort = {game},
    supervisor = {Matteini, Mattia and Magnini, Matteo},
    title = {Wizard Card Game},
    type = {Game Project},
    url = {https://github.com/pallax03/WizardCardGame},
    year = 2026
}
@courseproject{thunk-dss2526,
    abstract = {Thunk is a distributed runtime that evaluates pure functional computations on a cluster of peer nodes, without a central coordinator. Computations are expressed in a small functional language whose only parallel construct is a divide-and-conquer primitive, map and reduce are then built on it. Programs travel between nodes as data, so a node needs no prior knowledge of the programs it helps to run. Work is distributed by randomized work stealing and, since computations are pure, a piece lost with a failed node is simply recomputed by the node waiting for it: crashes are tolerated without replication. It was validated with automated tests on real additional nodes and with experiments on one machine and on two machines connected over the Internet.},
    apice = {Thunk},
    author = {Baro Carbonell, Yosberto},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = oct,
    sort = {product},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Thunk},
    type = {Product Project},
    url = {https://github.com/yosbotnet/thunk},
    year = 2026
}
@courseproject{tictactoe-ds2425,
    abstract = {This report describes the project developed for the 2024-2025 Distributed Systems course called Tic-Tac-Toe. The project consists on a distributed implementation of a variant of the classic multiplayer game Tic-Tac-Toe, in which two players can play against each other, creating a game or joining an existing one. The game consists in the two players placing alternatively their marks on a 3x3 grid; the first player who succeeds in placing three marks in an horizontal, vertical, or diagonal row wins the game. The variant consists in removing a random mark from the grid at each turn, after the third mark of the player has been placed, meaning that every player can have at most three marks on the grid at any time. In this way, there is no possibility of a draw, because the game can potentially last forever.},
    apice = {TicTacToe},
    author = {Pracucci, Filippo},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = oct,
    sort = {game},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Tic-Tac-Toe},
    type = {Game Project},
    url = {https://github.com/FilippoPracucci/Tic-Tac-Toe.git},
    year = 2026
}
@courseproject{smartroundaboutorchestrator-dss2526,
    abstract = {The project consists in a simulation of a CyberPhysical System, wheresome autonomous cars have to coordinate with each other to cross a roundabout, each from its starting point to its destination. Moreover, a centralcontroller is available to give them more efficient commands, trying to maximize the intersection’s throughput while always maintaining safety as thefirst priority. In fact, the main distributed systems challenge concerns thereliability and fault tolerance of the system as a whole: network and performance stability are also important, but failures, assumed to be inevitable,should never result into car accidents. Several measures have been implemented or just theorized in order to prevent deadlocks and starvation, toguarantee liveness, to coordinate together healthy vehicles with unreachableones and to improve controller’s predictions and evaluations in general.An application has also been produced to visualize the simulation in realtime and control it through some commands.},
    apice = {SmartRoundaboutOrchestrator},
    author = {D'Ugo, Daniele},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = oct,
    sort = {simulation},
    supervisor = {Matteini, Mattia},
    title = {Smart Roundabout Orchestrator},
    type = {Simulation Project},
    url = {https://github.com/papum20/unibo__projects__distributed-smart-roundabout},
    year = 2026
}
@courseproject{distributedsmb-ds2526,
    abstract = {This report presents Distributed SMB, a cooperative real-time 2D platform game inspired by Super Mario Bros, developed to explore the fundamental principles of Distributed Systems within an interactive environment. Up to four players, each on their own machine connected to a local network, take part in the same session and share a single game world, cooperating to complete a level. The game mechanics are intentionally kept simple, so that the difficulty of the project lies in the coordination among the nodes rather than in the game itself. From an architectural perspective, the system adopts a hybrid peer-to-peer model with a dynamically assigned authority. One node acts as the authoritative owner of the shared state and resolves the actions that affect it, while the other nodes anticipate the effect of their own actions locally in order to preserve responsiveness. In CAP terms this design is AP-oriented: it favours availability and low latency over immediate consistency, and relies on the convergence of the replicas over time. The project places a strong emphasis on fault tolerance and availability. Since the authority resides on one of the participating machines, it constitutes a single point of failure: the system therefore detects its failure, elects a successor among the surviving nodes without resorting to any central coordinator, and allows the session to continue, while a node that has failed can later rejoin the session in progress. 1 This report describes the requirements of the system, the architectural decisions and the consistency model adopted, the implementation and deployment choices, the validation carried out, and the limitations that remain open.},
    apice = {DistributedSMB},
    author = {Badioli, Filippo and Flamigni, Mattia and Nollino, Ludovico},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = oct,
    sort = {game},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Distributed SMB: a Co-Op Online Platform Game},
    type = {Game Project},
    url = {https://github.com/LudovicoNollino/Distributed-SMB},
    year = 2026
}
@courseproject{dvcsbasedoncvrdt-ds2425,
    abstract = {This work presents the design and evaluation of a decentralized Distributed Version Control System (DVCS) based on State based Conflict-free Replicated Data Type (CvRDT). The project provides a proof-of-concept about how distributed collaborative approaches can be integrated along DVCS into a peer-to-peer version control environment while preserving eventual consistency and minimizing coordination overhead. Traditional distributed version control systems rely on explicit synchronization and merge procedures to reconcile concurrent modifications performed by multiple users. While these mechanisms provide strong traceability and deterministic history management, they often require manual conflict resolution and assume intermittent coordination between replicas (this is sometime an intended and desiderable behavior, expecially when human control is necessary). In contrast CRDT-based systems are designed to garantee weak-consistency (eventual consistency) automatically, to enable replicas to evolve independently while reaching a single consistent global state. Through ConverGO, we want to demonstrate how CRDT technicques can be successfully used to improve decentralized DVCS systems while also exposing challenge and tradeoff about event causal relations, history management, semantic delivery and system scalability. The resulting software is not to be intended as a real-world production ready library but as a proof-of-concept prototype to provide insight about the applicability of CRDT models in the DVCS context along discussion about its inner limitation and necessary improvoment to make it a working product},
    apice = {DvcsBasedOnCvrdt},
    author = {Guidi, Stefano},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = oct,
    sort = {classic},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {ConverGO — A DVCS based on CvRDT updates},
    type = {Standard Project},
    url = {https://github.com/desabuh/ConverGO},
    year = 2026
}
@courseproject{aresmascostantini2026-ise2526,
    abstract = {ARES-MAS is a simulated, grid-based orchestrator designed to manage collaborative planetary exploration through a hybrid symbolic AI architecture. The project addresses the complex challenges of autonomous multi-agent coordination, specifically focusing on dynamic hazard avoidance, spatial pathfinding, and safety-critical resource management. To achieve this, the system enforces a strict architectural separation of concerns. The physical layer, implemented in Kotlin, provides a discretetime 2D spatial simulator that manages environmental state, battery consumption, and mutually exclusive resource locks. The deliberative logical layer encapsulates the system’s intelligence utilizing BDI (Belief-Desire-Intention) agents (Scouts and Harvesters) programmed in Jason and AgentSpeak(L). These autonomous agents communicate via the FIPA Agent Communication Language (ACL). By leveraging the Contract Net Protocol (CNP) for task negotiation, the agents evaluate real-time spatial heuristics (Manhattan distance) to effectively orchestrate task assignment. Crucially, a logic-based safety layer utilizing tuProlog acts as a runtime guardrail, preventing fatal collisions and ensuring fail-safe operations when agents make overoptimistic economic decisions.},
    apice = {AresMasCostantini2026},
    author = {Costantini, Marco},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = oct,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {ARES-MAS},
    type = {Standard Project},
    url = {https://github.com/MarcoCostantini26/ARES-MAS},
    year = 2026
}
@courseproject{mednet-ise2526,
    abstract = {MedNet is a two-tier multi-agent system that simulates a medical emergency network: a control centre, a fleet of ambulances and several hospitals that negotiate the admission of each patient among themselves and, internally, the assignment of a doctor. The system integrates BDI agents written in Jason/AgentSpeak, FIPA ACL communication, a generic Contract Net Protocol reused across two levels of negotiation, a tuProlog knowledge base shared between the Java side and the agent side, a STRIPS planner that derives care plans and role-based access control enforced on every environment action. The result is a system in which admissions are arbitrated by the control centre, a critical case can preempt a less urgent treatment and then be replanned while preserving the exams already performed, an ambulance can be rerouted during transport, and mutually exclusive equipment is coordinated by an arbiter with a priority queue and watchdogs.},
    apice = {MedNet},
    author = {Babini, Pier Costante and Morelli, Marco},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = oct,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {MedNet},
    type = {Standard Project},
    url = {https://github.com/piertv21/ISE-MedNet},
    year = 2026
}
@courseproject{parkingmas-ise2526,
    abstract = {The goal is to develop a distributed Multi-Agent System using Jason/AgentSpeak for the development and execution of BDI agents, and JADE as the framework for agent communication and distributed deployment. The MAS represents a parking system, in which three roles of BDI agents are present: Driver Agents: autonomously search for a parking spot with specific characteristics, evaluate the proposed alternatives according to their goals and preferences, and decide which parking facility to use; Area Agents: each one is responsible for an area of the city, maintains beliefs about the parking facilities in its area, and provides information to Driver Agents; Parking Agents: represent parking facilities, intended as sets of parking spots, maintain beliefs about their resources (occupied / available spots), and autonomously manage parking requests. The behavior of the MAS is demonstrated through a simulation based on a simplified grid representing a city, in which the aforementioned agents are placed. The environment models the physical aspects of the system, such as the city map, agent positions, and movement, while the decision-making and coordination logic is contained within the agents. Particular attention will be given to the modelling of autonomous behavior in the agents, including the representation of beliefs, goals and plans, agent reasoning and decision-making, and inter-agent communication and coordination. The different agent roles will be designed to exhibit distinct goals, knowledge, and behaviors within the parking system.},
    apice = {ParkingMAS},
    author = {Bedeschi, Federica},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = oct,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {ParkingMAS},
    type = {Simulation Project},
    url = {https://github.com/BedeschiFederica/ds-ise-parking-mas},
    year = 2026
}
@courseproject{bomberman-ds2425,
    abstract = {Distributed Bomberman is a real-time, fault-tolerant, multiplayer game inspired by the classic Bomberman arcade title, developed as a project for the Distributed Systems course at the University of Bologna (A.Y. 2024/25). Up to four players compete simultaneously on a shared grid, placing bombs to eliminate opponents. An unlimited number of spectators can observe the match and may request to join as a player when a slot becomes available. The system is built on an authoritative client-server architecture fronted by a session-aware TCP proxy, which hides a primary/backup server pair from clients. State is continuously replicated from the primary to the backup; on primary failure, the backup promotes itself automatically, re-binds the game port, and client sessions are restored transparently by the proxy; a second, independent retry loop on the client covers the failure of the proxy itself. The entire system is implemented in Python 3 using the standard library for networking and Pygame for the graphical client.},
    apice = {Bomberman},
    author = {Rinchiuso, Giovanni and Santi, Gioele},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = sep,
    sort = {game},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Distributed Bomberman},
    type = {Game Project},
    url = {https://github.com/Saint138/Distributed-Bomberman},
    year = 2026
}
@courseproject{distributedmultiplayerpacman-dss2526,
    abstract = {This project presents the design and implementation of a multiplayer adaptation of the classic arcade game Pac-Man. At its core, the system adopts a client-server architecture to manage real-time game state synchronization and player inputs. Around this foundation, additional services such as authentication, matchmaking and match results persistence were integrated. Beyond these aspects, the project addresses common distributed systems issues. Specifically, it implements horizontal game server scaling to handle fluctuating player demand, periodic game state checkpointing for match recovery and robust disconnection and reconnection handling.},
    apice = {DistributedMultiplayerPacman},
    author = {Carpi, Simone and Ronchi, Alessandro and Sun, Jiekai},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = sep,
    sort = {game},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Distributed Multiplayer Pacman},
    type = {Game Project},
    url = {https://github.com/MrDorby/distributed-multiplayer-pacman},
    year = 2026
}
@courseproject{dsinventorymanager-ds2526,
    abstract = {This report presents the design, implementation, and validation of a distributed, multi-warehouse inventory management system. Built to operate across a simulated Wide Area Network, the system uses a masterless, peer-to-peer architecture that prioritizes Availability and Partition Tolerance over strict consistency. The core objective is to ensure that local warehouse operators can continuously read and modify stock levels without blocking, even during severe network outages. The backend nodes are implemented in Go and communicate asynchronously via gRPC, utilizing embedded SQLite databases for serverless, lightweight data persistence. In order to guarantee eventual consistency and prevent data loss during split-brain scenarios, the system employs vector clocks for causality tracking and an additive state reconciliation protocol. The infrastructure is containerized using Docker and orchestrated via a local Kubernetes cluster (Minikube). Furthermore, Project Calico is integrated as the Container Network Interface (CNI) to enforce network policies, allowing for rigorous testing of simulated network partitions. The final system successfully demonstrates fault tolerance, automatic state recovery, and mathematical conflict resolution without relying on a central authoritative database.},
    apice = {DsInventoryManager},
    author = {Cornacchia, Enrico},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = sep,
    sort = {classic},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Distributed Multi-Warehouse Inventory Manager},
    type = {Standard Project},
    url = {https://github.com/Icobart/ds-inventory-manager},
    year = 2026
}
@courseproject{fractaldistributedfilesystem-ds2425,
    abstract = {Fractal is a distributed file system designed for large-scale, data-intensive workloads, drawing architectural inspiration from systems like the Hadoop Distributed File System (HDFS) and Google File System (GFS). Fractal adopts a CP (Consistency and Partition Tolerance) model, deliberately prioritizing data integrity and strong consistency over availability by rejecting operations whenever the required quorum or replica counts cannot be safely satisfied. The entire ecosystem is operated via a standalone CLI that exposes commands for file management (create, read, update, and burn) alongside diagnostic utilities such as list and status to monitor cluster health. A centralized NameNode maintains the cluster namespace and replica locations, persisting its state to a lightweight filesystem image, while raw data blocks are distributed across the physical disks of worker DataNodes. Rather than routing payload bytes through the master, Fractal utilizes a distributed pull model: clients query the NameNode solely for a chunk location blueprint, after which all heavy chunk streaming occurs concurrently and directly with the DataNodes to maximize bandwidth utilization. Incoming files are split into fixed-size chunks and distributed using a rack-aware allocation strategy that guarantees multi-rack fault isolation. The system operates under an immutable storage paradigm where file updates generate a timestamped replica set before executing an atomic metadata swap, rather than modifying bytes in place. Continuous heartbeat exchanges and quorum consensus protocols allow Fractal to safely coordinate multi-client concurrency, actively detect dead workers, and transparently repair stale or missing replicas on routine failure.},
    apice = {FractalDistributedFileSystem},
    author = {Zaccarini, Matteo},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = sep,
    sort = {classic},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {Fractal - Distributed File System},
    type = {Standard Project},
    url = {https://github.com/MatteoZacca/Fractal},
    year = 2026
}
@courseproject{syncnotes-dss2526,
    abstract = {SyncNotes is a collaborative note-taking system built around a three-tier client-gateway-cluster architecture. A set of shared plain-text notes lives on a cluster of three interchangeable server replicas, the sole source of truth; a lightweight, stateless gateway is the cluster’s single logical entry point, so clients never learn how many replicas exist, which one is serving them, or that a failover happened. The client itself is a full-screen terminal UI requiring no knowledge of commands, note names or file paths, so a non-technical user can browse, edit, create and delete notes with nothing but the arrow keys. The system is deliberately CP in CAP terms. Writes are ordered by a Raft replicated log and applied identically on every replica, so all clients see the same version of every note, and a replica that loses quorum during a network partition refuses writes rather than diverging. Concurrent edits are reconciled by a three-way merge that runs inside the replicated operation itself: disjoint edits are combined automatically, and a directly conflicting line is resolved deterministically in the server’s favour, with the losing client told exactly what happened. On top of consensus, a background reconciliation loop lets a lagging or corrupted replica repair itself from a healthy peer, closing the one gap consensus cannot see: storage-level corruption that never went through the log. The whole cluster, plus the gateway, runs as Docker containers wired by a single compose file; the client runs on the host. Validation combines an automated pytest suite, an end-to-end merge demo against a real cluster, and chaos scripts that kill the leader, partition the network, corrupt a replica’s storage and restart a node, asserting the system recovers exactly as the requirements demand.},
    apice = {SyncNotes},
    author = {De Maina, Marzia},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = sep,
    sort = {classic},
    supervisor = {Matteini, Mattia},
    title = {SyncNotes: A Consistency-Oriented Replicated Store for Collaborative Notes},
    type = {Standard Project},
    url = {https://github.com/marziademaina/SyncNotes},
    year = 2026
}
@courseproject{monopoly-dss2526,
    abstract = {DS-Monopoly is a distributed clone of the Monopoly board game. It is a simplified version of the game where a centralized server acts as the bank, it coordinates the game and keeps the game state, validates actions, prevents cheating and broadcasts the updates to all the connected clients. The clients are players that can join a game by connecting to the central server (2 to 4 players per game). Players can buy properties or houses, roll dice and see the board and the players information from a GUI. Disconnections from both sides, clients and server, are handled in order to keep the game running. Features like checkpointing, authentication and timeouts, are used to enhance fault tolerance and ensure more reliability and availability.},
    apice = {Monopoly},
    author = {Loverre, Daniele},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = sep,
    sort = {game},
    supervisor = {Magnini, Matteo and Matteini, Mattia},
    title = {DS-Monopoly},
    type = {Game Project},
    url = {https://github.com/22Daniele/DS-monopoly-clone},
    year = 2026
}
@courseproject{dspracticecourt-ds2526,
    abstract = {DS-PracticeCourt is a distributed web-based platform designed to manage sports facility reservations (such as soccer, tennis, and basketball) and associated services (like lighting, heating, or the possibility of renting equipment). The project focuses on solving the core challenges of distributed environments, such as data consistency, synchronization, high availability, and concurrency in a multi-node environment. The system uses a distributed client-server architecture consisting of a Field Node, acting as the Two-Phase Commit (2PC) coordinator, and a Utility Node serving as a participant. A responsive web client provides real-time interaction through WebSockets, ensuring global state transparency for all users. To ensure a robust and reliable system, several advanced distributed concepts are implemented: Concurrency & Distributed Locking: Exploiting Redis to implement distributed locks, ensuring that a single time slot cannot be double-booked by simultaneous requests. Atomic Transactions (2PC): A Two-Phase Commit protocol coordinates Field and Utility nodes. This ensures that a booking that includes both a field and a service is treated as an atomic unit. Temporary Slot Locking: Selected slots are temporarily reserved with a timeout mechanism, releasing the resource if the user does not confirm the booking. Real-Time Synchronization: Using WebSockets to push instant availability updates to all connected users, maintaining a consistent global state.},
    apice = {DSPracticeCourt},
    author = {Brighi, Federico},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = sep,
    sort = {application},
    supervisor = {Matteini, Mattia and Magnini, Matteo},
    title = {DS-PracticeCourt},
    type = {Application Project},
    url = {https://github.com/fedebrighi/DS-PracticeCourt},
    year = 2026
}
@courseproject{cotype-ds2526,
    abstract = {CO-Type is a distributed client server cooperative typing game. The main idea of the project is to build a robust and scalable system, with error recovery and state reconstruction from partial and potentially inconsistent data. The system is composed of a broker, which is the only endpoint known by the clients at startup, and multiple servers. There is no upper limit for the number of servers that can be used. The number of servers does not have to be defined, and new servers can be created at any moment. The game is designed to recover from client, server or broker crashes while having near zero downtime. If a client crashes during game, then the session is paused. If the broker crashes, then all the knowledge it had is reconstructed. If a server crashes, all the lobbies are transferred to a different server.},
    apice = {CoType},
    author = {Ceredi, Simone},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = aug,
    sort = {game},
    supervisor = {Matteini, Mattia},
    title = {Co-Type},
    type = {Game Project},
    url = {https://github.com/sceredi/co-type},
    year = 2026
}
@courseproject{ecoshield-ise2526,
    abstract = {EcoShield-MAS is a lightweight hybrid intelligent system for coordinating Scout and Fighter unmanned aerial vehicles in a discrete forest-fire environment. The system combines a collaborative Belief-Desire-Intention (BDI) loop, Prolog-style declarative policy guardrails, and STRIPS-inspired logistics planning. Fire evolves through a wind-influenced cellular automaton, while environmental policy prohibits chemical action in protected habitat and under high-wind conditions. A Streamlit dashboard exposes the operational map, agent cognition, policy proofs, and causal event traces. Four deterministic experiments evaluate baseline response, high-wind safety, protected-zone safety, and low-resource return-to-base planning. The final traces confirm 26 extinguishing actions in the baseline mission, correct blocking of all tested unsafe chemical actions, and successful STRIPS return with full resource restoration at tick 13.},
    apice = {EcoShield},
    author = {Kuang, Yi},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = aug,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {EcoShield},
    type = {Simulation Project},
    url = {https://github.com/leahkuang/EcoShield-MAS},
    year = 2026
}
@courseproject{kompozer-ds2425,
    abstract = {Kompo is a company that produces customizable modular furniture. Its catalog is organized into four product categories—Tondo, Quadro, Intelligente and Kube—which are not compatible with one another but share similar features, so that the logic for composing components stays homogeneous within each category. In the current purchasing process, customers must select the individual components on their own, already having a clear idea of the final result; this is complex and requires the knowledge of the product, forcing them to rely on the support of the company. KompozeR wants to make this process easier by letting customers interactively design and purchase modular shelving units through a visual configurator (CAD) that composes a product in an intuitive way avoiding incompatible combinations, keeps price and availability aligned with the catalog in real time, and notifies users when a saved configuration is affected by catalog changes. The system is built as a web application using the stack MEVN (MongoDB, Express, Vue.js, Node.js) and is deployed as a hexagonal architecture. Services communicate through synchronous REST for commands and queries, asynchronous Redis pub/sub for domain events (price and availability changes), and Socket.IO for real-time delivery of notifications and chatbot messages. Socket.IO also enables a collaborative configuration mode, where multiple users can work on the same shelving unit at the same time and see each other’s changes in real time. To keep the core configuration workflow available even under failures, the data is stored on a MongoDB replica set that provides replication and automatic failover, so that the loss of a single node does not interrupt the service. The whole system can be deployed both with Docker Compose for local development and on Kubernetes, which handles scaling, health checks and self-healing of the running services.},
    apice = {KompozeR},
    author = {Giannini, Valerio},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = aug,
    sort = {application},
    supervisor = {Magnini, Matteo},
    title = {KompozeR},
    type = {Application Project},
    url = {https://github.com/VG-University/KompozeR},
    year = 2026
}
@courseproject{urbandeliverymas-ise2425,
    abstract = {This report presents the architectural design, formal cognitive logic, and practical implementation of UrbanDeliveryMAS, a fully decentralized Multi-Agent System (MAS) designed to address dynamic, priority-aware last-mile logistics without reliance on a centralized routing authority or shared global locks. Operating on a discrete 10 ×10 micro-city grid topology, the system coordinates autonomous BDI (Belief-Desire-Intention) agents—comprising a central Distribution Hub and three delivery drones—negotiating task allocation via an extended Contract-Net Protocol (CNP). Agent cognitive architectures are developed in AgentSpeak(L) and executed using the Jason 3.3.0 interpreter running on Java 21. The system’s adaptive capacity is evaluated across three core operational edge cases: (1) proximitydriven spatial task division, (2) belief-triggered intention dropping and re-delegation during critical battery depletion, and (3) real-time task preemption following the mid-transit injection of high-priority Express orders. Experimental validation demonstrates 100% task completion (7/7 orders delivered) with zero unhandled goals or synchronization deadlocks. The results confirm that localized BDI deliberation paired with asynchronous message passing produces robust, self-organizing, and highly adaptive global fleet behavior.},
    apice = {UrbanDeliveryMAS},
    author = {Lajani, Arvin},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = jul,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {Urban Delivery MAS},
    type = {Simulation Project},
    url = {https://github.com/ArvinLajani/urban-delivery-mas},
    year = 2026
}
@courseproject{mapforger-ds2526,
    abstract = {MapForger is a distributed microservice-based platform designed for realtime 2D tabletop role-playing game (RPG) management. The system is architected to handle complex campaign logic, character persistence, and live session synchronization across multiple players. Unlike a monolithic game server, the application logic is decomposed into specialized services—Core and Gameplay—coordinated via Spring Cloud Eureka for service discovery and routed through a Spring Cloud Gateway. The project focuses on ensuring a consistent and resilient experience during gameplay sessions. The CAP Theorem trade-off is explicitly addressed: the system prioritizes Consistency over Availability within a single session, ensuring that no two actors can occupy the same map tile and that every action is atomically persisted before being broadcast. Fault tolerance is implemented through persistent state: every actor position, attack, and death event is recorded as an immutable row in PostgreSQL 17. Upon reconnection after a crash, the client re-fetches the full game state from the database, enabling seamless session recovery without data loss. Inter-service communication is handled via OpenFeign clients registered through Eureka, allowing the Core service to retrieve live session data from Ga},
    apice = {MapForger},
    author = {Alexandru, Eduard Toni},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {MapForger},
    type = {Game Project},
    url = {https://github.com/eduardalexandrut/MapForger},
    year = 2026
}
@courseproject{chefsync-ise2526,
    abstract = {ChefSync is a simulated, grid-based orchestrator designed to manage highly concurrent culinary environments through decentralized multi-agent coordination. The project addresses the complex challenges of modern restaurant kitchens, specifically focusing on dynamic workload balancing, spatial pathfinding, and the resolution of physical resource conflicts. To achieve this, the system enforces a strict architectural dichotomy. The physical layer, implemented in Java, provides a discrete-time 2D spatial simulator that manages environmental state, hardware constraints (workstations), and mutually exclusive resource locks. The logical layer encapsulates the system’s intelligence utilizing BDI (Belief-Desire-Intention) agents programmed in Jason and AgentSpeak(L). These autonomous agents—acting as Waiters, Head Chefs, and Station Chefs—communicate via the FIPA Agent Communication Language (ACL). By leveraging the ContractNet Protocol (CNP) for task negotiation, the agents evaluate real-time spatial heuristics and operational availability to effectively orchestrate the decomposition, assignment, and execution of unpredictable order streams.},
    apice = {ChefSync},
    author = {Fantilli, Giorgio},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = jul,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {ChefSync},
    type = {Simulation Project},
    url = {https://github.com/GiorgioFantilliUnibo/chefsync-mas},
    year = 2026
}
@courseproject{distributedadaptivecitytrafficsystem-ds2526,
    abstract = {ACTS is an advanced, agent-based smart city simulation focused on decentralized intersection management. Built in Python using the Mesa multiagent framework and NetworkX, the project models dynamic urban traffic flow where intersections operate autonomously without a central command server. At the core of the project is a procedural topology generator that constructs a directed graph representing a realistic road network, complete with external arterial roads and complex internal turning lanes. The simulation features two primary entities: Vehicle Agents that navigate the network, and Smart Traffic Light Agents deployed at intersection nodes. Instead of relying on rigid, pre-programmed timers, the smart traffic lights utilize a distributed consensus algorithm to negotiate the ”GREEN” state. Each agent continuously monitors its local environment, detecting queued vehicles, calculating waiting times, and receiving messages about incoming traffic waves from neighboring nodes. Based on this telemetry, each traffic light calculates a dynamic priority score. To ensure physical safety and prevent collisions, the system implements Signal Phasing (conflict matrices). Traffic lights communicate their scores and intentions through a distributed messaging channel, utilizing Lamport clocks for event synchronization. Agents assigned to non-conflicting trajectories (identical phases) can concurrently grant themselves permission to turn green. Conflicting requests are dynamically resolved by comparing real-time traffic scores and enforcing minimum safety durations. Ultimately, ACTS serves as a robust sandbox for testing distributed systems architectures, agent-based modeling, and modern traffic optimization algorithms in a highly reactive urban environment.},
    apice = {DistributedAdaptiveCityTrafficSystem},
    author = {Morsucci, Federico and Morbidelli, Cristian},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jul,
    sort = {simulation},
    supervisor = {Magnini, Matteo},
    title = {Autonomous City Traffic Simulation},
    type = {Simulation Project},
    url = {https://github.com/Morsu7/acts-project},
    year = 2026
}
@courseproject{distributedlupusinfabula-ds2526,
    abstract = {Distributed Lupus in Fabula is a real-time multiplayer web application that brings the classic social deduction game Lupus in Fabula online, allowing groups of players to create or join a game lobby from any browser and play a full match together over the internet. The system is composed of a Vue 3 single-page frontend and a FastAPI/Socket.IO backend, communicating via REST for stateless operations and via WebSocket for real-time, low-latency interactions such as votes, phase transitions, and private role actions. Game and lobby state is kept in Redis rather than a traditional database, acting both as a shared source of truth across backend replicas and as a Pub/Sub broker that lets events generated on one instance reach clients connected to any other instance. This design allows the backend to run as multiple concurrent, interchangeable replicas behind a reverse proxy, supporting many simultaneous matches while keeping every player’s view of the game synchronized in real time.},
    apice = {DistributedLupusInFabula},
    author = {Vorabbi, Leonardo and Bonifazi, Jacopo and Nicolescu, Alexandru Bogdan},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Distributed “Lupus in Fabula”},
    type = {Game Project},
    url = {https://github.com/AlexandruNicolescu00/distributed-lupus-in-fabula},
    year = 2026
}
@courseproject{distributedneuraltrainingsimulation-ds2526,
    abstract = {Distributed Neural Training Simulation (DNTS) is a software framework designed to simulate, analyze, and visualize the training process of Deep Neural Networks (DNN) in a fully decentralized Peer-to-Peer (P2P) environment. Traditional distributed machine learning typically relies on centralized architectures, such as Parameter Servers, which inherently introduce a Single Point of Failure (SPOF) and potential network bottlenecks. DNTS overcomes these limitations by implementing an asynchronous, leaderless architecture based on the Gossip Learning protocol. Within this framework, autonomous nodes process local data partitions and iteratively exchange model weights with randomly selected peers to achieve global consensus and model convergence. Developed entirely in Scala 3 utilizing the Actor Model (via Akka Cluster) and strict Pure Functional Programming principles.},
    apice = {DistributedNeuralTrainingSimulation},
    author = {Colletta, Lorenzo and Giacobbi, Francesco Domenico and Fantilli, Giorgio},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jul,
    sort = {advanced},
    supervisor = {Magnini, Matteo},
    title = {Distributed Neural Training Simulation},
    type = {Advanced Project},
    url = {https://github.com/GiorgioFantilliUnibo/DNTS},
    year = 2026
}
@courseproject{chameleontable-ds2526,
    abstract = {Chameleon Table is a distributed multiplayer card game inspired by Coloretto, developed as a final project for the Distributed Systems course. The application allows between 2 and 5 players to join a shared game room from different devices and play in turns, with one active game per authenticated user. The system follows a client-server architecture: a central FastAPI server manages game logic and state, while clients interact through a React single-page application running in the browser. Real-time updates are pushed to all connected clients via WebSocket, ensuring that every player sees the current state of the game without polling. Game state is persisted in a PostgreSQL database, so that active games survive server restarts and players can reconnect within a grace period. The full system is containerised with Docker and starts with a single command. Key distributed systems challenges addressed include crash recovery, real-time state synchronisation across multiple clients, and safe concurrent access to shared game state.},
    apice = {ChameleonTable},
    author = {La Rosa, Andrea},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Chameleon Table},
    type = {Game Project},
    url = {https://github.com/AndreaLaRosa1983/chameleon-table},
    year = 2026
}
@courseproject{adriabox-ds2526,
    abstract = {This report details the comprehensive architectural design, theoretical constraints, and operational mechanisms of AdriaBOX, a resilient, decentralized object storage system engineered over a multi-tenant cluster environment. AdriaBOX natively addresses the core challenges of distributed computing by separating high-performance binary transport protocol engines from global metadata orchestration. By employing a customized application-layer framed TCP streaming layer alongside a synchronous pipeline replication cascade, the system isolates fault domains, prevents resource starvation via strict boundary memory footprinting, and implements Zero-Knowledge client-side encryption. Crucially, to validate system behavior under realistic execution stresses, a multi-containerized emulation workspace is leveraged. This environment allows the simulation of concurrent, fully isolated tenant workspaces interacting across a virtualized network plane, proving that horizontal capacity scaling and hardware-level fault tolerance can be sustained without compromising strong sequential data consistency under severe network disruption.},
    apice = {AdriaBox},
    author = {Buzi, Sajmir and Pupillo, Massimiliano},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jul,
    sort = {advanced},
    supervisor = {Magnini, Matteo},
    title = {AdriaBOX},
    type = {Advanced Project},
    url = {https://github.com/Wearemassive78/AdriaBOX},
    year = 2026
}
@courseproject{federatedskillshare-dss2526,
    abstract = {Skillshare is a peer-to-peer platform in which users exchange knowledge by publishing skill announcements, requesting exchanges, communicating through chat, and reviewing one another. The original application used one server and one MapDB database. This project transforms it into a federated distributed system demonstrated through two local Docker instances, each with independent users and persistent state. Instances exchange domain events through HTTP using JSON representations and identify users as user@instance. Selected data concerning announcements, exchange requests, chat messages, and reviews is replicated asynchronously. Local operations remain available when a peer is unreachable, while a persistent outbox, manual and automatic retries, stable event identiers, and a processed-event inbox ledger support eventual consistency and idempotent handling. Federated chat uses persistent Lamport logical clocks to obtain a causality-compatible deterministic ordering without depending on synchronized physical clocks. Reviews are propagated to the reviewed user's home instance and contribute to local reputation. The prototype therefore provides a concrete study of federation, replication, partial failure, recovery, logical time, and the trade-o between availability and immediate consistency.},
    apice = {FederatedSkillshare},
    author = {Vigil Bravo, Jorge and González Menéndez, Yeray},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = jul,
    sort = {classic},
    supervisor = {Matteini, Mattia},
    title = {Federated Skillshare},
    type = {Standard Project},
    url = {https://github.com/yerayyay-27/federated-skillshare},
    year = 2026
}
@courseproject{aiadmissionagent-,
    abstract = {This project implements a domain-bounded conversational assistant for prospective students who need practical guidance about applying to Italian universities and handling adjacent study procedures such as student visas, residence permits, scholarships, and admission documents. The system is exposed primarily through Telegram, but its internal design is split into a Go bot layer and a Python retrieval service. The Go layer handles Telegram updates, access control, optional Redis-backed conversation memory, and optional event publication. The Python service performs guardrail checks, intent classification, retrieval-query clarification, document search, grounded answer generation, and attachment-handling logic. The repository shows a deliberate attempt to keep the assistant narrow in scope. Queries related to study abroad in Italy are routed toward retrieval over a curated document corpus, while unrelated or unsafe requests are refused before answer generation. The corpus itself is practical rather than encyclopedic: it contains visa, residence-permit, DSU scholarship, CV, motivation-letter, and recommendation-letter material in English, Russian, and partly Kazakh, which indicates a multilingual support goal for applicants who may not be comfortable using only English or Italian. The main contribution of the project is not a novel model, but an end-to-end engineering design that combines access-controlled messaging, document-grounded assistance, lightweight conversation memory, and operational tooling for dataset refresh and administration. At the same time, the repository also reveals important limits: the corpus is narrow, official procedures are time-sensitive, and the system depends on careful prompt design and retrieval quality to remain reliable. For that reason, the assistant is best understood as an informational support tool rather than a legal or institutional authority.},
    apice = {AIAdmissionAgent},
    author = {Rakymzhan Zhabagin and Adilet Zhumabay},
    month = jul,
    sort = {advanced},
    supervisor = {Ciatto, Giovanni},
    title = {AI Admission Agent},
    type = {Advanced Project},
    url = {https://github.com/qonstant/distributed-agent},
    year = 2026
}
@courseproject{haochi-ds2526,
    abstract = {This project aims to implement a distributed real-time multiplayer game inspired by Family Sytle, where 2 to 8 players cooperate in a shared virtual kitchen to prepare recipes under time constraints. Players join a game session through a room system: one player creates a room and receives a unique code that others use to enter the same match and participate in a synchronized environment.},
    apice = {Haochi},
    author = {Yan, Elisa and Malagoli, Anna},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Haochi - Cook&Pass},
    type = {Game Project},
    url = {https://github.com/elisayan/haochi-cook-and-pass},
    year = 2026
}
@courseproject{ultimatefightinggame-ds2526,
    abstract = {UFG is a small distributed 2D fighting game built to explore a hard real-time problem: keeping two machines in agreement while both players expect immediate input response. The project combines a desktop game client, an authentication service, a signaling service, and a direct peer-to-peer gameplay channel. The main contribution is the match architecture. During a fight, there is no authoritative game server. Each client runs the same deterministic simulation and exchanges only player inputs through a WebRTC data channel. Rollback netcode absorbs late inputs by rewinding and replaying local state, while committed-frame hashes detect cases where the two simulations diverge. The backend services are intentionally modest. Authentication stores accounts and issues session tokens. Signaling pairs players and relays WebRTC setup messages, then leaves gameplay traffic to the peers. This keeps the distributed system focused on the central consistency and latency problem rather than on a large online platform. The report first defines the product boundary and requirements, then explains the design, implementation, validation, deployment, and player-facing workflow. It ends with future work and self-evaluation, including the parts intentionally left outside the submitted scope.},
    apice = {UltimateFightingGame},
    author = {Paradisi, Giovanni and Samite, Mounir},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Ultimate Fighting Game},
    type = {Game Project},
    url = {https://github.com/giovihey/UFG},
    year = 2026
}
@courseproject{veritrace-ise2526,
    abstract = {Veritrace was built around a practical question: if an LLM can draft useful rules from text, how canthose rules enter a runtime system without becoming hidden, unreviewed behavior? The answer inthis prototype is a gated pipeline. The LLM drafts, the human reviews, the backend promotes andvalidates, and Jason performs the runtime reasoning.The review console supports two small demo areas. The Cardiac path is the main authoring demo:it has a prepared CMR Mass Score source, claim, and candidate rule for the fast walkthrough, andit can also be used through the live LLM pipeline. GDPR is stronger on the runtime side: it hasapproved rules, approved plan artifacts, benchmark cases, and expected traces for compliancescenarios such as missing legal basis, special-category processing, and late breach notification.At runtime, Veritrace returns a trace with the decision, risk, activated rules, evidence, missing data,source identifiers, human-review flags, and planner-generated next steps. The LLM can be usedagain at the end to turn this trace into a readable explanation, but it receives only the trace andselected source snippets. The trace remains the source of truth.The result is not meant to be a production compliance or medical tool. It is an exam prototypeshowing how LLM-assisted authoring, human review, symbolic execution, and trace inspection canbe connected in one reproducible local workflow.},
    apice = {Veritrace},
    author = {Leoni, Lorenzo},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = jul,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Veritrace},
    type = {Technology Project},
    url = {https://github.com/LoryBug/Veritrace},
    year = 2026
}
@courseproject{agentofrivia-ise2425,
    abstract = {This project is a fantasy creature hunting simulation inspired by The Witcher. The environment consists of a grid-based world where a Hero agent hunts and defeats enemy agents. Battles are triggered when the Hero encounters enemies in neighboring cells, and each victory allows the Hero to improve both health and strength. The simulation includes a health recovery area and tracks the number of Hero deaths. The system is implemented in Java, with agent behaviors programmed in Jason and a graphical interface developed using Java.},
    apice = {AgentofRivia},
    author = {Alhammadi, Shaikha and Chukarin, Igor},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = jul,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {Agent of Rivia},
    type = {Simulation Project},
    url = {https://github.com/Intelligent-Systems-Engineering-Team/Agent-of-Rivia/},
    year = 2026
}
@courseproject{yahrperlika2026-ise2526,
    abstract = {YAHR is a command-line tool that acts as your personal career co-pilot. It reads your resume, searches for relevant job openings, scores them against your profile, and tells you exactly how to improve your CV to maximize your chances — all from the terminal. Built on the A2A Protocol (an open standard for agent-to-agent communication), YAHR is composed of four specialized agents that work together under a single orchestrator: Job Searcher Agent — queries web search APIs to discover open positions matching your background Matching/Ranker Agent — parses your CV into a structured profile and scores each job against it CV Assistant Agent — analyzes the gaps between your profile and the top-ranked jobs, then gives you concrete suggestions to strengthen your resume Orchestrator Agent — ties everything together and exposes the full workflow through an intuitive CLI interface The whole system is written in Python. The CLI is built with Typer + Rich for colored, structured output. Each agent's reasoning comes from an LLM, accessed through OpenRouter so the system stays model-agnostic. Architecturally, each agent is a standalone HTTP server, not a module inside one program.},
    apice = {YahrPerlika2026},
    author = {Perlika, Elvis},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = jul,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {YAHR -- Yet Another HR},
    type = {Standard Project},
    url = {https://github.com/elvisperlika/YAHR},
    year = 2026
}
@courseproject{aeroguard-ise2526,
    abstract = {AeroGuard-MAS is a simulated multi-agent airspace conflict management system. Its goal is to model how intelligent agents can detect potential aircraft conflicts, reason about safety constraints, generate resolution plans, apply corrective maneuvers, and explain their decisions. The system addresses a simplified version of a real airspace management problem: multiple aircraft move through a shared sector while maintaining horizontal and vertical separation. When aircraft trajectories create a current or future loss of separation, the system must detect the unsafe situation and select an appropriate corrective action.},
    apice = {AeroGuard},
    author = {Testa, Alex},
    howpublished = {Intelligent Systems Engineering, A.Y. 2025/2026},
    month = jun,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {AeroGuard-MAS},
    type = {Simulation Project},
    url = {https://github.com/AlexTesta00/aeroguard-mas},
    year = 2026
}
@courseproject{masavpredictivemaintenance2026-ise2425,
    abstract = {This report presents the design, implementation, and evaluation of a Multi-Agent System (MAS) for autonomous vehicle predictive maintenance that unifies three graduate courses of the University of Bologna’s Master’s programme in Computer Science and Engineering: Machine Learning and Data Mining (Codice 95631), Distributed Systems (Codice 87474), and Embedded Systems and IoT (Codice 77780). The system demonstrates how three seemingly independent technical domains combine to solve a real automotive problem: keeping a distributed fleet healthy while minimising unplanned downtime and emergency repair costs. At the edge, ESP32 telematics devices collect sensor data, derive ECDSA signatures from each vehicle’s VIN, and publish authenticated telemetry over MQTT, with a dedicated Arduino controller acting as a hardware authentication gateway. A permissioned Hyperledger Fabric network of five peer nodes provides Byzantine fault-tolerant, immutable storage for telemetry and service records, sequencing transactions through a Raft ordering service. A Random Forest classifier trained on 50,000 vehicle records predicts maintenance needs with high accuracy and exposes feature-importance reasoning for explainability. Above these three layers, a Jason AgentSpeak multi-agent system coordinates vehicles, service centres, and a fleet coordinator through stigmergy-based signalling and consensus-validated agreements. The integrated system targets an 80% reduction in unplanned downtime and an estimated saving of €165,800 per 10,000 vehicles annually (€16.58 per vehicle). This document also details the Service Center Agent contribution, Mary Anne Selirio, framed as a capacity-focused resource manager that tracks technician availability and parts inventory, allocates service slots in response to fleet booking pressure, and logs immutable service records to the blockchain.},
    apice = {MasAvPredictiveMaintenance2026},
    author = {Katrenov, Dias and Khayatian, Danial and Selirio, Mary Anne},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    keywords = {Multi-Agent Systems, Predictive Maintenance, Stigmergy, Byzantine Fault Tolerance, Hyperledger Fabric, Raft Consensus, Random Forest, ESP32, ECDSA, MQTT, Jason, AgentSpeak, Intelligent Embedded Systems.},
    month = jun,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {A Multi-Agent System for Autonomous Vehicle Predictive Maintenance: Integrating Machine Learning, Distributed Ledger Consensus, and Embedded IoT Telematics},
    type = {Standard Project},
    url = {https://github.com/Dias266/Multi-Agent-System-for-Autonomous-Vehicle-Predictive-Maintenance},
    year = 2026
}
@courseproject{distributedbattleshipgame-ds2526,
    abstract = {The project consists of a simple, distributed battleship game where two users place their ships on a grid, and the first to sink the opponent’s fleet wins. A distributed architecture is employed, utilizing a peer-to-peer model for communication between the two players during the match, and a client-server model to enable both user matchmaking and the registration of backup servers with the primary server. This registration allows backup servers to receive constant state updates from the primary server, ensuring they are ready to take its place if it becomes unreachable.},
    apice = {DistributedBattleshipGame},
    author = {Viola, Leonardo},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jun,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Distributed Battleship},
    type = {Game Project},
    url = {https://github.com/leonardo284/Distributed-Battleship},
    year = 2026
}
@courseproject{scopa2-ds2526,
    abstract = {Scopa2 is an online two-player card game: a variant of the Italian Scopa Scientifica extended with a card-mutation mechanic based on Santi, playable through a native desktop client. Behind the game there is a deliberately distributed back end: two symmetric regions (Europe and North America)run the same stack on Kubernetes, the client picks the closest region by measuring latency at startup, and every component is replicated so that the death of a pod, of a database node, or even of an entire region does not interrupt a match. The two core ideas of the design are (1) modelling each match as an event-sourced deterministic state machine, so that any server can rebuild any game by replaying its move log, and (2) delegating the hard coordination problems (consensus, leader election, failover) to infrastructure that already solves them: YugabyteDB for Raft-replicated storage, Redis Sentinel for the cache and pub/sub tier, Kubernetes for scheduling and scaling. The report explains the design, the consistency trade-offs we made (CAP/PACELC), and how we validated the system with fault-injection tests on the live deployment.},
    apice = {Scopa2},
    author = {Coppola, Marco and De Nicola, Valerio Pio},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jun,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Scopa2: A Geo-Distributed Multiplayer Game},
    type = {Game Project},
    url = {https://github.com/Scopa2/scopa2-backend},
    year = 2026
}
@courseproject{marafonet-ds2526,
    abstract = {In this report we document the concept, design and testing of MarafoNet, a digitalised version of Marafone a traditional card game from Italy. The system’s design is focused on distribution as its main aspect, elicitating the benefits that this approach brings and defining requirements to be satisfied both for distribution and user-related. The features of the game are explained and modeled in an architecture coherent with the requirements cited. Security and scalability issues are addressed. Implementation strategies and integration between technologies are shown to achieve requirements and the architecture planned. Finally, tests are displayed to verify the correctness of the system’s operations as well as the insfrastructure components used. A guide will help the user deploy, use the system and understand the rules of the game.},
    apice = {MarafoNet},
    author = {Bagattoni, Federico and Turchi, Jacopo},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jun,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {MarafoNet, Marafone on the net},
    type = {Game Project},
    url = {https://github.com/juturbo/MarafoNet},
    year = 2026
}
@courseproject{pixie-ds2526,
    abstract = {Pixie is a collaborative platform for creating pixel art in real time. Multiple users interact simultaneously on the same digital canvas, cooperating on the creation of a shared drawing through an interactive web interface. The application is designed as a Single Page Application (SPA) whose central element is a grid of pixels whose state is kept consistent and updated for all connected clients, enabling a uniform view of the drawing in progress. The system follows a three-tier architecture comprising a Vue.js frontend, a Node.js/Express backend, and a MongoDB database. Real-time synchronisation relies on Socket.IO for bidirectional communication and Server-Sent Events (SSE) for push notifications. To support horizontal scalability and fault tolerance in a distributed deployment, the architecture integrates Redis as a shared state store and pub/sub message broker, Traefik as a load-balancing reverse proxy, and a coordination service that uses distributed locking to safely persist canvas data from any server instance.},
    apice = {Pixie},
    author = {Susca, Matteo and Zavatta, Andrea},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jun,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Pixie - Collaborative Pixel Art Platform},
    type = {Standard Project},
    url = {https://github.com/pixie-git/pixie},
    year = 2026
}
@courseproject{faulttolerantdistributedminesweeper-dss2526,
    abstract = {We built a cooperative, distributed Minesweeper game. But instead of relying on an external database to keep things in sync, we designed an in-memory Replicated State Machine (SMR) from scratch. Using pure Python TCP sockets, the architecture enforces Strong Consistency across a three-node cluster through a two-phase PREPARE/COMMIT chain replication protocol. If the leader dies, the cluster recovers automatically. We fully containerized the entire stack—even the graphical Tkinter client—proving that complex fault tolerance and deterministic state can work without heavy-weight dependencies.},
    apice = {FaultTolerantDistributedMinesweeper},
    author = {Maire Bravo, Nicolás and López Lamas, Iago},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = jun,
    sort = {game},
    supervisor = {Matteini, Mattia},
    title = {Fault-Tolerant Distributed Minesweeper},
    type = {Game Project},
    url = {https://github.com/nico-maire/distributed-minesweeper},
    year = 2026
}
@courseproject{energyconsumptionoptimizer2026-ds2324,
    abstract = {ECO is a distributed, microservices-based web platform for real-time monitoring and optimization of household utility consumption (electricity, gas, water). The system ingests telemetry from network-connected smart hookups, stores measurements in a time-series database, and exposes live dashboards, historical analytics, consumption forecasts, and configurable threshold alerts. Seven independently deployable services, derived from DDD bounded contexts, communicate through a Kafka-backed event-driven pipeline with transactional outbox, inbox deduplication, and dead-letter queues, achieving effectively—once processing and fault-tolerant data propagation. The Monitoring service maintains a Redis cache of measurement tags, hookup metadata, user existence, and zone mappings, kept consistent via Kafka domain events; on broker unavailability the system falls back to direct inter-service HTTP calls, with hookup ID misses always triggering a re-query to prevent measurement loss. The entire stack is containerized and deployed via Docker Compose on a single machine.},
    apice = {EnergyConsumptionOptimizer2026},
    author = {Bennici, Salvatore and Vasiliu, Rares},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = jun,
    sort = {application},
    supervisor = {Magnini, Matteo},
    title = {Energy Consumption Optimizer},
    type = {Application Project},
    url = {https://github.com/orgs/EnergyConsumptionOptimizer/},
    year = 2026
}
@courseproject{wineshop2026-ds2526,
    abstract = {This report describes the design and implementation of an e-commerce platform for wine sales built following a microservices architecture. The system is composed of seven independent services — users, catalog, inventory, cart, orders, and payments — coordinated by an API gateway and communicating via RabbitMQ as a message broker. The main objective of the project is to address two fundamental challenges of distributed systems: managing transactions that span multiple services without global ACID transactions, and maintaining the consistency of a distributed cache. The first challenge is solved through the implementation of the Saga Pattern in choreographed style, where services react to events published on a RabbitMQ topic exchange without a centralized orchestrator. The second is addressed through Redis, used both as a cache layer for the catalog and for temporary persistence of guest user carts, with asynchronous key invalidation when the underlying data changes. User authentication is handled via JSON Web Tokens, while payments are delegated to Stripe with cryptographic verification of incoming webhooks. The entire system is containerized with Docker Compose, which manages the lifecycle of all infrastructure components including six PostgreSQL databases, RabbitMQ, and Redis.},
    apice = {WineShop2026},
    author = {Savoca, Giovanni Maria and Valentini, Enrico},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jun,
    sort = {application},
    supervisor = {Magnini, Matteo},
    title = {WineShop: E-Commerce Platform for Wine Sales with Microservices Architecture and Distributed Transactions},
    type = {Application Project},
    url = {https://github.com/Giosc4/DSS_wineWebSite},
    year = 2026
}
@courseproject{lastbite-ds2425,
    abstract = {Food waste represents one of the most significant sustainability challenges worldwide, with large quantities of edible products discarded daily across the food supply chain. Restaurants and food service activities contribute substantially to this issue, especially through unsold products remaining at the end of the day. This report details the design and implementation of LastBite, a distributed web application designed to mitigate food waste by enabling restaurants to sell surplus products at the end of the day. The project is built on top of the MEVN (MongoDB, Express.js, Vue.js, Node.js) stack and orchestrated using a Docker-based approach to ensure scalability and isolation. The system comprises multiple containerized services, including two backend instances, a Vue frontend, a MongoDB replica set, a Redis database for distributed locking and an Nginx reverse proxy for load balancing and fault tolerance. Furthermore, LastBite implements several security features required by the application domain, such as secure authentication, password hashing, Role-Based Access Control (RBAC) and distributed locks for handling product purchases and modifications. The system offers dedicated interfaces for restaurants, which manage products and orders, and for customers, who can search for nearby restaurants using geospatial filtering. Finally, the application also includes real-time notifications and an AI-powered “Food Advisor” assistant.},
    apice = {LastBite},
    author = {Babini, Pier Costante and Morelli, Marco},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jun,
    sort = {application},
    supervisor = {Magnini, Matteo},
    title = {LastBite},
    type = {Application Project},
    url = {https://github.com/piertv21/LastBite},
    year = 2026
}
@courseproject{roddit-ds2526,
    abstract = {This project consists of a social-network-like web application developed from scratch, taking inspiration from similar products available on the market, such as Reddit, to tackle the usual problems of distributed services. In addition, we containerized the application using Kubernetes to increase its resilience to common runtime problems and added tools such as Grafana and Chaos Mesh to monitor, control, and manage its execution.},
    apice = {Roddit},
    author = {Babbi, Giovanni and Filippo Di Pietro},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jun,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Roddit},
    type = {Standard Project},
    url = {https://github.com/dippi9845/roddit},
    year = 2026
}
@courseproject{hanabimultiplayer-ds2526,
    abstract = {Hanabi is a cooperative multiplayer card game for 2--4 players where players score by guessing their own hidden cards based on hints given by other players. This project aims to implement a working version of the game that manages the shared state consistently and reliably, while being able to tolerate disconnects from a client or the server.},
    apice = {HanabiMultiplayer},
    author = {Savevski, Blagoja and Xu, Pengyue and Santi, Gabriele},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jun,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Distributed Hanabi},
    type = {Standard Project},
    url = {https://github.com/ajdonker/Hanabi_DS},
    year = 2026
}
@courseproject{connectfour-ds2425,
    abstract = {This report details the architectural design, protocol specifications, and validation framework of a highly available, networked multiplayer implementation of the classic strategy matrix board game Connect Four. Developed using Python, FastAPI, WebSockets, and PyQt6, the system addresses core concerns of modern distributed environments, specifically fault isolation, dynamic session state routing, and state machine replication. Adhering to the principles of the CAP Theorem, the architecture favors an AP (Availability and Partition Tolerance) model to preserve match state permanence across abrupt software failures. By implementing a strict master-slave warm standby synchronization model governed by real-time heartbeat monitors, the system demonstrates an automated, transparent 10-second failover recovery routine. This design ensures seamless user connection migration and prevents data corruption or game session resets when an active cluster coordinator unexpectedly terminates.},
    apice = {ConnectFour},
    author = {Lajani, Arvin},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jun,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Distributed Connect Four: A Fault-Tolerant Networked Multiplayer Game Architecture},
    type = {Game Project},
    url = {https://github.com/ArvinLajani/Distributed-Connect-Four},
    year = 2026
}
@courseproject{gossipbaseddistributedmonitoringsystem-ds2526,
    abstract = {This project presents the design and implementation of a fully decentralized monitoring system based on gossip (epidemic) protocols. The system consists of multiple independent nodes that collaboratively maintain cluster membership and detect failures without relying on any centralized coordinator. Each node periodically exchanges partial state information with a subset of randomly selected peers. Through these probabilistic interactions, membership updates propagate across the system, enabling nodes to converge toward a consistent global view even in the presence of network delays, packet loss, and node crashes. Failure detection is achieved through heartbeat mechanisms combined with timeout-based state transitions (ALIVE, SUSPECT, DEAD),following a design inspired by the SWIM protocol. The system is designed to operate in asynchronous and unreliable environments while ensuring eventual consistency. An experimental extension, called Gossip Arena, is introduced to study information dissemination dynamics. Synthetic rumor events are injected into the system to evaluate the impact of different gossip strategies and parameters on dissemination speed and communication overhead. Experimental results show that the system remains robust under moderate network impairments and highlight the trade-offs between convergence speed, communication cost, and accuracy of failure detection.},
    apice = {GossipBasedDistributedMonitoringSystem},
    author = {Testa, Thomas},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = jun,
    sort = {advanced},
    supervisor = {Magnini, Matteo},
    title = {Gossip-Based Distributed Monitoring System},
    type = {Advanced Project},
    url = {https://github.com/ThomasTesta/gossip-distributed-monitoring.git},
    year = 2026
}
@courseproject{distributedminingmonitor2026-ds2526,
    abstract = {This project presents a Distributed Mining Monitor, a controlled experimental platform designed to study Proof-of-Work (PoW) consensus in a distributed setting. The system includes a coordinator service, a configurable set of CPU and GPU miners, and a monitoring dashboard exposing the behaviour of the system in real time. The goal is not to implement a production-ready blockchain, but rather a reproducible laboratory for observing miner competition, fork creation, stale work, branch persistence, and reorganization events. The final version of the project supports heterogeneous miners, local branch persistence, configurable reorganization thresholds, simulated network delay, and a simplified difficulty-adjustment policy. Instead of re-synchronising to the coordinator before every mining attempt, miners can continue mining on their local branch and switch back to the coordinator only when they fall sufficiently behind. This makes competing branches persist long enough to generate visible reorgs. The coordinator stores the full block DAG, selects the canonical branch according to an explicit policy, and exposes metrics consumed by a dashboard that visualises chain growth, stale branches, accepted blocks by miner, reject rate, difficulty level, and block-DAG evolution.},
    apice = {DistributedMiningMonitor2026},
    author = {Remedi, Tommaso and Biagioni, Giacomo},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = may,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Distributed Mining Monitor},
    type = {Standard Project},
    url = {https://github.com/Reme240400/Distributed-System-Project-Remedi-Biagioni},
    year = 2026
}
@courseproject{mancalagame2026-ds2425,
    abstract = {This report presents the design and implementation of a distributed Mancala game system built using Spring Boot and WebSockets. The system enables two players to play the classic Mancala board game over a network in real-time. The primary focus is on handling distributed challenges such as player disconnection, session management, inactivity detection, and state consistency across multiple clients. The implementation demonstrates core distributed systems concepts including asynchronous communication, fault tolerance, and timeout mechanisms. The game is implemented with a clean separation between domain logic (game rules), service layer (business logic), and presentation layer (WebSocket controllers). Key features include automatic room creation, player joining, real-time game state synchronization, graceful disconnection handling with reconnection support, and inactivitybased player forfeit mechanisms.},
    apice = {MancalaGame2026},
    author = {Sabertehrani, Kasra and Sokuti, Parisa},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = may,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Distributed Mancala},
    type = {Game Project},
    url = {https://github.com/kasrasabertehrani/mancala-game},
    year = 2026
}
@courseproject{distributedaudioprocessingpipeline-dss2526,
    abstract = {This work presents a distributed, event-driven pipeline for asynchronous audio processing, designed as a practical case study for distributed systems principles and operational observability. Users submit audio files through a FastAPI service. The API stores binary objects in MinIO, persists job metadata in PostgreSQL, and publishes processing requests to RabbitMQ. A decoupled worker consumes queued jobs, extracts core audio metadata (duration, sample rate, channels), and writes results back to the database. The same API exposes upload, job tracking, and result retrieval endpoints, enabling a complete end-to-end workflow. The architecture separates ingestion and processing through asynchronous messaging, so API and worker instances can scale independently. Reliability is modeled through durable queue-based communication and explicit jobstate transitions (PENDING, PROCESSING, DONE, FAILED), while observability is supported via Prometheus-compatible metrics for throughput, latency, queue backlog, and worker activity. The stack is containerized with Docker and structured for Kubernetesbased deployment and scaling experiments. The project shows how messagedriven coordination, persistent state management, and monitoring can be combined into a reproducible distributed audio-processing system.},
    apice = {DistributedAudioProcessingPipeline},
    author = {Cardellini, Matteo},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = may,
    sort = {classic},
    supervisor = {Matteini, Mattia},
    title = {Distributed Audio Processing Pipeline with Observability},
    type = {Standard Project},
    url = {https://github.com/matteo1610/distributed-audio-pipeline},
    year = 2026
}
@courseproject{explodingkittens-ds2425,
    abstract = {The project is a distributed base implementation of the popular card game Exploding Kittens. Exploding Kittens is a card game for 2 to 4 players. On each turn, a player either plays action cards from their hand or draws cards from the deck. Draw an Exploding Kitten and you are out, unless you have a Defuse card to save yourself. The last player standing wins.},
    apice = {ExplodingKittens},
    author = {Versari, Alessandra and Balzoni, Margherita},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = may,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Exploding Kittens},
    type = {Game Project},
    url = {https://github.com/Aleversari15/DS25-ExplodingKittens},
    year = 2026
}
@courseproject{distributedsensorhubsantini2026-ds2526,
    abstract = {Distributed Sensor Hub is a fully decentralized peer-to-peer platform for smart-city sensor data collection and replication, designed to operate across multiple nodes without any central coordinator. Each node may manage connections to multiple local sensors, ingest their readings through a pluggable sensor interface to support different sensor types, and maintain a local replica of the shared system state. The platform disseminates sensor updates through push-pull gossip and resolves conflicts with deterministic timestamp-based Last-Writer-Wins merging, providing eventual consistency across replicas. To remain operational in realistic distributed environments, the system combines gossip-based membership, phi-accrual failure detection, and antientropy recovery after crashes or temporary network partitions. In CAP terms, the project prioritizes availability and partition tolerance over strong consistency, while still guaranteeing convergence once communication is restored.},
    apice = {DistributedSensorHubSantini2026},
    author = {Santini, Alex},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = may,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {P2P Distributed Sensor Hub for Smart City Monitoring},
    type = {Standard Project},
    url = {https://github.com/AlexSantini10/distributed-sensor-hub},
    year = 2026
}
@courseproject{dok-ds2526,
    abstract = {Dok is a distributed, real-time collaborative document editing platform implemented as a web application. It allows multiple users to create, share, and simultaneously edit text documents. The system is built on a client--server architecture in which the backend is horizontally scaled across two Node.js/Express server instances, load-balanced by an Nginx reverse proxy. Real-time collaboration is achieved through Yjs Conflict-free Replicated Data Types (CRDTs) transported over Socket.io WebSocket connections; cross-instance event propagation is coordinated via a shared Redis Pub/Sub adapter, which also enables cluster-wide user-presence tracking. Persistent state is stored in a MongoDB document database. Documents are organised in folders and can be made public or private, with sharing policies (viewer, commenter, editor) enforced through JWT-based authentication and role-based access control. An administrative dashboard provides real-time platform-wide statistics, audit trails, user presence information, and site-access logs. The entire infrastructure is containerised with Docker Compose, making deployment reproducible with a single command.},
    apice = {Dok},
    author = {Stefani, Alessandro and Tosi, Lorenzo},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = may,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Dok},
    type = {Standard Project},
    url = {https://github.com/lorenzotosi/Dok},
    year = 2026
}
@courseproject{votingpollingsystem2026-ds2526,
    abstract = {This project presents a distributed voting and polling system designed to operate in a decentralized and fault-tolerant environment. The system allows users to create polls and cast votes through a REST-based web service, while maintaining replicated application state across multiple nodes. The core challenge addressed is maintaining replicated poll state in the presence of concurrent updates, node crashes, and network partitions. To address this, the system adopts a Conflict-free Replicated Data Type (CRDT) model, allowing nodes to process updates independently while guaranteeing eventual convergence of replicas. Update dissemination is implemented through a best-effort replication strategy combined with periodic anti-entropy synchronization, ensuring that updates missed during temporary disconnections are eventually propagated. To improve dependability, each node persists updates using a write-ahead log (Write-Ahead Log (WAL)) and periodically creates checkpoints, allowing recovery after crashes with no loss of locally persisted updates. A heartbeatbased failure suspicion mechanism is also included to monitor node reachability and identify potentially failed or disconnected peers. The system prioritizes availability and partition tolerance over strong consistency, making it suitable for distributed environments where network reliability cannot be guaranteed. The final implementation demonstrates how fundamental distributed systems concepts such as replication, consistency trade-offs, and fault tolerance can be applied in a practical application.},
    apice = {VotingPollingSystem2026},
    author = {Pisu, Roberto},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = apr,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Distributed Voting and Polling System},
    type = {Standard Project},
    url = {https://github.com/robertop03/Distributed-Voting-and-Polling-System},
    year = 2026
}
@courseproject{showdownbaldazzi2026-ds2526,
    abstract = {The project presents a simple distributed real-time game based on the showdown mode of Supercell’s Brawl Stars. The players are forced to combat inside an arena and the last one standing is considered the winner. The only way to survive is to eliminate all the other players by shooting at them. The game features a distributed architecture that uses a peer-to-peer communication model between players and client-server model to enable the presence of a lobby server. To overcome unstable networks, the game implements client-side prediction mechanisms.},
    apice = {ShowdownBaldazzi2026},
    author = {Baldazzi, Andrea},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = apr,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Showdown},
    type = {Game Project},
    url = {https://github.com/baldo3000/showdown},
    year = 2026
}
@courseproject{taskflow-dss2526,
    abstract = {Effective coordination between centralized command centers and distributed field operatives requires strict state synchronization across unpredictable network topologies. TaskFlow is a distributed workforce management platform utilizing a microservices architecture that separates rigid HTTP REST data operations from real-time WebSocket streams. This report outlines the system requirements, architectural design choices, distribution aspects, and fully containerized deployment strategies. By implementing an event-driven messaging layer via RabbitMQ, the system prioritizes high availability and graceful fault tolerance, ensuring deterministic data consistency for distributed mobile clients operating in volatile environments.},
    apice = {TaskFlow},
    author = {Trabelsi, Ahmed and Toumi, Lotfi},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = apr,
    sort = {classic},
    supervisor = {Matteini, Mattia},
    title = {TaskFlow: A Distributed Tactical Mission Control System},
    type = {Standard Project},
    url = {https://github.com/toumilotfi/fullstack-project/},
    year = 2026
}
@courseproject{minidynamo2026-dss2526,
    abstract = {The goal of this project is to design and implement a simple distributed key-value store inspired by real-world systems such as Amazon Dynamo. The system will consist of multiple independent nodes that cooperate to store and retrieve key-value pairs while tolerating node failures. Each node will run as a separate process and communicate with other nodes over the network. The system will provide a basic client interface that supports storing and retrieving data in a distributed environment.},
    apice = {MiniDynamo2026},
    author = {Dominykas Arnauskas},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = apr,
    sort = {classic},
    supervisor = {Matteini, Mattia},
    title = {Mini-Dynamo: A Distributed Key-Value Store in Python},
    type = {Standard Project},
    url = {https://github.com/DominykasAr/Distributed-systems-project},
    year = 2026
}
@courseproject{eventonight-ds2324,
    abstract = {The project consists of the design and development of a distributed digital platform called EvenToNight, aimed at connecting organizations that promote socialevents with users interested in discovering and participating in them. The platform, accessible at EvenToNight, can be used either as a guest or through a registered account that provides additional functionalities. From a technical perspective, EvenToNight has been designed as a distributedsystem based on a microservices architecture, supporting modularity, scalability andthe independent management of application components. This architectural choice enables horizontal and autonomous scaling of the various system components, allowing the platform to handle a large number of usersconcurrently. Furthermore, the distributed architecture ensures reliable data persistence, availability and openness, thereby facilitating future extensions and adaptation to evolving requirements. Overall, the project represents a practical application of distributed systemsprinciples within the context of a realistic web-based platform.},
    apice = {EvenToNight},
    author = {Alice Alfonsi and Bravetti, Federico and Tommaso Brini},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = apr,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {EvenToNight},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-alfonsi-bravetti-brini-ay2324},
    year = 2026
}
@courseproject{nomicosecitta2026-ds2425,
    abstract = {This project presents a real-time, distributed implementation of the classic italian word game Nomi, Cose, Citt`a. It transforms the traditional pen-and-paper format into a modern multiplayer experience, where players compete in real time to find words that match given categories and starting letters. At the end of each round, participants collaboratively validate each other’s answers through an integrated voting and chat system. The game features a distributed architecture that combines client--server and peer-to-peer communication models, ensuring consistent gameplay with fault tolerance and synchronized state across all nodes.},
    apice = {NomiCoseCitta2026},
    author = {Chiara Giangiulli and Pisoni, Giovanni and Dilaver Shtini},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = apr,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Nomi, Cose Citt\`{a}},
    type = {Game Project},
    url = {https://github.com/DilaverShtini/nomi-cose-citta},
    year = 2026
}
@courseproject{unop2p2026-ds2526,
    abstract = {When it comes to playing games online, cheaters represent a major problem. Especially, peer-to-peer architectures are vulnerable to cheating as the game state and logic are handled purely by untrusted peers, rather than a single trusted server. However, using P2P approaches can increase scalability as this usually implies smaller bandwith requirements for the service provider. In this project, we develop and design a system that provides a (mostly) cheating-proof method for implementing a card game in a P2P fashion. As a proof-of-concept, we develop a card game, similar to the game ‘UNO’. Further, we design a distributed architecture that integrates this approach into a more complex system that additionally provides functionality for a leaderboard that tracks the win statistics of the players.},
    apice = {UNOP2P2026},
    author = {Luka Finn Born},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = mar,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {UNO-P2P: A Cheater-proof Peer-to-Peer implementation of a simple card game},
    type = {Game Project},
    url = {https://github.com/IchbinLuka/p2p-uno},
    year = 2026
}
@courseproject{opcuaindustrialplanthub-ds2526,
    abstract = {This report illustrates OPCUA Industrial Plant Hub, a software developed to demonstrate the fundamental principles of Distributed Systems by integrating them with the world of industrial automation. In the world of industrial automation, the issue of data collection from machines and machine lines is becoming increasingly important. Therefore, this project aims to provide a distributed data collection system for different production lines, which may also be distributed across the territory. The project is based on the use of IoT devices, which are connected to the production line and collect data on the production process. The data collected is then sent to a central server, which stores it and allows it to be analysed. The data can also be sent to the machines themselves, allowing them to be controlled and optimised. The underlying idea is that data is collected from the machine line using the OPC UA protocol, widely used in industry, saved and then retrieved via HTTP API. Unlike traditional data collection architectures based on a single physical node that reads data, the architecture of this project consists of three HUB nodes that collect OPC UA data, synchronised via Anti-Entropy and Gossip protocols, with an nginx load balancer that distributes client requests and implements data encryption via the TLS protocol. The project emphasises the AP behaviour of the CAP Theorem, i.e. it focuses on the aspects of Partition Tolerance and High Availability, thus ensuring that clients can always access data even in the presence of network partitions or individual node failures. The Strong Consistency concept is therefore not guaranteed, promoting data that is not updated to the latest possible value over a longer wait time that would result from the application of Strong Consistency itself. The system allows OPC UA sources to be added dynamically, by implementing an on the fly automation line connection mode, allowing individual machines or entire lines to be connected and added without the system needing to be restarted.},
    apice = {OPCUAindustrialPlantHub},
    author = {Federico Capitanio},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = mar,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {OPC UA Industrial Plant HUB},
    type = {Standard Project},
    url = {https://github.com/FedericoCapitanio-Unibo/DISI-DS-OPCUA-Industrial-HUB},
    year = 2026
}
@courseproject{distributedbomberman-dss2526,
    abstract = {We present a distributed, real-time Bomberman system designed for multi-player gameplay with scalability and fault tolerance. The architecture is split into two layers: a hub layer responsible for matchmaking and cluster coordination, and a room layer that executes the authoritative game loop. The hub server adopts an AP-oriented design, using UDP-based gossip to disseminate room availability and peer liveness without centralized coordination. The room server is CP-oriented, running a deterministic tick loop over a TCP and Protocol Buffers protocol to ensure consistent state across clients. The client is protocol-driven and renders the game as an ASCII interface. The system supports transient failure handling through bounded reconnection windows and state snapshotting, keeping matches stable under brief network interruptions. A Kubernetes-based deployment is used for hub scalability and room provisioning. The result is a coherent distributed design that balances availability with strong consistency at the game engine.},
    apice = {DistributedBomberman},
    author = {Enrico Ferraiolo and Daniele Romanella},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = mar,
    sort = {game},
    supervisor = {Matteini, Mattia},
    title = {Distributed Bomberman Game},
    type = {Game Project},
    url = {https://github.com/Distributed-System-AA-2025-2026/Bomberman},
    year = 2026
}
@courseproject{distributedconsistencyrtcollab-ds2425,
    abstract = {A comparative Analysis of Operational Transformation (OT) and Conflict Free Replicated Data Types (CRDTs)},
    apice = {DistributedConsistencyRTCollab},
    author = {Keith Barnes},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = feb,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Distributed Consistency in Real-time Collaboration},
    type = {Survey Project},
    year = 2026
}
@courseproject{pddlevolution-ise2425,
    abstract = {Foundations, Standardization, and Comparative Analysis of Planning Technologies},
    apice = {PDDLEvolution},
    author = {Keith Barnes},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = feb,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Classical Logic to Modern Solvers: The Evolution of PDDL},
    type = {Survey Project},
    year = 2026
}
@courseproject{townofsaviom-ds2526,
    abstract = {“Town of Saviom” is a web application developed as a joint project for the Distributed Systems and Applicazioni and Servizi Web courses. The application implements an online version of the party game “Lupus in fabula”, drawing inspiration from the mechanics of the video game Town of Salem. The game architecture centers on user interaction through a realtime shared chat, a crucial tool for discussion and deduction phases. Two game modes are provided: Classic (roles limited to Werewolf and Villager) and Advanced (introducing new roles such as Doctor and Seer). The gameplay is structured into three distinct phases that regulate chat reading and writing permissions: Day (global discussion and voting), Defense (only the accused player can defend themselves), and Night (Werewolves’ and special roles’ actions). The application offers a complete user management system, including registration, login, profile customization, and game statistics viewing. The main features of this web application allow users to create new games (acting as the lobby’s Host), search for existing lobbies via filters or unique codes, and handle automatic reconnection in case of disconnection. Additionally, a System Admin has global spectator privileges to monitor the proper conduct of matches (by viewing all players’ roles and exchanged messages).},
    apice = {TownofSaviom},
    author = {Fabio Pedrini and Lorenzo Zanetti and Alessandro Zanzi},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = feb,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Town of Saviom},
    type = {Game Project},
    url = {https://github.com/zanetti33/town-of-saviom-wrapper.},
    year = 2026
}
@courseproject{caboonline-ds2425,
    abstract = {The goal of this project is to develop a desktop application that allows users to play the online version of “Cabo”, a turn-based card game. Details about the game itself and how it works can be found in the report. The application runs on PC and provides a GUI to allow user interaction in every step of the system, from creating or joining a game, to the single actions performed during a turn. Games can be private or public: in the first case, other players can join only by using a unique code; in the second case, the game is shared through a lobby server and becomes visible to all players in the system. The server does not work as a dispatcher of messages between players; it is only used to obtain a reference to the host to start the communication. Therefore, the application is structured as a peer-to-peer (P2P) system, meaning that the players participating in a game are connected directly to each other. Without a centralized server, it is necessary that the information and data shared between players are always consistent and up to date. In particular, during a match, the game state (which includes the players’ hands and the table situation) must always be the same for every player at every turn, to ensure that the actions chosen by a player are coherent and correct with respect to the current situation.},
    apice = {CaboOnline},
    author = {Bachetti, Michele and Marcantognini, Elia and Tinti, Angelo},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = feb,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Cabo Online},
    type = {Standard Project},
    url = {https://github.com/angelo-will/cabo-online-distributed-systems-project},
    year = 2026
}
@courseproject{tinykeyvaluestore-dss2526,
    abstract = {TinyKV is a high performance distributed Key-Value store implementation. It is written in modern c++ (C++20) and uses grpc, multithreading and fine-grained locking to achieve up to 5000 Operations Per Second. TinyKV implements features like Tunable Consistency, Consistent Hashing, LWW Conflict resolution and asynchronous Heartbeats.},
    apice = {TinyKeyValueStore},
    author = {Emil Rafael Solberg},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = feb,
    sort = {classic},
    supervisor = {Matteini, Mattia},
    title = {TinyKV: A High Performance Distributed Key-Value Store},
    type = {Standard Project},
    url = {https://github.com/emsoraffa/TinyKV},
    year = 2026
}
@courseproject{distributedcollaborativestorytelling-ds2425,
    abstract = {Context: We propose the development of a Distributed Collaborative Storytelling Engine, a real-time platform where multiple users co-author a narrative under the guidance of a rotating narrator. Methodology: The system architecture implements a High Availability Master-Slave cluster. Key features include a dynamic role-rotation mechanism for the narrator and automated theme generation to ensure narrative flow. Robustness is guaranteed through a dual-layer strategy: active state replication for immediate failover and persistent storage for data durability.},
    apice = {DistributedCollaborativeStorytelling},
    author = {Arcese, Gabriele and Costantini, Marco},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = feb,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Distributed Collaborative Storytelling},
    type = {Standard Project},
    url = {https://github.com/MarcoCostantini26/DistributedStorytelling},
    year = 2026
}
@courseproject{robotsonmars-ise2425,
    abstract = {This project aims to create a Jason MAS simulating the behaviour of multiple robots exploring and collecting samples on Mars.},
    apice = {RobotsOnMars},
    author = {Venturini, Alessandro},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = feb,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {Robots on Mars},
    type = {Simulation Project},
    url = {https://github.com/Ventus218/robots-on-mars},
    year = 2026
}
@courseproject{distributedhoneypot-ds2425,
    abstract = {The proposed project involves the development of a distributed web application designed to monitor and analyze suspicious network activity through the use of Honeypots. Honeypots are specialized nodes configured to simulate vulnerable services, with the goal of attracting potential cyber threats and collecting valuable security data. The application features a centralized Dashboard that enables users to: Monitor the status of Honeypot nodes in real time. View detailed data on detected attacks. Manage the nodes directly from the interface. The collected data includes information on attacks, such as unauthorized access attempts, malicious file uploads, and other suspicious activities, all categorized by severity levels to prioritize responses. The system is designed to be distributed, allowing Honeypot nodes to operate on machines separate from the central server (in this case, within distinct containers). This architecture promotes scalability, isolation, and flexibility, making it suitable for dynamic and complex network environments.},
    apice = {DistributedHoneypot},
    author = {Diego Colì},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = feb,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Distributed Honeypot},
    type = {Standard Project},
    url = {https://github.com/floyddc/Distributed-Honeypot},
    year = 2026
}
@courseproject{dscinema-ds2526,
    abstract = {DS-Cinema is a distributed peer-to-peer system for cinema seat reservation. There is no central server managing the application logic or storing data: everything is distributed across the nodes in the network. The goal of the project is to implement from scratch the distributed coordination algorithms studied in class. In particular, I used the Ricart-Agrawala algorithm together with Lamport Clocks to guarantee mutual exclusion: if two users click at the same instant, they won’t have problems, but one of them will get the seat as booked, while for the other it will appear as occupied. The system also handles failures: if a node crashes during a reservation, the others detect it via timeouts and continue to work normally. New nodes can dynamically join the network and synchronize with the current state.},
    apice = {DSCinema},
    author = {Luca Cantagallo},
    howpublished = {Distributed Systems, A.Y. 2025/2026},
    month = feb,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {DS-Cinema: Distributed P2P Seat Reservation System},
    type = {Standard Project},
    url = {https://github.com/LucaCantagallo/DS-Cinema},
    year = 2026
}
@courseproject{distributedchessteambattle-dss2526,
    abstract = {This report presents ‘Distributed Team Chess’, a cooperative version of Chess designed to demonstrate fundamental principles of Distributed Systems within an interactive environment. Unlike traditional turn-based games, this system introduces a new gameplay mechanic based on Role Sharding and Distributed Consensus. Players are organized into teams where each node holds exclusive write permissions over a specific subset of game resources (specific chess pieces). To execute a state transition (a move), the team must reach a consensus through a voting protocol, transforming the game into a distributed coordination challenge. This way to play chess encourages collaboration, communication, and strategic planning among team members, giving the game a new dynamic and engaging dimension. From an architectural perspective, the system adopts a Broker-Based Hybrid Peer-to-Peer model. A scalable .NET backend, orchestrating communication via SignalR and persisting state on Redis, acts as a coordination bus and transaction log. This design choice prioritizes Strong Consistency and Partition Tolerance (CP in CAP terms), ensuring a single source of truth while offloading preliminary move validation logic to client nodes to simulate P2P filtering. The project places a strong emphasis on Fault Tolerance and High Availability. It implements automatic failure detection: in the event of a node crash or disconnection, a failover mechanism triggers a dynamic Rebalancing of the shards, transferring control of the ‘orphaned’ pieces to surviving teammates to ensure system liveness. Furthermore, a timeout-based supervisor prevents distributed deadlocks during the voting phase. This report details the architectural decisions, the consistency models adopted, and the resilience strategies implemented to guarantee a seamless user experience in a volatile distributed environment.},
    apice = {DistributedChessTeamBattle},
    author = {Matteo Raggi},
    howpublished = {Distributed Software Systems, A.Y. 2025/2026},
    month = feb,
    sort = {game},
    supervisor = {Matteini, Mattia},
    title = {Distributed Chess Team Battle},
    type = {Game Project},
    url = {https://github.com/matteraggi/DistributedChess},
    year = 2026
}
@courseproject{smartassistantdrive-ise2223,
    abstract = {From July 2024, all newly produced cars must have a camera to read speed signs (Intelligent Speed Assist), but this technology has yet to be ready as we expect it to be. As shown in this Quattroruote test , only some signs can be read correctly. This is because street signs are a human concept for human comprehension; in our opinion, cars should use a digitalized version of them. This also expands to other road-related concepts, such as traffic lights. The idea is to simulate a road and apply MAS to cars and traffic lights, rep},
    apice = {SmartAssistantDrive},
    author = {Brighi, Andrea and Di Lillo, Daniele},
    howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023},
    month = jan,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Smart Assistant Drive},
    type = {Standard Project},
    url = {https://github.com/orgs/Smart-Assistant-Drive/},
    year = 2026
}
@courseproject{mentalpoker-ds2425,
    abstract = {This project implements a decentralized poker game (Texas Hold’em) without requiring a trusted third party. The implementation guarantees fairness even when k−1 out of k players form a malicious coalition attempting to rig the game. The system consists of three main components: a cryptographic deck library implementing the Wei & Wang mental poker protocol[15], a poker game engine managing game logic and state, and a blockchain-based distributed ledger ensuring non-repudiation of player actions. The architecture follows a peer-to-peer design with broadcast-based communication primitives, enabling fully distributed gameplay over local area networks. The delivered artifacts include a Go library with all the core functionalities and a command-line interface that exposes this library as a usable application, allowing end-to-end experimentation and gameplay while deliberately minimizing effort on user interface concerns so that the project work could focus more on the distributed and cryptographic aspects.},
    apice = {MentalPoker},
    author = {Marco Galeri and Luca Patrignani},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jan,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Mental Poker: A Decentralized Implementation},
    type = {Game Project},
    url = {https://github.com/luca-patrignani/mental-poker},
    year = 2026
}
@courseproject{onlinerlslr2026-ise2425,
    abstract = {Online reinforcement learning (RL) enables autonomous agents to adapt their policies in real time, responding to dynamic and uncertain environments. This systematic literature review (SLR) examines high-impact studies from 2004 to 2026 on online RL methods for decision-making and explicit policy learning in autonomous agents, excluding approaches that do not adapt during execution. We analyze algorithmic strategies for handling non-stationarity, exploration-exploitation trade-offs, and multi-agent interactions. The review highlights emerging trends, practical implementations, and remaining challenges, offering actionable insights for designing adaptive and efficient online RL controllers in robotics, UAVs, and intelligent systems.},
    apice = {OnlineRLSlr2026},
    author = {Vargas Grateron, Pablo Sebastian},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = jan,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Online Reinforcement Learning for Decision-Making and Explicit Policy Learning in Autonomous Agents: A Systematic Literature Review},
    type = {Survey Project},
    url = {https://github.com/Zettaiki/ISE-SLR-online-rl-for-decision-making-and-policy-learning},
    year = 2026
}
@courseproject{agarioclone-ds2425,
    abstract = {Agar.io is an online, massively multiplayer action game. Players take on the role of a small, circular cell inside a map that resembles a Petri dish. The primary goal is to grow as large as possible by consuming smaller cells, both those controlled by other players and those that are scattered randomly throughout the game world as food. This simple premise leads to a dynamic and competitive environment where a player’s size directly dictates their power and vulnerability. Players can join a randomly assigned game session, create a new session, or join an existing one using a unique session ID. The session ends only when the player is eaten or decides to quit. The goal of this project is to design and develop a clone of Agar.io with a robust client--server architecture, ensuring scalability, performance, and smooth multiplayer interaction.},
    apice = {AgarIOClone},
    author = {Perlika, Elvis and Eleonora Falconi},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = dec,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Agar.io Clone},
    type = {Standard Project},
    url = {https://github.com/elvisperlika/Raga.io},
    year = 2025
}
@courseproject{domoticasw-ds2324,
    abstract = {The goal of the project is to create a smart home system and its own protocol, allowing devices to be added or removed dynamically (without having to stop the system).},
    apice = {DomoticASW},
    author = {Corrado Stortini and Francesco Carlucci and Raggini, Marco},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = dec,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {DomoticASW},
    type = {Standard Project},
    url = {https://github.com/DomoticASW},
    year = 2025
}
@courseproject{legalqandabasedonrag-ds2425,
    abstract = {AI RAG InPratica is an intelligent search platform designed to transform how legal professionals interact with complex road circulation regulations. By moving beyond traditional keyword matching, the system utilizes Retrieval-Augmented Generation to allow users to ask natural language questions and receive comprehensive, synthesized answers grounded in specific legal texts. The solution functions as a non-invasive integration layer, seamlessly synchronizing with legacy document repositories to ensure up-to-date accuracy without disrupting existing infrastructure. It supports two primary operational workflows: a dedicated web interface for editorial staff to refine AI-generated drafts, and an automated background service that integrates directly with the corporate ticketing platform. This dual approach significantly reduces research time and standardizes response quality, enabling legal authors to focus on high-value verification rather than manual information retrieval.},
    apice = {LegalQandABasedOnRag},
    author = {Lorenzo Leoni},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = nov,
    sort = {application},
    supervisor = {Magnini, Matteo},
    title = {AI RAG InPratica},
    type = {Application Project},
    url = {https://github.com/egaf-lorenzol/AI-RagInPratica},
    year = 2025
}
@courseproject{blockchaintelemetryintegration-ds2425,
    abstract = {The Blockchain-Enabled Digital Twin creation for Vehicles with secure vehicle identification number (VIN) authentication and IoT Telemetry Integration is a backend and dashboard system integrated with a Hyperledger Fabric blockchain. It allows secure registration, verification, and management of digital identities for vehicles with telemetry data collection from IoT devices. The system ensures Byzantine Fault Tolerance, Raft Consensus Protocol, Failure Detection and Recovery, Distributed Data Replication and Network Partition Tolerance. The project demonstrates the core principles of distributed systems through the integration of IoT sensor data with distributed blockchain storage, emphasizing data integrity, consensus protocols, and fault-tolerant replication.},
    apice = {BlockchainTelemetryIntegration},
    author = {Katrenov, Dias and Selirio, Mary Anne},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = nov,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Blockchain-Enabled Digital Twin Creation for Vehicles with Secure VIN Authentication and IoT Telemetry Integration},
    type = {Standard Project},
    url = {https://github.com/Dias266/Blockchain-Enabled-Digital-Twin-Creation-for-Vehicles-with-Secure-VIN-Authentication/},
    year = 2025
}
@courseproject{syntheticbiometricdatagenerationslr-ise2425,
    abstract = {This literature survey focuses on intelligent systems techniques used to generate Synthetic Biometric Data, in particular Fingerprints. The concern is to identify success in the implementation of design choices, algorithms, and principles used, the benefits of the application, and the challenges encountered. The study aims to derive insights into current trends and potential advancements in Synthetic Fingerprint generation (SFG).},
    apice = {SyntheticBiometricDataGenerationSlr},
    author = {Artegiani, Emanuele},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = nov,
    sort = {survey},
    supervisor = {Ciatto, Giovanni},
    title = {Literature Survey on Synthetic Biometric Data Generation Using Intelligent Systems},
    type = {Survey Project},
    url = {https://github.com/EmanueleArte/ISE-SLR-synthetic-fingerprint-generation},
    year = 2025
}
@courseproject{biasfairnessgenerative-ise2425,
    abstract = {Generative Artificial Intelligence (GAI) has emerged as a transformative technology, demonstrating a remarkable capacity to autonomously produce human-like content across diverse domains such as text, images, code, and media. GAI offers substantial benefits and influences critical decisions, particularly in fields such as education, healthcare, and the creative industries. However, it also introduces complex ethical challenges that necessitate careful consideration. A prominent concern within GAI is the pervasive issue of bias and fairness. Generative models, trained on vast datasets, can inadvertently learn and amplify societal stereotypes, prejudices, and historical inequalities, leading to discriminatory or unfair outcomes across various applications. While bias and fairness are central, GAI’s generative capabilities also amplify other significant ethical dilemmas, introducing new risks not typically posed by traditional AI systems. These include misinformation and deepfakes, data privacy violations, intellectual property issues, and challenges related to accountability and explainability. Understanding these interconnected challenges is crucial for a holistic approach to responsible GAI development. This systematic literature review focuses specifically on bias and fairness in GAI systems, recognizing them as key concerns within the broader ethical context. It explores the complex ethical issues surrounding generative models, highlighting key challenges as well as new technical solutions and mitigation strategies. By providing a holistic overview, this review seeks to contribute to the discourse on responsible AI development, fostering a deeper understanding of how to build equitable and trustworthy generative AI systems for the future.},
    apice = {BiasFairnessGenerative},
    author = {Montanari, Nicola},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = nov,
    sort = {survey},
    supervisor = {Ciatto, Giovanni},
    title = {Bias and Fairness in Generative Models: Ethical Challenges and Engineering Solutions},
    type = {Survey Project},
    url = {https://github.com/NIK4658/ISE-Bias-and-Fairness-in-Generative-Models},
    year = 2025
}
@courseproject{codemaster-ds2324,
    abstract = {CodeMaster is a distributed system to support collaborative coding challenges, inspired by coding platforms such as LeetCode. With CodeMaster every user can create, manage and resolve different coding problems, using different languages. In fact, its primary goal is to provide an extensible and scalable environment to practice problem solving, evaluate algorithmic solutions, and integrate advanced architectural concepts. CodeMaster is designed not only as a learning tool, but also as a practical environment to strengthen and refine individual coding skills through continuous practice and feedback. For this reason, the platform is intended not only for experienced programmers, but also for beginners who are approaching the world of computer science for the first time. The system provides services for solution submission, problem management, evaluation, and user interaction. Each service communicates through lightweight APIs and asynchronous messaging, enabling fault isolation, high availability, and independent scalability. This design choice supports distributed deployment and eases the integration of new features without disrupting the overall system. From an educational perspective, CodeMaster is not only a coding practice tool but also a case study in modern distributed systems. This demonstrates how principles such as service decoupling, resilience, observability, and scalability can be applied in practice. Furthermore, the project highlights challenges in consistency management, interservice communication, and error handling in distributed environments. By combining practical coding features with advanced architectural design, CodeMaster provides both end users and developers with a robust environment.},
    apice = {CodeMaster},
    author = {Testa, Alex and Rambaldi, Riccardo},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = nov,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {CodeMaster},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-testa-rambaldi-ay2324},
    year = 2025
}
@courseproject{generativeagentarchesposito2025-ise2223,
    abstract = {The advent of large language models (LLMs) has triggered the emergence of a new class of intelligent systems: generative agents. While promising unprecedented autonomy and flexibility, these agents introduce a fundamental engineering challenge: how to design, control, and make reliable systems whose decision-making core is an inherently stochastic and opaque component. This project proposes a critical and engineering analysis of emerging generative agent architectures, using the established principles of Agent-Oriented Software Engineering (AOSE) as an analytical lens. By examining four representative frameworks - AutoGen, CAMEL, Eclipse LMOS Arc and AgentLite - we aim to demonstrate how each adopts a different engineering strategy to impose structure and predictability on LLM behaviour. The analysis aims to reveal a functional convergence towards AOSE concepts, such as the reinvention of coordination artefacts similar to those of the CArtAgO model. However, it also aims to highlight a significant paradigmatic divergence' from formal organisational models such as Moise, analysing how social structures in generative systems are realised through alternative, often implicit and emergent approaches. It is concluded that a critical understanding of current architectures, informed by AOSE, is a prerequisite for the future synthesis of hybrid architectures that combine the structured deliberation of classical paradigms with the flexibility of LLMs.},
    apice = {GenerativeagentarchEsposito2025},
    author = {Esposito, Bruno},
    howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023},
    month = nov,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Generative Agent Engineering: A Critical Analysis of Emerging Architectures through the Lens of Agent-Oriented Software Engineering (AOSE)},
    type = {Survey Project},
    url = {https://github.com/BrunoEsposito2/ise-project},
    year = 2025
}
@courseproject{proxyldap-ds2324,
    abstract = {This project presents the design and implementation of a Lightweight Directory Access Protocol (LDAP) proxying service deployed within a containerized environment. The service accepts incoming LDAP requests and forwards them to one or more target servers, aggregating all the responses of the single servers into one. Its primary use case is the consolidation of multiple Active Directory domains, allowing authentication queries to be executed from a single entry point while transparently returning results as if all users resided within the same domain. While remaining online, the service can be configured through a control panel web app accessible to the administrators, which will be able to add and remove servers and clients.},
    apice = {ProxyLDAP},
    author = {Ravaioli, Michele and Tampieri, Eugenio},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = oct,
    sort = {advanced},
    supervisor = {Magnini, Matteo},
    title = {LDAP subtree merging proxy deamon},
    type = {Advanced Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-ravaioli-tampieri-ay2324},
    year = 2025
}
@courseproject{phaint-ds2425,
    abstract = {This project proposes the development of a distributed drawing and mock-up tool that combines the simplicity of Paint with the collaborative features of Figma. The platform will enable users to create mock-ups through freehand drawing while supporting real-time, multi-user collaboration. By introducing a distributed architecture, mock-ups will be seamlessly shared across users with configurable access rights, ensuring concurrent editing and version consistency. Phaint aims to empower teams with an intuitive yet powerful environment for ideation, sketching, and prototyping, leveraging both the accessibility of simple drawing tools and the “superpowers” of collaborative design systems.},
    apice = {Phaint},
    author = {Ghignatti, Nicolo and Farinelli, Ettore},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = oct,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Phaint},
    type = {Standard Project},
    url = {https://github.com/drptms/phaint_be},
    year = 2025
}
@courseproject{autonomousbikessharing-ds2324,
    abstract = {This is a bike sharing system which allows users to ride with rented bikes. The user requests a bike by signaling his position in a street graph and waits for the bike to come. The bikes (a-bikes) are autonomous as they: can autonomously reach a user, which asked for a bike. can autonomously reach the charging station, after being used; stop at red traffic lights The user can then ride anywhere he wants and then end the ride leaving he bike where he wants.},
    apice = {AutonomousBikesSharing},
    author = {Venturini, Alessandro},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = oct,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Autonomous Bikes Sharing},
    type = {Standard Project},
    url = {https://github.com/Ventus218/SAP-assignment-03},
    year = 2025
}
@courseproject{federatedlearningapplicationshealthcareslr-ise2324,
    abstract = {Over the last decade, Federated learning has gained rapid attention in its application to data privacy and security in the healthcare sector. Traditional machine learning models often rely on centralized data aggregation, which poses significant risks related to patient privacy and data security. Federated learning offers a different approach that enables the training of machine learning models across multiple institutions without the need to share sensitive patient data. This approach not only preserves privacy but also enhances the scalability, adaptability, and overall utility of machine learning in healthcare applications and scenarios. However, practical clinical deployments reveal major gaps between theory and practice. Healthcare data are highly heterogeneous, institutional resources and network quality vary widely, and threat models are stronger than typical FL assumptions. Further, privacy guarantees often require complementary mechanisms such as differential privacy, secure aggregation or cryptography, that trade off accuracy, latency, or computational cost. This survey aims to provide a review of FL in healthcare, analyzing representative case studies that demonstrate the practical viability of Federated Learning in healthcare settings. For each, we extract empirical lessons about convergence, accuracy of communication trade-offs, privacy measures, and deployment feasibility. The study takes a deliberately skeptical stance, exposing common assumptions, discussing failure modes, and highlighting practical mitigations. The scope is to provide an insight of the implementation of FL in healthcare, encompassing both foundational review articles and specific case studies that demonstrate practical implementations. To guide this comprehensive review, the following research questions will be addressed: What are the different implementations of Federated Learning in healthcare? What challenges are associated with implementing Federated Learning in healthcare? What are the potential future developments and research opportunities in Federated Learning?},
    apice = {FederatedLearningApplicationsHealthcareSlr},
    author = {Pieri, Valentina},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = oct,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Federated Learning Applications in Healthcare},
    type = {Survey Project},
    year = 2025
}
@courseproject{p2pfederatedlearningsac-ds2324,
    abstract = {This project is an implementation of the algorithm proposed in [1]. The goal is to simulate peer-to-peer Federated Learning implementing an n-out-of-n secret sharing schema and Secure Average Computation algorithm to let the peers collaborate in the training of a Neural Network, without the risk of direct or indirect training data theft, allowing the presence of semi-honest peers. The project will showcase some emblematic cases probing strengths and weaknesses of the approach.},
    apice = {P2PFederatedLearningSAC},
    author = {Randacio, Leonardo},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = sep,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {Secure P2P Federated Learning},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-randacio-ay2324},
    year = 2025
}
@courseproject{trafficcognitivestigmergy2025pioggia-ise2425,
    abstract = {Cognitive stigmergy is a paradigm for indirect coordination between agents, it allows to produce indirect feedback, modifying a shared space. It differs from traditional stigmergy, like ant swarms (in which feedback is defined by pheromone release), since in cognitive stigmergy the environment is enriched with structured information including intentionality, it's a shared memory. This project builds upon the research conducted by Ricci, Omicini and Viroli, aiming to explore the potential of cognitive stigmergy within the design of a multi-agent system (MAS) for the coordination of autonomous vehicles. The system defines an environment, populated by agents (autonomous vehicles) that have to cohexist in traffic, avoiding collisions, complying with traffic rules and coordinating in a decentralized manner. The work adopts an experimental perspective, providing an architecture that enables the automatic generation of dynamic maps and the simulation of diverse scenarios. Although primarily a proof of concept, the system highlights the potential of cognitive stigmergy as a viable approach for decentralized traffic management, while leaving room for further theoretical insights and future experimental validation in a relatively underexplored research area.},
    apice = {TrafficCognitiveStigmergy2025Pioggia},
    author = {Pioggia, Alessandro},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = sep,
    sort = {simulation},
    supervisor = {Omicini, Andrea},
    title = {Decentralized configuration among autonomous vehicles via cognitive stigmergy: Design of a multi-agent system},
    type = {Simulation Project},
    url = {https://github.com/AlePioggia/Decentralized-configuration-among-autonomous-vehicles-via-cognitive-stigmergy-MAS},
    year = 2025
}
@courseproject{restaurantsim-ise2425,
    abstract = {RestaurantSim has the goal of improving the knowledge about multi-agent programming and multi-agent systems, in particular, the usage of Jason, an interpreter for an extended version of AgentSpeak. This project aims to simulate a restaurant, implementing the behaviours of customers, waiters, and chefs.},
    apice = {RestaurantSim},
    author = {Raggini, Marco},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = sep,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Restaurant Simulator},
    type = {Standard Project},
    url = {https://github.com/MarkRagg/RestaurantSim},
    year = 2025
}
@courseproject{dddaose2025borriello-ise2425,
    abstract = {The increasing complexity of modern software systems, particularly those incorporating autonomous components, presents significant challenges for traditional software engineering methodologies. Domain-Driven Design (DDD) excels at managing structural domain complexity through strategic and tactical patterns, while Agent-Oriented Software Engineering (AOSE) provides powerful abstractions for modeling autonomy, reactivity, and social interaction. However, DDD struggles with the dynamic complexity of autonomous systems, and AOSE faces limited mainstream adoption despite its conceptual richness. This survey examines the largely unexplored integration of these complementary methodologies. Through analysis of the limited existing literature—primarily one comprehensive framework—and related approaches including actor-based architectures and Multi-Agent MicroServices, we identify how DDD’s domain modeling strengths can be enhanced by AOSE’s behavioral abstractions at multiple architectural levels. We reveal critical methodological gaps, analyze the current integration approaches, and propose future research directions for advancing DDD-AOSE synergy in intelligent systems engineering. Our findings suggest that selective, gradual integration strategies offer the most promising path forward for combining domain expertise with autonomous behavioral capabilities.},
    apice = {DddAose2025Borriello},
    author = {Borriello, Luigi},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = sep,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Integration of Domain-Driven Design and Agent-Oriented Software Engineering: Challenges, Opportunities and Future Directions},
    type = {Survey Project},
    year = 2025
}
@courseproject{mixtureofdoctors-ds2425,
    abstract = {Supporting patients in the self-management of chronic diseases requires continuous, personalized guidance, a task for which LLM-powered chatbots show immense promise. However, their deployment is contingent on overcoming a dual challenge: the inherent risk of LLM “hallucinations”, which undermines trust, and the architectural complexity of building a system that can manage multiple medical domains securely and reliably. This report introduces “Mixture of Doctors”, an agentic-RAG system designed to address these challenges in tandem. The former is mitigated through a RetrievalAugmented Generation (RAG) flow, where specialized “Doctor” components, each an expert on a specific chronic disease, ground their responses in curated knowledge bases to ensure factual accuracy. The latter is addressed by a robust, decoupled Orchestrator-worker architecture that leverages asynchronous messaging for resilience and open-source technologies for data privacy. The system’s core is an agentic Orchestrator that dynamically analyzes user queries, decomposes complex, cross-domain questions, and routes them to the appropriate specialists. The resulting framework demonstrates a viable path toward creating trustworthy and scalable conversational AI for personalized chronic care.},
    apice = {MixtureOfDoctors},
    author = {Castellucci, Lucia and Mitugno, Roberto and Samorè, Luca},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = sep,
    sort = {advanced},
    supervisor = {Magnini, Matteo},
    title = {“Mixture of Doctors”: an agentic-RAG system for self-management of chronic diseases},
    type = {Advanced Project},
    url = {https://github.com/LucaSamore/Mixture-of-Doctors},
    year = 2025
}
@courseproject{miro2425-ethicsofai20242025,
    abstract = {This article examines the ethical and legal implications of profiling bias that disproportionately affects neurodivergent individuals when interacting with advanced generative AI systems. It argues that such bias does not merely arise from data representation or processing, but from profiling mechanisms structurally embedded within model architectures. A transversal analysis demonstrates that the same systemic biases are present across the three major model families identified to date: Large Language Models (LLMs), Large Multimodal Models (LMMs), and Large Retrieval Models (LRMs). The study focuses specifically on interactions with neurodivergent users—including individuals with ADHD, dyslexia, or autism spectrum conditions—through tools such as ChatGPT. While these technologies are often promoted as accessibility-enhancing, they remain trained predominantly on neurotypical communication patterns. This structural configuration creates barriers leading to cognitive exclusion, semantic misinterpretation, and sensory overstimulation (Çarık et al., 2021), generating subjective experiences of anxiety and tension, particularly for users who process information in non-linear ways. The analysis draws on recent research addressing uncertainty in multimodal interaction and the limitations of generative AI in non-normative contexts (Tang et al., 2023), and situates these findings within the European regulatory framework. Relevant provisions of the AI Act (Regulation 2024/1689, Arts. 5 and 27), the GDPR (Regulation 2016/679, Arts. 9 and 22), and the Charter of Fundamental Rights of the EU (Arts. 7, 8, 21) are examined as legal safeguards against structural exclusion. The article concludes by proposing a normative and design-oriented framework for inclusive AI, calling for an explicit reform of profiling logic as a prerequisite for trustworthy and human-centred systems that safeguard neurodiverse populations.},
    apice = {Miro2425},
    author = {Elisabet Bolarín-Miró},
    howpublished = {Ethics of AI, A.Y. 2024/2025},
    keywords = {Neurodiversity; Profiling Bias; Cognitive Accessibility; Large Language Models (LLMs); Large Multimodal Models (LMMs); Large Retrieval Models (LRMs); Algorithmic Discrimination; AI Act; GDPR; ECHR; European Accessibility Act; Human-Centred AI.},
    month = sep,
    sort = {research},
    supervisor = {Calegari, Roberta},
    title = {Profiling Bias in LLMs, LMMs, and LRMs. An Ethical and Legal Framework for the Inclusion of Neurodivergent Users. A Case Study of ChatGPT.},
    type = {Research Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/bolarin-miro2425},
    year = 2025
}
@courseproject{webenvironmentinjakta-sd2223,
    abstract = {The project aims to extend the capabilities of the JaKtA framework by introducing the capacity for the agent to have a Web-interactive environment. The primary goal is to provide agents with the ability to make HTTP calls to online resources, interpret responses in various formats, in our case (HTML, YAML, RDF), and specifically query the received data using specific query languages. The core of the project is the design and development of a library of concrete actions that each agent can register and execute. These actions include, for example, the ability to make a GET, POST, PUT, or DELETE request to a specific URL, execute CSS queries on an HTML page, extract structured values from a YAML document using JSONPath, or query an RDF graph with SPARQL. Each action is encapsulated in a modular structure that conforms to the framework’s abstractions, with inputs and outputs. The envisaged use cases involve scenarios in which an autonomous agent needs to extract information from web pages, APIs, or semantic datasets. For example, consider an agent querying a public RDF endpoint to learn about an author’s work, or an agent reading a YAML configuration from a remote resource to adapt its behavior. The project offers a significant contribution both in terms of semantic interoperability and in terms of cognitive agents capable of actively interacting with the Web. This extension can find applications in domains such as Web Intelligence, Semantic Web, and Intelligent Automation based on dynamic data.},
    apice = {WebEnvironmentInJakta},
    author = {Pirazzoli, Federico},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = aug,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {Web Environment in JaKta},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-pirazzoli-ay2223#},
    year = 2025
}
@courseproject{distributedcodenamesgame-ds2425,
    abstract = {The Codenames’s resulting framework offers a reliable foundation for a trustworthy online version of Codenames, demonstrating a practical approach to building engaging and fair digital board games. This report introduces a robust client-server architecture designed to meet these needs. By centralizing the game’s authoritative logic on a single server, the system effectively prevents cheating and eliminates inconsistencies. The design leverages a ”thin client” approach, where each player’s application is responsible only for rendering the user interface and communicating actions to the server. This decoupled structure, combined with a reliable communication protocol, ensures a stable and scalable platform. Some tools like Overleaf, and Grammarly helped me to provide this report.},
    apice = {DistributedCodenamesGame},
    author = {Khayatian, Danial},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = aug,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Distributed Codenames Game},
    type = {Game Project},
    url = {https://github.com/danialkh/DistributedCodenamesGame},
    year = 2025
}
@courseproject{thesocialnetwork-sd2223,
    abstract = {I social network sono applicazioni che permettono agli utenti di interconnettersi su larga scala, condividendo pensieri ed emozioni con il resto della comunity. Con il tempo questa tipologia di applicazioni si \`{e} diffusa, affermandosi come strumento di comunicazione e divulgazione a livello globale. Il mercato moderno comprende diversi social network pronti all’uso, distinti l’uno dall’altro principalmente per i contenuti che la piattaforma permette di pubblicare e condividere. Altri fattori discriminanti sono il metodo di condivisione dei contenuti stessi, i quali possono essere pubblici, ristretti ad un gruppo di amici selezionati dall’utenza o spesso proposti da sofisticati algoritmi. The Social Network vuole ricreare un facsimile di questi sistemi, proponendo una soluzione tecnica concentrata sul garantire i quality attribute ritenuti fondamentali; a questo scopo ci si \`{e} concentrati sul deploy del sistema finale, che costituisce il contributo di maggior spessore per questo progetto.},
    apice = {TheSocialNetwork},
    author = {Romagnoli, Giacomo},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jul,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {The Social Network},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-romagnoli-ay2223},
    year = 2025
}
@courseproject{dubitoonline-ds2425,
    abstract = {This project's objective is to recreate a version of the famous card game called "Dubito", following the rules and ideas of the videogame "Liar's Bar" and "Master Bluff". The game rules are the following: At the start of each round each player receives 5 cards and a specific type of card is declared (Kings, Queens, Aces); Players during their turn can do one of the following actions:  Discard up to 3 cards from their hand facedown, those being of the same type that was declared at the start of the round or not.  Call the previous player "liar", if the player is not the first one playing in the round. When a player calls for a lie, the cards that were discarded are shown and 2 possible scenarios may occur:  If that player did lie, the lying player loses 1 life.  If that player did not lie, the one who called for the bluff loses 1 life. Each player starts with 2 lives, and the last remaining living player is declared the winner.},
    apice = {DubitoOnline},
    author = {Bianchi, Andrea and Arduini, Alberto},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Dubito Online},
    type = {Game Project},
    url = {https://github.com/Alb-Ard/dist-sys-dubito-online},
    year = 2025
}
@courseproject{capturetheflag-ds2425,
    abstract = {This project presents a real-time multiplayer web-based game named Capture the Flag. The primary goal of the project is to design and implement a fully functioning online game platform where users can connect from different devices, join game rooms, control their avatars, and compete to capture the opponent's flag. The system achieves real-time interaction using WebSocket technology and emphasizes scalability, fault-tolerance, and usability. The game has been extended to support multiple concurrent matches, room-based lobby management, and backup server redundancy for increased availability.},
    apice = {CaptureTheFlag},
    author = {Kuang, Yi},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Capture The Flag (CTF) Multiplayer Game},
    type = {Game Project},
    url = {https://github.com/leahkuang/Capture-the-Flag.git},
    year = 2025
}
@courseproject{rubamazzo-ds2425,
    abstract = {Project Goal The project aims to develop a distributed version of the card game "Rubamazzo," implemented as a command-line application using a client-server architecture. The rules are available at the following link: https://it.wikipedia.org/wiki/Rubamazzetto. The goal is to apply concepts of distributed systems, ensuring efficient management of communication and data exchange between client and server, all while utilizing the Scala programming language. Project Description Gameplay:  The game will follow the traditional rules of "Rubamazzo."  The focus will be on the multiplayer experience, allowing multiple players to join the same game. Architecture:  Server: Responsible for game logic, managing game state, and handling player turns.  Client: A command-line interface to interact with the server, send moves, and view the game state. Communication:  The HTTP protocol will be used with REST APIs for all client-server interactions.  Endpoints will include functionalities to join a game, make a move, check the game state, and calculate the final score. Technologies Used:  Scala: The primary language to implement both the client and the server.  Akka HTTP: For creating REST endpoints on the server.  cURL or Scala scripts: To send requests to the server from the client. Turn Management:  The server will strictly enforce turn management and return errors for invalid actions.  Updates to the game state will be accessible through periodic HTTP requests.},
    apice = {Rubamazzo},
    author = {Kentpayeva, Madina},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Rubamazzo},
    type = {Game Project},
    url = {https://github.com/madina9229/rubamazzo-game},
    year = 2025
}
@courseproject{factorysimulation-ise2425,
    abstract = {This project consists of a simulation of a multi agent system where multiple robot BDI agents inside a factory pick up packages from a specific location and deliver those to another, while avoiding obstacles such as walls, other robots and humans in the environment. Each robot has a battery and consumes it at each action it performs to step towards its objective, upon reaching a threshold, beliefs about their inner status makes them adopt goals to reach the nearest charging station and plan new intentions accordingly. Meanwhile, robots acting in the environment may randomly malfunction with a given probability or reach a battery level of 0 and ask for help to other robots, that dinamically change their plan to postpone objectives they were intending to reach and prioritize reparation and battery recharge of the malfunctioning robots before continuing with their previous task.},
    apice = {FactorySimulation},
    author = {Fontana, Marco},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = jul,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {Factory Simulation},
    type = {Simulation Project},
    url = {https://github.com/MarcoFontana48/Factory-simulation},
    year = 2025
}
@courseproject{smartdroneplan-ise2324,
    abstract = {This project presents an intelligent drone delivery path planning and simulation system based on the STRIPS (Stanford Research Institute Problem Solver) algorithm implemented through Kotlin-Prolog hybrid programming. The system addresses the growing demand for autonomous logistics solutions by providing comprehensive planning capabilities for multi-drone delivery scenarios within complex network topologies. Key innovations include a Horn-shaped map network modeling realistic urban delivery environments, energy-aware planning algorithms that optimize battery consumption and recharging strategies, multi-package delivery coordination supporting simultaneous operations, and a sophisticated JavaFX graphical user interface enabling real-time visualization and interactive simulation control. The implementation successfully demonstrates autonomous path planning capabilities across diverse operational scenarios including simple drone movements, single and multi-package deliveries, emergency low-energy situations, and complex multi-drone coordination tasks. The system achieves full automation of the planning process through STRIPS-based reasoning while providing comprehensive tools for scenario configuration, plan visualization, execution monitoring, and performance analysis. Validation through extensive testing confirms the system’s ability to handle complex delivery networks involving multiple drones, packages, and operational constraints including energy limitations, payload capacities, and network connectivity restrictions. The project delivers significant value for both academic research in AI planning algorithms and practical applications in logistics automation. The modular architecture supports extensibility for advanced algorithms while the intuitive interface facilitates educational demonstrations and research experimentation. Results demonstrate successful integration of classical AI planning theory with modern software engineering practices, creating a robust foundation for autonomous delivery system development.},
    apice = {SmartDronePlan},
    author = {Qu, Tianyu and Li, Yiming and Yang, Jing},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = jul,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {STRIPS-based Multi-Drone Delivery in a Horn-Shaped Map},
    type = {Standard Project},
    url = {https://github.com/Mob1us-YJ/UNIBO-ISE-project},
    year = 2025
}
@courseproject{evasim-ise2324,
    abstract = {The goal of the project is to simulate an environment using a BDI Agent framework in which agents simulate two types of creatures, doves and hawks, that compete for survival based on their behaviors, observing how the evolution of the species unfolds.},
    apice = {EvASim},
    author = {Antonioni, Giovanni and Tassinari, Luca},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = jul,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni and Baiardi, Martina},
    title = {Evolutionary Agent-based Aggression Simulation -- EvASim},
    type = {Simulation Project},
    url = {https://github.com/giovaz94/evasim},
    year = 2025
}
@courseproject{liarspoker-ds2425,
    abstract = {This report presents the design and development of a distributed game application for playing Liar’s Poker. It outlines all phases of the project, from the initial concept through to the final implementation, highlighting the evolution of the system as it was shaped to meet the specific demands of a distributed environment. The game logic adheres to the rules described in [1], with adaptations made to support distributed execution. The system architecture follows a client-server model and relies on the MQTT protocol to facilitate communication between components. The report provides an in-depth discussion of the design decisions taken throughout the project, along with detailed insights into the implementation process. Testing strategies are also described, focusing on both functionality and system robustness. Particular attention is given to fault tolerance, demonstrating how the application manages client disconnections and server failures. The application is developed in Python, leveraging the Paho MQTT library to implement reliable and efficient messaging and the NiceGUI library to create a user-friendly web interface.},
    apice = {LiarsPoker},
    author = {Buda, Francesco and Sanchi, Emanuele and Severi, Tommaso},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Liar's Poker},
    type = {Game Project},
    url = {https://github.com/FrancescoBuda3/LiarsPoker},
    year = 2025
}
@courseproject{sharedpomodoro-sd2223,
    abstract = {SharedPomodoro \`{e} un’applicazione web progettata per digitalizzare la tecnica del Pomodoro e renderla un’esperienza condivisa e collaborativa. Gli utenti possono creare una stanza di lavoro o unirsi a una stanza esistente per collaborare in tempo reale con altri partecipanti. All’interno della stanza, \`{e} possibile assegnare task a se stessi o agli altri, favorendo un ambiente di lavoro supportivo e motivante. La tecnica del Pomodoro si basa sull’alternanza tra periodi di lavoro, detti Pomodori, e pause regolari. SharedPomodoro applica questo metodo per aiutare gli utenti a migliorare la concentrazione e la produttivit\`{a}, con l’aggiunta di un elemento fondamentale: il timer \`{e} condiviso tra tutti i partecipanti della stanza, rendendo il lavoro sincronizzato. Il ciclo di lavoro si compone di tre fasi: Pomodoro: sessione di lavoro, della durata definita a livello di stanza, durante la quale ogni partecipante si dedica ai propri task senza interruzioni. Pausa corta: breve intervallo dopo ogni Pomodoro, utile per recuperare energie. Pausa lunga: dopo quattro Pomodori consecutivi, viene attivata una pausa pi\`{u} lunga, pensata per un recupero pi\`{u} completo. La durata delle fasi pu\`{o} essere personalizzata dal creatore della stanza o da chi \`{e} all’interno, ma una volta impostati, i tempi sono gli stessi per tutti i membri della stanza. Inoltre, gli utenti possono visualizzare i propri task completati, tenendo traccia dei progressi e dei risultati raggiunti. SharedPomodoro si propone come uno strumento semplice ma potente per aumentare la produttivit\`{a} e mantenere alta la concentrazione, sfruttando il sostegno del lavoro di gruppo.},
    apice = {SharedPomodoro},
    author = {Gallala, Ramzi},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jul,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {SharedPomodoro},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-gallala-ay2223},
    year = 2025
}
@courseproject{futureassistant2025-ise2425,
    abstract = {The project deals with a simulation of a Chat GPT named Future Assistant. The agent in the simulation is a text prompt who will be able to answer the questions asked by customer. Future Assistant is an agent designed as a personal assistant that will make everyday tasks and obtaining information easier for future users. Currently, four functionalities have been implemented, and English language is supported, but the possibilities of this agent are unlimited and in the future it is planned to develop new functionalities according to the needs of target users. Technically, this agent is a generic LLM that is the basis of low-code platforms where the reusability of such applications is very high.},
    apice = {FutureAssistant2025},
    author = {Kardovic, Faruk},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = jul,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Simulation of CHAT GPT -- Future Assistant},
    type = {Standard Project},
    url = {https://github.com/FarukKardovic-ai/FutureAssistant},
    year = 2025
}
@courseproject{onauction-sd2223,
    abstract = {AuctiOn is a real-time, multiplayer online platform designed for strategic auction-based gameplay. Participants engage in competitive sessions initiated within game lobbies. Each player begins with an initial allocation of virtual items and currency. The game proceeds through timed rounds where one designated player acts as the seller, offering items for auction. Concurrently, other players submit bids within the specified time limit. The highest bidder acquires the auctioned items, transferring the bid amount to the seller. The system accommodates players rejoining sessions after disconnection. The primary goal is to maximize accumulated currency by the game’s conclusion. Success requires effective management of resources and strategic bidding.},
    apice = {OnAuction},
    author = {Frattarola, Marco},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {AuctiOn},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-frattarola-ay2223},
    year = 2025
}
@courseproject{tetrisbattleroyale-ds2425,
    abstract = {This project is a multiplayer version of the classic game Tetris, where all players in a room play a standard game of Tetris. When a player completes a ”Tetris” (defined as clearing four rows with a single piece), they send a broken row to all other players. One by one, all but one player will be defeated, and a winner will emerge.},
    apice = {TetrisBattleroyale},
    author = {Moretti, Riccardo and Rigoni, Lorenzo},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jul,
    sort = {game},
    supervisor = {Omicini, Andrea},
    title = {Tetris Battleroyale},
    type = {Game Project},
    url = {https://github.com/LorenzoRigoni/DS25-Tetris_Battleroyale},
    year = 2025
}
@courseproject{railsync-ds2425,
    abstract = {This report details the design and implementation of RailSync, a full-stack web application for train ticket booking. The project is built on the MEVN (MongoDB, Express.js, Vue.js, Node.js) stack and architected using a Dockerbased microservice approach to ensure scalability and resilience. The system comprises multiple containerized services, including two backend instances, a frontend, a Redis database, a MongoDB replica set, and an NGINX reverse proxy for load balancing and fault tolerance. Key features include secure user authentication and authorization using JSON Web Tokens (JWT) and Role-Based Access Control (RBAC). The application provides a user-friendly interface for searching real-time train solutions by integrating with the official Trenitalia API. A critical component is the seat reservation system, which leverages Redis to implement a distributed locking mechanism, preventing race conditions and ensuring data consistency during concurrent booking attempts. The project also features a comprehensive administrative backend for user and reservation management. The development process followed a Git flow model with semantic versioning. System reliability was validated through a suite of automated Jest tests covering core functionalities and manual acceptance tests to verify frontend behavior, fault tolerance by simulating service failures, and security token handling. The entire application is packaged and deployed using Docker Compose, simplifying setup and ensuring a reproducible environment.},
    apice = {RailSync},
    author = {Amadori, Nicolas and Mazzi, Riccardo},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jul,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {RailSync -- Distributed Train Booking},
    type = {Standard Project},
    url = {https://github.com/mRickk/RailSync},
    year = 2025
}
@courseproject{battleshipgame-ds2425,
    abstract = {This project implements a networked, turn-based Battleship game in Python 3.13 using UDP sockets. Two players connect to a central server, place their fleets on a 10×10 grid, and fire at each other’s ships. The server mediates all messages: connection, shot requests, hit/miss verification, turn control, and game termination. The architecture demonstrates low-latency UDP communication, error handling for invalid messages, and modular code design for client and server components.},
    apice = {BattleshipGame},
    author = {Horri, Kalile and Bel Meddeb, Intisar},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jun,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Battleship Game},
    type = {Game Project},
    url = {https://github.com/Horri-kalile/Battleship-Game.git},
    year = 2025
}
@courseproject{fairlib2025-ise2324,
    abstract = {This report analyzes the issue of fairness in automated decision-making systems, highlighting its challenges, importance and some potential solutions. The study conducted delves into the various definitions of fairness, some types of bias, and sources of discrimination that can occur in artificial intelligence systems. It also examines state-of-the-art approaches to identifying and mitigating bias, including pre-processing, in-processing and post-processing techniques. In addition, the report proposes a modular library, FairLib, designed to aid in the analysis and mitigation of bias in artificial intelligence systems. The library aims to provide comprehensive tools for bias analysis and intervention. Ultimately, the approaches and methods presented in this work are envisioned to contribute to a future where AI systems operate in an increasingly fairer and transparent manner. This will gradually foster trust and reduce inequalities in various domains, including finance, healthcare, justice, and autonomous systems.},
    apice = {Fairlib2025},
    author = {Di Zio, Valerio},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = jun,
    sort = {research},
    supervisor = {Ciatto, Giovanni},
    title = {Fairness in Artificial Intelligence: Challenges and Solutions},
    type = {Research Project},
    url = {https://github.com/pikalab-unibo-students/master-thesis-dizio-ay2324},
    year = 2025
}
@courseproject{shiftingnarrativesbdi-ise2223,
    abstract = {The goal of this project is to develop a system for explaining, debugging, and validating the behavior of BDI (Belief-Desire-Intention) agents through the reimplementation of a multi-level explainability framework, using a set of declarative sifting patterns. The system aims to bridge the gap between technical implementation details and human-understandable explanations of agent behavior by providing a DSL that allows to extract higher-level narratives out of raw execution traces.},
    apice = {ShiftingNarrativesBDI},
    author = {Battistini, Riccardo},
    howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023},
    month = jun,
    sort = {game},
    supervisor = {Omicini, Andrea},
    title = {Understanding the behavior of BDI agents at different levels of abstraction through incremental sifting of narratives},
    type = {Game Project},
    url = {https://github.com/pikalab-unibo-students/master-thesis-battistini-ay2425/tree/feat/jakta-sifting-patterns},
    year = 2025
}
@courseproject{overviewonserverlesscomputing-ds2425,
    abstract = {Serverless computing has gained importance in both academia and industry due to its cost-efficiency, automated scalability, and virtually unlimited resource availability, offering a novel pay-as-you-go model compared to traditional cloud computing solutions. The serverless paradigm not only eases end-users of the burden of infrastructure management, but its cost model enables users to pay only for resources consumed, while the provider bears the cost of idle resources. However, the stateless nature of the services offered and communication needs of related executions are problems that need to be addressed, as they could pose performance issues and limit the applications of the paradigm. This survey provides an overview of the current advancements in serverless computing, examining its opportunities, challenges, and potential solutions.},
    apice = {OverviewOnServerlessComputing},
    author = {Monaldini, Nicolo},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jun,
    sort = {survey},
    supervisor = {Magnini, Matteo and Omicini, Andrea},
    title = {An Overview on Serverless Computing, its Opportunities and its Challenges},
    type = {Survey Project},
    url = {https://github.com/nicolo-mn/serverless},
    year = 2025
}
@courseproject{squidstorage2025-ds2425,
    abstract = {Squid Storage is a distributed storage designed to provide file management, replication, and synchronization across multiple nodes. The system employs a client-server architecture, where clients interact with a central server to perform operations such as file creation, updates, deletion, and locking. The server coordinates with data nodes to ensure redundancy and fault tolerance through replication mechanisms. It leverages a custom text-based communication protocol, to handle message parsing, file transfers, and request dispatching. The project offers a GUI to interact with the local filesystem.},
    apice = {SquidStorage2025},
    author = {Basigli, Gabriele and Salman, Muhamad Huseyn},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jun,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Squid Storage},
    type = {Standard Project},
    url = {https://github.com/MHS-20/Squid-Storage},
    year = 2025
}
@courseproject{simaquarium2025-ise2425,
    abstract = {DESCRIPTION The project aims to explore the features of competitive agents that consume energy, through a simulation of a domestic fish aquarium with the following characteristics: the agents in our simulation are represented by fish the environment in our simulation is represented by the aquarium itself, which contains obstacles to the movement of fish (stones) -> the environment will be represented by a 2D space, in which all the entities that contains (fish and stones) move and are arranged the food is generated in a random position on the surface of the water and falls vertically downwards -> the fish compete to reach it but the characteristics of the individual fish affect this task (large fish are slower and need more food to satiate themselves, vice versa small fish are faster and need less food to satiate themselves) the goal of the fish is to survive as long as possible and feed themselves while avoiding obstacles a fundamental characteristic that we intend to explore is the fact that the fish, in order to carry out their actions, consume energy and earn it by feeding, therefore it will be necessary to define some strategies so that the agent also takes into account its energy when deciding whether to pursue or abort a goal, i.e. whether or not to follow food -> the fish will therefore have to compete with each other to achieve their goals TECHNICAL ASPECTS The following technologies will be used for the development of the project: Java as the programming language of the overall system Jason to program the agents/fish Java Swing for the graphical interface PLANNED WORKFLOW The project will start with a preliminary phase of studying the literature papers regarding the competition between agents and agents having the notion of energy and energy consumption A system design phase is then planned, followed by implementation and testing During the continuation of this entire workflow we will also write the report GOALS Put into practice the theoretical notions that have been presented to us on the concepts of agent and environment Explore the scientific literature and the practical implications on the subject of competing agents and agents that consume and manage their energy Merge in a single project the use of Java and Jason},
    apice = {SimAquarium2025},
    author = {Bedei, Andrea and Bertuccioli, Giacomo Leo and Notaro, Fabio},
    howpublished = {Intelligent Systems Engineering, A.Y. 2024/2025},
    month = jun,
    sort = {simulation},
    supervisor = {Omicini, Andrea},
    title = {Sim-Aquarium},
    type = {Simulation Project},
    url = {https://github.com/AndreaBedei/SimAquarium},
    year = 2025
}
@courseproject{nosqlemulator-ds2425,
    abstract = {The project goal is to develop a lightweight, distributed NoSQL emulator that implements sharding and replication using a peer-to-peer (P2P) architecture. The system will follow the BASE (Basically Available, Soft state, Eventually consistent) approach, ensuring high availability and reasonable fault tolerance while prioritizing low latency for read and write operations. It’s a cli application, interaction will be based on scripts or command line commands.},
    apice = {NoSQLEmulator},
    author = {Pioggia, Alessandro},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = jun,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {NoSQL CLI Emulator},
    type = {Standard Project},
    url = {https://github.com/AlePioggia/NoSql-cli-emulator},
    year = 2025
}
@courseproject{highnoonblitz-ds2324,
    abstract = {The project aims to build a peer-to-peer Android game using the Bluetooth communication protocol. The objective is to implement a reaction-based game where the players have to react faster than each other to a specific random signal, miming a “high noon dual”. Any node of the network (a phone) will be able to create or participate in a match. The game will consist of several rounds that end when one of the players finishes lifes. In the case there are more than two, the game will end when only one of them is left.},
    apice = {HighNoonBlitz},
    author = {Becci, Alessandro and Tonelli, Luca},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    keywords = {Bluetooth},
    month = may,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {High Noon Blitz: Reaction Challenge},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-becci-massone-tonelli-ay2324},
    year = 2025
}
@courseproject{mindroll-ds2425,
    abstract = {MindRoll is a distributed, turn-based multiplayer dice game designed to explore and apply key concepts in distributed systems such as authentication, remote procedure calls (RPC), real-time synchronization, and client-server communication. The system is implemented in Python, with a graphical user interface (GUI) developed using Pygame and a custom RPC framework enabling communication between clients and the central game server. Players can register, log in, create or join rooms, and take part in rounds of strategic gameplay that involve calling and revealing dice values. The server manages the game state, verifies turns, synchronizes player actions, and broadcasts results to all connected users to ensure fairness and consistency. The system also supports fault tolerance through reconnection logic, and scalability is considered for future extensions. Core game logic is abstracted from the UI and communication layers to maintain modularity. This project provides a hands-on implementation of core distributed system principles in a real-time interactive environment. It serves as a foundational prototype for building more advanced online multiplayer systems and highlights the practical challenges of synchronization, state consistency, and user coordination in a distributed setting.},
    apice = {MindRoll},
    author = {Qu, Tianyu and Li, Yiming and Yang, Jing},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = may,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {MindRoll: A Multiplayer Dice Game},
    type = {Game Project},
    url = {https://github.com/Mob1us-YJ/UNIBO-DS-project/},
    year = 2025
}
@courseproject{surveydistributedtechniquesneuralnetworks-sd2223,
    abstract = {This paper presents a systematic literature review of distributed and parallel techniques for running deep neural networks on multiple machines and GPUs. It is composed of three parts: 1) a review of the available libraries that enable distributed training across GPU clusters, 2) a review of the most popular frameworks that facilitate parallelizing the training process on GPUs, and 3) a practical section that demonstrates a proof-of-concept implementation of the training process using common frameworks, namely PyTorch DDP and cuDNN. The review synthesizes research from the past decade, examining various approaches to distributed training, their effectiveness, and implementation challenges. The work is aimed at students and practitioners, with the goal to provide an introduction to the topic and help frame a general idea of the most common libraries in each domain. The distributed experiments use data parallelism to accelerate the training process, while the GPU experiments use cuDNN, cuBLAS and manual kernel implementations to train a small network. The effectiveness of each approach is demonstrated and to aid reproduction and experimentation Docker environments are provided. This allows to simulate a multi-GPU setup on a single Nvidia GPU, promoting ease of use by not relying on cloud services.},
    apice = {SurveyDistributedTechniquesNeuralNetworks},
    author = {Vasile, Razvan Florian},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = may,
    sort = {survey},
    supervisor = {Magnini, Matteo},
    title = {Survey on Distributed Techniques applied to Neural Networks},
    type = {Survey Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-vasile-ay2223},
    year = 2025
}
@courseproject{sudokoop-sd2223,
    abstract = {Sudokoop \`{e} una piattaforma per giocare a sudoku online in modalit\`{a} singola e multiplayer, con l’obiettivo di offrire un’esperienza collaborativa e competitiva in tempo reale. Gli utenti possono scegliere tra diverse modalit\`{a} di gioco e osservare le azioni degli altri giocatori durante la partita. Modalit\`{a} di gioco: Single Player: modalit\`{a} classica con 3 vite per risolvere un sudoku. Multiplayer Coop: modalit\`{a} cooperativa dove 2 o pi\`{u} giocatori risolvono insieme un sudoku condiviso con 3 vite totali. Multiplayer Battle: due squadre si sfidano completando lo stesso sudoku; vince chi risolve pi\`{u} celle. In tutte le modalit\`{a} multiplayer, ogni giocatore pu\`{o} vedere le celle selezionate dagli altri. Sudokoop utilizza un’architettura client-server basata sullo stack MEVN.},
    apice = {Sudokoop},
    author = {Mastrilli, Alice and Siroli, Alex},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = may,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Sudokoop: Sudoku Online},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-mastrilli-siroli-ay2223},
    year = 2025
}
@courseproject{distributedcsvsynchronizationsystem-ds2425,
    abstract = {list_sync is a Python-based system designed for Change Data Capture (CDC) from relational databases to Apache Kafka. It supports both MySQL and PostgreSQL as data sources, providing real-time streaming of database changes through a distributed system architecture while maintaining data consistency and fault tolerance.},
    apice = {DistributedCsvSynchronizationSystem},
    author = {Babini, Stefano},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = apr,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {list_sync: Distributed CSV Synchronization System},
    type = {Standard Project},
    url = {https://github.com/ste-script/list-sync},
    year = 2025
}
@courseproject{escaperoom-ds2425,
    abstract = {This project is a real-time, multiplayer escape room game designed to demonstrate the principles of distributed systems and real-time communication. Players join a lobby, coordinate via an integrated chat system, and collaboratively solve a series of mini-games and quizzes within a global time limit to “escape” the room. The front-end is built using React for dynamic user interface components and integrated with Phaser to manage the game’s 2D interactive canvas. The back-end is developed using Node.js with Express, and real-time communication is handled through socket.io. This architecture ensures that game states, such as puzzle completion and chat messages, are synchronized across all players in real time, providing a seamless cooperative gaming experience.},
    apice = {EscapeRoom},
    author = {Meco, Daniel},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = apr,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Escape Room},
    type = {Game Project},
    url = {https://github.com/danielmec/Escape-Room.git},
    year = 2025
}
@courseproject{p2psurvivordecisiongame-ds2425,
    abstract = {The Peer-to-Peer Decision-Making Game is a multiplayer survival game where two players stranded on a deserted island must collaborate to make decisions that affect the story. Players manage resources, face challenges, and communicate in real-time via a local network using P2P architecture, with handling for disconnections.},
    apice = {P2PSurvivorDecisionGame},
    author = {Sánchez Gómez, Pablo},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = apr,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Peer to Peer Survivor Decision Making Game},
    type = {Game Project},
    url = {https://github.com/pablosg-5/Peer-to-peer-Survivor-Decision-Game.git},
    year = 2025
}
@courseproject{agentbasedcardgame21-ise2324,
    abstract = {Smart 21 aims to develop an intelligent system composed of agents that are capable of playing 21. The objective is to create different agents with different levels of intelligence to exploit the famouse game, cheating like counting the cards is not forbideen here but encouraged. Table will be attended always by a single agent that plays against a dealer and has a precise amount of funds to raise or to loose. Deck will be the classical 52 cards in two colors so 104 cards and when all the cards are used another deck will be used so the game could go on. Expectation are to find the ideal BDI to create an agent capable of understand when is hand is gonna win so raise the bet and capapable of doing the opposite.},
    apice = {AgentBasedCardGame21},
    author = {Santoro, Matteo},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = mar,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Smart 21},
    type = {Game Project},
    url = {https://github.com/mega2799/ISE-BlackJack},
    year = 2025
}
@courseproject{distributeddiagnosis4osteoarthritis-sd2122,
    abstract = {Il progetto \`{e} incentrato sullo sviluppo di un sistema distribuito per supportare la diagnosi dell’osteoartrite delle ginocchia tramite l'analisi di radiografie. Il sistema consente a pazienti e medici di caricare le proprie radiografie tramite un’applicazione web, che sfrutta una rete neurale convoluzionale (CNN) pre-addestrata per fornire diagnosi automatizzate. Il sistema \`{e} stato containerizzato utilizzando Docker, assicurando portabilit\`{a}, modularit\`{a} e una gestione semplificata dell’infrastruttura. Successivamente, \`{e} stato distribuito su una macchina virtuale ospitata su Google Cloud Compute Engine, permettendo l'accesso al sistema tramite l'indirizzo IP pubblico della VM. Questo approccio ha garantito una distribuzione scalabile e facilmente accessibile.},
    apice = {DistributedDiagnosis4Osteoarthritis},
    author = {Magnani, Alessandro and Matteucci, Andrea and Montanari, Simone},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = mar,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Distributed diagnosis system for osteoarthritis},
    type = {Standard Project},
    url = {https://github.com/alessandromagnani17/osteoarthritis-project},
    year = 2025
}
@courseproject{smartcrossroads-ise2324,
    abstract = {Smart Crossroads is an application that aims to simulate traffic in a certain area of a city, in which there are 4 intersections regulated by traffic lights. The goal of the project is to exploit agent programming, provided by the combination of Java and Jason, to implement efficient traffic management through communication between intelligent agents, i.e. cars and traffic lights. The vision of the project is that of an automatic management of cars within an area: a self-driving car, for example, may want to communicate with traffic lights and other cars to create intelligent traffic management, calculate better routes, save fuel/energy, etc. This is still a fairly unrealistic scenario today, but it certainly represents an interesting idea regarding what an automatic traffic management could be like through various agents of various types interconnected with each other.},
    apice = {SmartCrossroads},
    author = {Lamagna, Emanuele},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = mar,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Smart Crossroads},
    type = {Standard Project},
    url = {https://github.com/Pedoni/SmartCrossroads},
    year = 2025
}
@courseproject{multiplayersupermario-ds2425,
    abstract = {This report presents the Distributed Pixformer project, made for the 2024-2025 Distributed Systems course at Unibo. This project builds upon the Pixformer project, developed for the 2022-2023 Object-Oriented Programming course at Unibo, crafted in Java with an MVC architecture combined with ECS (Entity Component System), which was selected as a good foundation due to its modularity and maintainability. In this enhanced version it becomes possible to compete against players over the network in a fun Super Mario-like adventure. Credits for the original project go to: Giorgio Garofalo, Giacomo Antonelli, Nicol\`{o} Ghignatti, Luca Patrignani.},
    apice = {MultiplayerSuperMario},
    author = {Garofalo, Giorgio},
    howpublished = {Distributed Systems, A.Y. 2024/2025},
    month = mar,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Pixformer: Multiplayer Super Mario},
    type = {Game Project},
    url = {https://github.com/iamgio/distributed-pixformer},
    year = 2025
}
@courseproject{autveicmas2024-mas2324,
    abstract = {The proposed project focuses on the development of a system where autonomous vehicles are modeled as agents, using Multi-Agent Reinforcement Learning (MARL) to coordinate their actions. The goal is to optimize traffic flow, minimize travel time, and avoid collisions. The system will be evaluated in a simulated environment, measuring key performance metrics such as traffic efficiency and safety. This project will combine the areas of multi-agent systems, reinforcement learning, and autonomous driving to produce a scalable solution for real-world traffic management.},
    apice = {AutveicMas2024},
    author = {Conca, Edoardo},
    howpublished = {Multi-Agent Systems, A.Y. 2023/2024},
    month = mar,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Multi-Agent Reinforcement Learning for Autonomous Vehicle Coordination},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/mas/projects/mas-project-conca-2324},
    year = 2025
}
@courseproject{morellizanotti2324-mas2324,
    abstract = {This project aims to develop a simplified version of the game Fat Princess, where two teams of agents with different roles and specific abilities compete to rescue their princess while protecting their own, within a shared environment. The environment models base layouts, resource locations, and agent states (e.g., health, positions, and tasks) to facilitate strategic interactions. The overall gameplay is governed by fixed rules with the possibility of dynamic variations based on the game state, adding complexity and adaptability to the system. Our work provides a platform to explore the dynamics of cooperation and competition in multi-agent systems: by assigning agents distinct roles and objectives, it enables the analysis of emergent behaviors and decision-making processes in controlled scenarios. This approach also facilitates a deeper understanding of role-based collaboration, studying how agents with complementary capabilities can work together to achieve shared goals.},
    apice = {Morellizanotti2324},
    author = {Morelli, Antonio and Zanotti, Fabio},
    howpublished = {Multi-Agent Systems, A.Y. 2023/2024},
    month = feb,
    sort = {game},
    supervisor = {Calegari, Roberta},
    title = {MAS Princess},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/morellizanotti2324},
    year = 2025
}
@courseproject{dpkinfrastructurewithidentityretention-ds2324,
    abstract = {Public Key Infrastructures (PKIs) enable users to look up and verify one another’s public keys based on identities. One of the biggest vulnerabilities in current approaches to PKIs is the lack of identity retention, meaning a user can register a public key under another’s already-registered identity. This project aims to design and implement a PKI that ensures this security property utilizing the consistency guarantees provided by cryptocurrencies. Our primary objective is to conduct an in-depth analysis on the blockchain in order to proper understand how to build one and what benefits this technology might bring in terms of security.},
    apice = {DPKInfrastructureWithIdentityRetention},
    author = {Pesic, Marco and Alni, Riccardo},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = feb,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {A Decentralized Public Key Infrastructure with Identity Retention},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-pesic-alni-ay2324},
    year = 2025
}
@courseproject{masmerli2324-mas2324,
    abstract = {Through this project, we aim to test the applicability of Multi-Agent methods to the efficient automated scheduling of trains. To this end, we chose the Flatland 3 challenge, a multi-agent reinforcement learning environment that simulates a railway network, in order to have a setting realistically similar to the real-world problem. We implemented a Multi-Agent Proximal Policy Optimization (MAPPO) algorithm, together with two observations tailored to the problem and two network architectures. We evaluated our trained models and found that our best model would have reached the 1st place on the RL track of the Flatland 3 challenge.},
    apice = {MasMerli2324},
    author = {Merli, Edoardo},
    howpublished = {Multi-Agent Systems, A.Y. 2023/2024},
    month = feb,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Multi-Agent Proximal Policy Optimization on Flatland 3},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/mas/projects/mas-merli2324},
    year = 2025
}
@courseproject{beachvolletballmanager-ds2324,
    abstract = {This project aims to develop a Beach Volley Tournaments Management Software designed to enhance the setup and execution of beach volley tournaments for private organizers. The system will improve all aspects of tournament management, beginning with player registration and continuing until the competition’s conclusion. Organizers will have the ability to create new tournaments and customize various elements, such as the number of matches each player will participate in and the overall competition structure. This flexibility is crucial for accommodating different tournament types, ensuring a enjoyable experience for both organizers and participants. The software will feature a range of functionalities that allow for the delegation of specific roles to tournament members, facilitating efficient management throughout the event. It will support player registration, match creation, and tracking of match start and end times, including score entry, all while maintaining the integrity of the games. A key feature of the system will be a real-time leaderboard, providing immediate updates on individual player rankings. This feature enhances audience engagement by enabling spectators to follow the live status of the tournament through graphical user interface (GUI) displays.},
    apice = {BeachVolletballManager},
    author = {Montanari, Nicola},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = jan,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Beach volleyball management software},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-montanari-ay2324},
    year = 2025
}
@courseproject{loveletter-ds2324,
    abstract = {Love Letter is a famous card game introduced in 2012 by Seiji Kanai. In this game each player aims to deliver a love letter to the Princess with the assistance of relatives and acquaintances. The goal of the mobile app is to replicate the gaming experience offered by the physical game, allowing you to create rooms of players (from 1 to 4) from which to start the games.},
    apice = {LoveLetter},
    author = {Lamagna, Emanuele},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = jan,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Love Letter Game},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-lamagna-ay2324},
    year = 2025
}
@courseproject{distributedcachesystem-ds2324,
    abstract = {The project focuses on developing a library that implements a Publish\Subscribe cache system, leveraging Apache Pulsar and Caffeine Cache. This library serves as a practical demonstration of the foundational principles of distributed caching, emphasizing data propagation, consistency, and fault management. The objective is to explore how these technologies can collaborate to enable efficient data distribution and synchronization in real-time scenarios.},
    apice = {DistributedCacheSystem},
    author = {Branco, Gianfranco},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = jan,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {Publish/Subscribe Cache Using Caffeine Cache and Apache Pulsar},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-branco-ay2324},
    year = 2025
}
@courseproject{distributedcafesystem-ds2324,
    abstract = {Our project aims to implement a distributed system for a caf\`{e}. It involves three front-end applications relying on a microservices-based back-end. The first application is used by the caf\`{e} employees to manage the customers orders, made by the second application, in real time. The last one provides some functionalities to manage the warehouse.},
    apice = {DistributedCafeSystem},
    author = {Albertini, Elisa and Bertoni, Eleonora},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = jan,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Distributed Caf\`{e} System},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-albertini-bertoni-ay2324},
    year = 2025
}
@courseproject{dpongpydistributedpong-seids2223,
    abstract = {Distributed Pong is an educational project that implements the classic Pong game in a distributed environment, showcasing various networking patterns and distributed system concepts. The project adopts a flexible architecture centered around a coordinator-terminal pattern, where a coordinator (server) manages the overall game state and synchronizes multiple terminals (clients). This report documents additional implementations of communication protocols such as ZeroMQ and WebSockets (with a RESTful API for game start coordination), and an alternative state management solution using etcd with a basic leader election mechanism and state synchronization using events pushed on the etcd database.},
    apice = {DPongPyDistributedPong},
    author = {Massone, Lorenzo},
    howpublished = {Software Engineering for Intelligent Distributed Systems, A.Y. 2022/2023},
    month = jan,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Distributed Pong: Adding Communication Protocols and Etcd State Management},
    type = {Game Project},
    url = {https://github.com/massone99/dpongpy},
    year = 2025
}
@courseproject{cybersecurityautonomousvehiclespaganelli-ise2324,
    abstract = {The rapid development of autonomous vehicles (AVs) introduces transformative potential for modern transportation systems, but it also raises critical concerns regarding cybersecurity. As AVs increasingly rely on complexity, the attack surface for potential threats expands, demanding robust and proactive security measures. This survey aims to provide an overview of current research on security challenges in autonomous vehicles, focusing on key cybersecurity threats, standards, and industry practices. Emphasizing the need for a multi-layered approach to cybersecurity in AVs, integrating secure software development, hardware resilience, and regulatory compliance is essential. Moreover, the survey explores future trends and emerging technologies that could enhance the security of autonomous vehicles helping the development of secure and reliable systems.},
    apice = {CybersecurityautonomousvehiclesPaganelli},
    author = {Paganelli, Alberto},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = jan,
    sort = {survey},
    supervisor = {Ciatto, Giovanni},
    title = {Cybersecurity in Autonomous On-Road Motor Vehicles focusing on connectivity and perception systems},
    type = {Survey Project},
    url = {https://github.com/paga16-hash/survey-ise/},
    year = 2025
}
@courseproject{applicationsofselforganisingsystems-ise2324,
    abstract = {The focus of this paper is to examine publications that apply self-organizing systems within various domains to address distributed, complex challenges. This review includes studies that use self-organization principles in applications for Distributed Information Systems, Military UAV Relay Networks, and Urban Traffic Management. Although the majority of these applications have been validated through simulations rather than real-world scenarios, they offer valuable insights into the potential and limitations of self-organizing systems. This paper systematically presents each application as a case study, analyzing both their commonalities and unique adaptations across domains. The primary objectives are to identify effective use cases for self-organizing systems, to assess the advantages and limitations of adopting decentralized coordination in these settings, and to evaluate the effectiveness of self-organization in achieving key performance goals. Lastly, this paper examines the characteristics of successful implementations and highlights current trends and challenges, aiming to outline a pathway for future research in the practical application of self-organizing systems.},
    apice = {ApplicationsOfSelfOrganisingSystems},
    author = {Akpinar, Mert},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = jan,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Literature Survey on Applications of Self-Organising Systems},
    type = {Survey Project},
    year = 2025
}
@courseproject{conquerorsofmars-ds2324,
    abstract = {I propose creating a real-time strategy game where players establish their civilization on Mars, starting from a simple base. Players will compete against each other to steal resources or defend their own bases to maintain control. The main actions players can perform include: collecting materials from Mars, spending materials to construct buildings (e.g., military bases, material collectors), upgrading buildings (e.g., evolving the headquarters from level 1 to level 2), and training troops to attack other players' bases. The game should continue running even when players are offline, which necessitates a server-client architecture. Additionally, a small database (SQLite) is needed to store progress in case the server goes down or needs to be restarted. I also plan to develop a minimalistic graphical user interface (GUI) to ensure user interaction is simple and intuitive.},
    apice = {ConquerorsOfMars},
    author = {Bonetti, Federico},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = jan,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Conquerors of Mars},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-bonetti-ay2324},
    year = 2025
}
@courseproject{maraffaonline-sd2223,
    abstract = {Il progetto consiste nell’eseguire una manutenzione evolutiva del gioco di carte Maraffa/Beccacino reperibile su MaraffaOnline, attualmente sviluppato dalla prof.ssa Lumini. In particolare, il nostro lavoro sar\`{a} quello di aggiungere nuove funzionalit\`{a} ed effettuare un refactoring non soltanto a livello del codice, ma anche architetturale. Anche con i nuovi sviluppi MaraffaOnline consentir\`{a} ai giocatori di partecipare, di creare partite e di comunicare.},
    apice = {MaraffaOnline},
    author = {Tosi, Sofia and Santoro, Matteo},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jan,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Maraffa Online},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-tosi-santoro-ay2223},
    year = 2025
}
@courseproject{masseriaterenzianiluise2324-mas2324,
    abstract = {The goal of this project is to develop a MultiAgent System to play a classic Flash game, Papa’s Burgeria, that used to be very popular a few years ago. It consists in managing a small burger restaurant, trying to complete orders as fast as possible while also cooking the best burgers possible. The gameplay is split into three areas or ”stations”: 1. the counter, where the orders are taken 2. the grill, where the meat is cooked 3. the ”burger assembly”, where the other ingredients are put together Upon receiving their order, the clients give a final score to their food and leave a corresponding tip, which can be used to buy improvements for the restaurants (which do affect future gameplay). The player can always switch between one of the stations, but can’t focus too much or too little on just one: ignoring the counter, for example, makes clients queue up, while leaving a burger on the grill too much will burn it.},
    apice = {MasseriaTerenzianiluise2324},
    author = {Terenziani, Andrea and Luise, Alberto},
    howpublished = {Multi-Agent Systems, A.Y. 2023/2024},
    month = jan,
    sort = {game},
    supervisor = {Calegari, Roberta},
    title = {Papa’s MASseria: A MultiAgent AI for a classic Flash game},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/mas/projects/mas-projects-terenziani-luise-2324},
    year = 2025
}
@courseproject{openstack-sd2122,
    abstract = {Il progetto \`{e} incentrato sulla distribuzione e gestione di un’infrastruttura cloud privata utilizzando OpenStack. Ci\`{o} prevede l’installazione e la configurazione di vari servizi OpenStack tra cui Keystone, Nova, Neutron, Glance ecc., all’interno di un cluster di server. L’architettura \`{e} stata progettata per fornire risorse di elaborazione, archiviazione e rete virtualizzate per supportare le esigenze di un’organizzazione. I temi che copre questo report sono la progettazione e implementazione di Open-Stack, inclusa l’architettura, i requisiti hardware e software e una guida finale sull’interazione con i suoi servizi: Dashboard Horizon e OpenStack Client. Il progetto ha presentato diverse sfide, tra cui problemi di compatibilit\`{a} software, che hanno richiesto un’attenta risoluzione dei problemi e configurazione adeguata. Nonostante ci\`{o}, \`{e} stato implementato con successo e ha fornito servizi cloud affidabili, scalabili e flessibili. Il progetto ha dimostrato la fattibilit\`{a} e il valore dell’utilizzo di OpenStack come piattaforma per l’implementazione di cloud privati.},
    apice = {OpenStack},
    author = {Semprini, Gloria},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = dec,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {DevOps on OpenStack},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-semprini-ay2122},
    year = 2024
}
@courseproject{wafflerughi2024-ds2324,
    abstract = {This project aims to implement an addition to a Web App that was developed as a group project (which I was a part of); this addition is oriented towards the course of Distributed Systems, with the goal of examining how the application handles issues typical of distributed systems and implementing improvements. The project I sought to expand is called Waffles - a "to-do" single page Web application for making lists, alone or in collaboration with friends.},
    apice = {WaffleRughi2024},
    author = {Rughi, Elena},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = dec,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Waffles -- The to-do app: NGINX add-on},
    type = {Standard Project},
    url = {https://github.com/elena-rh/todo-app-sd},
    year = 2024
}
@courseproject{predatorpreysimulationusingmarl-sd2223,
    abstract = {Reinforcement Learning (RL) is a sub-area of Machine Learning which focuses on building strategies to make decisions that maximize the future expected reward. The RL finds applications in problems concerning self-driving cars, industrial automation, and finance but also in systems that involve the interaction of multiple agents in a shared environment, where it’s more specifically called Multi-Agent RL (MARL). In computational biology, it’s useful to study the population of one or more intelligent species that interact with each other to build population models: in this project, a predator-prey ecosystem is implemented, using a MARL approach in a mixed environment, i.e. cooperative and competitive, where agents of the same species cooperatively make decisions to maximize their total expected reward. To achieve this goal, the MADDPG algorithm is exploited. The distribution of the system is realized by parallelizing the environments and by introducing a distributed training technique, inspired by the Mava framework.},
    apice = {PredatorPreySimulationUsingMarl},
    author = {Fabri, Luca},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = dec,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Predator-prey simulation using MARL},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-fabri-ay2223},
    year = 2024
}
@courseproject{agentseek-ise2324,
    abstract = {Agent Seek aims to develop a stealth-based video game where players have to complete several levels composed of obstacles and enemies, using the environment to avoid being detected. The player navigates a 2D arena with a top-down view seeking for the exit without alerting any enemy, implemented as intelligent agents. Agents will be provided with algorithms that analyze the state of the game and make optimal decisions independently, in order to make the user’s gaming experience challenging.},
    apice = {AgentSeek},
    author = {Capelli, Thomas and Magnani, Francesco},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = dec,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {AgentSeek - A 2D stealth based videogame},
    type = {Game Project},
    url = {https://github.com/FreshMag/AgentSeek},
    year = 2024
}
@courseproject{spaceteamgame-ds2324,
    abstract = {This project focuses on the development of a multiplayer game inspired by the video game Spaceteam. In this game, players work together to conduct a spaceship on a journey across the galaxy. Each player has a unique control panel displaying the ship’s current state, with a randomized assortment of buttons and other controls labeled with technobabble, symbols, and hard-to-read words. During each level, players designated as captains receive random orders to activate specific controls, however, the actions often apply to another player’s control panel. Each order is timed, and if not completed succesfully, the spaceship takes damage. If the damage sustained becomes too severe, the game ends. Players must communicate verbally, either in person or through online voice chat, to ensure the correct actions are performed. Succesfully completing the required amount of orders within a level advances the team to the next level, where challenges get tougher. The objective of the game is to progress as far as possible.},
    apice = {SpaceteamGame},
    author = {Omiccioli, Riccardo},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = nov,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Spaceteam Game},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-omiccioli-ay2324},
    year = 2024
}
@courseproject{claudeladdaga2024-ise2324,
    abstract = {This report analyzes the relationship between autonomy and intelligence in AI systems, with a focus on Claude 3.5 Sonnet and its new computer use functionality. It explores theoretical and practical implications, especially concerning security, transparency, and reliability challenges such as prompt injection attacks. A key aspect of this analysis is the comparison between Claude’s unique ”Use Computer” mode with its autonomy and traditional agent-based systems, highlighting its ability to perform multi-step tasks autonomously within dynamic environments. This discussion provides insights into the evolving role of AI systems in complex, autonomous interactions and identifies future directions for their safe and effective integration.},
    apice = {ClaudeLaddaga2024},
    author = {Laddaga, Michele},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = nov,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Autonomy and Intelligence in AI Systems: An Analysis of Claude 3.5 Sonnet},
    type = {Standard Project},
    year = 2024
}
@courseproject{dimarco2024flypizza-ise2324,
    abstract = {The project proposes the development of a MAS (Multi-Agent System) using the JASON programming language to simulate a drone delivery system for a pizzeria. The aim is to create a realistic environment composed of several agents: drones, a pizzeria, and a rescue robot. The simulation include a map with obstacles. The drones are autonomous agents capable of navigating, avoiding obstacles, and making decisions based on their beliefs. The overall delivery system is centrally controlled by the pizzeria. A user interface is also provided to visualize the environment and observe how the system works. This project aims to simulate an autonomous drone delivery system demonstrating the agents’ ability to perform tasks independently.},
    apice = {DiMarco2024FlyPizza},
    author = {Di Marco, Davide},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = nov,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {FlyPizza - Autonomous Drone Delivery System},
    type = {Standard Project},
    url = {https://github.com/davidedimarco00/FlyPizza},
    year = 2024
}
@courseproject{catlady-sd2223,
    abstract = {Il progetto prevede lo sviluppo del gioco da tavolo Cat Lady in versione online. Ogni giocatore pu\`{o} creare o unirsi a una lobby creata da un altro giocatore. Ogni lobby pu\`{o} contenere fino a 4 giocatori, raggiunto il numero minimo di 2 partecipanti \`{e} possibile iniziare una partita. Il gioco si svolge a turni, ad ogni turno il giocatore pu\`{o} acquisire una riga o colonna da una matrice 3x3 di carte e giocare specifiche carte per avvantaggiarsi. Il gioco termina quando non ci sono pi\`{u} carte per riempire la matrice. L’obiettivo del gioco \`{e} quello di ottenere il maggior numero di punti vittoria. I punti vittoria sono ottenibili tramite le varie tipologie di carte presenti nel gioco.},
    apice = {CatLady},
    author = {Leonardi, Laura and Pandolfini, Serafino},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = nov,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Cat Lady},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-leonardi-pandolfini-ay2223},
    year = 2024
}
@courseproject{bft2f-ds2324,
    abstract = {This report describes the BFT2F algorithm implementation as a Python library, building from the popular CastroLiskov PBFT. The main focus is on investigating the system’s behavior beyond f failures, covering the, often ignored, spectrum between full correctness and arbitrary failure. Similar to PBFT, BFT2F provides liveness and consistency when up to f replicas fail. In scenarios where f < failures ≤ 2f, BFT2F confines malicious servers to specific consistency violations, providing a nuanced approach to system behavior. This report presents a practical implementation of the BFT2f algorithm, designed to enhance reliability and security in distributed systems. This report describes the design, implementation, testing, and validation that were performed in this project and provides a general view of the application-level facts on Byzantine Fault Tolerance in distributed environments.},
    apice = {BFT2F},
    author = {Pacilli, Benedetta and Pieri, Valentina},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    keywords = {BFT},
    month = oct,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {Beyond One-third Faulty Replicas in Byzantine Fault Tolerant Systems},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-pacilli-pieri-ay2324},
    year = 2024
}
@courseproject{querymylibraryvasile2024-ise2324,
    abstract = {Large Language Models (LLMs) have gained significant popularity in recent years due to their remarkable question answering capabilities. However, when tackling a large corpus of text, the quality of the answers varies, largely due to the model’s inability to focus on contextualized information. This may lead to less accurate answers, poor handling of long-tail questions1 and exposure bias to the data it was pre-trained on. I present a creative approach to tackle these challenges by employing data-agents powered through LLMs. These agents employ complex workflows to intelligently perform operations over the knowledge base. These operations can be characterized as follows: 1) decompose the task into a series of function calls (thoughts), 2) employ multiple fetch operations over the knowledge base to retrieve relevant information (actions), 3) summarize at each step the extracted information to facilitate the final aggregation (observations) and 4) synthesise a final answer by combining the results. The project supports the adoption of Open LLMs, making the library usable freely without the financial burden of using proprietary providers. The library is available at [[https://github.com/atomwalk12/librarian]].},
    apice = {QuerymylibraryVasile2024},
    author = {Vasile, Razvan Florian},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = oct,
    sort = {advanced},
    supervisor = {Ciatto, Giovanni},
    title = {Query My Library! Question-Answering with Open-Source LLMs and Local Books},
    type = {Advanced Project},
    url = {https://github.com/atomwalk12/librarian},
    year = 2024
}
@courseproject{patterdiscastagnari24-mas2324,
    abstract = {Explainability is a critical requirement in clinical decision-making, where the reasoning behind diagnostic pathways must be clear and transparent. In clinical practice, diagnoses are often made by following established sequences of steps, such as laboratory tests, observations, or imaging, which are outlined in guidelines created by expert organizations. Inspired by these clinical guidelines, the study focuses on developing explainable diagnostic pathways using Large Language Models (LLMs). This work has been tested with two LLMs—Large Language Model Meta AI (LLaMA) and Mistral—on a synthetic yet realistic dataset to differentially diagnose anemia and its subtypes. By leveraging advanced prompting techniques, the aim is to enhance the transparency and interpretability of the decision-making process, generating diagnostic pathways that could be easily understood and validated by clinicians. The experiments demonstrated that LLMs have significant potential for discovering and explaining clinical pathways from patient data, with LLaMA consistently outperforming Mistral across various metrics. Utilizing the Chain of Thought technique, we analyzed the rationale behind each model’s diagnostic decisions, providing insights into their reasoning processes and the nature of errors they tend to make. These findings underscore the importance of explainability in the application of LLMs to clinical diagnostics and offer valuable insights into how these models can be better aligned with clinical standards. The patterns will be compared using RDF and P-Plan ontology, providing an explainable structure.},
    apice = {PatterdisCastagnari24},
    author = {Castagnari, Elisa},
    howpublished = {Multi-Agent Systems, A.Y. 2023/2024},
    month = oct,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Pattern Discovery in Clinical Workflows for Anemia Diagnosis},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/castagnari2324},
    year = 2024
}
@courseproject{strategisimspecialemas2324-mas2324,
    abstract = {This project implements a Multi-Agent System (MAS) using the Belief-Desire-Intention (BDI) model within a real-time strategy simulation. It explores agent interactions in a dynamic environment, focusing on emergent cooperative and competitive behaviors. The study aims to provide insights into how simple rules lead to complex strategies and interactions.},
    apice = {StrategisimSpecialeMas2324},
    author = {Speciale, Giuseppe},
    howpublished = {Multi-Agent Systems, A.Y. 2023/2024},
    keywords = {Simulation, Emergence, BDI, RTS, MAS},
    month = oct,
    sort = {advanced},
    supervisor = {Calegari, Roberta},
    title = {Cooperative and Competitive Dynamics in BDI-based Multi-Agent Systems from a Real-Time Strategy Game Simulation},
    type = {Advanced Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/mas/projects/mas-project-speciale2324},
    year = 2024
}
@courseproject{gymmanagementsystem-ds2324,
    abstract = {The project goal is to develop a distributed system for managing a gym, involving tree types of users: administrators, personal trainers and clients. Each personal trainer will have access to their own reserved area with a calendar, through which they can view appointments booked by clients for classes and private lessons. Additionally, personal trainers will be able to view the list of attendees for their classes or private lessons and access the profiles of individual clients, which will include personal information. Clients, on the other hand, will access their private area where they can view their profile, including personal data and bookings made for classes and private lessons. They will have the ability to enroll in classes and lessons by consulting the trainers' calendars, checking for available slots, and, if necessary, canceling a booking. In case of a cancellation, the slot will be made available again. It should be noted that clients cannot enroll in a class that has reached its maximum capacity, nor book a private lesson already assigned to another client. Administrators have access to tools for creating and managing courses, clients, and personal trainers within the database. They can also modify or delete courses, clients, and trainers from the database.},
    apice = {GymManagementSystem},
    author = {Giannelli Taccarino, Claudia},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = oct,
    sort = {application},
    supervisor = {Magnini, Matteo},
    title = {Gym Management System},
    type = {Application Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-giannelli-ay2324},
    year = 2024
}
@courseproject{pommermanmas-mas2223,
    abstract = {The aim of the project is to implement Pommerman, a modified version of the classic game Bomberman by Nintendo (1983). The game consists in four agents that can either cooperate in teams of two in the Co-op mode or can be opponents in the free for all (FFA) mode. The goal of the agents is to place bombs on the board and try to eliminate the opponents so that it remains at least one member of either team alive or only agent alive in the FFA version. To implement this project, we are going to use Jason, a suitable framework for developing multi- agent systems. Then, for the learning part of the project, since the Reinforcement Learning out-of-the-box algorithms are shown to be not satisfactory [REH+22] for this particular game, our purpose is to find an algorithm that could get us better results.},
    apice = {PommermanMas},
    author = {Morselli, Enrico and Vorabbi, Sara},
    howpublished = {Multi-Agent Systems, A.Y. 2022/2023},
    month = oct,
    sort = {research},
    supervisor = {Calegari, Roberta},
    title = {Agent Speak Pommerman},
    type = {Research Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-morselli-vorabbi-ay2223},
    year = 2024
}
@courseproject{jaktaactionlibrary-ise2324,
    abstract = {JaKta is an internal Domain-Specific Language (DSL) designed to support the definition of BDI agents in Kotlin. Inspired by Jason, Jakta makes use of internal and external actions to practically extend AgentSpeak; however, since it is still a project in development, the user is responsible for independently implementing its own actions. The purpose of this project is to address the lack of predefined actions by adding a library, which the programmer can use as a starting point in the declaration of a Multi-Agent System (MAS).},
    apice = {JaktaActionLibrary},
    author = {Romagnoli, Giacomo},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = oct,
    sort = {research},
    supervisor = {Giovanni Ciatto},
    title = {Action library for JaKta},
    type = {Research Project},
    url = {https://github.com/GiacomoRomagnoli/jakta},
    year = 2024
}
@courseproject{maraffa-ds2324,
    abstract = {The project involves the creation of an online multiplayer version of the card game Maraffa. The games will consist of 4 players who will compete 2vs2. The cards to play are 40, divided into 4 suits (cups, coins, clubs, swords).},
    apice = {Maraffa},
    author = {Capannini, Daniel},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = oct,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Maraffa},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-capannini-ay2324},
    year = 2024
}
@courseproject{unoonline-sd2223,
    abstract = {Questo progetto nasce con l’obiettivo di sviluppare una versione digitale del gioco da tavolo Uno, un gioco conosciuto ormai da tutti, molto popolare. Ciascun utente, tramite un applicativo web, potr\`{a} creare o partecipare ad una stanza di gioco nella quale giocare con altri utenti. La partita si avvier\`{a} appena il numero di partecipanti presenti nella stanza sar\`{a} uguale a 4. Il gioco si compone di un mazzo di carte suddivise in quattro colori principali: rosso, giallo, verde e blu. Ogni colore presenta carte numerate da 0 a 9, oltre a una serie di carte speciali. Queste includono “Salta”, che consente di saltare il turno del giocatore successivo; “Inverti”, che cambia la direzione del gioco; “Pesca Due”, che obbliga il giocatore successivo a pescare due carte; “Jolly”, che permette al giocatore di cambiare il colore in gioco; e “Pesca Quattro”, una versione potenziata del “Jolly” che consente anche di far pescare quattro carte al giocatore successivo. A inizio partita, ogni giocatore riceve 7 carte, mentre una viene scoperta al centro per formare la pila degli scarti. Ciascun giocatore, al proprio turno, deve scartare una carta che corrisponda per numero o colore a quella in cima alla pila degli scarti. In alternativa, il giocatore pu\`{o} giocare una carta speciale, indipendentemente dal colore della carta in cima alla pila. Se un giocatore non pu\`{o} giocare una carta valida, deve pescare una carta dal mazzo e, se ancora non pu\`{o} giocare, deve passare il turno. L’obiettivo del gioco \`{e} rimanere senza carte in mano prima degli altri giocatori. Quando un giocatore rimane con una sola carta in mano, deve dichiarare “Uno” per informare gli altri. Se un giocatore non dichiara “Uno” prima che il turno passi, deve pescare due carte come penalit\`{a}. Il gioco si conclude quando rimane un giocatore con ancora carte in mano.},
    apice = {UnoOnline},
    author = {Totaro, Giacomo and Bertaccini, Serena},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = oct,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Uno Online},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-totaro-bertaccini-ay2223},
    year = 2024
}
@courseproject{agentpacman-ise2324,
    abstract = {In this project, I aimed to develop a game like the famous Pacman game, implemented using Java and a Swing GUI. The project was developed as part of the Intelligent Systems course at the University and aimed to demonstrate the ability to design and develop complex software that can integrate an intelligent agent behaviour, with a particular focus on technologies like JASON.},
    apice = {AgentPacman},
    author = {Marzoli, Leo},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = oct,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Agent Pac-Man},
    type = {Game Project},
    url = {https://github.com/MarzoliLeo/Intelliget-PacMan},
    year = 2024
}
@courseproject{perna2324-mas2324,
    abstract = {This project aims to implement a Multi-Agent System (MAS) in Python to sim- ulate a multi-robot team during a Search and Rescue (SAR) operation within a multi-room house. The system will employ an aggregative optimization al- gorithm to ensure that robots autonomously organize and execute tasks while meeting both local and global objectives. The robots, modeled as a graph, will compute their optimal trajectories using a gradient method algorithm to mini- mize their cost functions derived from local targets, global information such as walls and obstacles, and consensual data shared among neighbors. Each agent will solve a decoupled optimization problem with respect to its own position and target but will experience coupling in the cost function due to aggregative variables such as the formation’s barycenter and the gradient of the cost with respect to the barycenter. These consensual decision variables will be learned by the agents through dynamic average consensus. Additionally, the agents’ cost functions will be influenced by obstacle points, which will be avoided through potential functions associated with each obstacle. The environment will be two- dimensional (as well as the robots), with different rooms connected by passages and corridors. The number of agents, the order of the rooms, and other op- timization parameters will be chosen by the user in advance and specified in yaml configuration files. Throughout the SAR operation, the robots will navi- gate from the house entrance to the exit, collaboratively solving tasks specified in advance by the user. Obstacles and global targets, such as protecting a person, will be treated as artifacts necessitating coordinated action among the robots. The entire system will be developed using an object-oriented program- ming (OOP) approach in Python, ensuring modularity and future integration into the ROS2 framework for real-world deployment. Animations and plots will be presented at the end of the trajectory computations to demonstrate the algorithm’s effectiveness in accomplishing each task of the SAR process.},
    apice = {Perna2324},
    author = {Perna, Andrea},
    howpublished = {Multi-Agent Systems, A.Y. 2023/2024},
    month = sep,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Distributed Multi-Robot Search and Rescue Operations Using Aggregative Optimization in a Multi-Room House Environment},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/perna2324},
    year = 2024
}
@courseproject{bellatreccia2324-ethicsofai20232024,
    abstract = {The aim of this project is to measure fairness in automatic skin disease diagnosis using a convolutional neural network. The dataset used for this work is a compilation of various images of skin diseases taken by the medical personnel from the pedriatic ward at Sant’Orsola hospital in Bologna. These images were collected using consumer-grade cameras, resulting in considerable variance in illumination, angle, and quality. The first part of this work involes processing the images to create a dataset with uniform image sizes. The second part focuses on determining the skin tone of each sample using the Individual Typology Angle. The third part involves training a simple convolutional neural network and evaluating its performance across different skin tones by computing traditional metrics for each skin tone and different fairness metrics.},
    apice = {Bellatreccia2324},
    author = {Chiara Bellatreccia},
    howpublished = {Ethics of AI, A.Y. 2023/2024},
    keywords = {Skin Tone Bias, Fairness, CNN, ITA},
    month = sep,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Measuring fairness in automatic skin disease diagnosis with a convolutional neural network},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/bellatreccia2324},
    year = 2024
}
@courseproject{huesle-sd1920,
    abstract = {Il progetto ha lo scopo di realizzare una versione digitale e distribuita del gioco da tavolo Mastermind. Tale versione rappresenta una variante rispetto a quella originale e prevede che i due sfidanti abbiano lo stesso ruolo e che debbano competere per la risoluzione di una partita. Per farlo, devono a turni cercare di indovinare un codice composto da una sequenza di 4 colori sulla base dei suggerimenti forniti a partire dai tentativi gi`a effettuati. Tale codice viene generato casualmente dal backend dell’applicazione. La modalit\`{a} di gioco risulta asincrona in quanto i due giocatori non devono per forza essere online e collegati alla partita nello stesso momento per far s\`{i} che il gioco possa andare avanti. L’interazione tra di essi avviene per mezzo della rete Internet e attraverso i client di gioco, che sono eseguiti sui singoli dispositivi dei giocatori. L’implementazione in questione consentir\`{a} di creare due tipologie di partite: una pubblica e una privata. In seguito alla creazione, una partita potr\`{a} iniziare solo quando entrambi i giocatori si saranno uniti ad essa. Da quel momento in poi, il gioco fornir\`{a} 10 tentativi totali (5 per utente) entro i quali dovr\`{a} essere indovinata la sequenza di colori. Vincer\`{a} la partita il primo che indovina la sequenza nelle mosse a sua disposizione. Al contrario, il match terminer\`{a} in pareggio se nessuno riesce a svelare il codice. Oltre alle operazioni di gioco, l’applicazione permetter\`{a} agli utenti di registrarsi, autenticarsi, modificare alcune informazioni del profilo e visionare le partite in corso e quelle terminate, nonch\'{e} lo stato attuale degli avversari.},
    apice = {Huesle},
    author = {Spadoni, Alberto},
    howpublished = {Distributed Systems, A.Y. 2019/2020},
    month = aug,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Huesle-java},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-agnoletti-spadoni-ay2021},
    year = 2024
}
@courseproject{baiocco2324-ethicsofai20232024,
    abstract = {The first goal of this project is to determine if a model's inherent feature importance serves as a proxy for its interpretability when assessed through Model-Agnostic Explanation methods. The second aim is to investigate whether low feature importance scores for prohibited features, obtained through model-agnostic explanation methods, correspond to a low Disparate Treatment Index. If such a correspondence exists, it would suggest that models assigning low importance to these features are less likely to be discriminatory. Lastly, the project applies a Lagrangian approach to a neural network to minimize the Disparate Treatment Index, comparing feature importances before and after mitigation. This comparison highlights which features have decreased in importance, revealing those that were originally correlated with prohibited features.},
    apice = {Baiocco2324},
    author = {Daniele Baiocco},
    howpublished = {Ethics of AI, A.Y. 2023/2024},
    keywords = {Interpretability, Feature Importance, Mitigation Technique},
    month = aug,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Comparing Different Models’ Reliance on Prohibited Features in the Adult Census Income},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/balocco2324},
    year = 2024
}
@courseproject{scootermonitor-sd2223,
    abstract = {This report provides an in-depth overview of the development process for a single-page application (SPA) specifically designed for the reservation and utilization of electric scooters. The primary objective of this project was to create an application that serves as a Minimum Viable Product (MVP) for a comprehensive urban mobility solution. The application is intended to offer a seamless and user-friendly experience, enabling users to efficiently locate, reserve, and use electric scooters for their urban transportation needs. Through the application, users can access an interactive map that displays all available scooters in their vicinity, providing real-time information on the scooters’ locations and availability. The application includes robust monitoring features that allow users to track and analyze their scooter usage. These functionalities provide detailed statistics, such as the duration of scooter use, distances traveled, and other relevant metrics. This data can help users better understand their usage patterns and make more informed decisions regarding their mobility options.},
    apice = {ScooterMonitor},
    author = {Ferrarese, Nicola},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = aug,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Scooter Monitor},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-ferrarese-ay2223},
    year = 2024
}
@courseproject{multitasklearningpacilli2024-ise2324,
    abstract = {This literature survey focuses on applications of multi-task learning in intelligent systems. The concern is to identify success in the design choices implementation, algorithms, and principles used, the benefits of the application, and the challenges encountered. The study aims at deriving insights into current trends and potential advancements in MTL.},
    apice = {MultitasklearningPacilli2024},
    author = {Pacilli, Benedetta},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = jul,
    sort = {survey},
    supervisor = {Ciatto, Giovanni},
    title = {Multi-Task Learning Applications in Intelligent Systems},
    type = {Survey Project},
    year = 2024
}
@courseproject{dldefectdetectiondtm2024-sedtm2223,
    abstract = {This study investigates the application of deep learning techniques, specifically Convolutional Neural Networks (CNNs) and Recurrent Neural Networks (RNNs), for defect detection in software engineering. A systematic search was conducted across databases including IEEE Xplore, ACM Digital Library, and Google Scholar, focusing on literature published between 2010 and 2023. Studies were selected based on relevance, rigor, credibility, and originality. The methodology involved evaluating the performance metrics of various neural network architectures in different industrial contexts. By synthesizing data through a narrative approach, the study provides insights into the strengths and limitations of CNNs and RNNs, guiding the selection of the most appropriate model for specific defect detection applications. The findings aim to contribute to the optimization of defect detection processes in software engineering, enhancing th},
    apice = {DldefectdetectionDtm2024},
    author = {Wayessa, Dame Haile and Tootazehi, Maryam and Hasan, Ruaa Khalid Abdulmoniem and Sassaoui, Dounya},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = jul,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Deep Learning for Image Processing in Defect Detection: Systematic Review and Meta-Analysis Study of Algorithms and Their Applications in Industry},
    type = {Survey Project},
    year = 2024
}
@courseproject{chipairstation-sd2021,
    abstract = {Il seguente progetto mira a implementare un servizio di stazioni metereologiche per monitorare temperatura, pressione, umidit\`{a} e indice di qualit\`{a} dell’aria in ambienti urbani o in diverse citt\`{a}. Utilizzando un sistema a microcontrollore ESP32 con moduli di comunicazione LoRa e Wi-Fi, assieme al sensore BME680, i dati vengono trasmessi ai Gateway mediante connessione radio LoRa. I Gateway ricevono cos`ı le informazioni da tutti i sensori nel raggio di copertura, inviando i dati pre-elaborati tramite interfaccia Wi-Fi e rete Internet a un Broker MQTT. Infine, un servizio MQTT Reader, sfruttando un servizio database inserir\`{a} e aggregher\`{a} i dati all’interno di quest’ultimo, il quale verr\`{a} utilizzato per fornire, mediante Web Service, opportune API o Client Web per il monitoraggio e l’interazione con il sistema.},
    apice = {ChipAirStation},
    author = {Rotundo, Antonio},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = jul,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {CAS -- Chirp Air Station},
    type = {Standard Project},
    url = {https://github.com/antoniorotundo2/chirp-air-station},
    year = 2024
}
@courseproject{weathertrack-sd2223,
    abstract = {WeatherTrack is a distributed system that collects and processes real-time weather data from a network of simulated Internet of Things (IoT) sensors, and provides users with a web-based interface to visualize and analyze the collected data. The system is designed to be scalable, fault-tolerant, and extensible. At the core of the system are the weather sensors, which simulate the behavior of real IoT devices by continuously generating and transmitting weather data, such as temperature, humidity and wind speed. A message broker acts as an intermediary, receiving the sensor data and routing it to the message consumers, which process the information and store it in a database. The web application, built using a full-stack Javascript approach, provides users with a dashboard to interact with the collected weather data. Users can view real-time sensor readings, explore trends and statistics, and receive alerts for any detected weather anomalies. The system’s modular and containerized architecture, combined with the use of tools like Docker, GitLab CI/CD, and automated testing, ensures the project can be easily deployed, maintained and extended in the future with the integration of additional features.},
    apice = {WeatherTrack},
    author = {Nediani, Gian Luca},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jul,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {WeatherTrack},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-nediani-ay2223},
    year = 2024
}
@courseproject{masbdiapplicationsilling2024-ise2324,
    abstract = {The search scope of this survey are publications that use Multi-agent systems (MAS) and Belief-desire-intention (BDI) agents in their approach to solve a problem in their domain. Preferably, publications which present a fully implemented and evaluated solution in a real world scenario will be selected. Nonetheless, publications that propose a solution using MAS and BDI agents, that are evaluated with e.g. computer simulations, will also be considered. This survey aims to provide an overview of current and past approaches using MAS and BDI agents by systematically presenting them as case studies and highlighting their differences and similarities. The goal of this study is to identify the use cases and domains where the use of MAS and BDI agents is promising, to weigh the benefits and disadvantages of using this approach, and to evaluate their efficiency of achieving the desired result compared to alternative approaches. Additionally, if possible, I want to analyze what the of the successful approaches are and identify current trends and future challenges in the research field.},
    apice = {MAsbdiapplicationsIlling2024},
    author = {Illing Arizti, Yago Agustin},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = jul,
    sort = {survey},
    supervisor = {Ciatto, Giovanni},
    title = {Real-world applications of MAS and BDI agents},
    type = {Survey Project},
    year = 2024
}
@courseproject{aimusiccannatadervishimistroni2024-sedtm2223,
    abstract = {This paper explores the application of artificial intelligence (AI) and machine learning (ML) in the music industry, focusing on analytical and generative tools. The study is divided into two main sections: Music Recommendation Systems (MRS) and Music Generation Systems (MGS). In the first section, the paper examines the role of AI and ML in enhancing MRS, which have revolutionized music consumption by providing personalized recommendations. Techniques such as Collaborative Filtering (CF), Content-based Filtering (CBF), and advanced deep learning models are discussed. The paper also highlights the BaRT algorithm used by Spotify as a case study, demonstrating the practical implementation of these technologies. The second section delves into generative AI for music creation. It explores computational creativity, emphasizing the distinction between music composition and synthesis. Various methods, including Markov Chains, Recurrent Neural Networks (RNNs), and Long Short-Term Memory (LSTM) networks, are analyzed for their effectiveness in generating music. The Google Magenta project is presented as a case study, showcasing advanced tools like Performance RNN and NSynth for creating expressive and innovative musical pieces.},
    apice = {AimusicCannatadervishimistroni2024},
    author = {Cannata, Antonio and Dervishi, Gabriele and Mistroni, Riccardo},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = jul,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Artificial Intelligence in the music industry: analytical and generative tools},
    type = {Survey Project},
    year = 2024
}
@courseproject{humanlikeaicolombaripollutri2024-sedtm2223,
    abstract = {Artificial Intelligence (AI) has made remarkable strides in emulating human-like behavior across various domains, ranging from video games to natural language generation. This paper investigates the extent to which AI systems can exhibit human-like behavior through a comparative analysis of two distinct implementations: the Skyrim Herika's mod and Google's generative agents. The Skyrim Herika's mod, enhances the behavior of non-player characters (NPCs) in the popular video game "The Elder Scrolls V: Skyrim." In contrast, Google's generative agents, exemplified by models like GPT-3 and GPT-4, utilize large-scale deep learning architectures to generate human-like text based on input prompts. Through a comparative analysis, this paper examines the approaches to achieving human-like behavior in AI. We explore the underlying technologies, methodologies, and limitations of each system. Additionally, we discuss the implications of these advancements in AI for different fields and applications. By critically evaluating the human-like behavior exhibited by the Skyrim Herika's mod and Google generative agents, this paper contributes to a deeper understanding of the capabilities and challenges in creating AI systems that approach or simulate human-level intelligence and behavior. Moreover, it sheds light on the ethical, social, and philosophical implications of AI advancements in replicating human behaviors, offering insights into the future trajectory of AI research and development.},
    apice = {HumanlikeaiColombaripollutri2024},
    author = {Colombari, Alessio and Pollutri, Simone},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = jul,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Exploring human-like behavior in AI: A comparative analysis of the Skyrim Herika's mod and Google Generative Agents},
    type = {Standard Project},
    year = 2024
}
@courseproject{citysimturriniravanas2024-mas2324,
    abstract = {This project aims to simulate the traffic flows in a city by means of a multi-agent system. The main characters of our city are cars, that drive in the streets, and pedestrians that walk within buildings. They rely on their perception of the environment to achieve specific goals. These agents will be autonomous and intelligent, capable of decision making and interaction. The implementation of this system is based on the JaCaMo development platform[6], where Jason is used as the reference agent programming language to implement agents driven by their beliefs and their goals (BDI architecture).},
    apice = {CitysimTurriniravanas2024},
    author = {Turrini, Alice and Ravanas-Deshays, Maud},
    howpublished = {Multi-Agent Systems, A.Y. 2023/2024},
    month = jul,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {City Dynamics: Multi-Agent Simulation},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/mas/projects/mas-project-turrinideshays2324},
    year = 2024
}
@courseproject{chatbottouropalboccino2024-sedtm2223,
    abstract = {The paper explores the revolutionary potential of generative AI in chatbots for the tourist industry, focusing on the case study of Alpha Tour Operator. The progression of chatbots from rule-based systems to complex AI-driven models demonstrates considerable improvements in consumer engagement capabilities. Generative AI, including Natural Language Understanding (NLU) and Large Language Models (LLMs), allows chatbots to participate in more natural, context-aware discussions, improving user experience and operational efficiency. The report provides an in-depth look at the present status of AI-generative chatbots in the tourist sector, as well as the precise technology developments that have enabled these improvements. It explores Alpha Tour Operator's business requirements, determining how AI chatbots might improve customer service, automate routine questions, and deliver data-driven insights.},
    apice = {ChatbotTouropAlboccino2024},
    author = {Alboccino, Giulia},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = jul,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {The Impact of AI-Driven Chatbots for Tour Operators -- A Case Study of Alpha Tour Operator},
    type = {Standard Project},
    year = 2024
}
@courseproject{replicationlab-ds2324,
    abstract = {The projects aims at preparing the teaching materials (exercises, code, repos, references, slides, …) for a laboratory (two 2-hours sessions) on replication in distributed systems},
    apice = {ReplicationLab},
    author = {Casamenti, Gianmaria and Pasini, Luca},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = jul,
    sort = {teaching},
    supervisor = {Omicini, Andrea and Magnini, Matteo},
    title = {Replication Laboratory},
    type = {Teaching Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-casamenti-pasini-ay2324},
    year = 2024
}
@courseproject{distributedrealtimesystemforvideosurveillance-sd2223,
    abstract = {Revue is a real-time video surveillance and environment monitoring system. It is designed to be used in multiple scenarios such as home, office or warehouses following the user needs. Revue permits controlling the environment through sensors and cameras, providing real-time data and video streaming. It is also possible to configure security rules, to get notified when a sensor data exceeds a specified range, or when camera recognise an intrusion.},
    apice = {DistributedRealTimeSystemForVideoSurveillance},
    author = {Matteini, Mattia and Paganelli, Alberto},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jul,
    sort = {advanced},
    supervisor = {Magnini, Matteo},
    title = {Revue -- Distributed real-time system for video surveillance},
    type = {Advanced Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-matteini-paganelli-ay2223},
    year = 2024
}
@courseproject{unoclone-sd2021,
    abstract = {Il progetto ha lo scopo di studiare e presentare una versione distribuita multiplayer del gioco di carte UNO. Il gioco \`{e} realizzato utilizzando l’architettura client-server e il paradigma ad attori. Il linguaggio utilzzato per sviluppare l’intero progetto \`{e} Scala},
    apice = {UnoClone},
    author = {Gardini, Lorenzo},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = jul,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {UNO Clone},
    type = {Game Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-gardini-ay2021},
    year = 2024
}
@courseproject{multiplayerteamdeathmatch-sd2223,
    abstract = {Il progetto "Team Deathmatch in UE5" si propone di sviluppare un videogioco che ricrea l'esperienza di un classico Team Deathmatch. Il giocatore avr\`{a} la possibilit\`{a} di assumere il ruolo di server (G.S.) o client (G.C.) al momento dell'avvio, consentendo cos\`{i} di avviare una sessione di gioco come host o di unirsi ad essa come cliente. La battaglia si svolge in una mappa il pi\`{u} minimale possibile ai fini del progetto. Il gioco termina quando il team che elimina per primo tutti i membri della squadra avversaria vince. L'aspetto grafico e di gameplay \`{e} volutamente non curato, in quanto al di fuori dello scopo del progetto. Il videogioco \`{e} sviluppato utilizzando Unreal Engine 5 (UE5), una delle piattaforme di sviluppo videogiochi pi\`{u} avanzate e potenti disponibili. L'obiettivo principale del progetto \`{e} quello di fornire una sessione multiplayer in tempo reale e affrontare argomenti trattati nel corso relativi ai sistemi distribuiti.},
    apice = {MultiplayerTeamDeathmatch},
    author = {Marzoli, Leo},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jul,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Multiplayer Team Deathmatch},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-marzoli-ay2223},
    year = 2024
}
@courseproject{intelligentbriscola-ise2324,
    abstract = {Intelligent Briscola aims to develop the Italian classic card game Briscola where users can play against a sophisticated bot designed as an intelligent agent. The objective is to create a dynamic and challenging gameplay experience where the bot simulates human-like strategies in the card game. The project will involve the implementation of different levels of bot intelligence. Each level will employ varying degrees of strategic decision-making processes, allowing the bot to adapt its gameplay according to the intelligence level selected by the user. The intelligent agent will utilize advanced algorithms to analyze the state of the game and make optimal decisions, providing a realistic and competitive gaming experience. The matches will exclusively consist of two players, in a 1vs1 mode (one human and one bot). The cards used to play Briscola are 40, grouped into 4 suits: clubs, coins, cups and swords. The type of cards will be the ”Romagnola” variety. The total points available in the deck are 120; to declare a winner, it is necessary to reach a minimum of 61 points, while if 60 points are reached, a tie occurs.},
    apice = {IntelligentBriscola},
    author = {Zammarchi, Andrea},
    howpublished = {Intelligent Systems Engineering, A.Y. 2023/2024},
    month = jul,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Intelligent Briscola},
    type = {Game Project},
    url = {https://github.com/andreazammarchi3/intelligent-briscola},
    year = 2024
}
@courseproject{lupus-sd2021,
    abstract = {Questo progetto nasce con l’obiettivo di creare una versione digitale del gioco Lupus, conosciuto anche come Mafia [1], un gioco conosciuto ormai da tutti, molto popolare tra i gruppi di universitari. Il gioco prevede che ci siano almeno 6 giocatori ed un narratore esterno che orchestri la partita. Prima di iniziare la partita, il narratore assegna casualmente un ruolo a ciascun giocatore. Generalmente questa assegnazione viene effettuata con l’ausilio di carte da gioco o token fisici, poich\'{e} \`{e} fondamentale per lo svolgimento che i ruoli rimangano segreti per tutta la partita. I ruoli presenti nel gioco possono variare a seconda del numero di giocatori o del tipo di partita che si vuole effettuare. Durante lo svolgimento del gioco ci sar\`{a} un alternarsi di fasi diurne e notturne nelle quali i diversi personaggi potranno intraprendere azioni specifiche. Il narratore avr\`{a} il compito di supervisionare l’alternarsi delle fasi di gioco, tenere traccia delle decisioni dei giocatori e delle loro azioni. Nella versione originale e pi\`{u} semplice del gioco i ruoli sono quelli di cittadino e mafioso, per cui si andranno a creare due squadre con obiettivi contrapposti, identificare i mafiosi ed uccidere i cittadini. Ad ogni turno di notte il narratore dovr\`{a} chiedere ai mafiosi chi vogliono uccidere all’insaputa dei cittadini, mentre durante il turno di giorno tutti i giocatori dovranno decidere chi accusare di essere un mafioso, consapevoli per\`{o} che i mafiosi cercheranno di influenzare a loro favore la decisione. La partita termina nel momento in cui tutti i giocatori di una delle due squadre hanno la meglio sugli altri, avendo ucciso tutti i cittadini od imprigionato tutti i mafiosi. A questo punto sar\`{a} sufficiente distribuire nuovamente i ruoli per iniziare una nuova partita.},
    apice = {Lupus},
    author = {Serafini, Andrea},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = jun,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Lupus},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-serafini-ay2021},
    year = 2024
}
@courseproject{pokemonlitebrocchini-sd2223,
    abstract = {La premessa del progetto \`{e} la creazione di un emulatore online che permetta a giocatori di costruire un team Pokemon secondo le regole presenti nei giochi originali, e giocare l’uno contro l’altro in tempo reale, in pratica permettendo la costruzione di squadre in maniera molto pi\`{u} semplice ed efficiente rispetto al processo nei giochi ufficiali (in quanto in questi ultimi i particolari pi\`{u} minuti delle caratteristiche dei pokemon necessitano di sforzi prolungati per essere ottimizzati, processo fattibile in pochi click all’interno di un emulatore di questo genere). Di particolare importanza \`{e} la tecnologia distribuita utilizzata.},
    apice = {PokemonliteBrocchini},
    author = {Brocchini, Michele},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jun,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Pokemon Lite},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-brocchini-ay2223},
    year = 2024
}
@courseproject{activelylearningsquarcialupi-ise2223,
    abstract = {Active learning is a method where a learner attempts to learn some kind of knowledge by posing questions to a teacher. In computational learning theory, classically, the questions made by the learner are called membership queries and are answered with ‘yes’ or ‘no’ (or equivalently, with ‘true’ or ‘false’). Here we consider that the teacher is a language model and we study the case where the knowledge is expressed as an ontology. To evaluate the approach, we present results showing the performance of GPT and other language models when answering whether concept inclusions on existing EL ontologies are ‘true’ or ‘false’.},
    apice = {ActivelylearningSquarcialupi},
    author = {Squarcialupi, Riccardo},
    howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023},
    month = jun,
    sort = {research},
    supervisor = {Magnini, Matteo},
    title = {Actively Learning: an LLM extension for the Exact Learner framework},
    type = {Research Project},
    url = {https://github.com/MatteoMagnini/ExactLearner},
    year = 2024
}
@courseproject{freeforallbattleship-ds2324,
    abstract = {This project aims to design and implement a new version of the classic Battleship game by transforming it into a dynamic free for all experience for four players. In this game, individual players compete against each other in a challenge for naval dominance. The objective remains simple - strategically deploy their fleet to sink as many enemy ships as possible while safeguarding their own. After logging in, users can create lobbies (waiting rooms) or join existing ones. In the lobby, players must strategically position their ships on a grid within a time limit of 1 minute. Once the game starts, players take turns calling out shots, and each turn has a 15-seconds time limit.},
    apice = {FreeForAllBattleship},
    author = {Di Marco, Davide and Fraccalvieri, Ines},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = jun,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Free-for-all Battleship},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-dimarco-fraccalvieri-ay2324},
    year = 2024
}
@courseproject{cassanodabramo2324-ethicsofai20232024,
    abstract = {In response to the critical need for safeguarding privacy and security within the medical sector, this project capitalizes on recent advancements in artificial intelligence (AI). Leveraging the innovative architecture of Federated Learning pioneered by Google, combined with the advantages offered by blockchain technology, our objective is to develop a framework that prioritizes trust, reliability, and ethical conduct throughout the learning process within a Federated Learning system. Specifically, our focus lies in employing this framework to detect brain tumor cancer through an Artificial Neural Network (ANN), thereby simulating a realistic scenario where each participant in the Federated Learning process represents a distinct hospital with its own repository of sensitive patient data. By integrating Federated Learning with blockchain technology, we aim to establish a robust infrastructure capable of ensuring the confidentiality, integrity, and security of patient information while fostering collaborative learning among distributed healthcare institutions.},
    apice = {CassanoDabramo2324},
    author = {Lorenzo Cassano and Jacopo D’Abramo},
    howpublished = {Ethics of AI, A.Y. 2023/2024},
    keywords = {Federated learning, Blockchain, ETH, CNN, Neuroimaging},
    month = may,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Fortifying Medical Diagnosis: Federated Learning Augmented by Blockchain for Enhanced Privacy, Security, and Robustness},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/cassano-dabramo-ay2324},
    year = 2024
}
@courseproject{hashchainreplicationwithraft-ds2324,
    abstract = {This project aims to design and implement a robust application that employs servers to oversee a hash chain across a network of replicated state machines, utilizing the RAFT consensus algorithm [2]. The project includes the development of a user-friendly client capable of appending blocks to the replicated hash chain through a web application interface. The stored data on the hash chain will be in the form of simple text. The primary objectives are to conduct a comprehensive exploration of the RAFT consensus algorithm, study the hash chain data structure, and acquire technical expertise in network application programming. Through this undertaking, the project seeks to contribute to the understanding of distributed systems and consensus algorithms while providing a practical application for managing data in a decentralized and reliable manner.},
    apice = {HashChainreplicationWithRaft},
    author = {Akpinar, Mert and Illing Arizti, Yago Agustin},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = apr,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {Hash chain replication with RAFT Consensus},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-akpinar-illingarizti-ay2324},
    year = 2024
}
@courseproject{collaborativetexteditor2-ds2324,
    abstract = {This project aims to realize a client-server architecture to host, edit and collaborate in writing a text file in an online text-editor. The text editor will be hosted in the web browser, and inside it a user can create a document. Once the document is created, the owner of the document can share the document with other users based on two distinct permissions: Write Permission: any user with this permission can edit the shared document. Read-Only Permission: any user with this permission can only read a document, while it is not allowed to perform changes. Inside the web interface, users can perform real time edits alongside other users with write permissions. At any given moment, the owner of the document can edit or revoke permissions to a specific user. The permission can then be: Downgraded: from write permission to read-only permission. Upgraded: from read-only permission to write permission. Revoked: any permission previously granted is revoked.},
    apice = {CollaborativeTextEditor2},
    author = {Furi, Stefano and Iorio, Matteo and Vincenzi, Fabio},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = apr,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Collaborative Text Editor},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-furi-iorio-vincenzi-ay2324},
    year = 2024
}
@courseproject{warehousesimulationcommodaro-ise2223,
    abstract = {The project proposes the development of a multi-agent system, based on Jason, to simulate and manage an autonomous warehouse. The research focuses on creating a dynamic and realistic environment, where agents represent robots that load and unload goods at predetermined points. The robot agents will have autonomous behaviors and a realistic navigation system, allowing them to move from one point to another within the warehouse, avoiding obstacles. Goods management will involve the implementation of loading and unloading operations and in the delivery of the goods. During the simulation, the battery level of the robots will be considered, and when it reaches a certain threshold, they will need to recharge. Additionally, will be simulate a scenarios where a robot may break down, and another robot intervenes to repair it. The navigation system will consider obstacles and possible congestion situations, ensuring accurate simulation. Warehouse modeling will include loading/unloading zones and the ability to dynamically move goods. A user interface will provide real-time visualization of the simulation, allowing the user to monitor the robot positions and warehouse status.},
    apice = {WarehouseSimulationCommodaro},
    author = {Commodaro, Daniele},
    howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023},
    month = apr,
    sort = {simulation},
    supervisor = {Ciatto, Giovanni},
    title = {Simulation for the Management of an Autonomous Warehouse},
    type = {Simulation Project},
    url = {https://github.com/pankake/ise_project},
    year = 2024
}
@courseproject{chubby-ds2324,
    abstract = {This project explores the design and implementation of Chubby, a distributed file system, designed by Google, that offers a lock service for loosely-coupled distributed systems. Chubby prioritizes consistency over availability and provides coarse-grained locking alongside reliable, low-volume storage. The platform enables users to perform various operations such as creating and deleting files, reading and writing text data, managing permissions, and receiving notifications about file system changes. The system was developed using Java and the Raft consensus algorithm.},
    apice = {Chubby},
    author = {Fontana, Marco},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    keywords = {BFT, Raft, Chubby},
    month = apr,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {Java-based Implementation of Google’s Chubby Lock Service using Raft Consensus Algorithm},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-fontana-ay2324},
    year = 2024
}
@courseproject{dixitdilillo-sd2122,
    abstract = {The main goal of the project is to create a clone of the so called Dixit card game, in a distributed fashion and based on actor oriented paradigm.},
    apice = {DixitDiLillo},
    author = {Di Lillo, Daniele},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = apr,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Dixit Clone},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-dilillo-ay2122},
    year = 2024
}
@courseproject{sievebft-ds2324,
    abstract = {This project aims to create a simulation of the Sieve protocol for Byzantine Fault Tolerance (BFT). Establishing a resilient and dependable replicated state machine (RSM) that can tolerate Byzantine faults in a distributed network was the main goal. During the simulation process, it is important to guarantee scalability and effective resource management. Furthermore, we offer a basic client that can communicate with the RSM by performing a small set of actions. To evaluate the resilience of the protocol, Byzantine actors are included in the simulation, which comprises numerous nodes, each of which represents a participant in the RSM. Identifying and alleviating Byzantine faults by putting the Sieve protocol into practice will protect the distributed system’s integrity and consistency even when there are malicious nodes present. In order to resist Byzantine failures, the Sieve protocol requires at least 3f + 1 nodes, where f is the number of faulty ones. The simulation’s outcomes show how well the Sieve process works to achieve BFT. This project offers a basic, user-friendly tool for experimentation and analysis, advancing our understanding of and ability to apply Byzantine fault-tolerant protocols in distributed systems.},
    apice = {SieveBft},
    author = {De Tuglie, Samuele and Artegiani, Emanuele and Vargas Grateron, Pablo Sebastian},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    keywords = {BFT},
    month = apr,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {Study and Implementation of the Sieve Protocol in BFT},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-detuglie-artegiani-grateron-ay2324},
    year = 2024
}
@courseproject{alzheimerai-sedtm2223,
    abstract = {Alzheimer’s Disease (AD) is a progressive neurodegenerative condition that affects memory, cognition, behavior, and other cognitive functions. It is regarded as a silent global health crisis due to alarming statistics and projections for the future. However, there are currently no effective treatments or precise diagnostic methods available. Despite the absence of a cure, early detection of AD is paramount for developing therapeutic and care plans that aim to preserve cognitive function and prevent irreversible decline. In this Systematic Literature Review (SLR) we delve into the potential contribution of AI to aid in the detection of Alzheimer’s Disease. Firstly, we outline the methods presently employed for diagnosing AD, which include both invasive and non-invasive biomarkers. Focusing exclusively on Magnetic Resonance Imaging (MRI) as the primary neuroimaging technique, we underscore the significance of data preprocessing. Subsequently, we investigate the potential contributions of AI and outline three fundamental approaches: supervised learning, Weakly Supervised Learning (WSL), and transfer learning, the latter arising as a bridge between supervised learning and WSL/unsupervised learning. Finally, the paper addresses the most relevant legal and ethical implications, alongside the necessary skills enhancement required for healthcare professionals to effectively implement AI in the ethical medical domain. A description of a possible scenario is also provided as a suggestion to improve the quality of the healthcare system.},
    apice = {AlzheimerAi},
    author = {Bellesia, Riccardo and Manca, Giovanni},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = mar,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {The potential for Artificial Intelligence in the diagnosis of Alzheimer’s Disease: A Systematic Literature Review},
    type = {Standard Project},
    year = 2024
}
@courseproject{dockersharedvolumesplugin-ds2324,
    abstract = {In a distributed computing environment built using docker-swarm technology and used by multiple workgroups, there is a problem with separating the working areas on disk / volumes. Indeed, in this environment, knowing where the common data resides, anyone can access the data of other groups. The aim of this project is therefore to create a layer of separation between the management of the volumes by the user and the physical part of the volume itself. This can be achieved through a plugin (or driver, as they say) that allows you to abstract the physical folder from the virtual one used by docker. Furthermore, since docker swarm is indeed a distributed cluster, it is necessary to allow the containers running on the various nodes to access the data in a transparent manner regardless of the node on which they are executed. To achieve this result, we have relied on a distributed file system such as NFS (Network File System).},
    apice = {DockerSharedVolumesPlugin},
    author = {Fiumana, Enrico},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = mar,
    sort = {research},
    supervisor = {Ciatto, Giovanni},
    title = {Docker Plugin for Volume Sharing},
    type = {Research Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/ay2324/ds-project-fiumana-ay2324},
    year = 2024
}
@courseproject{trafficligths-sd2223,
    abstract = {Almost everywhere, traffic lights are managed as independent units in each intersection. Each one has its own state cycle and it is synchronized with its corrisponding twin on the other side of the street. The timing for each state might vary depending on the type of the street. This mechanism assures a stable management of the single intersection where average traffic is homogeneous. But what happens if certain streets have unpredictable peaks of traffic in certain time frames? Or what happens in case of exceptional events, such as a football game, that could cause certain city areas to be more trafficated rather than others? All these problems could be solved with a dynamic management of the semaphores cycles based on data that tells which one requires more green light time than the others. This project aims to develop a system where a central server acquires the data sent by sensors placed in the streets near the intersecionts and continuously process the timings each semaphore cycle will be based on. The main focus of the project is to show the interaction between these entities, by providing a simple interface that emulates a streetmap window which shows the vehicle movements in real time.},
    apice = {TrafficLigths},
    author = {Ercolani, Francesco},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = mar,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Server based system for small cities traffic lights management},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-ercolani-ay2223},
    year = 2024
}
@courseproject{elasticsearch-sd2122,
    abstract = {Il progetto ha lo scopo di studiare e illustrare le principali funzionalit\`{a} di Elasticsearch. Elasticsearch \`{e} un motore di ricerca e di analytics distribuito e RESTful, basato sulla libreria Apache Lucene e in grado di lavorare su qualsiasi tipo di dato, che sia numerico, strutturato o non strutturato. Sviluppato da Shay Banon, il primo precursore di Elasticsearch, chiamato Compass, risale al 2004, mentre la sua prima versione \`{e} stata rilasciata 6 anni dopo, nel 2010; ad oggi, secondo il DB-Engines, Elasticsearch risulta il motore di ricerca pi\`{u} popolare in contesti enterprise.},
    apice = {ElasticSearch},
    author = {Sun, Yuqi},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    keywords = {Elasticsearch, search engines, web analytics},
    month = mar,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Elasticsearch -- il motore distribuito di ricerca e analytics},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-sun-ay2122},
    year = 2024
}
@courseproject{aiinsuranceunipol2024-sedtm2223,
    abstract = {This paper provides an in-depth exploration of the insurance industry, with a particular focus on the transformative impact of artificial intelligence. The study begins by examining the fundamental aspects of the insurance sector, including the various types of policies and the historical evolution of the insurance market. It then delves into the Insurtech landscape, offering insights into the industry’s classification, innovative strategies, and game-changing technologies. Within the game-changing technologies, a significant portion of the paper is dedicated to the role of Artificial Intelligence (AI) in the insurance field. The analysis covers the drivers of AI adoption, the implementation of Narrow AI, and presents real-world use cases. The benefits and potential risks associated with integrating AI in insurance operations are thoroughly discussed, along with the challenges and opportunities that insurers may encounter. To provide a practical perspective, the paper includes a case study on Unipol Group S.p.A., examining its presence in the insurance, financial, and real estate sectors. The paper concludes with reflections on the future trajectory of the insurance industry, considering the ongoing innovations and challenges. By synthesizing theoretical insights with a concrete case study, this paper contributes to a holistic understanding of the evolving dynamics within the insurance sector, emphasizing the pivotal role of Insurtech in shaping its future landscape.},
    apice = {Aiinsuranceunipol2024},
    author = {Arcuri, Alessandra and Mazzotti, Martina and Mattioli, Melissa},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = feb,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Artificial intelligence impact on the insurance industry: the Unipol Group S.p.A. case},
    type = {Standard Project},
    year = 2024
}
@courseproject{plantlo-sd2122,
    abstract = {Per il progetto di Sistemi Distribuiti, si \`{e} pensato di realizzare un’applicazione che consenta di gestire una serra “smart”, in modo da poter visualizzare un elenco di tutti i tipi di ortaggi coltivati e gestire il loro ambiente di sviluppo. Per poter utilizzare l’applicativo, un utente deve registrarsi, in modo tale da avere la visualizzazione esclusiva della propria serra. Ogni utente ha la possibilit\`{a} di: visualizzare le piante presenti in serra, gestire l’irrigazione delle piante e monitorare i dati relativi alla qualit\`{a} dell’aria all’interno della serra. Il progetto comprende anche una componente di Internet of Things, in quanto l’applicazione comunica con “oggetti intelligenti” tramite la connessione di rete: nello specifico, sono presenti sensori per rilevare dati ambientali come temperatura, umidit\`{a}, pressione e livello di CO e un attuatore che controlla l’impianto di irrigazione.},
    apice = {Plantlo},
    author = {Baiardi, Alex and Frattini, Francesca},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = feb,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Plantlo},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/sd-project-baiardi-frattini-ay2122},
    year = 2024
}
@courseproject{slrfairnessperiti-mas2223,
    abstract = {This systematic literature review (SLR) delves into the evolving landscape of fairness implementation and management within Multi-Agent Systems (MAS). Over the past decade, the integration of fairness considerations in MAS has gained prominence, necessitating a closer examination of methodologies and challenges associated with this integration. This review categorises several approaches, highlighting the nuanced dimensions of fairness, including distributive fairness, procedural fairness and multi-objective optimisation problem, and scrutinise strategies for managing fairness. By synthesising these findings, this review offers a comprehensive understanding of the current state of fairness in MAS, contributing to the discourse on responsible and equitable multiagent system development.},
    apice = {SlrfairnessPeriti},
    author = {Periti, Alex},
    howpublished = {Multi-Agent Systems, A.Y. 2022/2023},
    keywords = {fairness, multi-agent system, SLR},
    month = feb,
    sort = {survey},
    supervisor = {Calegari, Roberta},
    title = {Fairness in Cooperative Multi-Agent Systems},
    type = {Survey Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-periti-ay2223},
    year = 2024
}
@courseproject{floodwarning-ds2324,
    abstract = {The objective of this project is to create a distributed application that aims to monitor possible flooding in a city. In order to achieve this, a predefined number of sensors are deployed in the city acquiring environmental data. The sensors used in this particular case are rain gauge, which can detect the level of rainfall fallen expressed in mm3 in a certain time interval. The city is divided into predefined zones, a WxH rectangle, and each sensor operates in only one area. Among many shapes the rectangle has been chosen to represent a city for its nature. Other shapes, like circles, seems to be not optimize to achieve this goal, in fact we should implement an algorithm to manage the intersection of the circles to respect the requirements of the project. The alarm situation is triggered when the majority of sensors exceeds a threshold value and a fire station has been alerted. Only one fire station can be in a single area. The firefighters can access to a GUI to manage the alarm.},
    apice = {FloodWarning},
    author = {Tullio, Alessandro and Rubri, Michael},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = feb,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Flood Warning},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-tullio-rubri-ay2324},
    year = 2024
}
@courseproject{webbasedwodt-sd2021,
    abstract = {Nell’ultimo decennio i Digital Twins sono diventati un argomento d’interesse all’interno dell’accademia e a livello industriale. L’uso del paradigma Digital Twin \`{e} stato esplorato in diversi domini: Healthcare, Smart City, Industria 4.0, ecc. Nel tempo, sono state proposte diverse definizioni del termine Digital Twin, ognuna delle quali mette in evidenza solo le caratteristiche necessarie nel dominio di applicazione. Questo ha portato alla creazione di numerose proposte di sistemi per la creazione di Digital Twins che spesso sono chiusi e progettati solo per scopi specifici ed applicazioni verticali, andando di fatto a limitare le reali possibilit\`{a} abilitate dal paradigma Digital Twin. I principi dei Digital Twins possono essere estesi alla virtualizzazione di realt\`{a} pi\`{u} complesse composte da asset provenienti da diversi domini e organizzazioni in una visione pi\`{u} aperta. Questa visione \`{e} quello che differenzia Web of Digital Twins. Web of Digital Twins mira alla creazione di un layer condiviso che pu\`{o} essere utilizzato dalle applicazioni o da agenti per l’osservazione degli asset fisici che compongono il mondo reale (processi, persone, oggetti, ...) puntando all’interoperabilit\`{a} e alla possibilit\`{a} di rappresentare, a livello di Digital Twins, le relazioni presenti tra gli asset fisici appartenenti a diversi domini e a diverse organizzazioni. Il Web \`{e} stato recentemente proposto da diversi lavori scientifici come ”application architecture” per la creazione di sistemi dinamici, aperti e long-lived come ad esempio Web of Things. In queste proposte, lo stile architetturale REST e l’hypermedia sono centrali al fine di ereditarne le caratteristiche e permettere la creazione di sistemi scalabili. Questi sistemi hanno alcuni requisiti e caratteristiche simili a quelli dei Digital Twins, quindi il Web `e un approccio interessante per il design di un Web-based Web of Digital Twins.},
    apice = {WebBasedWoDT},
    author = {Andrea Giulianelli},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = feb,
    sort = {advanced},
    supervisor = {Magnini, Matteo},
    title = {Web-Based Web of Digital Twins},
    type = {Advanced Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-giulianelli-ay2021},
    year = 2024
}
@courseproject{blastpursuit-mas2223,
    abstract = {We propose BlastPursuit for the Multi-Agent Systems project. This innovative project aims to create an augmented version of the classic Bomberman game, showcasing advanced concepts of multi-agent systems, including agent autonomy, strategic interaction, and adaptive learning within a complex environment. Our primary objective is to develop a multi-agent system where two squads of agents, Bombermen and Killers, each with distinct goals, navigate and interact within a grid-based environment. By employing various Reinforcement Learning (RL) algorithms, we aim to investigate their efficacy in enabling these agents to develop successful strategies and autonomously make decisions in different scenarios.},
    apice = {BlastPursuit},
    author = {Laudenzi, Guido and Osman, Sami Mohammed},
    howpublished = {Multi-Agent Systems, A.Y. 2022/2023},
    month = feb,
    sort = {game},
    supervisor = {Calegari, Roberta},
    title = {BlastPursuit},
    type = {Game Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-laudenzi-osman-ay2223},
    year = 2024
}
@courseproject{kafkapulsarrabbitmqanalysis-sd2122,
    abstract = {L'obiettivo del progetto è effettuare un confronto tecnico fra i più popolari message broker presenti sul mercato. In primo luogo verrà effettuata una panoramica teorica delle caratteristiche e delle funzionalità messe a disposizione da ciascun message-broker. Successivamente verranno confrontate le loro architetture, il modello dei dati, il modello di consegna dei messaggi e i protocolli utilizzati. La fase pratica del progetto coinvolgerà la creazione di test per valutare e confrontare i message-broker dal punto di vista delle performance, scalabilità, resilienza e facilità d'uso.},
    apice = {KafkaPulsarRabbitMQAnalysis},
    author = {Acampora, Andrea and Accursi, Giacomo},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    keywords = {Apache Kafka, Apache Pulsar, RabbitMQ},
    month = feb,
    sort = {technology},
    supervisor = {Magnini, Matteo},
    title = {Apache Kafka vs. Apache Pulsar vs. Rabbit MQ: un’analisi tecnica},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-acampora-accusi-ay2122},
    year = 2024
}
@courseproject{akkadistributeddatabassi2023-ds2324,
    abstract = {This lab illustrates the capabilities of Akka Distributed Data in handling shared data structures, focusing on consistency. Students will explore various Read/Write strategies, including Local, Majority, and All (strict), to understand their impact on distributed systems' behavior, considering CAP characteristics. The lab includes practical examples on setting up a basic Akka Cluster and Distributed Data in Java and implementing a Conflict-free Replicated Data Type (CRDT), for example the Last Write Wins Map (LWWMap).},
    apice = {AkkadistributeddataBassi2023},
    author = {Bassi, Barry},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    keywords = {Akka  •  Akka Distributed Data  •   Java  •  replication  •  consistency},
    month = jan,
    sort = {teaching},
    supervisor = {Omicini, Andrea},
    title = {Exploring Akka Distributed Data: Managing Replication and Consistency in Java-Based Systems},
    type = {Teaching Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-bassi-ay2324},
    year = 2024
}
@courseproject{thegame-sd2021,
    abstract = {Il progetto consiste nella realizzazione di una versione digitale e distribuita del gioco da tavolo ``The Game'' con GUI molto semplici ed utilizzando il framework Akka, in particolare Akka Cluster e Akka Cluster Sharding. In breve, una partita di questo gioco consiste in una sessione in cui uno o pi\`{u} giocatori collaborano per disfarsi delle carte presenti nel mazzo principale in cui si trovano in ordine casuale le carte numerate dal 2 al 98. Le carte devono essere giocate in 4 ``mazzetti'' di cui 2 partono dal numero 1 e possono accogliere solo carte pi\`{u} grandi dell'ultima giocata, mentre gli altri due partono dal 99 e possono accogliere solo le carte pi\`{u} piccole. L'unica eccezione che consente di giocare carte che non rispettino questo ordine \`{e} quando si ha una carta che differisce esattamente di una decina dall'ultima giocata. Dopo aver avviato il software un giocatore pu\`{o} creare una nuova partita ed aspettare che i suoi amici si colleghino prima di iniziare effettivamente il gioco oppure pu\`{o} entrare nella stanza di una partita gi\`{a} creata ma non ancora iniziata. L'utente che ha avviato la partita sar\`{a} il primo a giocare. Durante il proprio turno un giocatore deve posizionare almeno due carte (oppure tre se si sceglie una difficolt\`{a} superiore) in uno specifico mazzetto tra quelli validi; quando il giocatore vorr\`{a} concludere il suo turno dovr\`{a} ripescare fino ad avere nuovamente 6 carte in mano (o fino alla fine del mazzo); sar\`{a} poi il turno del giocatore seguente. Il gioco finisce quando si giocano tutte le carte oppure un giocatore non pu\`{o} giocare il numero di carte minime. In seguito si pu\`{o} scegliere di avviare una nuova partita con quel gruppo di amici o uscire dal gioco.},
    apice = {TheGame},
    author = {Luzi, Simone},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    keywords = {The Game, Akka, Akka Cluster, Akka Sharding, attori, messaggi asincroni},
    month = jan,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {The Game},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/sd-project-luzi-2021},
    year = 2024
}
@courseproject{middlewareforjakta-ise2223,
    abstract = {Jakta distributed is an extension of the Jakta framework, a platform tailored for programming BDI agents through a Kotlin DSL. This project focuses on the design and development of such an extension that aims to empower jakta users to create distributed systems leveraging the capabilities offered by the Jakta framework and a message passing system.},
    apice = {MiddlewareForJakta},
    author = {Cortecchia, Angela and Micelli, Leonardo and Vissani, Filippo},
    howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023},
    month = jan,
    sort = {product},
    supervisor = {Ciatto, Giovanni},
    title = {Middleware for the communication between Distributed Agents in JaKtA},
    type = {Product Project},
    url = {https://github.com/FilippoVissani/jakta},
    year = 2024
}
@courseproject{piperchat-sd2223,
    abstract = {Il progetto consiste nella realizzazione di una piattaforma che permette la comunicazione fra gli utenti, ispirata a Discord. Piperchat, mira a creare un ambiente di comunicazione ispirato a Discord, dove gli utenti possono interagire in varie forme. Offrir\`{a} la possibilit\`{a} di registrazione e accesso tramite un sistema di login, consentendo agli utenti di stabilire e gestire connessioni sociali attraverso richieste di amicizia. La piattaforma faciliter\`{a} la comunicazione intra-utente, con notifiche per messaggi e la gestione delle amicizie. Gli utenti avranno la libert\`{a} di creare e gestire i propri server, con funzionalit\`{a} per la gestione di canali testuali e multimediali. Sar\`{a} possibile inviare messaggi, partecipare a chiamate vocali e video e gestire webcam e microfono all’interno dei canali. Inoltre, i creatori dei server potranno moderarli, rimuovendo membri indesiderati.},
    apice = {Piperchat},
    author = {Andruccioli, Manuel and Borriello, Luigi and Mazzoli, Alessandro and Patriti, Tommaso},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jan,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Piperchat},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-andruccioli-borriello-mazzoli-ay2223},
    year = 2024
}
@courseproject{raftjs-ds2324,
    abstract = {The purpose of this report is to introduce and explain our proposed project regarding the Raft consensus algorithm. In particular, our project has required a preliminary phase of studying and understanding the recommended paper. The project then involved an implementation of the consensus protocol in Javascript language and then it has been used as the basis of a web application for online auction management, so as to identify and report any advantages and disadvantages of the studied algorithm.},
    apice = {RaftJS},
    author = {Bedei, Andrea and Notaro, Fabio and Bertuccioli, Giacomo Leo},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    keywords = {Raft  •. consensus  •  JavaScript},
    month = dec,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Raft: study and implementation in JavaScript},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-bedei-bertuccioli-notaro-ay2324},
    year = 2023
}
@courseproject{perudoonline-sd2223,
    abstract = {Il progetto prevede lo sviluppo di una versione online del gioco da tavolo ”Perudo”. In questo gioco, da 2 a 6 giocatori, ogni giocatore ad inizio partita ha a disposizione 5 dadi ed un bicchiere. Tutti i giocatori mischiano i propri dadi all’interno del proprio bicchiere ed il giocatore di turno effettua una supposizione sui dadi totali. Il giocatore successivo pu\`{o} rilanciare la supposizione oppure dubitare. In caso di dubito il giocatore che ha sbagliato perde un dado e si incomincia un nuovo turno, mischiando nuovamente i dadi. Se invece il giocatore rilancia si va avanti finch\'{e} un giocatore non dubita. Lo scopo del gioco consiste nell’essere l’ultimo giocatore ad avere almeno un dado a disposizione.},
    apice = {PerudoOnline},
    author = {Lumini, Enrico},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = dec,
    sort = {game},
    supervisor = {Magnini, Matteo},
    title = {Perudo Online},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-lumini-ay2223},
    year = 2023
}
@courseproject{lambdaasaservice-sd2021,
    abstract = {This project aims to realize the software component of an hypothetical cloud service for the execution of portable code, which is provided by the users of the service itself. A user submits their code to the system as an executable file through a specific client. For example, a user can submit to the system a JAR file containing Java code, so it can be executed following the specifications dictated by the language itself and the Java Virtual Machine on which is being executed. The client task is to contact a server, which firstly persists the code that the user provided using a relational database. Secondly, it reaches the real service, which task is to allocate the resources needed for the code execution. The service, after completing its task, returns an endpoint which can then be returned by the server to the client, in order to complete the request made by the latter. After this, the user can contact the given endpoint through a RESTful API which allows them to execute the previously provided code passing the adequate parameters that the code itself needs. The system responsible for the resources management is made by an ensemble of agents, which organization follows the "master-worker" pattern. The "master" agent notifies the other agents of a new pending request and decides which of them will perform the execution of this request. The "worker" agents task is to allocate the resources needed for the code execution. Those latter can be, so as to make the computational ability as scalable as possible, distributes on different machines. This means that all agents communicate and synchronize with the aid of a remote tuple centre. The "workers", after accepting a request, are able to create a new agent whose task is to wait for the user requests and, after they received one, to execute the given code.},
    apice = {LambdaAsAService},
    author = {Castellucci, Matteo},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = dec,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Lambdas-as-a-Service},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-castellucci-ay2021},
    year = 2023
}
@courseproject{copsthievesmas-mas2223,
    abstract = {The aim of this project is to simulate the Cops and Thieves game through a multi-agent system. The Cops and Thieves game involves players assuming the roles of either cops or thieves, where thieves aim to collect coins while evading capture by cops. We will employ Jason and the Q-Learning reinforcement learning algorithm to model the game’s dynamics effectively. Jason, as a platform for multi-agent system development, provides the essential infrastructure for creating intelligent agents capable of strategic decision-making and interaction. Furthermore, the Q-Learning algorithm, renowned for its ability to facilitate agents’ learning from experience and optimizing their actions, aligns seamlessly with the project’s goal of enabling intelligent decisionmaking among the game entities. The game dynamics will involve randomly generating teams of cops and thieves, positioning safe zones and coins, and determining the playing area size based on the number of players. Thieves will navigate the playing area, including safe zones, to collect coins, while cops will patrol the area to apprehend thieves. The game concludes when either all coins are collected by the thieves, resulting in their victory, or all thieves are apprehended by the cops, leading to the cops’ triumph.},
    apice = {CopsThievesMas},
    author = {Scala, Simona and Nestola, Matteo},
    howpublished = {Multi-Agent Systems, A.Y. 2022/2023},
    month = dec,
    sort = {research},
    supervisor = {Calegari, Roberta},
    title = {Cops and Thieves: a Multi-Agent Game},
    type = {Research Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-nestola-scala-ay2223},
    year = 2023
}
@courseproject{chainvote-sd2223,
    abstract = {Electronic voting systems based on blockchain technology have emerged as a potential solution to enhance the security and transparency of traditional voting methods. In this system, voters cast their votes electronically, and the results are stored on a decentralized blockchain ledger, which ensures the integrity of the vote by preventing any tampering or manipulation. This system provides a transparent and immutable record of votes, which can be accessed by anyone in the network, thus increasing trust in the electoral process. Nevertheless, the use of blockchain technology in electronic voting systems holds promise for creating a more secure, transparent, and democratic electoral process.},
    apice = {ChainVote},
    author = {Antonioni, Giovanni and Rubboli, Luca and Tassinari, Luca},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = dec,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {ChainVote: An electronic voting system},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-antonioni-rubboli-tassinari-ay2223},
    year = 2023
}
@courseproject{risiko-sd2122,
    abstract = {Si vuole sviluppare la versione distribuita del gioco da tavolo “RISIKO” seguendo le regole del gioco. Il progetto sar\`{a} composto da: Server Client (successivamente peer-to-peer) Le regole sono le seguenti: Numero di giocatori da 2 a 6 con differente numero armate/giocatore 42 carte territorio con simbolo per bonus annesso (soldato, cavallo, cannone o jolly) Regole di attacco, difesa e lancio dadi del Risiko classico 20 carte obiettivo segrete (1 carta a giocatore) che se soddisfatte portano il giocatore alla vittoria Un giocatore per vincere deve completare il suo obiettivo prima degli altri, la partita finisce non appena questa condizione si avvera.},
    apice = {Risiko},
    author = {Squarcialupi, Riccardo and Benvenuti, Filippo},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = dec,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {“Risiko” Clone -- Design, Development and Deployment},
    type = {Game Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-benvenuti-squarcialupi-ay2122},
    year = 2023
}
@courseproject{smartparking-sd2223,
    abstract = {Oggigiorno sempre pi\`{u} frequentemente viene alla luce il problema della ricerca di parcheggi per la sosta di auto e moto. Ci\`{o} accade maggiormente nelle aree urbane pi\`{u} densamente popolate. Nasce da qui l’idea di creare una piattaforma che venga incontro alle necessit\`{a} degli utenti che si ritrovano spesso con questa problematica da affrontare: una mappa che segnali lo stato al momento attuale per ogni punto sosta (a strisce blu) e che permetta di prenotarne l’occupazione in base alle esigenze dell’utente.},
    apice = {SmartParking},
    author = {Davide Bucchieri and Davide Boldini},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = dec,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Smart Parking},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-bucchieri-boldini-ay2223},
    year = 2023
}
@courseproject{replicationclasssoriani2023-ds2324,
    abstract = {The project aims at preparing the teaching materials (slides, references, …) for a class (4-6 hours) on replication in distributed systems},
    apice = {ReplicationClassSoriani2023},
    author = {Soriani, Arianna},
    howpublished = {Distributed Systems, A.Y. 2023/2024},
    month = dec,
    sort = {teaching},
    supervisor = {Omicini, Andrea},
    title = {Replication Class},
    type = {Teaching Project},
    url = {https://github.com/pikalab-unibo/ds-2023-project-soriani},
    year = 2023
}
@courseproject{webappdelivery-sd2223,
    abstract = {Si vuole realizzare una web-app per la consegna a domicilio di beni, che metta in diretto contatto clienti, esercenti e rider. Nello specifico, un utente dovr\`{a} poter effettuare ordini presso i negozi nelle vicinanze e avere aggiornamenti sullo stato dell’ordine. Per facilitare la gestione degli ordini agli esercenti, questi potranno modificare il men\`{u}, dichiararsi non disponibili alla vendita e consultare lo storico degli ordini, il tutto tramite un’UI intuitiva. Infine, i rider avranno la possibilit\`{a} di ricevere ordini in real-time, visualizzando in anticipo il compenso per la consegna proposta. Se questa sar\`{a} accettata, verr\`{a} attivata la modalit\`{a} navigazione, tramite la quale il rider visualizzer\`{a} il percorso per arrivare al punto di pick-up prima e dal cliente poi.},
    apice = {WebAppDelivery},
    author = {Pastore, Lorenzo},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = dec,
    sort = {application},
    supervisor = {Magnini, Matteo},
    title = {Foodio: Web app di delivery},
    type = {Application Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-pastore-ay2223},
    year = 2023
}
@courseproject{slrthrustworthyai-ise2223,
    abstract = {Ethical, fairness, and responsible AI have emerged as pivotal concerns in the design and construction of artificial intelligence systems. This systematic literature review aims to comprehensively analyze the evolving landscape of ethical and responsible AI practices and principles within the domain of AI system development. Over the past decade, the rapid proliferation of AI technologies has underscored the critical need for ethical considerations that extend beyond mere compliance. The review investigates the frameworks, methodologies, and best practices that advocate for embedding ethical, fairness, and responsible AI principles into the very fabric of AI systems during their design and construction. By examining a wide array of scholarly contributions, this review seeks to elucidate the key ethical challenges faced by AI developers, the strategies employed to integrate fairness and ethical considerations, and the emergent best practices for cultivating responsible AI. Furthermore, it will explore the impact of ethical and responsible AI design on society, policy, and the broader AI landscape. The findings from this review will provide valuable insights for AI practitioners, researchers, and policymakers, highlighting the importance of ethical and responsible AI as an inherent part of the AI design process.},
    apice = {SlrThrustworthyAI},
    author = {Iannotta, Antonio},
    howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023},
    month = nov,
    sort = {survey},
    supervisor = {Ciatto, Giovanni and Calegari, Roberta},
    title = {Systematic Scientific Review on Trustworty-by-Design AI approaches},
    type = {Survey Project},
    year = 2023
}
@courseproject{2ppy-as2021,
    abstract = {2P-Kt is a multi-platform logic programming framework written in Kotlin, mainly targeting the Java Virtual Machine. The framework supports symbolic manipulation and reasoning in an extensible and flexible way. 2PPy is an experimental Python library that aims to port a portion of the 2P-Kt ecosystem to Python. The porting is enabled by JPype1, a Python module that provides full access to Java from within Python. This project consists of the design and implementation of the next iteration of the 2PPy project lifecycle. Indeed, the project currently lacks proper documentation and unit tests, while can be improved in CI/CD, java bundle in the deliverable and contributor friendliness. Each of these aspects will be addressed in this document.},
    apice = {2ppy},
    author = {Deluigi, Luca},
    howpublished = {Autonomous Systems, A.Y. 2020/2021},
    month = nov,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Updating the 2pKt library for Python},
    type = {Standard Project},
    url = {https://github.com/ldeluigi/2ppy},
    year = 2023
}
@courseproject{realtimecollaborativewhiteboard-sd2223,
    abstract = {Il progetto da noi presentato consiste in una lavagna collaborativa real-time dove pi\`{u} utenti possono disegnare e vedere le modifiche apportate dagli altri in tempo reale. Vi \`{e} un interfaccia web dove gli utenti, tramite sistema di autenticazione, possono accedere e creare, modificare, eliminare e condividere la propria lavagna virtuale. L’architettura \`{e} di tipo client-server, ogni client sfrutta delle API esposte dal server per interagire con il sistema. L’interazione degli utenti con la lavagna \`{e} stata realizzata tramite tecnologie che sfruttano protocolli real-time (Socket.IO). Per ridurre la quantit\`{a} di dati che vengono inviati durante l’interazione real-time, sono state utilizzate tecniche di interpolazione in modo da mostrare l’interazione come pi\`{u} fluida possibile.},
    apice = {RealTimeCollaborativeWhiteboard},
    author = {Magnani, Francesco and Di Zio, Valerio and Capelli, Thomas},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = nov,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Real-Time Collaborative Whiteboard},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-magnani-dizio-capelli-ay2223},
    year = 2023
}
@courseproject{alchemistsimulationbatchesdistribution-sd2223,
    abstract = {{{alchemist/}} is an open-source and general-purpose simulator developed in the University of Bologna. Simulation can be executed by writing their configurations in YAML. Sometimes it may be useful to execute the same configuration with different parameters, called variables. The set of simulation differing by their variables constitute a batch. Alchemist provides a way to launch a simulation batch sequentially. The aim of this project is to implement in {{alchemist/}} a batch distribution mechanism in order to parallelize batch simulations computation and reduce the time spent in executing the batch.},
    apice = {AlchemistSimulationBatchesDistribution},
    author = {Olaiya, Kelvin Oluwada Milare Obuneme},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = oct,
    sort = {research},
    supervisor = {Magnini, Matteo},
    title = {Alchemist simulation batches distribution},
    type = {Research Project},
    url = {https://github.com/kelvin-olaiya/Alchemist},
    year = 2023
}
@courseproject{citytwin-sd2223,
    abstract = {Il progetto CityTwin si propone di realizzare la simulazione di un sistema di digital twin nel contesto della smart city. In particolare, si vuole realizzare un sistema che sia in grado di catturare e rappresentare in formato digitale il comportamento delle varie entit\`{a} presenti all’interno della citt\`{a}. Questo pu\`{o} portare ad una serie di benefici, alcuni dei quali vengono elencati di seguito: Rilevazione di possibili problematiche con intervento tempestivo e automatizzato. Riduzione del consumo energetico. Rilevazione della qualit\`{a} dell’aria e dell’acqua. Analisi dell’inquinamento acustico. Ottimizzazione della mobilit\`{a} urbana. La simulazione sar\`{a} composta da due tipologie di nodi: i nodi Mainstay, che rappresentano la struttura portante del sistema, e i nodi Resource, che rappresentano astrazioni di sensori, attuatori o entit\`{a} pi\`{u} complesse. I nodi Mainstay si occupano di scambiare informazioni con i nodi Resource, rilevare eventuali malfunzionamenti e salvare in modo persistente le informazioni rilevate dai nodi Resource. I nodi Mainstay devono essere sempre sincronizzati tra loro, in modo da poter garantire la coerenza dei dati. I nodi Resource, invece, si occupano di rilevare informazioni e comunicarle ai nodi Mainstay nel caso in cui vengano considerati come sensori. Nel caso in cui i nodi Resource rappresentino attuatori, invece, si occupano di ricevere informazioni dai nodi Mainstay e agire di conseguenza. Per la memorizzazione delle dello stato dei nodi viene disposto un servizio apposito di persistenza dei dati. Tale servizio viene utilizzato sia dai nodi Mainstay che da altri clienti, come ad esempio il pannello di controllo. L’utente potr\`{a} visualizzare lo stato attuale del sistema, lo storico dei dati ed eventuali statistiche, nonch\'{e} interagire con il sistema tramite GUI, ad esempio per intervenire dopo la rilevazione di un incendio.},
    apice = {CityTwin},
    author = {Vissani, Filippo and Barzi, Eddie},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = oct,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {CityTwin},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-vissani-barzi-ay2223},
    year = 2023
}
@courseproject{cleaningagentswithdeepqlearningaperfomancecomparisonbetwenmlpandrnnnetworks-ise2223,
    abstract = {In this report, I investigate the application of Deep Reinforcement Learning (DRL) techniques, tailored for Multilayer Perceptron (MLP) and Long ShortTerm Memory Recurrent Neural Networks (LSTM RNN), within VMAS (Vectorized Multi-Agent Simulator). My study introduces the "Cleaning Agents" scenario, where N agents are tasked with efficiently cleaning M stationary targets in a 2D space. The central goal of this project is to evaluate and compare the impact of DRL methods, specifically MLP and LSTM RNN, on agent coordination and decision-making within this scenario. To achieve this goal, I employ time-based performance metrics to assess the efficiency and effectiveness of these DRL variants. By quantifying the temporal aspects of agent behavior, I aim to provide practical insights into the application of DRL in multi-agent systems. This comparative analysis offers valuable guidance for selecting the most suitable DRL architecture for similar multi-agent tasks.},
    apice = {CleaningAgentswithDeepQLearningAperfomancecomparisonbetwenMLPandRNNnetworks},
    author = {Cavallari, Filippo},
    howpublished = {Intelligent Systems Engineering, A.Y. 2022/2023},
    keywords = {MARL  •  DeepQLearning},
    month = oct,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Cleaning Agents with DeepQLearning -- A perfomance comparison betwen MLP and RNN networks},
    type = {Standard Project},
    url = {https://github.com/Filocava99/VMAS-DQL-playground},
    year = 2023
}
@courseproject{cluedo-sd2021,
    abstract = {Il progetto consiste nella realizzazione di una versione distribuita del noto gioco da tavolo Cluedo. In questa versione del gioco, gli utenti possono creare o partecipare a partite create da altri giocatori. Inizialmente viene creata un “room” di attesa, in cui gli utenti attendono l’arrivo di altri utenti. Appena raggiunto il numero minimo di giocatori ossia 3, la partita pu\`{o} essere avviata da qualsiasi giocatore nel gioco. La partita pu\`{o} avere al massimo 6 giocatori. Durante il proprio turno, un giocatore potr\`{a}: tirare un dado per potersi muove nella casa. Le facce del dado raffigurano le stanze della casa + uno o pi\`{u} ingressi; formulare un’ipotesi nel caso sia in una stanza; formulare un’accusa. Nel caso di un’ipotesi gli altri giocatori devono allora confutarla (se possibile), mostrando al massimo una carta che contenga uno degli elementi nominati dal giocatore di turno; tale azione dimostra che la carta sicuramente non pu\`{o} essere all’interno della busta contenente la soluzione dell’assassinio. Nel caso di un’accusa, il giocatore di turno, se l’accusa non \`{e} corretta, esce dal gioco; altrimenti se “pronuncia” un’accusa esatta, le carte della soluzione sono rivelate agli altri giocatori e la partita finisce. I giocatori che hanno effettuato accuse sbagliate devono continuare a esibire le carte agli altri partecipanti per il resto della partita, oppure possono redistribuire le proprie carte e abbandonare il gioco.},
    apice = {Cluedo},
    author = {Pasquali, Marica},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = sep,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Cluedo Online},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-pasquali-ay2021},
    year = 2023
}
@courseproject{jokinghazardonline-sd2223,
    abstract = {Il progetto \`{e} concepito con l’obiettivo di sviluppare una versione multiplayer online del noto gioco da tavolo Joking-Hazard. In ogni round, un giocatore designato come giudice seleziona una carta dal mazzo e la pone in vista di tutti. Ogni carta raffigura una vignetta di un fumetto, e ogni giocatore, attingendo dalle 7 carte in suo possesso, sceglie quella che ritiene possa completare la striscia fumettistica nel modo pi\`{u} divertente. Le scelte dei giocatori vengono raccolte coperte, mescolate e presentate al giudice, il quale, senza sapere chi ha presentato quale carta, sceglie quella che ritiene sia la conclusione migliore per la striscia fumettistica. Il giocatore la cui carta viene scelta guadagna punti. Nei round successivi, il ruolo del giudice passa al giocatore successivo in senso orario. Il vincitore \`{e} il primo a raggiungere il punteggio massimo stabilito dai partecipanti. Un elemento cruciale di questo progetto \`{e} l’interazione tra il front-end e il back-end. Grazie alla comunicazione con il server, l’interfaccia di ogni utente viene aggiornata in tempo reale con ogni modifica. La chat costituisce il canale di comunicazione tra i giocatori, in cui vengono pubblicate dagli utenti informazioni quali il vincitore del round, possibili spiegazioni relative alle decisioni prese, qual’\`{e} il punteggio massimo e molto altro.},
    apice = {JokingHazardOnline},
    author = {Sanità, Riccardo},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = sep,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Joking Hazard Online},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-sanita-ay2223},
    year = 2023
}
@courseproject{smartpionedgezhang2023-seids2223,
    abstract = {This project aims to explore the implementation of software engineering concepts, particularly focusing on autonomy and agents, in the context of the Internet of Things. Autonomy and agents in the project refer to the integration of intelligent software components into our everyday surroundings. By combining ESP8266 with sensors, Raspberry Pi as an edge device with multiple modules, and Azure Cloud services, this project creates a scalable IoT system with autonomous edge modules.},
    apice = {SmartpionedgeZhang2023},
    author = {Zhang, Boyang},
    howpublished = {Software Engineering for Intelligent Distributed Systems, A.Y. 2022/2023},
    month = sep,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Smart-Pi-on-Edge},
    type = {Standard Project},
    url = {https://github.com/Bobo-bug-lab/smart-pi-on-edge/},
    year = 2023
}
@courseproject{algobiaseconomictrivelloni2023-sedtm2223,
    abstract = {Algorithmic bias in economic decision making has become a topic of growing concern as artificial intelligence and machine learning algorithms play an increasingly prominent role in various domains, including resource allocation, lending, and hiring. This paper aims to explore the multifaceted dimensions of algorithmic bias in these areas and its potential consequences for individuals and society. First, the paper submerges into the concept of algorithmic bias, examining how biases can emerge within algorithms due to factors such as biased training data, flawed algorithms, or systemic inequalities. It discusses the ethical and social implications of algorithmic bias, highlighting the potential reinforcement of existing inequalities and the erosion of fairness and equal opportunity. Next, the paper focuses on the specific domains of resource allocation, lending, and hiring, depicting how algorithmic decision-making systems have been employed in these areas. It explores the ways in which algorithmic bias can influence resource allocation decisions, potentially perpetuating disparities in access to critical resources. The paper also examines how biased algorithms in lending can disproportionately impact marginalised communities, exacerbating financial inequality and reinforcing historical patterns of discrimination. Additionally, it explores the role of algorithms in hiring processes, highlighting concerns related to unfairness, lack of diversity, and the potential for perpetuating biased practices. To better understand and address algorithmic bias, the paper presents a range of methodologies and strategies that have been proposed to mitigate bias in economic decision making. These include approaches such as algorithmic auditing, transparency and accountability measures, diverse and representative training data, and regular evaluation of algorithms for bias. The paper also discusses the challenges and limitations associated with these mitigation strategies. Overall, this paper seeks to contribute to the existing body of knowledge on algorithmic bias in economic decision making and stimulate further discussions on creating a more inclusive and just AI-powered economy.},
    apice = {AlgobiaseconomicTrivelloni2023},
    author = {Trivelloni, Santiago},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = sep,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Algorithmic bias in economic decision making (resource allocation, lending, hiring)},
    type = {Standard Project},
    year = 2023
}
@courseproject{raincontrol-sd2122,
    abstract = {DSmart Flood Monitoring System \`{e} un’applicazione distribuita che permette di monitorare i possibili allagamenti in una citt\`{a}. In particolare, si tratta di un applicativo pensato in un contesto di smart city, che si interfaccia con una serie di sensori che controllano il quantitativo di pioggia caduta nel tempo. Lo scopo di questa applicazione \`{e} di semplificare il monitoraggio e le azioni di intervento da parte dei pompieri, permettendo loro sia di controllare lo stato dei pluviometri sia di intervenire in caso di allarmi di allagamenti},
    apice = {RainControl},
    author = {Esposito, Bruno and Ingargiola, Andrea and Teodorani, Cecilia},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = sep,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {DSmart Flood Monitoring System},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-esposito-ingargiola-teodorani-ay2122},
    year = 2023
}
@courseproject{corinahypercore-sd1920,
    abstract = {Il progetto ha lo scopo di studiare ed approfondire, attraverso documentazione disponibile su Internet e paper scientifici, le caratteristiche che distinguono Hypercore Protocol. Inoltre, si prevede di fare una breve introduzione sulla storia delle reti p2p, in modo di evidenziare concetti tali da poter fare un confronto tra Hypercore Protocol e altre tecnologie simili.},
    apice = {CorinaHypercore},
    author = {Corina, Jacopo},
    howpublished = {Distributed Systems, A.Y. 2019/2020},
    month = sep,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Technology-Know-How: Hypercore Protocol},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-corina-aa1920},
    year = 2023
}
@courseproject{multitierprogrammingscalalocianalysis-sd2223,
    abstract = {The problems of distributed systems are well-known and have been studied for decades. The main challenges are related to the fact that distributed systems are inherently concurrent, asynchronous and that they are composed of multiple components that communicate over a network. Using a multitier architecture is advantageous for distributed systems, as it allows for separating the different components of the system and for having a clear separation of concerns. For example, a 3-tier (or 3-layer) application is organized into three major parts usually presentation, application processing, and data management residing in different network locations. By organizing a system into tiers, the functionality that is encapsulated into one of the tiers can be modified independently, instead of redesigning the entire application. However, writing multitier applications is still a challenging task as it usually requires to use different programming languages for different tiers, to make the tiers communicate with each other, and it usually makes the programmer consider one tier at a time, instead of the system as a whole. Multitier languages’ purpose is to simplify the development of distributed applications by bringing the development of code closer to programming single-host applications. The project’s purpose is to analyze and illustrate how multitier languages (ScalaLoci1 in particular) work and how they can be used to solve some of the aforementioned problems. Examples of distributed systems written in ScalaLoci will be provided and analyzed. A comparison with the same systems written in a “standard” programming language will be provided to highlight the advantages of using ScalaLoci.},
    apice = {MultitierProgrammingScalaLociAnalysis},
    author = {Vitali, Linda},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = sep,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Multitier Programming and ScalaLoci Analysis},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-vitali-ay2223},
    year = 2023
}
@courseproject{ethicalaialibekiliyaskuanyshdtm2023-sedtm2223,
    abstract = {This paper aims to investigate and analyze the ethical implications of artificial intelligence (AI) technologies in the context of education and academic environment. With the increasing integration of AI in educational systems and institutions, it is important to examine the ethical considerations associated with its implementation. This paper will explore key ethical issues such as privacy, bias, transparency, accountability By addressing these concerns, we can use responsible and ethical practices in the application of AI technologies in education, making sure that they align with the values and goals of education systems. Through an interdisciplinary approach, taking on insights from education, ethics, and computer science, this paper provides a comprehensive overview of the ethical considerations surrounding AI in education and offers recommendations for educators, developers and students to navigate this new and complex landscape. Through this research, we aim to contribute to the ongoing discourse on the ethical dimensions of AI in education and provide practical guidance for stakeholders to navigate the complex intersection of AI and ethics in the academic environment.},
    apice = {EthicalaiAlibekIliyasKuanyshDtm2023},
    author = {Marat, Alibek and Ysmaiyl, Iliyas and Otan, Kuanysh},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = aug,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Ethical considerations in AI: Exploring the ethical implications of AI technologies in education and the academic environment},
    type = {Standard Project},
    year = 2023
}
@courseproject{softwaregestionaleautoscuola-sd2122,
    abstract = {L’obiettivo di questo progetto \`{e} creare un nuovo software, utile per le Scuole Guida e tutti gli aspetti di questo settore. Si vuole andare a supportare il dominio, partendo dalle informazioni degli iscritti, supportando il concetto di Dossier. Un ulteriore aspetto sono le guide pratiche, anch’esse presenti e supportate insieme alle visite mediche necessarie al conseguimento degli esami. Infine, si procede con il completo supporto degli esami pratici e teorici. Su questo aspetto risiede la maggiore complessit\`{a}, causa numerose limitazioni e constraints in merito al numero di guide, periodo di validit\`{a} o tentativi effettuabili. Il progetto si basa sulla creazione di un sistema distribuito che implementa l’architettura dei Microservizi: favorendo riutilizzo, espansione e separazione dei concetti supportati dai vari servizi. Si \`{e} inoltre deciso di seguire i principi DevOps, come la Build Automation e la Continuous Integration.},
    apice = {SoftwareGestionaleAutoscuola},
    author = {Grushchak, Denys and Bacca, Riccardo},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = aug,
    sort = {application},
    supervisor = {Ciatto, Giovanni},
    title = {Driving School Distributed Management Software},
    type = {Application Project},
    url = {https://denguzawr22.github.io/DSDMS-DS-Report/},
    year = 2023
}
@courseproject{aiconsultingmarchinibouikilaachieng2023-sedtm2223,
    apice = {AiConsultingMarchiniBouikilaAchieng2023},
    author = {Marchini, Giulia and Bouikila, Barnia and Achieng Ombaka, Lynette Patricia},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = aug,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Artificial Intelligence in Consulting: A Deep Dive into the Impact, Advantages, and Cybersecurity Challenges at Deloitte and E&Y},
    type = {Survey Project},
    year = 2023
}
@courseproject{drisavoiceassistantkayakemalyilmaz2023-sedtm2223,
    abstract = {In today's fast-paced world, technology has become an indispensable part of our lives, revolutionizing the way we work, communicate, and travel. With the increasing number of drivers relying on mobile devices for navigation and entertainment, there is a growing need for a smarter and more intuitive driving companion. This software project aims to address this need by developing a mobile app with an integrated AI voice assistant specifically designed for drivers. The primary goal of this project is to enhance the driving experience by providing a comprehensive and user-friendly solution that combines the power of artificial intelligence, mapping services, and entertainment platforms. The AI voice assistant will act as a reliable co-pilot, offering a range of functionalities and services to assist drivers during their journeys. By integrating popular services such as Google Maps, Spotify, Waze, and ChatGPT the mobile app will offer seamless navigation, personalized music streaming, real-time traffic updates, and access to relevant information about the driver's current location. Moreover, it will go beyond the basic functionalities by providing insights into nearby restaurants, public facilities, and cultural or historical points of interest, making each trip an enriching and enjoyable experience. The significance of this project lies in its ability to streamline and simplify the driving experience, allowing drivers to focus on the road while effortlessly accessing the information they need. Whether it's finding the nearest gas station, learning about the historical landmarks along the route, or enjoying their favorite music, drivers can accomplish all these tasks through voice commands, minimizing distractions and promoting safer driving practices. In addition to everything mentioned, it can help the users for decision making. Bayesian reasoning can help us model and update probabilities based on new evidence, allowing us to make informed decisions about driver safety measures. For example, if the system receives conflicting information about a road condition. Throughout this document, we will delve into the various aspects of this software project, including the design considerations, integration of the AI voice assistant, functionalities and features, technical implementation, testing strategies, and deployment plans. By creating a mobile app that combines intelligent voice interactions with essential services, we aim to redefine the way drivers navigate, discover, and enjoy their journeys.},
    apice = {DrisavoiceassistantKayaKemalYilmaz2023},
    author = {Mustafa Kemal Kaya and Ezginur Cendik and Ekin Yilmaz},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = aug,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {DRISA: AI Voice Assistant},
    type = {Standard Project},
    year = 2023
}
@courseproject{dodgedronekiadecaminati2023-sa1920,
    abstract = {Il progetto prosegue lo sviluppo dell’artefatto presentato dal Team Bravo durante la partecipazione alla challenge DodgeDrone tenutasi all’interno della conferenza ICRA-2022.},
    apice = {DodgedroneKiadecaminati2023},
    author = {Kiade, Sara and Caminati, Gyordan},
    howpublished = {Autonomous Systems, A.Y. 2019/2020},
    month = aug,
    sort = {research},
    supervisor = {Giovanni Pau},
    title = {Dodge Drone},
    type = {Research Project},
    url = {https://github.com/camillo2008/gym-pybullet-drones},
    year = 2023
}
@courseproject{visionprosentimentanalysis2023-sedtm2223,
    abstract = {This research paper explores the perception of the future of virtual and augmented reality through predictive sentiment analysis, focusing on Apple’s Vision Pro technology. The aim of conducting this research is to obtain a general idea of whether the public perceives this technology as a potential mass consumer product in the years to come. Through sentiment analysis on technical forums regarding both Apple and competitor’s AR products, conclusions are drawn which will provide opportunities to investigate various viewpoints on the subject at hand. To this purpose, the Python programming language was used to perform sentiment analysis on the various data collected, while business intelligence tools aided in visualizing the outputs. This analysis does not seek to accurately predict the technology’s future success, rather it aims to gauge people’s expectations regarding how this technological advancement might impact their daily lives, comparing it to existing innovations from the past. By focusing on these insights, the research aims to shed light on the potential adoption and implications of Apple’s Vision Pro and other AR technologies in the coming years.},
    apice = {VisionproSentimentanalysis2023},
    author = {Dias Bahmed, Bruna Moema and Mendoza, Mikayla Alessandra and Rattini, Cecilia Mina},
    howpublished = {Software Engineering, A.Y. 2022/2023},
    month = jul,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {The perception on the future of Virtual and Augmented Reality: A predictive sentiment analysis on Apple’s Vision Pro technology},
    type = {Survey Project},
    year = 2023
}
@courseproject{digitalpheromonesmas-smalm1213,
    abstract = {Discussing and possibly implementing stigmergic coordination via digital pheromones on an existing distributed middleware for MASs},
    apice = {DigitalPheromonesMAS},
    author = {Montesi, Stefano},
    howpublished = {Multi-Agent Systems (2nd Cycle), A.Y. 2012/2013},
    month = jul,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Digital Pheromones in Multiagent Systems},
    type = {Standard Project},
    year = 2023
}
@courseproject{bdiplayersrealtime-smalm1112,
    abstract = {The aim of the project is to work on an already existing RTS game and exploit agents to develop the artificial intelligence of the units. The chosen target is 0ad : an open source game already in its final stages of development that uses high end graphics and refined mechanics to deliver a simulation of historical warfare and economics. The first step of the project was to understand how the game's AI was accessed and developed: at the very core of 0ad there is a powerful open source game engine, called "Pyrogenesis", that manages various aspects of the game, including graphics, menus and player interaction; all of the game logic, including the AI, is instead developed using javascript and xml, then interpreted at runtime by the engine using Mozilla's SpiderMonkey. The project then consisted in the design and development of a multi-agent system platform, to support the control of the game's entities using BDI agents logic. Since the platform had to be in javascript, to be integrated into the game, it was developed from the ground up albeit it followed loosely Jason's reasoning cycle and AgentSpeak's language constructs. The last part was to develop some basic behaviours for the agents controlling units and buildings, to test the validity of the created platform and of MAS in the current contest. [[image:http://lh4.ggpht.com/_1QSDkzYY2vc/TErgNxDC0iI/AAAAAAAABkA/LnnNThy6k_U/0%20a.d.jpeg]]},
    apice = {BDIPlayersRealtime},
    author = {Gabriele Dallatana},
    howpublished = {Multi-Agent Systems LM, A.Y. 2011/2012},
    month = jul,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {BDI Agents as Players in Real-time Strategy Games},
    type = {Standard Project},
    year = 2023
}
@courseproject{slrautoml-mas2122,
    abstract = {Machine Learning has become very popular these years and has deeply changed our daily lives. However, most of the Machine Leaning tasks need heavy work from human experts to achieve good results. Therefore, an end-to-end Machine Learning technique without the assistance of humans, i.e., AutoML, will make it much easier to apply Machien Learning in different areas. In this report, a survey on AutoML will be carried out, focusing on the theoretical background, the main approaches and techniques used in AutoML.},
    apice = {SlrAutoML},
    author = {Zhang, Hanying},
    howpublished = {Multi-Agent Systems, A.Y. 2021/2022},
    month = jul,
    sort = {survey},
    supervisor = {Calegari, Roberta},
    title = {Systematic Literature Review on the state of the art of Auto ML},
    type = {Survey Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-hanying-ay2122},
    year = 2023
}
@courseproject{mapfmas-mas2122,
    abstract = {The integration of autonomous driving technology has brought about a new level of convenience in how we move and park vehicles. However, as the number of self-driving cars increases, the task of parking multiple vehicles simultaneously becomes a more intricate challenge. This project aims to tackle this challenge by developing a solution for the multi-agent path planning problem in automatic vehicle parking. The objective is to create a system that allows multiple autonomous vehicles to find the optimal path from their starting location to their designated parking spot while avoiding collisions with each other. To achieve this, the project proposes a combination of A* algorithm and Conflict-Based Search (CBS) techniques to ensure efficient path planning and safe navigation.},
    apice = {MapfMas},
    author = {Li, Jialing and Zhang, Molin},
    howpublished = {Multi-Agent Systems, A.Y. 2021/2022},
    month = jul,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Path Planning for Automatic Vehicle Parking Problem Based on MAPF},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-jialingmolin-ay2122},
    year = 2023
}
@courseproject{actord-sd2122,
    abstract = {The library Actor-D aims to be a basic actor framework based on message passing for the D programming language, as there are no other up to date packages with the same purpose. The project will focus on providing a simple actor abstraction capable of performing the actions of send (to both local and remote actors, with the focus mainly on the latter), receive, create and become, while also decoupling actors from threads and optimizing the required resources.},
    apice = {ActorD},
    author = {Speranza, Alex},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = jul,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Actor-D: an Actor framework for D},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-speranza-ay2122},
    year = 2023
}
@courseproject{rediquadri-sd2223,
    abstract = {Il progetto prevede la progettazione e l’implementazione del seguente gioco, che prende il nome di Re di Quadri, tratto dalla serie tv ”Alice in Border- land”, in versione online. Ogni giocatore inizia la partita con 5 vite, ad ogni round deve scegliere un numero da 1 a 100, viene calcolata la media dei numeri inseriti da tutti i giocatori e moltiplicata per 0.8, chi si avvicina di piu` al numero calcolato vince e gli altri perdono una vita. Quando un giocatore ha finito le sue vite ha perso e viene eliminato. Ad ogni eliminazione viene aggiunta una nuova regola e l’ultimo giocatore che rimane in vita ha vinto.},
    apice = {ReDiQuadri},
    author = {Lelli, Pietro},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jul,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Re di Quadri},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-lelli-ay2223},
    year = 2023
}
@courseproject{scarabeo-sd2223,
    abstract = {Il progetto prevede lo sviluppo di una versione online del noto gioco da tavolo “Scarabeo”. In questo gioco, da 2 a 4 utenti competono per la vittoria finale, componendo parole sulla scacchiera, utilizzando ciascuno le pedine in proprio possesso. Ad ogni parola formata corrisponde un punteggio ed a fine partita, il giocatore che ha totalizzato pi\`{u} punti \`{e} il vincitore. La soluzione proposta deve possedere tutte le propriet\`{a} che ci si aspetta di trovare in un qualsiasi sistema di questo tipo, soprattutto scalabilit\`{a} e consistenza.},
    apice = {Scarabeo},
    author = {Malucelli, Nicolò},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jul,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Scarabeo},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-malucelli-ay2223},
    year = 2023
}
@courseproject{lpaas2pktgrpc-sd2021,
    abstract = {Il Logic Programming \`{e} un paradigma di programmazione altamente basato sulla logica formale. Un programma di questo tipo \`{e} composto da un insieme di fatti e regole che rappresentano implicazioni logiche del dominio di un problema. Nel caso particolare di Prolog \`{e} stato creato 2p-kt[, un ecosistema Kotlin-based costituito da vari moduli interdipendenti volto all’integrazione multipiattaforma della Symbolic Artificial Intelligence e che punta a arricchire il paradigma logico, ad esempio con meccanismi di concorrenza e gestione di stream di dati. Il progetto consister\`{a} nell’estendere questo framework, sviluppando un Server Web che esponga le funzionalit\`{a} per osservare ed usare un qualsiasi Solver Logico da remoto.},
    apice = {LPaaS2pKtGrpc},
    author = {Osimani, Lorenzo},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = jun,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Web Server per l’utilizzo di Solver di Logic Programming},
    type = {Technology Project},
    url = {https://github.com/pikalab-unibo-students/ds-project-osimani-ay2021},
    year = 2023
}
@courseproject{2pktwebide-ise2122,
    abstract = {{{tuprolog/}} is a language and environment designed for logic programming, enabling knowledge representation, reasoning, and rule-based programming for artificial intelligence applications. These are essential components of numerous AI applications. The objective of this project is to develop a web-based IDE for the {{tuprolog/}} platform. This IDE will offer users a user-friendly web environment for conducting {{tuprolog/}} experiments conveniently. The project builds upon an existing implementation of tuProlog in Kotlin, leveraging Kotlin-based web native technologies for research and development purposes.},
    apice = {2pktWebIde},
    author = {Donati, Alberto and Muratori, Fabio},
    howpublished = {Intelligent Systems Engineering, A.Y. 2021/2022},
    month = jun,
    sort = {advanced},
    supervisor = {Ciatto, Giovanni},
    title = {tuProlog Web IDE},
    type = {Advanced Project},
    url = {https://github.com/fmuratori/2p-kt/tree/feature/web-gui},
    year = 2023
}
@courseproject{werewolfmas-mas2122,
    abstract = {The goal of this project is to develop a Multi Agent implementation of the famous game called Werewolf. This game is based on the rivalry between two factions of agents (i.e. farmers and wolves) who challenge each other during the development of each game in order to eliminate as many agents as possible from the opposing faction. This game contains multiple components common to multi-agent systems: there is an advanced communication mechanism associated with each faction, which also contains different privacy policies for each of these. Furthermore, each agent is independent and simultaneously implements both the principle of cooperation with respect to the agents of his faction and the principle of competition with respect to the agents of the opposing faction. In addition to this, we have also implemented several elements of this game in the form of ”artifacts”, mainly represented by the ”perks” available to each agent. Finally, each agent has been provided with an ”intelligence” mechanism through the structuring of a Bayesian network capable of representing the probabilities associated with each game event throughout its continuation. The results presented were obtained from the simulation of multiple games based, in turn, on multiple different configurations relating both to the game and to the strategies associated with each agent. The results themselves highlighted the correctness of the completed implementation, highlighted the differences with respect to the possible game policies associated with each agent and, at the same time, brought to light the effects of the artifacts with respect to the game strategy of each agent.},
    apice = {WerewolfMas},
    author = {Conti, Matteo and Sangiorgi, Davide},
    howpublished = {Multi-Agent Systems, A.Y. 2021/2022},
    month = jun,
    sort = {advanced},
    supervisor = {Calegari, Roberta},
    title = {Multi Agent Implementation Of The Werewolf Game},
    type = {Advanced Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-conti-sangiorgi-ay2122},
    year = 2023
}
@courseproject{mastermindonline-sd2223,
    abstract = {Il progetto consiste nella realizzazione di una versione online del gioco da tavolo Mastermind1. Ogni partita sar\`{a} formata da 2 giocatori, un codificatore e un decodificatore. Il codificatore sceglier\`{a} un codice segreto composto da 4 cifre decimali, che il decodificatore dovr\`{a} indovinare. Per ogni tentativo verranno forniti degli indizi sulla correttezza del codice. Il decodificatore avr\`{a} 9 tentativi per riuscire a indovinare il codice e quindi vincere, se non ci riuscir\`{a} avr\`{a} vinto il codificatore.},
    apice = {MastermindOnline},
    author = {Negri, Andrea},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jun,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Mastermind Online},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-negri-ay2223},
    year = 2023
}
@courseproject{cardsagainstumanity-sd2122,
    abstract = {Si vuole sviluppare una versione digitale e distribuita del gioco “Cards Against Humanity”. L’obiettivo del gioco \`{e} quello di creare delle frasi bizzarre e strampalate. Ciascun utente, tramite un applicativo web, potr\`{a} creare o partecipare ad una stanza di gioco nella quale giocare con altri utenti. L’utente creatore della stanza potr\`{a} avviare il gioco appena il numero di partecipanti presenti in essa sar\`{a} maggiore o uguale a 3. Il gioco si compone di due mazzi di carte, uno nero e uno bianco. Ogni carta contiene delle frasi o parole, in particolare quelle nere presentano delle frasi incomplete o con delle parole mancanti. All’inizio della partita, un giocatore casuale verr\`{a} selezionato per essere lo “Czar” delle carte. Ciascun giocatore ricever\`{a} 10 carte bianche mentre lo Czar ricever\`{a} una carta nera. Da adesso in poi il gioco si svolger\`{a} a turni. Ad ogni turno, lo Czar riveler\`{a} la sua carta nera agli altri giocatori e ognuno di essi presenter\`{a} in risposta una carta bianca cercando di completare la frase nel modo pi\`{u} esilarante e inappropriato possibile. Lo Czar ora visualizzer\`{a} tutte le risposte e selezioner\`{a} quella migliore per lui. A questo punto il vincitore diventer\`{a} il nuovo Czar e guadagner\`{a} un punto. Ora gli altri giocatori pescheranno tante carte bianche quante ne mancano per arrivare a 10 e il nuovo Czar perder\`{a} le sue carte bianche e pescher\`{a} una nuova carta nera per iniziare il nuovo turno ed inizier\`{a} il nuovo turno. Alla fine della partita vince il giocatore che ha pi\`{u} punti. Il punteggio massimo a cui arrivare \`{e} 10.},
    apice = {CardsAgainstUmanity},
    author = {Dall'Ara, Emanuele and Ricci, Nicholas},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = jun,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Cards Against Umanity Clone},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-dallara-ricci-ay2122},
    year = 2023
}
@courseproject{connect4online-sd2223,
    abstract = {Il progetto consiste nello sviluppo del gioco Connect 4, in versione multi-player online. Le partite saranno esclusivamente composte da due giocatori, in modalit\`{a} 1vs1. Il campo da gioco consiste in una griglia 6X7, nella quale gli utenti dovranno posizionare le proprie pedine. I giocatori, a turno, dovranno scegliere la colonna nella quale posizionare la pedina e questa verr\`{a} collocata nella prima cella disponibile a partire dal basso. Vince la partita l’utente che riuscir\`{a} a collegare quattro pedine dello stesso colore di seguito e questo potr\`{a} essere fatto in tre diversi modi: orizzontalmente, verticalmente e diagonalmente.},
    apice = {Connect4Online},
    author = {Marcolini, Martin},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jun,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Connect4 Online},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-marcolini-ay2223},
    year = 2023
}
@courseproject{nginx-sd1920,
    abstract = {Il progetto nasce con l’obbiettivo di utilizzare Nginx come un reverse proxy, con la capacit\`{a} di inoltrare le richieste attraverso diverse tipologie di protocolli. In particolare, verr\`{a} considerata la necessit\`{a} di configurare il proxy Nginx per convertire la richiesta adattandola ai vincoli dei servizi invocati. Per la realizzazione dell’elaborato, nello specifico, si proceder\`{a} come segue: studio di Nginx incentrato sull’architettura, i concetti chiave e le possibili configurazioni realizzazione della parte applicativa: il proxy, a fronte della ricezione di una chiamata, inoltra quest’ultima al servizio di destinazione criptando il traffico dove necessario, utilizzando i certificati richiesti dal servizio stesso.},
    apice = {Nginx},
    author = {Morelli, Elena},
    howpublished = {Distributed Systems, A.Y. 2019/2020},
    month = may,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Technology Know-How: NGINX},
    type = {Technology Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-morelli-ay1920},
    year = 2023
}
@courseproject{opentelemetry-sd1819,
    abstract = {Questo progetto ha lo scopo di analizzare e testare la struttura e le principa- li feature fornite dall’infrastruttura OpenTelemetry (https://opentelemetry.io). OpenTelemetry \`{e} uno standard aperto per i dati di telemetria, definisce inoltre la tecnologia per raccogliere ed esportare i dati dalle applicazioni distribuite per poterli monitorare e analizzare.},
    apice = {OpenTelemetry},
    author = {Laddaga, Michele},
    howpublished = {Distributed Systems, A.Y. 2018/2019},
    month = may,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Una infrastruttura per la raccolta di dati di telemetria in ambienti distribuiti: OpenTelemetry},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-laddaga-1819},
    year = 2023
}
@courseproject{multiplayerminesweeper-sd2021,
    abstract = {Minesweeper, known in Italy as Campo minato, is a classic single-player puzzle game developed in the 1990s for the Windows 3.1 operating system. The game is set on a grid, where players have to uncover squares to reveal whether or not there is a hidden mine underneath. The player’s objective is to clear the entire board without detonating any mines. When the game begins, players are presented with a grid of squares, some of which contain hidden mines. The number of mines on the grid depends on the difficulty level chosen by the player. The objective is to uncover all the squares on the grid that do not contain mines. Each square that a player selects reveals a number that indicates how many mines are adjacent to that square. The player must use this information to determine the locations of the mines and avoid uncovering them. If a player uncovers a square with a mine, the game is over, and the player loses. However, if the player successfully uncovers all squares without detonating any mines, they win the game. Minesweeper quickly became a popular game, and was shipped with most versions of the Windows operating system. It has since been ported to various other platforms and remains a beloved classic among players. This project aims to develop a version of the game that enables multiple players to collaborate and play in the same match.},
    apice = {MultiplayerMinesweeper},
    author = {Muratori, Fabio},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = may,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Multiplayer Minesweeper},
    type = {Game Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-muratori-ay2021},
    year = 2023
}
@courseproject{housekeeping-sd2122,
    abstract = {Per il progetto di Sistemi Distribuiti, si \`{e} pensato di realizzare un’applicazione che consenta di gestire e pianificare diverse attivit\`{a} domestiche fra diversi utenti, in un contesto di convivenza. L’applicazione potr\`{a} essere utilizzata sia tramite un’app Android che mediante una Web App. Un utente per poter iniziare ad utilizzare l’applicazione deve per prima cosa registrarsi, dopodich\'{e} avr\`{a} la possibilit\`{a} di: creare un nuovo spazio rappresentante la casa in cui convive con gli altri utenti, oppure unirsi a uno spazio esistente. All’interno di uno spazio vi possono essere due tipi di utente: amministratore e membro; gli utenti amministratori si occupano di gestire lo spazio, pianificando i turni e le relative faccende da svolgere e di gestire gli utenti, potendo aggiungere nuovi partecipanti allo spazio, rimuoverli o nominare dei membri amministratori. Un utente appartenente a uno spazio, avr\`{a} la possibilit\`{a} di visionare per le diverse faccende, i diversi turni che sono stati assegnati e di poter inviare e ricevere notifiche dagli altri membri, per indicare il completamento di un turno. Inoltre, un utente ricever\`{a} una notifica quando sar\`{a} il suo momento di svolgere una determinata faccenda e in caso di ritardo nello svolgimento di un determinato compito, gli utenti dello spazio potranno inviare notifiche per ricordare all’utente “pigro” che \`{e} il suo momento di svolgere il turno.},
    apice = {HouseKeeping},
    author = {Laghi, Aurora and Vitali, Anna and Yan, Elena},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = may,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Setting Up Home},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-laghi-vitali-yan-ay2122},
    year = 2023
}
@courseproject{middlewareforturnbasedgames-sd2122,
    abstract = {Il progetto si pone come obiettivo lo sviluppo di una versione mobile multi-giocatore del celebre gioco di carte ”Beccacino”. Le regole del gioco sono consultabili su WIkipedia. ”Beccaccino” \`{e} un famoso gioco romagnolo, che \`{e} stato protagonista in diversi progetti accademici passati. Per questo motivo, e per altri quali la semplice logica di gioco e la non-necessaria importanza grafica, abbiamo deciso di procedere alla realizzazione di una versione distribuita fruibile tramite dispositivo Android mobile che ci permettesse di focalizzarsi maggiormente su altri aspetti core dei Sistemi Distribuiti. Nella versione da noi realizzata, un giocatore potr\`{a} accedere ad una partita gi\`{a} esistente o crearne una nuova. Ogni nuova partita avr\`{a} un codice che dovr\`{a} essere inserito manualmente dai giocatori tramite l’apposita interfaccia. Una volta raggiunto il numero massimo di giocatori (4), la partita potr\`{a} cominciare. Terminate le mani, verr\`{a} decretato il vincitore.},
    apice = {MiddlewareForTurnBasedGames},
    author = {Alpi, Davide and Parrinello, Angelo and Penazzi, Paolo},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = may,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Gioco Multigiocatore a turni: Beccaccino},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-alpi-parrinello-penazzi-ay2122},
    year = 2023
}
@courseproject{metajade-sd2122,
    abstract = {Il progetto ha lo scopo di realizzare il design e l’implementazione di un DSL per la programmazione di agenti, denominato MetaJade. Si tratta un linguaggio per la programmazione di agenti basato sulla piattaforma Jade, funzionale, staticamente tipizzato e con una sintassi ispirata allo pseudoco- dice. Catturando le principali astrazioni emerse dall’uso delle piattaforme ad agenti ed equipaggiandole con un linguaggio dedicato, si propone l’obiettivo di ridurre la complessit\`{a} inerente alla programmazione di sistemi multi-agente. Come modello di riferimento per il suo sviluppo \`{e} stato impiegato Jadescript, un DSL realizzato con Xtext avente obiettivi simili. Lo strumento impiegato per la modellazione e l’ implementazione del linguaggio \`{e} il language workbench MPS. Il suo utilizzo ha permesso di realizzare un linguaggio facilmente estendibile e integrabile con MPS stesso, senza la necessit\`{a} di definire una grammatica formale per il parsing. Come base per l’implementazione \`{e} stato impiegato il linguaggio funzionale KernelF, ideato per fornire un insieme di primitive comuni.},
    apice = {MetaJade},
    author = {Battistini, Riccardo},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = apr,
    sort = {advanced},
    supervisor = {Ciatto, Giovanni},
    title = {MetaJade -- A DSL for Jade},
    type = {Advanced Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-battistini-ay2122},
    year = 2023
}
@courseproject{apacheignite-sd1920,
    abstract = {Le aziende che vogliono perseguire iniziative di digital transformation spesso scoprono che la loro infrastruttura IT esistente non \`{e} in grado di supportare la velocit\`{a} e la scalabilit\`{a} richieste. Infatti, la necessit\`{a} di fornire un’esperienza utente finale pi\`{u} personalizzata e in tempo reale costringe le aziende a trasformare i propri processi impostati in modalit\`{a} batch, che possono richiedere ore oppure giorni, in processi automatizzati che operino in tempo reale. L’adozione di tecnologie web, mobile, social o IoT per supportare questa trasformazione porta spesso a un incremento di interrogazioni e di transazioni fino a 10-1000 volte. La sfida \`{e} pertanto quella di riuscire a sfruttare a proprio vantaggio questo incremento nel volume dei dati, in modo da supportare in maniera pi\`{u} puntuale i processi decisionali senza per\`{o} incorrere in tempi di elaborazione proibitivi. L’in-memory computing \`{e} stata la risposta di molte aziende. L’elaborazione in memoria offre infatti velocit\`{a} e scalabilit\`{a} per applicazioni nuove ed esistenti. La velocit\`{a} \`{e} resa possibile dal fatto che la memoria RAM viene utilizzata sia per l’archiviazione dei dati che per la loro elaborazione, evitando il piu` possibile di usare il disco il cui accesso \`{e} molto pi\`{u} lento. Dall’altra parte, la scalabilit\`{a} viene raggiunta andando a distribuire sia i dati che le elaborazioni su un cluster di server distribuiti. Tra le varie piattaforme che offrono questo tipo di caratteristiche e di prestazioni, Apache Ignite rappresenta un’ottima soluzione per i problemi sopracitati, trattandosi di una piattaforma open-source distribuita che sfrutta un cluster di pi\`{u} nodi a supporto dell’elaborazione, del caching e della persistenza dei dati, in modalit\`{a} in-memory. Le sue funzionalit\`{a} la rendono particolarmente adatta nell’ambito dell’High-Performance Computing, ed \`{e} usata da importanti aziende quali Microsoft, Netflix, Apple, Yahoo! e PayPal.},
    apice = {ApacheIgnite},
    author = {Meluzzi, Marco and Sutera, Lorenzo},
    howpublished = {Distributed Systems, A.Y. 2019/2020},
    month = apr,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Apache Ignite: analisi di una piattaforma distribuita di elaborazione in-memory},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-meluzzi-sutera-aa1920},
    year = 2023
}
@courseproject{myclinic-sd2223,
    abstract = {Lo scopo del sistema realizzato in questo progetto \`{e} gestire le visite mediche di una clinica privata, automatizzandone le operazioni di prenotazione e di refertazione. In particolare, l’applicazione si pone lo scopo di facilitare il lavoro sia dei medici della clinica che dei pazienti. Infatti, ogni medico potr\`{a} accedere alla sua area personale per registrare gli orari settimanali in cui sar\`{a} presente in studio e potr\`{a} eseguire delle visite. L’applicazione inoltre divider\`{a} i medici in reparti, in modo che un paziente, una volta effettuata la registrazione al sistema, potr\`{a} visualizzare il calendario degli orari disponibili per ricevere una visita nel suo reparto di interesse. Ovviamente il paziente potr\`{a} scegliere l’orario che pi\`{u} gli aggrada visualizzando anche il nominativo del medico che effettuer\`{a} la visita. Medico e paziente potranno gestire i dati della prenotazione fino al giorno dell’appuntamento ed inoltre il medico potr\`{a} aggiungere delle note per il paziente o caricare dei documenti (immagini o PDF utili ad esempio per inviare risultati o referti di eventuali analisi svolte durante la visita). Infine, se sar\`{a} il paziente a volere entrare in contatto con il medico, sar\`{a} messa a disposizione una chat privata tra i due utenti diversa per ogni appuntamento prenotato.},
    apice = {MyClinic},
    author = {Chiavaroli, Marco and Torroni, Michele},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = apr,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {MyClinic: WebApp per la gestione prenotazioni visite mediche},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-chiavaroli-torroni-ay2223},
    year = 2023
}
@courseproject{briscolaonline-sd2223,
    abstract = {Il progetto prevede la realizzazione di una versione online multiplayer del famoso gioco di carte Briscola. Le partite saranno esclusivamente composte da due giocatori, in modalit\`{a} 1vs1. Le carte utilizzate per giocare a Briscola sono 40, raggruppate in 4 gruppi definiti “semi” (coppe, denari, bastoni, spade). La tipologia di carte sar\`{a} quella Romagnola. I punti totali presenti nel mazzo sono 120; per decretare il vincitore \`{e} necessario raggiungere un minimo di 61 punti, mentre se i punti raggiunti sono 60, si verifica una situazione di parit\`{a}.},
    apice = {BriscolaOnline},
    author = {Zammarchi, Andrea},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = apr,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {BriscolaOnline},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-zammarchi-ay2223},
    year = 2023
}
@courseproject{blackjack-sd2223,
    abstract = {Il progetto consiste nello sviluppo di una versione semplificata del gioco d’azzardo Blackjack in versione online. Ogni tavolo di gioco \`{e} composto da almeno un giocatore fino ad un massimo di tre. Ogni partita inizia con la scelta della scommessa da puntare da parte degli utenti. Successivamente vengono assegnate due carte ad ogni giocatore e viene mostrata la prima carta del croupier. Ogni giocatore effettua il suo gioco, ha la possibilit\`{a} di chiedere altre carte oppure di stare. Quando tutti i giocatori hanno completato il loro gioco, vengono estratte e mostrate agli utenti le carte del banco. Quando il valore delle carte del banco \`{e} di almeno 17 punti, il banco termina l’estrazione delle carte e stabilisce i risultati della partita. Se il valore delle carte di un utente \`{e} superiore a 21, oppure se il valore delle carte del Croupier \`{e} superiore a quella dell’utente, viene sottratta la scommessa. Se il valore delle carte del banco \`{e} superiore a 21 oppure \`{e} minore al valore delle carte dell’utente viene vinta la scommessa. Se l’utente riceve il Blackjack (composto da un asso e una carta con valore 10) vince la partita e ha diritto al pagamento di 3 a 2 della scommessa. Se invece \`{e} il Croupier a effettuare il Blackjack tutti gli utenti in gioco perdono la scommessa.},
    apice = {Blackjack},
    author = {Di Girolamo, Alberto},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = apr,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Blackjack},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-digirolamo-ay2223},
    year = 2023
}
@courseproject{srlinductivelp-as2021,
    abstract = {Inductive Logic Programming or ILP is a research area that has emerged in last thirty years. The idea that gave the bases for ILP is merging machine learning and logic programming, in that way we can extract the best of both technologies and overcome many of the limitations of its forebears. ILP paradigm allows new methods for machine learning, and it allows to investigates the inductive construction of first-order clausal theories from a knowledge base and sets of positive and negative examples for a specific domain. That clausal will compose the logic program who can generalise positive example and it can exclude negative example. The document realised is a Systematic Literature Review (SLR). SLR is a revision type that uses analytical and repeatable methods to collect and analyse data. In detail in the document will be analysed the theoretical basis of ILP, and the main approaches and technologies will be presented, described and compared.},
    apice = {SrlInductivelp},
    author = {Cassano, Francesco},
    howpublished = {Autonomous Systems, A.Y. 2020/2021},
    keywords = {ILP, Inductive Logic Prorgamming, Machine Learning, Logic programming, First Order Logic, Systematic Literature Review},
    month = apr,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Systematic Literature Review on Inductive Logic Programming (ILP)},
    type = {Survey Project},
    year = 2023
}
@courseproject{pbft-sd2122,
    abstract = {Il progetto ha lo scopo di studiare l’algoritmo di consenso PBFT (Pratical Byzantine Fault Tolerance), un algoritmo introdotto nel 1999 che garantisce la Byzantine Fault Tolerance, ovvero la capacit\`{a} di un sistema distribuito di raggiungere il consenso nonostante alcuni suoi nodi siano irraggiungibili, impossibilitati a rispondere o tentino di propagare informazioni errate. I nodi del sistema sono organizzati in sequenza, senza l’ausilio di un cordinatore centrale, e co- municano tramite messaggi adottando un protocollo di comunicazione basato su 3 principali fasi: PREPREPARE, PREPARE e COMMIT. La correttezza di ogni fase del protocollo viene garantita mediante l’utilizzo di Quorum, rappresentati dai vari messaggi scambiati dalle repliche, grazie ai quali per ogni richiesta vengono rilasciati dei certificati che permettono l’avanzamento. Contestualmente allo studio dell’algoritmo verr\`{a} analizzato il meccanismo di Proactive Reco- very dello stesso PBFT, che consente alle repliche attive di innescare proattivamente e periodi- camente dei processi di riavvio al fine di scongiurare o risolvere eventuali failure e recuperare lo stato aggiornato del servizio. Verr\`{a} infine presentato un proof of concept, sviluppato in linguaggio Java ed eseguibile me- diante interfaccia a riga di comando, in grado di replicare il funzionamendo dell’algoritmo nei suoi aspetti di primaria importanza.},
    apice = {PBFT},
    author = {Perugini, Leonardo},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = mar,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Practical Byzantine Fault Tolerance},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-perugini-ay2122},
    year = 2023
}
@courseproject{hangmanonline-sd2223,
    abstract = {L’obbiettivo di questo progetto \`{e} la realizzazione di una versione multi-player online del gioco Hangman, meglio conosciuto come “L’Impiccato”. Ad una partita partecipano due giocatori, il primo deve decidere una parola che verr\`{a} codificata utilizzando il carattere ’+’ per le vocali e ’-’ per le consonanti, il secondo ha l’obbiettivo di indovinare la parola in un numero finito di tentativi, proponendo una lettera per turno. Il gioco termina con la vittoria del primo giocatore se i tentativi sono terminati o del secondo giocatore se \`{e} stata indovinata la parola.},
    apice = {HangmanOnline},
    author = {Venturini, Filippo},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = feb,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Hangman Online},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-venturini-ay2223},
    year = 2023
}
@courseproject{deliverychecker-sd2122,
    abstract = {Scopo del progetto \`{e} la realizzazione di un sistema che supporti il lavoro dei magazzinieri di un'azienda di logistica in cui all'interno del magazzino e in particolare per questo progetto il task principale da considerare \`{e} il controllo dei prodotti in ingresso da parte dei magazzinieri. I prodotti arrivano al magazzino organizzati in spedizioni. Ogni spedizione si divide in scatole e ogni scatola contiene poi tipologie di prodotti diversi in diverse quantit\`{a}. Le informazioni relative a come la spedizione sia composta vengono indicate al momento in cui i prodotti vengono spediti e i magazzinieri sono tenuti al corrente solo delle spedizioni che possono essere lavorate perch\`{e} gi\`{a} arrivate in magazzino. Per verificare la spedizione i prodotti devono essere contati all'interno delle scatole e devono corrispondere con quanto dichiarto dal mittente. Eventuali anomalie dovranno essere segnalate tramite nota testuale. I magazzinieri collaborano per la lavorazione delle spedizioni talvolta controllando spedizioni differenti, altre volte in maniera cooperativa sulla stessa, con la possibilit\`{a} di lavorare sul conteggio delle unit\`{a} dello stesso prodotto nella stessa scatola. Il sistema da realizzare deve supportare l'editing in modalit\`{a} cooperativa e distribuita dello stato della spedizione all'arrivo, facendo si che sia comparabile con a quanto \`{e} stato dichiarato dal mittente della spedizione.},
    apice = {DeliveryChecker},
    author = {Simone Del Gatto},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = feb,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {Delivery Checker},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-del-gatto-ay-2122},
    year = 2023
}
@courseproject{codename-sd2021,
    abstract = {L’obiettivo del progetto `e la realizzazione di una versione distribuita del gioco da tavolo ”Nome in Codice”. Nel gioco, i giocatori si dividono in due squadre: rossa e blu con un capo ciascuna. Si posizionano sul tavolo 25 carte, ognuna delle quali rappresenta il nome in codice asseg- nato a venticinque agenti, in modo da formare un tabellone. Queste parole rappresentano agenti rossi, agenti blu, un letale assassino e innocenti passanti. I capi, i quali sono gli unici a conoscere la posizione dei propri agenti, hanno l’obiettivo di farli individuare alla propria squadra prima degli altri e senza beccare l’assassino. Ogni round viene data una parola come indizio e l’effettivo numero di agenti collegati a tale parola. Tutte le regole sono consultabili al seguente link: Nome in codice (gioco) - Wikipedia},
    apice = {CodeName},
    author = {Bazzocchi, Luca and Casadei, Giacomo},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = feb,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Nome in codice},
    type = {Game Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-bazzocchi-casadei-ay2021},
    year = 2023
}
@courseproject{lpgnnslr-ise2122,
    abstract = {Deep learning has recently begun to have great success in numerous fields of artificial intelligence, particularly in that of natural language processing (NLP). Traditionally, text inputs are represented as token sequences, with models such as bag of words, a representation of text that describes the occurrence of words within a document that keeps track of word counts and disregards the grammatical details, word order and location, word structure and its semantics; often along with some kind of scoring metric like TF-IDF, a numerical statistic intended to reflect how important a word is to a document in a collection or corpus by increasing proportionally to the number of times a word appears in a document, but is offset by the number of documents that contain the word. So, words that are common in every document, rank low even though they may appear many times, since they don’t mean much to that document in particular. However, there is a huge variety of NLP problems that can be expressed with a graph structure, indeed popular deep learning techniques such as Recurrent Neural Networks (RNN) and Convolutional Neural Networks (CNN) have begun to generate a lot of interest for the realization of new deep learning techniques based on graphs, namely Graph Convolutional Networks (GCN) and Graph Recurrent Neural Networks (GRNN). These new deep learning tecniquest have been used in a large variety of graph-related problems, including NLP problems as the sentence structural information in text sequence can be exploited to augment original sequence data by incorporating the task-specific knowledge. Similarly, the semantic information in sequence data can be leveraged to enhance original sequence data as well. The objective of this systematic literature review (SLR) is to investigate which new techniques have been developed in the context of knowledge injection that is, the act of combining the purely data-driven learning of neural networks with the infusion of knowledge from external sources, focusing on NLP applications and examining the pros and cons compared to the approaches considered traditional.},
    apice = {LpGnnSlr},
    author = {Atti, Nicola},
    howpublished = {Intelligent Systems Engineering, A.Y. 2021/2022},
    month = feb,
    sort = {advanced},
    supervisor = {Ciatto, Giovanni},
    title = {Graph Neural Networks for Natural Language Processing: A Systematic Literature Review},
    type = {Advanced Project},
    year = 2023
}
@courseproject{guessthesong-sd2122,
    abstract = {Questo progetto nasce dall’idea del noto programma televisivo Sarabanda. Pi\`{u} precisamente abbiamo preso spunto dall’ultima fase di gioco, il 7x30, dove il concorrente deve indovinare 7 canzoni in 30 secondi. Per semplificare la fase di gioco abbiamo realizzato una versione rivisitata in cui l’utente ha a disposizione 30 secondi per ogni canzone e il nome dell’autore. Il gioco \`{e} suddiviso in turni, il numero di turni \`{e} selezionabile dal men\`{u} iniziale, ad ogni turno il giocatore deve indovinare una sola canzone e riceve dei punti in caso di risposta corretta. Alla fine di ogni turno viene visualizzata la classifica parziale con il totale dei punti ricevuti da ogni utente, e il tempo complessivo impiegato per rispondere. Vince chi alla fine ha pi\`{u} punti, o in caso di pareggio chi ha impiegato di meno complessivamente per rispondere.},
    apice = {GuessTheSong},
    author = {Fontanella, Simone and Avagnano, Marco},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = feb,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Guess the Song},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-avagnano-fontanella-ay2122},
    year = 2023
}
@courseproject{bdimasinkotlin-ise2122,
    abstract = {The aim of the project is to create a domain specific language to develop a multi-agent system following the BDI (Beliefs, Desires, Intentions) model defined by Rao and Georgeff. The library provides a tool to develop agents who perceive and act within a shared environment and communicate with each other.},
    apice = {BdiMasInKotlin},
    author = {Baiardi, Martina},
    howpublished = {Intelligent Systems Engineering, A.Y. 2021/2022},
    month = jan,
    sort = {research},
    title = {Kotlin DSL for BDI multi-agent systems},
    type = {Research Project},
    url = {https://github.com/pikalab-unibo-students/ise-2022-project-baiardi},
    year = 2023
}
@courseproject{onevsall-sd2223,
    abstract = {One vs All \`{e} un gioco multiplayer online nel quale un giocatore si ritrova ad affrontare altri concorrenti in una serie di domande a scelta multipla. I partecipanti accedono al turno successivo rispondendo correttamente alla domanda del turno corrente. Ogni turno ha la durata di 30 secondi. Una volta terminati, il turno \`{e} considerato concluso e sar\`{a} elaborato il turno successivo. Il gioco termina quando il giocatore, rispondendo correttamente a tutte le domande, vince ed elimina tutti gli avversari oppure sbaglia una risposta venendo cos\`{i} sconfitto. Il sistema che offre il servizio One vs All ha caratteristiche di fault tolerance, scalabilit\`{a} e replicabilit\`{a}.},
    apice = {OneVsAll},
    author = {Venturi, Simone},
    howpublished = {Distributed Systems, A.Y. 2022/2023},
    month = jan,
    sort = {classic},
    supervisor = {Magnini, Matteo},
    title = {One vs All: a web based quiz game implementation},
    type = {Standard Project},
    url = {https://dvcs.apice.unibo.it/pika-lab/courses/ds/projects/ds-project-venturi-ay2223},
    year = 2023
}
@courseproject{abductionbasedexplanations-ise2122,
    abstract = {Abductive Reasoning is a form of logical inference: it starts with an observation or set of observations and then seeks the simplest and most likely conclusion. Abduction has already been studied in the field of XAI, the understandable Artificial Intelligence, as an approach to explain the machine learning prediction of samples from a data set by generating subset-minimal or cardinality-minimal explanations with respect to features. This work is born as a reproduction of the study Abduction-Based Explanations for Machine Learning Models, curated by Alexey Ignatiev, Nina Narodytska and Joao Marques-Silva, and it’s focused on building such an abductive model agnostic strategy based on two algorithms in order to obtain explanations for neural networks (NNs). The experimental results, on well-known datasets, validate the scalability of the proposed approach as well as the quality of the computed solutions.},
    apice = {Abductionbasedexplanations},
    author = {D'Errico, Christian},
    howpublished = {Intelligent Systems Engineering, A.Y. 2021/2022},
    month = dec,
    sort = {advanced},
    supervisor = {Ciatto, Giovanni},
    title = {Abduction-Based Explanations for ML Models},
    type = {Advanced Project},
    url = {https://github.com/pikalab-unibo-students/ise-project-derrico-ay2122},
    year = 2022
}
@courseproject{stracciacamicia-sd2122,
    abstract = {L'applicazione rappresenta il gioco di carte Straccia camicia. La partita si svolge a turni: ogni giocatore dato il proprio mazzo di carte ordinato e coperto, durante il proprio turno dovr\`{a} giocare una carta oppure un numero di carte pari al valore dell'ultima carta giocata se si tratta di una carta speciale (Asso, Due o Tre). Il giocatore che ha giocato una carta speciale e che ha ricevuto un numero di carte relativo potr\`{a} aggiungere il mazzo centrale alla propria mano. Il gioco termina quando uno dei giocatori termina le carte in mano. L'applicazione ha un'architettura client-server in cui i client fungono da interfaccia tra utente e server e, la partita vera e propria resta interamente gestita dal server, ad eccezione del mazzo di carte in possesso del player.},
    apice = {StracciaCamicia},
    author = {Galassi, Meshua},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = dec,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Straccia Camicia},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-galassi-ay2122},
    year = 2022
}
@courseproject{clpmas-mas2122,
    abstract = {This is a project realized as case study for the Multi-Agent Systems exam of Master's degree in Artificial Intelligence, University of Bologna. In this project it is described a problem which involves both Constraint Programming and Multi-Agent Systems. The problem consists of finding a school timetable for each professor of a school such that different constraints related to different aspects of the problem are respected, and trying to satisfy all preferences of each professor as much as possible.},
    apice = {ClpMas},
    author = {Boezio, Giuseppe},
    howpublished = {Multi-Agent Systems, A.Y. 2021/2022},
    month = dec,
    sort = {advanced},
    supervisor = {Calegari, Roberta},
    title = {SchoolTimetable: A hybrid CP and MAS case study},
    type = {Advanced Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-boezio-ay2122},
    year = 2022
}
@courseproject{dtmfacilitatorsgentili2022-sedtm2122,
    apice = {DtmfacilitatorsGentili2022},
    author = {Nicola Gentili},
    howpublished = {Software Engineering, A.Y. 2021/2022},
    month = dec,
    sort = {advanced},
    supervisor = {Ricci, Alessandro and Omicini, Andrea and Pianini, Danilo},
    title = {Digital Transformation Management facilitators},
    type = {Advanced Project},
    year = 2022
}
@courseproject{collaborativetexteditor-sd2122,
    abstract = {Sempre pi\`{u} spesso capita di dover scrivere un documento collaborando con pi\`{u} persone, il che pu\`{o} portare a diversi problemi qualora il documento sia accessibile da un solo utente per volta. Il seguente progetto verte alla realizzazione di un’applicazione web in grado di fornire uno strumento per la creazione e scrittura collaborativa di documenti testuali in real-time, sfruttando tecnologie come Express, Node.js e altri servizi esterni. L’obiettivo principale di questa applicazione \`{e} quindi quello di permettere ad un gruppo di persone di avere uno spazio unico e condiviso su cui poter prendere appunti contemporaneamente e visionare chi attualmente sta modificando il documento.},
    apice = {CollaborativeTextEditor},
    author = {Mengozzi, Maria},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = nov,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Real-time collaborative text editor},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-mengozzi-ay2122},
    year = 2022
}
@courseproject{distributedpong-sd2122,
    abstract = {Questo progetto verte sullo sviluppo di un’applicazione web basata su una comunicazione di tipo real-time. In particolare, si vuole realizzare una variante del videogioco Pong sotto forma di servizio web, quindi accessibile tramite browser, che permetta a pi\`{u} giocatori di competere tra di loro. Il gioco \`{e} una simulazione del ping pong. In ogni partita competono due giocatori, a cui viene assegnata una barra ciascuno, utilizzata per colpire una pallina. Quando la pallina oltrepassa la barra dell’avversario, si guadagna un punto. Lo scopo del gioco \`{e} di ottenere un certo numero di punti, prima del proprio avversario. Nella variante proposta, chiamata Relay Pong oppure Pong a staffetta, il gioco non \`{e} pi\`{u} limitato a due giocatori. In ogni partita competono infatti due squadre, composte da almeno un giocatore, ognuna delle quali controlla una barra. I giocatori della stessa squadra si alternano a controllare la barra della squadra durante lo sviluppo della partita. Le condizioni per vincere una partita rimangono le medesime. Lo scopo iniziale di questo progetto \`{e} quello di realizzare una proof of concept del servizio descritto, quindi un prototipo che mostri la fattibilit\`{a} della sua realizzazione. Il servizio si baser\`{a} su un’architettura di tipo client-server, in cui il server mantiene l’originale dello stato della partita e lo condivide con i client, mentre i client inviano al server degli eventi, che rappresentano le intenzioni dei giocatori, da cui dipenderanno gli aggiornamenti sullo stato della partita. Per la comunicazione di tipo real-time, si sperimenter\`{a} con l’uso del protocollo WebSocket, che, rispetto ad altri protocolli supportati dai browser, privilegia una comunicazione bidirezionale con basso overhead dei pacchetti. Altri punti interessanti saranno la progettazione del modello logico usato per rappresentare il gioco, la progettazione delle dinamiche che regolano lo svol- gimento di una partita e la gestione della sincronizzazione dei giocatori con il server.},
    apice = {DistributedPong},
    author = {Jahrim Gabriele Cesario},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = nov,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Relay Pong, a Pong-inspired web application},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-cesario-ay2122},
    year = 2022
}
@courseproject{marltechsurvey-sd2122,
    abstract = {Al giorno d’oggi stiamo assistendo ad un rapido sviluppo nei campi del Pervasive Computing e dell’Intelligenza Artificiale. Quotidianamente siamo circondati da oggetti e/o sistemi intelligenti, sviluppati per aiutarci nei compiti da svolgere. Questo pu\`{o} avvenire, ad esempio, nella nostra abitazione mediante infissi, o elettrodomestici smart oppure sul posto di lavoro dove possono essere presenti sistemi robotici applicati alle catene di montaggio o al comparto logistica. Il campo del Multi Agent Reinforcement Learning cerca di unire le due discipline sopra citate, al fine di rendere sempre pi\`{u} autonomi i sistemi che ci circondano. Questo progetto ha lo scopo di effettuare una panoramica del paradigma MARL, producendo una sezione teorica e una sezione pratica dove vengono testate due delle tecnologie pi\`{u} promettenti e stabili in questo ambito: PettingZoo e Mava. A tal fine, sono stati condotti diversi esperimenti che riproducono alcuni dei pi\`{u} classici problemi nel campo MARL e ne sono stati riportati i risultati ottenuti, evidenziando le potenzialit\`{a} e i limiti di questi framework.},
    apice = {MarlTechSurvey},
    author = {Domini, Davide and Veronika Folin},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = nov,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {MARL -- Multi Agent Reinforcement Learning},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-domini-folin-ay2122},
    year = 2022
}
@courseproject{decentalizedmultiplayerpuzzlegame-sd2122,
    abstract = {L’idea iniziale \`{e} quella di sviluppare, in modo distribuito, il gioco da tavolo ”puzzle”. L’obiettivo del gioco \`{e} quello di ricomporre una figura, precedentemente scomposta in pezzi (tessere), per poi generare un’immagine chiara e definita. Al termine di ci\`{o}, ai giocatori apparir\`{a} su schermo un messaggio di avvenuta risoluzione del gioco e di conseguenza la sua fine. Un giocatore pu\`{o} entrare nel gioco partecipando ad una sessione di un’altro giocatore. Gli utenti devono giocare in modo asincrono, concorrente (non c’\`{e} un modello a turni). Quando il puzzle \`{e} risolto, la sessione finisce e tutti i partecipanti vedono un messaggio corrispondente (“Risolto!”).},
    apice = {DecentalizedMultiplayerPuzzleGame},
    author = {Di Raddo, Carlo and Andriani, Demetrio},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = nov,
    sort = {classic},
    title = {Decentalized Multiplayer Puzzle Game},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-andriani-buccoli-diraddo-ay2122},
    year = 2022
}
@courseproject{ipfs-sd2122,
    abstract = {L’Interplanetary File System, conosciuto anche come IPFS, \`{e} un file system distribuito che cerca di connettere tutti i dispositivi informatici sotto lo stesso sistema di file. Se un file system indica un meccanismo con il quale i file sono organizzati su dispositivi informatici utilizzati per l’archiviazione dei dati [1], un file system distribuito \`{e} un particolare file system che permette la memorizzazione di risorse su dispositivi di archiviazione distribuiti in una rete informatica. L’obiettivo perseguito da questa tecnologia \`{e} quello di creare un network di portata globale che consenta l’archiviazione delle informazioni in maniera completamente decentralizzata, con elevata scalabilit\`{a} e con grande resistenza alla censura dell’informazione. IPFS \`{e} quindi un sistema di storage distribuito peer-to-peer (p2p): l’accesso al contenuto dei file \`{e} possibile grazie ai peer, nodi che possono essere localizzati in una qualsiasi parte del globo il cui ruolo \`{e} quello di trasmettere e/o memorizzare dati. Il protocollo sotto esame si compone di tre aspetti fondamentali sui quali soffermarsi: L’identificazione univoca dei file grazie al content-addressing; Il collegamento dei contenuti tramite grafici aciclici diretti (DAG); La scoperta dei contenuti tramite tabelle hash distribuite (DHT).},
    apice = {Ipfs},
    author = {Michele Mongardi},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = oct,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Technology Know-How: IPFS},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-mongardi-ay2122},
    year = 2022
}
@courseproject{customp2pfilesharing-sd2122,
    abstract = {L’idea alla base del progetto \`{e} quella di sviluppare una rete di file sharing scalabile, in modo tale da poter funzionare in qualsiasi ambiente essa venga posta, da reti di piccole dimensioni a grandi. La rete sviluppata si ispira a reti attualmente esistenti, quali BitTorrent. Infatti, come trattato suc- cessivamente, alcuni meccanismi di consivisione hanno avuto come progettazione iniziale una visione del funzionamento dello stesso meccanismo sulla rete BitTorrent. Alla base del progetto si \`{e} tenuto in considerazione la nacessit\`{a} di garantire l’anonimato delle risorse pubblicate, facendo si di mascherare le risorse di cui non si hanno interesse.},
    apice = {CustomP2pFileSharing},
    author = {Matteo Lazzari},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = sep,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Progettazione e sviluppo di un sistema peer to peer di file sharing},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-lazzari-ay2122},
    year = 2022
}
@courseproject{learningwalkmas-mas2122,
    abstract = {The goal of the project is to implement a multi-agent system of two agents that will control the leg movement of the human body skeleton inside the artificial environment. Each agent will control 11 muscles of each leg and collaboratively they have to learn how to walk.},
    apice = {LearningWalkMas},
    author = {Burov, Nikita},
    howpublished = {Multi-Agent Systems, A.Y. 2021/2022},
    month = sep,
    sort = {classic},
    supervisor = {Calegari, Roberta},
    title = {Learning to walk as a MAS task},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-burov-ay2122},
    year = 2022
}
@courseproject{planninglibrary-ise2122,
    abstract = {Planning is a leading area of Artificial Intelligent that has made relevant advancements in terms of efficiency and sophistication of its algorithms since its emergence in the late 1970s. However, despite numerous planners avail- able, their preponderance is no longer maintained. Whence we decided to create our planning framework based on PDDL. Thus, the project aims to realize a planning framework supporting PDDL and implementing STRIPS as a planning algorithm. Since PDDL syntax is not often intelligible, the planner is delivered with a DSL to increase its usability for lay users.},
    apice = {PlanningLibrary},
    author = {Brugnatti, Giulia},
    howpublished = {Intelligent Systems Engineering, A.Y. 2021/2022},
    month = sep,
    sort = {advanced},
    supervisor = {Ciatto, Giovanni},
    title = {A PDDL-compliant Kotlin library for automated planning},
    type = {Advanced Project},
    url = {https://github.com/pikalab-unibo-students/ise-2122-project-brugnatti},
    year = 2022
}
@courseproject{qubft-sd1920,
    abstract = {In virt\`{u} della sua importanza nell’ambito dei sistemi distribuiti, le soluzioni prodotte dalla comunit\`{a} scientifica al cosiddetto problema del consenso, soprattutto nel contesto dei protocolli Bizantine Fault-Tolerant (BFT), sono numerose e variegate. Con l’avvento della tecnologia delle blockchain e il vasto riscontro che la sta caratterizzando, l’interesse verso questi protocolli si \`{e} ulteriormente rinnovato. Sebbene molteplici, non esiste attualmente una soluzione unanimemente individuata come migliore in ogni contesto, quanto piuttosto un insieme di approcci che meglio si adattano ognuno ad esigenze specifiche. Q/U rappresenta una di queste soluzioni, ossia un protocollo client/server per la realizzazione di servizi BFT distribuiti su una rete asincrona attraverso un’interfaccia costituita da operazioni di query e di update, ciascuna delle quali necessita dell’approvazione da parte di un quorum di nodi prima di essere accettata ed eseguita. Individuato dagli autori come alternativa efficiente a protocolli ben pi\`{u} affermati, Q/U si focalizza sulla fault-scalability, ossia la capacit\`{a} di tollerare un numero crescente di fallimenti senza un significativo decremento delle prestazioni. Oltre che studiare ed approfondire il problema del consenso e gli approcci per affrontarlo nel contesto dei sistemi distribuiti, obiettivo del progetto che questo report accompagna \`{e} comprendere e implementare Q/U anche mostrandone il funzionamento mediante la realizzazione di una semplice Replicated State Machine.},
    apice = {QuBft},
    author = {Giulianini, Daniele},
    howpublished = {Distributed Systems, A.Y. 2019/2020},
    month = sep,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Realizzare servizi Byzantine Fault-Tolerant e Fault-Scalable: protocollo Query/Update (Q/U)},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-giulianini-ay1920},
    year = 2022
}
@courseproject{masconnect4-mas2122,
    abstract = {Agent-oriented programming (AOP) is a programming paradigm that is still in its infancy but is very promising for use in systems that interact with the real world. Since gamification is getting more and more ubiquitous and is by definition an interaction with the real world, this project investigates the use of AOP when programming a game. An example game, Connect Four, is developed in an AOP language (JADE) and this implementation is compared to implementations in other programming paradigms. This shows the big advantages of AOP. AOP is a great and very natural programming paradigm for reasoning about games and ensures great performance on a lot of important non-functional requirements.},
    apice = {MasConnect4},
    author = {Støle, Ole August and Milis, Sebastiaan},
    howpublished = {Multi-Agent Systems, A.Y. 2021/2022},
    month = aug,
    sort = {game},
    supervisor = {Omicini, Andrea},
    title = {Multi-Agent Connect Four},
    type = {Game Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-stoele-milis-ay2122},
    year = 2022
}
@courseproject{automlanomalydetection-ise2122,
    abstract = {In this work we’re gonna first discover what AutoMl is, why it is important in 2022 to automate the process and steps involved in the Machine Learning field and next what are the main tools used right now, analyzing and discussing the literature present at this time. Regarding the framework, we’re gonna analyze the distribution of each of them, in particular referring to the peculiarities and differences of each of them and the usability, that is the ease of installing and use of the tools.},
    apice = {AutomlAnomalyDetection},
    author = {Davide Schiaroli},
    howpublished = {Intelligent Systems Engineering, A.Y. 2021/2022},
    month = aug,
    sort = {advanced},
    supervisor = {Omicini, Andrea},
    title = {AutoML for anomaly detection},
    type = {Advanced Project},
    year = 2022
}
@courseproject{ciansibledockerjenkins-sd2021,
    abstract = {CI/CD \`{e} un metodo per la distribuzione frequente delle app ai clienti, che prevede l’introduzione dell’automazione nelle fasi di sviluppo dell’applicazione. Principalmente, si basa sui concetti di integrazione, distribuzione e deployment continui. L’approccio CI/CD supera le difficolt\`{a} legate all’integrazione di nuovo codice, una situazione cos\`{i} problematica per i team operativi e di sviluppo da essere coniata "inferno dell’integrazione". Pi\`{u} specificamente, il metodo CI/CD introduce l’automazione costante e il monitoraggio continuo in tutto il ciclo di vita delle applicazioni, dalle fasi di integrazione e test a quelle di distribuzione e deployment. Nel complesso, questi processi interconnessi vengono definiti "flussi CI/CD" e sono supportati dai team operativi e di sviluppo che collaborano secondo modalit\`{a} agili[1]. Il proposito di questo progetto \`{e} quello di realizzare l’automazione di un flusso CI/CD, utilizzando Ansible, Docker e Jenkins. Un approccio comune per creare una pipeline automatizzata consiste nel combinare due piattaforme per orchestrare e quindi distribuire, in modo Agile e continuo, applicazioni e infrastruttura. Ansible viene utilizzato per il provisioning di ambienti, configurazioni dell’infrastruttura e distribuzione di app all’interno di un processo CI/CD utilizzando una pipeline Jenkins. Nel mondo del processo CI/CD, Jenkins \`{e} uno strumento popolare per il pro- visioning di ambienti di sviluppo/produzione e per la distribuzione di applicazioni attraverso il flusso della pipeline. Tuttavia, a volte, mantenere lo stato dell’applicazione diventa opprimente e il riutilizzo degli script diventa pi\`{u} difficile man mano che il progetto cresce. Per superare questa limitazione, Ansible svolge un ruolo fondamentale come esecutore di script di shell. Lo scopo del suo utilizzo nel flusso della pipeline \`{e} di riutilizzare ruoli e playbook per il provisioning, lasciando Jenkins solo come orchestratore di processi anzich\`{e} come esecutore di script di shell. L’impiego di Jenkins facilita anche l’utilizzo di Docker, il quale pu\`{o} rendere il processo di software delivery pi\`{u} veloce, prevedibile e gestibile. L’implementazione della Continuous Delivery su applicazioni pacchettizzate in Docker favorisce molteplici vantaggi, tra cui una maggiore automazione ed una migliore gestione dello sviluppo software e dei processi di delivery, conferendo al contempo un livello di sicurezza maggiore alle applicazioni che girano in un ambiente condiviso.},
    apice = {CiAnsibleDockerJenkins},
    author = {Commodaro, Daniele},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = jul,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Integrazione di Ansible e Docker per una pipeline CI/CD utilizzando Jenkins},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-commodaro-ay2021},
    year = 2022
}
@courseproject{sieveprotocol-as2021,
    abstract = {This project considers a modular approach for dealing with non-determinism in replicated services, where some processes are subject to faults and arbitrary behaviour (so-called Byzantine faults), with an implementation of the protocol Sieve by IBM (Cachin et al., 2016). This approach doesn’t require any changes to the potentially non-deterministic application (and neither access to its internal data) for filtering out non-deterministic operations. It ensures that all correct processes produce the same outputs and that their internal states do not diverge. The chosen programming language is Python and the system is runnable locally.},
    apice = {SieveProtocol},
    author = {Antonio Tagliente and Davide Del Vecchio},
    howpublished = {Autonomous Systems, A.Y. 2020/2021},
    month = jul,
    sort = {classic},
    supervisor = {Omicini, Andrea},
    title = {Sieve protocol: a modular approach to replicating non-deterministic applications in a Byzantine Fault-Tolerant system},
    type = {Standard Project},
    url = {https://drive.google.com/file/d/1LEcGfRLCWKH33lV0W-_ZUr0LS0CZKes1/view},
    year = 2022
}
@courseproject{privacypreservingfederatedlearning-sd2122,
    abstract = {All’intersezione tra i sistemi distribuiti e il machine learning, si \`{e} sviluppato recentemente ed \`{e} in rapida ascesa il federated learning, un approccio all’apprendimento automatico distribuito che permette di addestrare un modello predittivo condiviso da un insieme di dispositivi diversi mantenendo i dati sui dispositivi stessi, facendo cos\`{i} a meno della necessit\`{a} di raccogliere e archiviare i dati in maniera centralizzata, con lo scopo di garantire la privacy dei dati dei partecipanti. Oggigiorno esistono alcuni framework software, in vari stadi di sviluppo, che consentono di implementare nella pratica semplici sistemi di federated learning su dispositivi eterogenei. Questo lavoro nasce dall’idea di estendere Flower, uno dei pi\`{u} promettenti framework a disposizione, per supportare un nuovo meccanismo di federated learning che consente l’implementazione di algoritmi ispirati a una procedura comune in ambito accademico, detta di revisione tra pari o peer review in inglese, con l’obiettivo di ottenere modelli di previsione pi\`{u} performanti. La libreria sviluppata, chiamata PeerReview-Flower, \`{e} stata quindi utilizzata per implementare un nuovo algoritmo federato di tipo gradient boosted decision trees, chiamato FedLSBT, con cui si sono realizzati esperimenti per task di regressione e classificazione.},
    apice = {PrivacyPreservingFederatedLearning},
    author = {Passeri, Mattia},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = jul,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {PeerReviewFlower: un framework per il federated learning con peer review},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-passeri-ay2122},
    year = 2022
}
@courseproject{luckyauction-sd1920,
    abstract = {Il progetto prevede la realizzazione di un sistema distribuito di aste online, in cui ciascun utente pu\`{o} rilanciare un’offerta per un determinato bene. Il sistema, organizzato a microservizi, pu\`{o} essere concepito sia come un sistema in cui gli utenti effettuano le aste in prima persona, sia come un sistema automatizzato in cui per ciascun utente viene impostato un processo che, in autonomia, conduce l’asta al posto dell’utente sulla base di opportune configurazioni/preferenze. Il sistema includer\`{a} entrambe le implementazioni, offrendo la possibilit\`{a} all’utente di scegliere quale tipo di interazione avere con il sistema. In tutti e due i casi \`{e} previsto un sistema centrale che controlla e monitora la correttezza delle singole aste.},
    apice = {LuckyAuction},
    author = {Gianmarco Magnani and Nicolas Pasolini},
    howpublished = {Distributed Systems, A.Y. 2019/2020},
    month = jul,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Lucky Auction},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-magnani-pasolini-ay1920},
    year = 2022
}
@courseproject{grpctusowservice-sd2122,
    abstract = {This project aims to add a new way of remotely accessing tuple spaces by using Google Remote Procedure Call 1 ; by using gRPC it will be possible to use all the supported languages and platforms (i.e. Web, Android) giving more choices to the developers and also improving interoperability between different systems.},
    apice = {GrpcTusowService},
    author = {Cavallari, Filippo},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = jun,
    sort = {research},
    supervisor = {Ciatto, Giovanni},
    title = {Implementing gRPC in the TuSoW project},
    type = {Research Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-cavallari-ay2122},
    year = 2022
}
@courseproject{checkerswebapp-sd1920,
    abstract = {Checkers Web App rappresenta una versione multiplayer online del gioco da tavolo dama. Le regole di gioco sono quelle della dama internazionale, in cui due giocatori muovono alternativamente i propri pezzi in base al turno. I pezzi si muovono diagonalmente, solo sulle caselle nere non occupate da altri pezzi ed hanno la possibilit`a di prendere(o ”mangiare”) quelli avversari, scavalcandoli. I pezzi catturati vengono rimossi dalla damiera ed esclusi dal gioco. Il giocatore a cui vengono catturati tutti i pezzi o che, durante il suo turno e impossibilitato a muovere, ha perso. Se, dopo aver effettuato una presa e nella casella di arrivo si presentano le condizioni per la pedina di una nuova presa e obbligatoria la presa multipla, che va effettuata nello stesso turno di gioco. Il progetto consiste nella realizzazione di una versione distribuita del gioco che permetta agli utenti di connettersi da remoto e di giocare insieme attraverso un meccanismo di stanze virtuali.},
    apice = {CheckersWebApp},
    author = {Konrad Gomulka and Luca Salvigni and Manuele Pasini},
    howpublished = {Distributed Systems, A.Y. 2019/2020},
    month = jun,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Checkers Web App},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-gomulka-pasini-salvigni-aa1920},
    year = 2022
}
@courseproject{droneobstacleavoidance-seids2122,
    abstract = {Software engineering is hard. Engineering something intelligent is even harder. That is when the process of software development becomes even more important. In this report, we will share how we applied different principles from the Software Engineering for Intelligent Distributed Systems course at the University of Bologna to create the software solution for our project. We took part in the ICRA 2022 DodgeDrone Challenge. The DodgeDrone Challenge is a competition where anyone can participate and hand-in submissions online. Then, the finalists will be announced and the grand finals will happen live at the ICRA 2022 conference in Philadelphia, USA. The goal is to create a vision or state-based algorithm for a drone to reach a destination as fast as possible while avoiding obstacles. More specifically, we needed to write a python program that given the current state and vision of the drone (and possibly knowledge of the positions of the obstacles), returns a command that would lead the drone down the optimal path. (Joint project with the courses of "Embedded Systems" & "Vehicular Systems")},
    apice = {DroneObstacleAvoidance},
    author = {Jore Booy and Christoph Konheisner and Eetu Kahelin and Lorenzo Morelli},
    howpublished = {Software Engineering for Intelligent Distributed Systems, A.Y. 2021/2022},
    month = jun,
    sort = {advanced},
    supervisor = {Omicini, Andrea},
    title = {Drone Obstacle Avoidance: the Software Engineering Strategy applied},
    type = {Advanced Project},
    year = 2022
}
@courseproject{agentspeaktictactoemas-mas2122,
    abstract = {In this project a multi-agent system consisting of two agents competing in tic-tac-toe was implemented. The system was developed in AgentSpeak using Jason. Two agent types were implemented; a random agent playing random moves and a strategic agent using the Mini-max algorithm to calculate it's moves. The strategic agent was tested against both a random agent and against a strategic agent using the same strategy. These results were compared to the work of Govind G Nair, who uses reinforcement learning to make strategic moves. The Mini-max agent performs optimally when playing against an equal opponent. Further, when the opponent is a random agent the reinforcement learning agent achieves a higher winrate than the Mini-max agent. However, the reinforcement learning agent sometimes looses to the random agent, while the Mini-max agent always wins or ties.},
    apice = {AgentSpeakTicTacToeMas},
    author = {Jessen, Andrea Stette and Mohr, Solveig Jørgensen},
    howpublished = {Multi-Agent Systems, A.Y. 2021/2022},
    month = may,
    sort = {game},
    supervisor = {Calegari, Roberta},
    title = {Tic Tac Toe with AgentSpeak in MAS},
    type = {Game Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-solveig-jessen-ay2122},
    year = 2022
}
@courseproject{onixdvcs-sd2021,
    abstract = {Il progetto consiste nella realizzazione di un sistema di controllo di versione distribuito (DVCS) che permetta di tener traccia delle modifiche e delle versioni apportate a codice sorgente senza utilizzare un server centrale. La nostra versione sar\`{a} fortemente ispirata al DVCS Git e ne implementer\`{a} le funzioni descritte nella sezione 1. Nello specifico, gli utenti che accedono al client web vedranno una sorta di linea di comando accompagnata da un toolbox che offre semplici funzionalit\`{a}, come creare un nuovo repository o visualizzare quelli a cui si ha accesso. Tramite la riga di comando sar\`{a} possibile scrivere del codice corrispondente alle tipiche azioni di un DVCS precedute dall’istruzione onix, omonima del progetto: con queste si potr\`{a} apportare modifiche a file, crearne delle versioni (commit), caricarle o scaricarle.},
    apice = {OnixDvcs},
    author = {Marcantoni, Alessandro and Romagnoli, Simone},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = apr,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Onix: sistema di controllo di versione distribuito},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-marcantoni-romagnoli-aa2021},
    year = 2022
}
@courseproject{distributedblackjack-sd1920,
    abstract = {Lo scopo del progetto \`{e} la realizzazione di una versione autonoma e distribuita del gioco di carte blackjack. Ogni giocatore parteciper\`{a} alla partita in maniera autonoma, scegliendo quali mosse effettuare nel proprio turno per vincere la partita. Il sistema verr\`{a} realizzato con un’architettura client-server mediante l’utilizzo di WebSocket per la gestione della comunicazione tra le parti, con l’implementazione di un timeout che vada ad escludere eventuali giocatori che per qualsiasi motivo dovessero interrompere la comunicazione con il server.},
    apice = {DistributedBlackjack},
    author = {Lorenzo Simoncini and Maichol Dadi},
    howpublished = {Distributed Systems, A.Y. 2019/2020},
    month = apr,
    sort = {game},
    supervisor = {Ciatto, Giovanni},
    title = {Autonomous Distributed Blackjack},
    type = {Game Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-dadi-simoncini-aa1920},
    year = 2022
}
@courseproject{ciavattizookeeper-sd2021,
    abstract = {This project aims to a better understanding of the technology named ”Apache Zookeeper”. The exploration of this technology will start from the architecture, provided services, system components. This information, for the most part, is taken from the official documentation or academic re- searches. The project is made from two main section, the theory section and the practical section. The first one introduces structure and consensus protocol. The practical one describes the testing part of the project. The major aim of the first part is the understanding, the main aim of the second one is testing performances.},
    apice = {CiavattiZookeeper},
    author = {Ciavatti, Ilaria},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = apr,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {On the way to Apache ZooKeeper},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-ciavatti-ay2021},
    year = 2022
}
@courseproject{nlpmas-mas2122,
    abstract = {The project involves the design and implementation of a multi-agent system for training classifiers with different configurations given a parameter space. Using a master-slave architecture, the system searches the parameter space by random sampling and trains the classifiers for named-entity recognition on the CoNLL-2003 dataset in a round-robin manner. The best trained classifier is then determined and evaluated on the test set. Results show that the proposed multi-agent system is able to search the parameter space efficiently.},
    apice = {NlpMas},
    author = {Mizutani, Miki and Gee, Leonidas},
    howpublished = {Multi-Agent Systems, A.Y. 2021/2022},
    month = apr,
    sort = {research},
    supervisor = {Calegari, Roberta},
    title = {Collaborating NLP Agents},
    type = {Research Project},
    url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-mizutani-gee-ay2122},
    year = 2022
}
@courseproject{pushnotificationsonrethinkdb-sd2122,
    abstract = {L’obiettivo di questo studio prevede la realizzazione di un sistema che permetta di emettere e distribuire notifiche legate ad eventi. Questa funzionalita` sar\`{a} fruita da servizi software al fine di fornire informazioni costantemente aggiornate agli utenti delle applicazioni web e per monitorare lo stato di avanzamento di task/procedure. La parte iniziale del lavoro \`{e} stata dedicata all’analisi del contesto in cui si colloca questo problema: \`{e} stato definito il concetto di Database real-time e di seguito sono stati analizzati i sistemi e le tecnologie disponibili in commercio in grado di offrire il servizio di distribuzione delle notifiche ai servizi client implementando il famoso pattern di messaggistica Publish/Subscribe. Per il design del sistema \`{e} stato, quindi, necessario acquisire una solida conoscenza dei sistemi distribuiti, dei problemi di concorrenza sui dati condivisi e dell’interfacciamento con database real-time. Il progetto ha previsto due attivit\`{a} principali: la progettazione e implementazione di una libreria lato client e l’automazione dell’avvio del server tramite Docker. In seguito all’analisi del software scelto per il server di sistema (RethinkDB) si \`{e} proceduto con un’attenta fase di progettazione della libreria di sistema UtilityRethink che garantir\`{a} ai servizi client l’interfacciamento con il server RethinkDB. Grazie a questa iniziale fase di analisi e progettazione si \`{e} potuto sviluppare un primo prototipo della libreria in .Net funzionante ed efficiente che garantisca il principale requisito del sistema. I servizi client attraverso la libreria e interagendo con il server RethinkDB potranno sia inviare nuove notifiche, sia registrarsi per ricevere quelle per cui sono interessati.},
    apice = {PushNotificationsOnRethinkDB},
    author = {Foschini, Francesco},
    howpublished = {Distributed Systems, A.Y. 2021/2022},
    month = apr,
    sort = {classic},
    supervisor = {Ciatto, Giovanni},
    title = {Progettazione e sviluppo di un sistema distribuito di notifiche basato su database realtime},
    type = {Standard Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-foschini-ay2122},
    year = 2022
}
@courseproject{authenticationprotocols-sd2021,
    abstract = {L’ISO/IEC 27000 definisce l’autenticazione come “un processo utilizzato per confer- mare che una caratteristica dichiarata di un’entit\`{a} sia effettivamente corretta”. L’autenticazione consiste, dunque, nel processo di verifica della rivendicazione di una determinata propriet\`{a}. Il progetto intende fornire una panoramica dei principali protocolli di autenticazione, analizzandone le debolezze ed i punti di forza; come caso di studio di quanto trattato, illustra l’esecuzione di un protocollo di autenticazione basato su password utilizzato da una web application sviluppata; tale protocollo viene eseguito dai partecipanti in scenari differenti che dipendono dalla configurazione dei sistemi interessati; per ciascun scenario viene effettuata un’autovalutazione della sicurezza dei sistemi, che partecipano al protocollo, sotto forma di vulnerability assessment, mediante l’utilizzo di un sistema terzo con il ruolo di avversario, che effettua attacchi ai danni dei partecipanti allo scopo di individuare le credenziali di autenticazione. Il progetto \`{e} strutturato secondo il seguente schema: presentazione generale con premesse concettuali e nozioni di base sui protocolli crittografici, la sicurezza computazionale, i protocolli di autenticazione, le tipologie di autenticazione, gli attacchi a tali protocolli e le convenzioni di comportamento dei partecipanti nell’esecuzione; trattazione dei principali protocolli esaminati, con particolare riferimento a quelli basati su password, su challenge-response ed a conoscenza zero, comprensiva per ciascun protocollo della descrizione delle caratteristiche, debolezze e punti di forza; illustrazione del caso di studio relativo alla web application sviluppata, che utilizza un protocollo di autenticazione basato su password, comprensivo dei dettagli di implementazione di tale applicazione e della virtualizzazione applicata ai sistemi realizzati che interagiscono con la stessa nell’esecuzione del protocollo, dell’autovalutazione della sicurezza di tali sistemi e di un approfondimento sull’implementazione del SSL/TLS e di ulteriori strategie di remediation alle debolezze del protocollo impiegato.},
    apice = {AuthenticationProtocols},
    author = {Latini, Guido},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = apr,
    sort = {survey},
    supervisor = {Omicini, Andrea},
    title = {Un’analisi dei principali protocolli di autenticazione corredata di un caso di studio},
    type = {Survey Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-latini-ay2021},
    year = 2022
}
@courseproject{apachepulsar-sd2021,
    abstract = {Il progetto ha lo scopo di studiare, presentare e testare le principali funzionalit\`{a} e caratteristiche della tecnologia Apache Pulsar (https://pulsar.apache.org/). Apache Pulsar \`{e} un sistema open-source di messaggistica distribuita, basata su publisher / subscriber, nativa per il cloud e originariamente creata su Yahoo. E` stato creato per alimentare le applicazioni critiche di Yahoo (e.g. Yahoo Mail, Yahoo Finance, Yahoo Sports).},
    apice = {ApachePulsar},
    author = {Ismam Abu},
    howpublished = {Distributed Systems, A.Y. 2020/2021},
    month = apr,
    sort = {technology},
    supervisor = {Ciatto, Giovanni},
    title = {Un’architettura multi-tenant ad alte prestazioni per la messaggistica server-to-server: Apache Pulsar},
    type = {Technology Project},
    url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-abu-ay2021},
    year = 2022
}
mostra tutti i 782 (482 in più, più lento)