Progetti di corso
| homehome | per annoper anno | per statoper stato | per tipoper tipo | personepersone | tag 965tag | tutti 782tutti | cercacerca |
progetto standard 328progetto avanzato 102progetto ludico 97progetto di rassegna 65progetto tecnologico 49progetto di ricerca 44progetto di prodotto 37progetto di simulazione 34progetto applicativo 13progetto didattico 13
782 record: qui il primo gruppo; per gli altri, sceglierne uno sopra.
progetto standard 328
@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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{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{settemmezzo-sd2122, abstract = {Si vuole sviluppare una versione digitale e distribuita del noto gioco di carte “Sette e mezzo”, seguendo alcune delle regole classiche ed altre che verranno rivisitate. L’obiettivo per i giocatori \`{e} avvicinarsi il pi\`{u} possibile al punteggio di sette e mezzo, sommando i punteggi delle carte che via via richiedono al “mazziere”, senza per\`{o} “sballare” (andare oltre). In tal caso si perde immediatamente. Gli utenti, per giocare, dovranno connettersi ad un applicativo CLI, che permetter\`{a} loro di creare o partecipare ad una stanza di gioco, tramite la quale potranno giocare con altri utenti. Nel momento in cui l’utente crea una stanza, egli dovr\`{a} scegliere il numero dei partecipanti che vi potranno entrare e il numero di round da svolgere. Quando la stanza sar\`{a} piena, il suo creatore potr\`{a} avviare la partita. All’avvio della partita, ogni giocatore ricever\`{a} dal mazziere una carta coperta casuale estratta dal mazzo. La carta iniziale pu`o essere vista solo dal giocatore che l’ha ricevuta. Da quel momento in poi il gioco si svolger\`{a} a turni. Ad ogni turno, al giocatore verr\`{a} domandato se desidera ricevere un’altra carta: in caso affermativo la carta verr\`{a} assegnata scoperta al giocatore, in modo che tutti i giocatori possano vederla. Questo procedimento si ripete fino a quando il giocatore di turno non decida di rifiutare la carta offerta dal mazziere, oppure nel caso abbia ottenuto un punteggio maggiore a sette e mezzo. Nel secondo caso, il giocatore ha ”sballato” e perde la manche, nel primo caso egli attender\`{a} a carte scoperte la fine della manche. Alla fine del round, vince chi si \`{e} avvicinato di pi\`{u} al punteggio di sette e mezzo, \`{e} possibile anche avere pi\`{u} vincitori. Questa sequenza di gioco verr\`{a} ripetuta tante volte quante \`{e} stato deciso alla creazione della stanza. La partita invece viene vinta da chi ottiene il numero maggiore di vittorie.}, apice = {Settemmezzo}, author = {Cortecchia, Angela and Micelli, Leonardo}, howpublished = {Distributed Systems, A.Y. 2021/2022}, month = mar, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Sette e Mezzo Clone}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-cortecchia-micelli-ay2122}, year = 2022 }
@courseproject{jadeloadbalancer-mas2021, abstract = {This project aims at creating an agent-based load balancer by means of JADE and Kubernetes (K8s). After an introduction in which the technologies used are presented, it will be described how the developed agents behave and how they interact with each other. Next, it will be explained how the whole infrastructure has been containerized and deployed to K8s, and how it has been addressed the problem of distributing the work across agents through the use of Prometheus and K8s’ Horizontal Pod Autoscaler thus, achieving an effective load balancer.}, apice = {JadeLoadbalancer}, author = {Matteo Milanese}, howpublished = {Multi-Agent Systems, A.Y. 2020/2021}, month = mar, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Load Balancer in JADE}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/mas/projects/mas-project-milanese-ay2021}, year = 2022 }
@courseproject{whatdoyoumeme-sd1920, abstract = {Like many board games before it, it’s time for “What Do You Meme” to have an online counterpart. The rules are simple: in each round, the player who is established as a judge has to pull a picture from the deck and place it on the board so that everyone can see it. Then each competitor chooses from the 7 caption cards in his hand the one that best describes the picture on the board. All the caption cards chosen by the players are collected and shuffled to faces covered by the judge. In this way the judge can decide the winner of that round with total impartiality after reading all the entries. In a clockwise direction each player becomes the judge of the next rounds. The winner is the one who first reaches the chosen maximum score. The project aims to implement an online and distributed version of the game, with a lobby system that allows groups of friends to play together.}, apice = {WhatDoYouMeme}, author = {Boschi, Francesco and Tumedei, Gianni and Rossi, Mattia}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = feb, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {What do you meme}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-boschi-rossi-tumedei-ay1920}, year = 2022 }
@courseproject{microservicebasedim-sd2021, abstract = {Sistema di messaggistica istantanea sviluppato seguendo le metodologie: Domain Driven Design DevOps e progettato a microservizi che comunicano ad eventi.}, apice = {MicroservicebasedIM}, author = {Angelini, Thomas and Deluigi, Luca and Magnani, Simone}, howpublished = {Distributed Systems, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Microchat: la chat a microservizi}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-angelini-deluigi-magnani-ay2021}, year = 2022 }
@courseproject{webauctionsystem-sd2122, abstract = {Progetto di un motore per la gestione delle aste online con il quale \`{e} possibile gestire le aste e le offerte. Il sistema offre caratteristiche di scalabilit\`{a}, fault tolerance e minima latenza operativa nel caso di inserimento delle offerte.}, apice = {WebAuctionSystem}, author = {Venturi, Matteo}, howpublished = {Distributed Systems, A.Y. 2021/2022}, month = feb, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Web Auction Systems}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-venturi-ay2122}, year = 2022 }
@courseproject{agentrace-as2021, abstract = {Agent Race is a multi-agent system designed to deepen its engineer’s skills on various topics of the Autonomous Systems course, while providing entertainment to its human users. This MAS represents a society where its agents’ purpose is to win a running race performed in straight lanes. When the system is deployed, many agent-athletes are spawn with different characteristics and each one of them will try its best to exploit its strengths and the mutable environmental conditions to arrive first to the finish line. Each agent perceives itself as well as the surrounding environment and the other competitors in the race and decides the best move to play next amongst many options, like sprinting, slowing down, stopping at a refreshment point when available. The environment plays a key role in the competition’s outcome influencing the behaviour of the agents through its traits and artifacts, like race length, weather conditions, agent’s lane conditions, refreshment points availability.}, apice = {AgentRace}, author = {Sperandio, Andrea}, howpublished = {Autonomous Systems, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Agent Race}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/as/projects/as-project-sperandio-ay2021}, year = 2022 }
@courseproject{slrparallellp-sa1920, abstract = {A logic program is expressed as a set of logical formulas precisely specifying what is true. This approach to programming is different from the others, where the concern is how a specific problem should be solved. Here, the specification how a problem is to be solved is expressed in the form of a precise sequence of steps executed by an engine. One of the most attractive features of logic programming is the clean separation of logic and control. The efficiency of the solution to a problem can be improved without any change in the solution itself. The programming language Prolog utilizing one of many possible evaluation (control) strategies, is an example of a successful logic programming language. The aim of this work is to understand how a logic program can be parallelized and what are the techniques studied in the last 30 years with an analysis of the problems arised. A Systematic Literature Review process has been carried out following a methodological approach, with the claim of becoming a starting point for defining new research areas and future projects.}, apice = {SlrParallelLp}, author = {Alessia Cerami and Giordano, Andrea}, howpublished = {Autonomous Systems, A.Y. 2019/2020}, month = sep, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Parallelism in Logic Programming: A Systematic Literature Review}, type = {Standard Project}, year = 2021 }
@courseproject{bacterialagent-as2021, abstract = {Bacterial Agent is a multi-agent system in which we will apply the arguments studied in the Autonomous Systems course. Our project turns out to be a reproduction of a bacterial colony, in which each bacterium will be a living being with a main goal to play, that is to survive and reproduce itself. These activities will be carried out within an environment shared with other bacteria. Each of them can coordinates with the other entities through the release of molecules in the environment. This method of communications allow them to cooperate in order to help each other in the surviving tasks. The purpose of the simulator, therefore, is to show the possible scenarios of the life of a bacterial colony, being a set of collaborative autonomous entities.}, apice = {BacterialAgent}, author = {Gnagnarella, Enrico and Scucchia, Matteo}, howpublished = {Autonomous Systems, A.Y. 2020/2021}, month = sep, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Bacterial Agent}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/as/20-21/projects/as-project-gnagnarella-scucchia-a.y.-20-21}, year = 2021 }
@courseproject{raftoverjade-sd1718, abstract = {Raft is a consensus algorithm enabling a distributed replicated state machine dynamics to evolve equally for all replicas. It can be used to build fault tolerant distributed systems. JADE is a Java framework easing the development of FIPA-compliant multi agent systems. This project aims at designing and implementing the RAFT consensus algorithm on top of JADE in order to: Achieve a deeper understanding of consensus and consensus algorithms Producing a testbed environment easing the development and testing of future fault tolerant distributed application Paving the way across novel permissioned Blockchain implementations The final JADE system should also enable to simulate network failures and agents faults, thus easing the stress-testing of applications.}, apice = {RaftOverJade}, author = {Pierfederici, Eugenio}, howpublished = {Distributed Systems, A.Y. 2017/2018}, month = sep, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Implementazione dell’algoritmo di consenso Raft su middleware JADE}, type = {Standard Project}, url = {https://gitlab.com/das-lab/blockchain/sd-project-pierfederici-1718}, year = 2021 }
@courseproject{gitselfhosted-sd2021, abstract = {Il progetto ha come obiettivo quello di studiare le possibili realizzazioni per una soluzione self-hosted che gestisca i repository Git di studenti e ricercatori dell’universit\`{a}. Git \`{e} un software di controllo di versione distribuito utilizzato per condividere e tenere traccia delle directory di progetti hostate sui server. L’idea generale \`{e} quella di hostare quindi nei server interni all’universit\`{a} i progetti degli studenti e ricercatori confrontando tra le feature delle soluzioni selezionate. Inoltre, oltre alle funzioni base, studiare ed eventualmente implementare il deploy delle soluzioni selezionate su Kubernetes e/o Docker. Le possibili soluzioni sono GitLab, Gogs, Gitea, Phabricator, GitBucket e altre alternative GitHub come GitPrep, Kallithea, TuleapL.}, apice = {GitSelfHosted}, author = {Donati, Alberto and Rocco, Alessia}, howpublished = {Distributed Systems, A.Y. 2020/2021}, month = aug, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Self Hosted Git}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-donati-rocco-ay2021}, year = 2021 }
@courseproject{telemetryracevehicles-sd2021, abstract = {In alcuni contesti l'analisi della telemetria avviene solamente a gara conclusa. Risulterebbe, invece, molto utile ai team osservare e analizzare la telemetria in concomitanza con lo svolgimento della gara affinch\'{e} si possano attuare azioni di sicurezza malfunzionamento del veicolo, ecc.) oppure per gestire stategie da adottare per migliorare la prestazione. Il sistema ha l'obiettivo di collezionare i dati provenienti dalla telemetria dei veicoli. Nello specifico il sistema ha il compito di immagazzinare i dati della telemetria in tempo reale e renderli fruibili al team per l'analisi. Inoltre il sistema prevede meccanismi di comunicazione tra pilota e ingnengere di pista facendo in modo che, in qualsiasi momento, il pilota possa essere avvisato di guasti, avvisi ecc. Infine il sistema fornisce un meccanismo di accesso ai dati da parte della federazione affinch\'{e} quest'ultima possa verificare in tempo reale il regolare svolgimento della corsa. Vista la criticit\`{a} e la riservatezza dei dati, il sistema adotta forme di autenticazione e autorizzazione in modo tale che utenti non autorizzati non siano in grado di prenderne visione.}, apice = {TelemetryRaceVehicles}, author = {Nicholas Farabegoli}, howpublished = {Distributed Systems, A.Y. 2020/2021}, month = aug, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Sistema di acquisizione telemetria da veicoli da corsa}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-farabegoli-ay-20-21}, year = 2021 }
@courseproject{moviepartywithmicroservices-sd2021, abstract = {Nel seguente elaborato si intente simulare la realizzazione di un progetto commissionato da un’azienda fittizia, in cui la prestazione riguarda l’aggiornamento di una piattaforma Web. Questa richiesta deriva da un notevole incremento di popolarit\`{a} del sistema, in cui si desidera quindi investire ottenendo un software maggiormente scalabile, resiliente ai guasti e con una maggiore indipendenza tra i vari servizi esposti. Il team di sviluppo adotter\`{a} quindi varie tecniche di ingegnerizzazione per soddisfare le richieste del cliente, aumentando al contempo il business value del prodotto.}, apice = {MoviePartyWithMicroservices}, author = {Rei Beshiri and Vaienti, Andrea}, howpublished = {Distributed Systems, A.Y. 2020/2021}, month = jul, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {MovieParty with Microservices}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-beshiri-vaienti2-ay2021}, year = 2021 }
@courseproject{agentsmanagedwarehouse-sd1920, abstract = {Rispetto a qualche decennio fa, oggi i magazzini hanno al loro interno una notevole mole di complessit\`{a}. La ricerca di sempre pi\`{u} efficienza ha infatti portato col tempo le aziende a fornire ai loro dipendenti strumentazioni per rendere pi\`{u} agevole e produttivo il lavoro, e le pi\`{u} grandi di queste hanno addirittura sostituito parte del lavoro dipendente con macchine totalmente automatizzate. Prendendo in considerazione quest’ultima casistica, la pratica attuale pi\`{u} comune consiste nell’automatizzare il deposito per mezzo di pochi PLC che si occupino della gestione del sistema nel suo complesso. Tramite l’implementazione di un sistema in cui ogni macchina appaia come un agente robotico, si vuole fornire un’alternativa distribuita alla pratica di centralizzazione attuale. In questa visione, le macchine dovranno gestire ordini entranti, recuperare i prodotti richiesti e risultare il pi\`{u} flessibili possibile, anche tramite l’upgrade automatico di conoscenza procedurale nello svolgimento di attivit\`{a} ‘non standard’.}, apice = {AgentsManagedWarehouse}, author = {Paolo Baldini}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = may, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {AMW -- Agents Managed Warehouse}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-baldini-1920}, year = 2021 }
@courseproject{donatiwebappgeolocal-sd2021, abstract = {Il progetto verte alla realizzazione di un’applicazione web in grado di fornire uno strumento per il monitoraggio dinamico di entit\`{a} geo-localizzate, sfruttando tecnologie come Express, Vue, Node.js e servizi esterni. L’obiettivo principale di questa applicazione \`{e} di permettere ad un suo utilizzatore di poter scegliere la tipologia di entit\`{a} che desidera monitorare (e.g. ve- icoli, pazienti di un ospedale), configurando, tramite un file apposito, i criteri e i parametri per i quali queste entit\`{a} vengono monitorate e/o evidenziate a schermo. La scelta di questi elementi tramite il file di configurazione permette anche, in maniera automatica e dinamica, la costruzione di un’interfaccia utente perfettamente e strettamente adattata alle esigenze espresse dall’utilizzatore. L’applicazione permette anche una continua constestualizzazione geografica tramite un processo di reverse-geocoding. {{stringEngIta eng="thesis" ita="tesi"}}{{/stringEngIta}}}, apice = {DonatiWebappgeolocal}, author = {Donati, Michele}, howpublished = {Distributed Systems, A.Y. 2020/2021}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Monitoraggio dinamico di entit\`{a} geo-localizzate: un’applicazione web modulare}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-donati-aa1920}, year = 2021 }
@courseproject{zyzzyva-sd2021, abstract = {Nell’ambito dei sistemi distribuiti, caratterizzati dall’assenza di memoria condivisa, il modo pi\`{u} diffuso che hanno i processi di comunicare tra loro \`{e} con uno scambio di messaggi attraverso una rete asincrona. L’assenza di memoria condivisa implica il fatto che ci potrebbero essere delle inconsistenze nello stato dei vari nodi che compongono il sistema con conseguente invio di dati errati all’applicazione che li richiede; altre possibilit\`{a} dovute all’architettura distribuita possono essere fallimento di un nodo del sistema o il fallimento della rete di comunicazione. Questi errori portano alla necessit\`{a} di implementare algoritmi per arrivare al consenso, cio\'{e} ottenere un accordo sullo stato del sistema tra macchine inaffidabili connesse in una rete asincrona. Nel contesto del consenso ha molta importanza raggiungere il consenso in un sistema che presenta la possibilit\`{a} di “Byzantine Failure”: il fallimento bizantino \`{e} relativo al problema che alcuni nodi del sistema potrebbero essere compromessi o comportarsi in maniera arbitraria, mandando quindi valori errati come risposta a una richiesta. Sono dunque nati vari algoritmi per assicurare sistemi con una Byzantine Fault Tolerance (BFT), dove per BFT si indica la capacit\`{a} di funzionare in modo corretto, e dunque raggiungere il consenso tra i nodi del sistema nonostante la presenza di nodi bizantini. Un contesto in cui questi algoritmi sono molto utilizzati \`{e} quello dei sistemi State Machine Replication (SMR), che \`{e} un metodo generale per implementare un servizio fault-tolerant replicando i server e coordinando le interazioni del client con le repliche server.}, apice = {Zyzzyva}, author = {Mormone, Giovanni and Aspee Encina, Fabian}, howpublished = {Distributed Systems, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Zyzzyva: analisi ed implementazione dell’algoritmo per consenso in sistemi distribuiti}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-mormone-aspee-encina-aa2021}, year = 2021 }
@courseproject{walmatespaggiari-foiot2021, apice = {WalmateSpaggiari}, author = {Federico Spaggiari}, howpublished = {Fundamentals of IoT, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {WalMate: Portable device for Identification and Card payments through NFC communication}, type = {Standard Project}, year = 2021 }
@courseproject{synthsenselogoluso-foiot2021, apice = {SynthsenseLogoluso}, author = {Mauro Logoluso}, howpublished = {Fundamentals of IoT, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {SynthSense: A new way of learning}, type = {Standard Project}, year = 2021 }
@courseproject{digitalphotoframepazlopes-foiot2021, apice = {DigitalphotoframePazlopes}, author = {Jaime Paz Lopes}, howpublished = {Fundamentals of IoT, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Device Proposal: Digital Photo Frame}, type = {Standard Project}, year = 2021 }
@courseproject{lanofthingsbidoiaserra-foiot2021, apice = {LanofthingsBidoiaserra}, author = {Filippo Bidoia and Roberta Serra}, howpublished = {Fundamentals of IoT, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Internet Offline: a Local Area Network of Things developed for hospitals}, type = {Standard Project}, year = 2021 }
@courseproject{smartglassesndtdenunzio-foiot2021, apice = {SmartglassesNdtDenunzio}, author = {Mirko De Nunzio}, howpublished = {Fundamentals of IoT, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Smart Glasses for NDT (Non-Destructive Testing)}, type = {Standard Project}, year = 2021 }
@courseproject{greenbeanderosa-foiot2021, apice = {GreenbeanDerosa}, author = {Fabrizia De Rosa}, howpublished = {Fundamentals of IoT, A.Y. 2020/2021}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Going Zero Waste: Building a sustainable world through technology}, type = {Standard Project}, year = 2021 }
@courseproject{sudokiller-sd1011, apice = {SudoKiller}, author = {Quarta, Riccardo and Tessarini, Jennifer and Collina, Francesca and Papini, Alessia and Balducci, Mattia}, howpublished = {Distributed Systems, A.Y. 2010/2011}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {SudoKiller}, type = {Standard Project}, year = 2020 }
@courseproject{reservatorassister-sd1011, apice = {ReservatorAssister}, author = {Venturi, Matteo}, howpublished = {Distributed Systems, A.Y. 2010/2011}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {A case study for Java RMI: Reservator Assister}, type = {Standard Project}, year = 2020 }
@courseproject{tusowandroid-sd1920, abstract = {Lo scopo del progetto consiste nell’utilizzo di un moderno middleware distribuito basato sul modello di coordinazione LINDA, all’interno di un ambiente Android. La volont\`{a} \`{e} quella di usufruire di un Tuple Space condiviso fornendo, cos\`{i}, interoperabilit\`{a} tra due o pi\`{u} dispositivi. In particolare l’obiettivo \`{e} quellodi armonizzare le API di TuSoW con le API di Android nonch\'{e} rendere il pi\`{u} naturale possibile l’impiego dello stesso framework per un programmatore Android. L'accesso allo spazio di Tuple, sia in lettura sia in scrittura, avviene mettendoa disposizione un insieme di primitive tra le quali poter scegliere sulla base dell’azione che si vuole intraprendere. Come ulteriore funzionalit\`{a} del sistema verr\`{a} studiato e sperimentato lo standard Wi-Fi Direct, il quale rappresenta una nuova metodologia di comunicazione tra dispositivi dotati di tecnologia Wi-fi.}, apice = {TusowAndroid}, author = {Francesca Tonetti and Ylenia Battistini}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = sep, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Sperimentazione del framework TuSoW in ambiente Android}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-battistini-tonetti-aa1920}, year = 2020 }
@courseproject{honeybadger-sd1920, abstract = {Nell’ambito dei sistemi distribuiti il problema del consenso ricopre un ruolo di primaria importanza. In questo report il problema del consenso viene dapprima formalmente introdottotte successivamente analizzato in base ai vari modelli e soluzioni proposti in letteratura. Viene poi presentato un algoritmo di consenso in grado di operare in modo completamente asincrono e in presenza di nodi bizantini: Honey Badger Byzantine Fault Tolerant (abbreviato semplicemente in Honey Badger o HoneyBadgerBFT). L’algoritmo viene dapprima analizzato e documentato sotto l’aspetto teorico, poi implementato in linguaggio Scala per mezzo delframework Akka sotto forma di libreria utilizzabile in applicazioni terze. È fornita un'applicazione per testare le funzionalit\`{a} della libreria che permette all’utente di instanziare ed osservare lo stato di avanzamento dell’algoritmo HoneyBadgerBFT.}, apice = {HoneyBadger}, author = {Andrea Giannini and Linda Guiducci and Magnini, Matteo}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = aug, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {HoneyBadgerBFT: studio, implementazionee utilizzo dell’algoritmo di consenso}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-giannini-guiducci-magnini-aa1920}, year = 2020 }
@courseproject{factorylinker-sd1920, abstract = {L’obiettivo del progetto \`{e} di mostrare le potenzialit\`{a} di Redis all’interno di un’architettura distribuita a microservizi. Redis \`{e} uno store in-memory open-source di strutture dati, usato come database, cache e message broker. Supporta vari tipi di strutture dati, dalle pi\`{u} semplici: stringhe, hash, liste, set alle pi\`{u} complesse: sorted set, bitmaps, hyperloglogs, indici geospaziali e infine gli stream. Gli stream risultano la struttura dati di riferimento all’interno del progetto in quanto, oltre a gestire la propagazione di dati, sono ripercorribili in entrambe le direzioni, perci\`{o} utilizzati anche come struttura dati di salvataggio delle informazioni raccolte, prima che queste vengano elaborate e successivamente storicizzate per le analisi a lungo termine. Gli stream in Redis offrono anche la possibilit\`{a} di gestire vari gruppi di consumatori, il che permette di imbastire un’architettura distribuita basata sul pattern produttore-consumatori. L’idea infatti \`{e} di utilizzare Redis come punto di raccolta e propagatore delle informazioni.}, apice = {Factorylinker}, author = {Semprini, Luca and Jacopo Ricciputi}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = jun, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Factory Linker}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-riciputi-semprini-aa1920}, year = 2020 }
@courseproject{spatialtuplesunity-sd1920, abstract = {Distributed multi-agent-systems greatly benefit from the advantages of the Linda model, however, the latest developments of mobile Augmented Reality applications require an approach that takes space into account as a first- class citizen. More specifically, the lack of a direct and natural support for space-aware and space-based coordination in tuple spaces brought the birth of the theoretical model Spatial Tuples, an extension of the basic Linda model where tuples are conceptually placed in regions of the physical world and the behaviour of primitives depends on the spatial properties of the coordinating agents, tuples and the topology of space. However a fulfilling implementation of Spatial Tuples had not been devel- oped yet, so the goal of this project was exploring the feasibility and suit- ability of Game Engines as a tool for implementing the spatial abstraction, thanks to their innate capabilities of modeling virtual geometric spaces. The Game Engine of choice is Unity due to its wide use in the academic field. This report presents the development of a prototype middleware based on Spatial Tuples, along with a case study to showcase the capabilities of the solution.}, apice = {SpatialtuplesUnity}, author = {Francesco Dente and Nemati, Shapour and Burattini, Samuele}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Suitability of Game Engine technologies for the implementation of a Spatial Tuple based middleware}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-burattini-dente-nemati-aa1920}, year = 2020 }
@courseproject{globalchat-sd1920, abstract = {Nell’ambito dei Sistemi Distribuiti si fa largo l’esigenza di poter condividere informazioni sempre pi\`{u} velocemente da vari dispositivi ed a fruizione di tutti. Per questo, i servizi di chat hanno conosciuto negli ultimi anni un’enorme diffusione, grazie alla sua capacit\`{a} di soddisfare efficacemente il bisogno di comunicazione del popolo di internet. Ad esempio, molti videogiochi o piattaforme online necessitano di chat in cui tutti gli utenti possano inviare e leggere messaggi velocemente. Solo recentemente per\`{o} esso \`{e} entrato a far parte di quella classe di servizi che un’azienda pu\`{o} utilizzare per aumentare la propria produttivit\`{a} incoraggiando il dialogo in tempo reale fra i dipendenti appartenenti a reparti o sedi distaccate. Tale ambito di utilizzo presuppone un’architettura maggiormente affidabile, che ne garantisca la disponibilit\`{a} con una certa qualit\`{a} di servizio rispetto ai modelli diffusi in ambiente Internet. A tal proposito, il presente lavoro si \`{e} prefissato l’obiettivo di realizzare un servizio di Chat Globale raggiungibile tramite Applicazione Web o Dispositivi Mobili (Android o iOS), in cui tutti gli utenti collegati possono eseguire l’accesso, assumere dei ruoli precisi all’interno della chat, inviare e leggere messaggi e partecipare alle conversazioni. In particolare, si andranno ad utilizzare i protocolli HTTP, WebSocket, Vert.X e Java. Altre caratteristiche sono state aggiunte in seguito durante la progettazione per aumentare l’affidabilit\`{a}, l’availability e l’efficienza del servizio.}, apice = {Globalchat}, author = {Oleg Konchenkov and Giovanni Poggi and Pasqualini, Elia}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Global Chat}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-konchenkov-pasqualini-poggi-1920}, year = 2020 }
@courseproject{bufferodunlami-foiot1920, apice = {BufferOdunlami}, author = {Oladayo Odunlami}, howpublished = {Fundamentals of IoT, A.Y. 2019/2020}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Buffer: Enchanted Thing}, type = {Standard Project}, year = 2020 }
@courseproject{smarthelmetlaso-foiot1920, apice = {SmarthelmetLaso}, author = {María Paz Laso Pinto}, howpublished = {Fundamentals of IoT, A.Y. 2019/2020}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {IoT in Occupational Safety: Smart Helmet}, type = {Standard Project}, year = 2020 }
@courseproject{guidancedementiaakawi-foiot1920, apice = {GuidanceDementiaAkawi}, author = {Caroline Marie Akawi}, howpublished = {Fundamentals of IoT, A.Y. 2019/2020}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Guidance: Dementia and the Internet of Things}, type = {Standard Project}, year = 2020 }
@courseproject{domotica-sd1920, abstract = {"HSH - Il comfort in casa tua" \`{e} un progetto che nasce con l’obiettivo di realizzare un sistema di Agenti fisici, al fine di simulare un servizio di- namico di domotica IoT. Gli Agenti sono realizzati tramite micro-controllori Arduino collocati fisicamente nell’ambiente domestico. La comunicazione e coordinazione tra di essi avviene tramite scambio di messaggi con un Agente Coordinatore, modellato tramite Raspberry, il quale offre servizi white/yellow pages per consentire la registrazione al MAS e la sua organizzazione. Ogni Agente, inteso come mero Sensore/Attuatore, lavora autonomamente al suo compito specifico, interagendo anche con gli altri per portare avanti una missione comune: migliorare la vita dell’utente umano nell’ambiente di casa.}, apice = {Domotica}, author = {Sperandio, Andrea}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {HSH: il comfort in casa tua}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-sperandio-aa1920}, year = 2020 }
@courseproject{tobydavico-foiot1920, apice = {TobyDavico}, author = {Alessandro Davico}, howpublished = {Fundamentals of IoT, A.Y. 2019/2020}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {TOBY: The First Universal Wireless Charger Empowered by A.I.}, type = {Standard Project}, year = 2020 }
@courseproject{bodylenseszacharopoulou-foiot1920, apice = {BodylensesZacharopoulou}, author = {Marina Zacharopoulou}, howpublished = {Fundamentals of IoT, A.Y. 2019/2020}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Body Lenses: Internet of Healthy Things}, type = {Standard Project}, year = 2020 }
@courseproject{firedetection-sd1920, abstract = {In the urbanisation process, new technologies are playing a key role in improving the quality of life through sustainable resource management. These technologies are adopted to distribute and deploy in the environment the systems useful to carry out all the functionalities necessary for its monitoring and control. Wireless Sensor Networks are application-specific, and therefore must to involve both software and hardware. The aim of this project is the creation of a Multi-Agent System that allows the control of Wireless Sensor Networks by reducing as much as possible the dependence on specific scenarios. In order to test the results obtained, Forest Fire Detection was chosen as a case study. The whole work will be focused on the design of the Multi-Agent System and to the development of the software through the use of the framework Smart Python Agent Development Environment (SPADE). Anything related to the hardware part goes beyond the aspects related to the Distributed Systems and therefore the interactions of sensors and actuators with the environment will be simulated through data streams.}, apice = {Firedetection}, author = {Filippo Paganelli}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = mar, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Forest Fire Detection using Multi-Agent Systems and Wireless Sensor Networks}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-paganelli-1920}, year = 2020 }
@courseproject{smartcockpithubmariani-foiot1920, apice = {SmartcockpithubMariani}, author = {Matteo Mariani}, howpublished = {Fundamentals of IoT, A.Y. 2019/2020}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Smart Cockpit Hub: IoT Twins and Metal 3D Printing, the Final Solution to Machines Failure}, type = {Standard Project}, year = 2020 }
@courseproject{brainstimulationzubytska-foiot1920, apice = {BrainstimulationZubytska}, author = {Anna Zubytska}, howpublished = {Fundamentals of IoT, A.Y. 2019/2020}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {IoT-powered intelligent object boosting the capacity of human brain}, type = {Standard Project}, year = 2020 }
@courseproject{masmsp-sd1920, abstract = {Oggi giorno sempre pi\`{u} aziende medio piccole si affidano a terzi per la gestione del IT at- traverso un meccanismo ben conosciuto chiamato Outsourcing. Tra i vari servizi di questo tipo troviamo il Managed Service Provider (o MSP) che \`{e} una tipologia di outsourcing di tutto l’apparato informatico in base alle esigenze e alle possibilit\`{a} del cliente. Le aziende che forniscono il servizio spesso si trovano a lavorare con moltissime aziende e, di con- seguenza, con reti formate da molti dispositivi, con vari compiti e controlli da svolgere. Per queste aziende \`{e} necessario avere del personale competente in grado di gestire e ri- solvere eventuali problemi da remoto qualora si verificassero dei malfunzionamenti o in locale in caso la rete dovesse cadere. Spesso per queste aziende avere un sistema di con- trollo autonomo che anche in caso di isolamento continui a svolgere il suo lavoro e provi a ristabilire in autonomia una connessione pu\`{o} rappresentare un guadagno enorme in ter- mini di tempo ma anche economici. In pi\`{u} queste tecnologie spesso sono scritte attraverso l’uso di linguaggi e framework complicati e potenti che, da un lato garantiscono affidabil- it\`{a} e potenza computazionale, dall’altro fanno si che il tecnico informatico medio fatichi a metterci mano per risolvere anche i problemi pi\`{u} semplici. Con questo progetto vogliamo inserirci in questo spazio e creare quindi un sistema che provi a gestire queste problem- atiche. Questo progetto sar\`{a} per aziende medio piccole che necessitano di un sistema di Remote Management. Quindi per avere un sistema di controllo dei vari servizi offerti facile e veloce. Il fornitore quindi potr\`{a} monitorare i servizi IT forniti utilizzando un sistema dis- tribuito che garantir\`{a} una certa autonomia dei singoli servizi, il controllo su di essi per garantire un corretto funzionamento e una serie di funzionalit\`{a} per gestire runtime prob- lematiche comuni senza l’intervento diretto di un operatore.}, apice = {Masmsp}, author = {Lorenzo Valgimigli and Riccardo Soro}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Sistema Multi-Agente per il supporto agli MSP}, type = {Standard Project}, year = 2020 }
@courseproject{ethereumsmartcontract-sd1920, abstract = {L’idea del progetto in questione \`{e} nata dalla necessit\`{a}, da parte del mercato dell’usato di veicoli stradali, di rendere la compravendita il pi\`{u} trasparente ed affidabile possibile. Essendo oggigiorno molto frequenti le truffe dovute alla vendita di mezzi con conta chilometro alterato, in quanto il chilometraggio di un mezzo \`{e} il fattore chiave considerato dai consumatori al momento dell’acquisto, si \`{e} deciso di sviluppare una tecnologia in grado di prevenire la modifica di quest’ultimo. Un’ acquisto trasparente permetter\`{a} al consumatore di valutare i costi di manutenzione futura che ne deriveranno. L’idea proposta \`{e} di creare una dApp (applicazione decentralizzata), basata su Smart Contract Ethereum, in grado ricevere segnali inviati dai veicoli (relativi al chilometraggio), per poi memorizzarli in un registro pubblico e distribuito. L’integrit\`{a} dei dati all’interno di questa nuova tecnologia sar\`{a} estremamente affidabile, in quanto basata su blockchain e smart contracts. Una attenta fase di analisi \`{e} stata seguita da una fase di progettazione, nella quale si sono valutate e successivamente definite le scelte architetturali adottate. Lo sviluppo dello Smart Contract ha seguito un approccio test driven, portando a termine con successo i test progettati. Ci si \`{e} concentrati poi sullo sviluppo di una tecnologia client in grado di poter interagire con la rete blockchain, sulla quale si sono eseguiti i test grazie al framework Truffle. Essendo riuscito a potare a termine gli obiettivi definiti si pu\`{o} quindi concludere di avere portato a termine con successo il progetto entro la deadline prevista.}, apice = {EthereumSmartcontract}, author = {Filippo Pistocchi}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = dec, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Ethereum Smart Contract dApp for vehicle mileage tracking}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-pistocchi-1920}, year = 2019 }
@courseproject{dbreplicationdocker-sd1920, abstract = {Databases replication and sharding operations are not widely spread as theuse of databases themselvers. This is amenable to its complexity that might discourage from embarking in the development steps and action needed to deployit. This project aims to discover a potential solution on how to integrate such technologies with Docker Swarm’s orchestration capabilities to improve load-balancing perfomance and data consistency, while simplifying the process andproviding a basic “know-how”, from a technological standpoint, on how all theservices used in the operation work.}, apice = {DbReplicationDocker}, author = {Cardiota, Andrea}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = dec, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Database replication with Docker Swarm}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-cardiota-1920}, year = 2019 }
@courseproject{bookingjadeagatensibracci-sd1819, apice = {BookingJadeAgatensibracci}, author = {Luca Agatensi and Elia Bracci}, howpublished = {Distributed Systems, A.Y. 2018/2019}, month = sep, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Booking JADE Project}, type = {Standard Project}, year = 2019 }
@courseproject{lpaasondocker-sd1718, abstract = {Il progetto, sviluppato nell’ambito del corso di Sistemi Distributi, ha lo scopo di realizzare deploy e distribuzione di LPaaS (Logic Programming as a Service) con un approccio a container. A tal fine ci \`{e} stato richiesto di integrare la pi\`{u} recente versione di LPaaS con le moderne tecnologie di containerizzazione; una volta fatto ci\`{o}, avremmo dovuto valutare una piattaforma per la distribuzione dei container cos\`{i} realizzati con particolare attenzione alla gestione dello stato interno.}, apice = {LpaasOnDocker}, author = {Nicolò Maltoni and Federico Naldini}, howpublished = {Distributed Systems, A.Y. 2017/2018}, month = sep, sort = {classic}, supervisor = {Mariani, Stefano}, title = {LPaaS on Docker}, type = {Standard Project}, year = 2019 }
@courseproject{tucsonrefactoring-sd1920, abstract = {The purpose of this project is to refactor the TuCSoN Java library. In particular the main goal is to make all of the main five modules independent and to split the core into four sub-modules. Subsequently we focus on the dependencies of the main five modules, and especially all the external libraries that need to be imported from Maven and must be included in the jars. A side goal is to create JUnit test for end-to-end.}, apice = {TucsonRefactoring}, author = {Stefano Bernagozzi}, howpublished = {Distributed Systems, A.Y. 2019/2020}, month = aug, sort = {classic}, supervisor = {Mariani, Stefano}, title = {TuCSoN refactoring}, type = {Standard Project}, url = {http://gitlab.com/pika-lab/tuples/tucson/-/tree/feature/bernagozzi}, year = 2019 }
@courseproject{dynechiossi-sd1819, apice = {DyneChiossi}, author = {Antony Chiossi}, howpublished = {Distributed Systems, A.Y. 2018/2019}, month = jul, sort = {classic}, supervisor = {Omicini, Andrea}, title = {DyNE (Dynamic Network Enumeration)}, type = {Standard Project}, year = 2019 }
@courseproject{mmpnboomparty-sa1718, abstract = {Il progetto \`{e} realizzato come artefatto finale per dimostrare la conoscenza acquisita durante il corso di Sistemi Autonomi. Boom Party mira, partendo dalle logiche di un gioco di societ\`{a}, a modellare situazioni altamente dinamiche in cui le intenzioni del singolo individuo sono il risultato dell’unione tra gli obiettivi personali e quelli della collettivit\`{a} a cui appartengono. La simulazione consiste nella progettazione di un MAS con gli strumenti forniti durante il corso. In particolare nella relazione viene descritto come \`{e} stata affrontata l’integrazione delle varie tecnologie (Jason, Tucson e Cartago) cos\`{i} come la logica adottata durante la fase di progettazione. Sono inoltre presentati gli eventuali spunti per evoluzioni future, utilizzando il progetto realizzato come framework.}, apice = {MmpnBoomParty}, author = {Maestri, Luca and Masini, Gioele and Pruccoli, Andrea and Neri, Alessandro}, howpublished = {Autonomous Systems, A.Y. 2017/2018}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Boom Party: Simulazione Two Rooms and a Boom}, type = {Standard Project}, year = 2019 }
@courseproject{lindamqtt-sd1819, abstract = {Il progetto si pone come obiettivo quello di definire e realizzare un’interfaccia che permetta di interagire con uno o pi\`{u} tuple space Linda, attraverso una comunicazione basata esclusivamente su MQTT. MQTT \`{e} un protocollo di rete a livello applicativo di tipo publish/subscribe e, per questo, \`{e} richiesta la presenza di un server centrale (broker) che permetta la diffusione dei messaggi ai vari client. L’interfaccia che sar\`{a} realizzata dovr\`{a} fungere da tramite fra i client connessi al broker MQTT ed uno o pi\`{u} tuple space Linda (gestiti eventualmente da un sistema separato). Per rendere possibile l’intercomunicazione dei due sistemi dovr\`{a} essere introdotto un client speciale (PS-Linda Server) connesso al broker MQTT. Esso rimarr\`{a} in ascolto dei messaggi provenienti dagli altri client MQTT (PS-Linda Client), li interpreter\`{a} e li tradurr\`{a}, inoltrandoli poi come richieste di operazioni (primitive) al sistema Linda. La risposta prodotta dal sistema Linda sar\`{a} quindi tradotta in un messaggio MQTT ed inoltrata ai client in attesa di essa. Il formato dei messaggi e le regole di interpretazione e traduzione saranno specificate esaurientemente dall’interfaccia che sar\`{a} definita. I canali di comunicazione fra il PS-Linda Server ed i PS-Linda Client saranno definiti da specifici topic del pattern publish/subscribe. Inoltre, sfruttando le funzioni di autenticazione ed autorizzazione messe a disposizione dal broker MQTT sar\`{a} possibile ottenere un sistema sufficientemente sicuro, poich\'{e} i vari client potranno leggere o scrivere solamente su determinati topic specificati.}, apice = {LindaMQTT}, author = {Barbieri, Edoardo and Lorenzo Mondani and Emanuele Pancisi}, howpublished = {Distributed Systems, A.Y. 2018/2019}, month = mar, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {PS-Linda with MQTT (Publish Subscribe Linda)}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-aa1819-barbieri-mondani-pancisi}, year = 2019 }
@courseproject{chilllpaas-sd1819, apice = {ChillLpaas}, author = {Marco Canducci and Eugenio Cavina}, howpublished = {Distributed Systems, A.Y. 2018/2019}, month = mar, sort = {classic}, supervisor = {Omicini, Andrea}, title = {ChiLL with LPaaS: Chess in Logic Language with Logic Programming as a Service}, type = {Standard Project}, year = 2019 }
@courseproject{lindagrpc-sd1819, abstract = {Lo scopo del progetto \`{e} quello di modellare ed implementare un'interfaccia lato server per LINDA ed integrarla con gRPC. Utilizzando gRPC un'applicazione client pu\`{o} direttamente invocare metodi su un'applicazione server remota come se la chiamata avvenisse su un oggetto locale, ci\`{o} favorisce lo sviluppo di applicazioni distribuite e l'integrazione di sistemi sviluppati in linguaggi di programmazione differenti. Lato server, vengono esposti tramite interfacce i metodi che possono essere invocati e viene eseguito un processo (gRPC server) per la gestione delle richieste da parte del client. gRPC agevola notevolmente il processo di definizione delle interfacce avvalendosi di un linguaggio IDL chiamato proto (giunto alla versione 3). In tale linguaggio, metodi appartenenti al medesimo concetto applicativo vengono racchiusi all'interno dello stesso servizio. Lato client, attraverso uno stub sar\`{a} possibile interrogare i servizi (con relativi metodi) disponibili sul server. gRPC utilizza i protocol buffer per la serializzazione e la de-serializzazione dei dati, agevolando lo scambio di informazioni tra gli end point applicativi. Tramite i protocol buffer si definiscono le strutture dati che verranno fornite e restituite ai/dai servizi remoti}, apice = {LindaGRPC}, author = {Daniele Rossi and Giacomo Tontini}, howpublished = {Distributed Systems, A.Y. 2018/2019}, month = feb, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {ReLINDA: Un'interfaccia gRPC per l'utilizzo di LINDA in remoto}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-aa1819-rossi-tontini}, year = 2019 }
@courseproject{ltsgenerator-sd1718, abstract = {L'elaborato tratta uno degli argomenti visti a lezione nell'anno accademico 2018/2019: le Process Algebrae. L'algebra dei processi \`{e} un formalismo che consente di modellare sistemi concorrenti e distribuiti che eventualmente interagiscono tra loro. L'algebra dei processi offre la possibilit\`{a} di: rappresentare la struttura e il comportamento di un sistema concorrente; fare "verification" del funzionamento del sistema. In questo progetto, andremo a considerare solo il primo caso.}, apice = {LtsGenerator}, author = {Chiara Volonnino and Lucchi, Giulia}, howpublished = {Distributed Systems, A.Y. 2017/2018}, month = feb, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Labelled Transition Systems Generator}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ ds-project-aa1718-lucchi-volonnino}, year = 2019 }
@courseproject{vertxrecommenderapi-sd1718, abstract = {Il recommender system \`{e} un prodotto healthcare che mette in stretta relazione il paziente con il proprio medico, cambiando il modo classico di portare avanti le procedure cliniche. Il sistema non si ferma alle semplici prescrizioni del clinico, ma sfrutta wearable technologies utilizzate dal soggetto in cura per un monitoraggio sugli obiettivi che deve conseguire. Il monitoraggio e le prescrizioni sono alla base dell’intero prodotto, introdotti nel software rispettivamente come accomplishment (o fulfillment) e prescriptions. L'obiettivo del progetto \`{e} la creazione di un sistema distribuito basato su un'architettura a microservizi per esporre le API del Recommender System. L'implementazione vera e propria di questo backend segue una fase di design delle API RESTful, in cui vengono definiti tutti i dettagli: dai modelli degli oggetti da restituire come HTTP response fino ai parametri delle HTTP requests.}, apice = {VertxRecommenderApi}, author = {Zanotti, Giacomo}, howpublished = {Distributed Systems, A.Y. 2017/2018}, month = feb, sort = {classic}, supervisor = {Mariani, Stefano}, title = {Microservizi con Vert.x: Creazione di un Recommender System}, type = {Standard Project}, url = {https://bitbucket.org/agentgroup/rs-physical-activity.git}, year = 2019 }
@courseproject{edith-sd1819, abstract = {Oggigiorno alcune grandi aziende come SAP Sistemi, stanno investendo sullo sviluppo di nuove tecnologie per l’industria 4.0, che mirano all’automazione assistita per il personale di quello che pu\`{o} essere un ambiente industriale. Ad esempio viene sempre pi\`{u} automatizzata l’assistenza nelle mansioni quotidiane degli operai all’interno dei magazzini. Mediante dispositivi wearable, i lavoratori vengono seguiti e indirizzati nello svolgimento dei loro compiti, risultando pi\`{u} efficienti e permettendo al sistema di essere distribuito e, nella quasi totalit\`{a}, autonomo. EDITH \`{e} un sistema di controllo dell’esecuzione dei compiti, distribuito e autonomo che consente di migliorare la produttivit\`{a} degli operai e quindi dell’intero magazzino, coordinando il carico di lavoro tra il personale, in base alla disponibilit\`{a} dello stesso.}, apice = {Edith}, author = {Gnagnarella, Enrico and Scucchia, Matteo}, howpublished = {Distributed Systems, A.Y. 2018/2019}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {EDITH: Prototipo per l’Ambiente di Lavoro nell’Industria 4.0}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/sd-project-gnagnarella-scucchia-1920}, year = 2019 }
@courseproject{tusowinspectability-sd1819, abstract = {Il progetto si propone l'obiettivo di fornire un modulo aggiuntivo per TuSoW in grado di interfacciarsi con esso, avente il compito specifico di implementare un servizio di monitoraggio attraverso un'interfaccia grafica. Fornir\`{a} la possibilit\`{a} di dialogare con TuSoW tramite le primitive gi\`{a} implementate, operando all'interno di spazi di tuple, e sar\`{a} presente la possibilit\`{a} di osservare il fusso di richieste ed eventi e il loro sviluppo all'interno del webserver. Le funzionalit\`{a} descritte verranno sviluppate tramite Javascript, che gestir\`{a} l'invio di richieste direttamente al web service. Inoltre verr\`{a} adottato il pattern publish/subscribe (senza un'autenticazione) per poter dare la possibilit\`{a} di ispezionare cio che avviene all'interno degli spazi di tuple.}, apice = {TuSoWInspectability}, author = {Chiara Forresi and Montalti, Giacomo}, howpublished = {Distributed Systems, A.Y. 2018/2019}, month = jan, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Observability module for TuSoW enabling a Web-based monitoring (graphical) interface}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-aa1819-forresi-montalti}, year = 2019 }
@courseproject{beedsl-sd1819, abstract = {The agent-oriented framework which we implemented and employed towards the end of the Distributed Systems course has proven to be able to handle the creation, execution and communication between agents effectively. Still, its verbosity and complexity might discourage its usage for the implementation of concurrent and reactive systems of varying scale. The main goal of this project is to develop a Domain Specific Language which simplifies the definition of agents and behaviours, in order to let the users focus on the problem they are trying to solve, rather than on the underlying infrastructure.}, apice = {BeeDSL}, author = {Rizzato, Lorenzo and Bonarrigo, Manuel}, howpublished = {Distributed Systems, A.Y. 2018/2019}, month = jan, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {Behaviour Editing Environment: a simple agent-oriented DSL}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/courses/ds/projects/ds-project-aa1819-bonarrigo-rizzato}, year = 2019 }
@courseproject{hqpoverakka-sd1718, abstract = {This project aims to implement HQ: a hybrid state machine replication protocol with Byzantine-fault-tolerance. HQ employs a lightweight quorum-based protocol when there is no contention, but uses BFT to resolve contention when it arises, this is why it is called hybrid. The system has been implemented using akka actors and scala as programming language, keeping in mind every details of HQ. Some details has been fitted because of the constraints of the actors paradigm, and it was added an optimization, called "Early Grants", described by the authors of HQ. Testing phase was done using various cases attached in "Entry Point" file, based on the examples described the original paper.}, apice = {HqpOverAkka}, author = {Mattia Oriani and Federico Vitali}, howpublished = {Distributed Systems, A.Y. 2017/2018}, month = dec, sort = {classic}, supervisor = {Ciatto, Giovanni}, title = {HQ Replication: A Hybrid Quorum Protocol for Byzantine Fault Tolerance}, type = {Standard Project}, url = {https://gitlab.com/pika-lab/blockchain/sd-project-oriani-vitali-1718}, year = 2018 }
@courseproject{bftbct-sd1718, abstract = {In the last few years topics like Blockchain, cryptocurrency, Bitcoin and Ethereum have become very popular and have catalyzed global interest. Even if the publication of the Bitcoin protocol by Satoshi Nakamoto dates back to 2008 it is closely related to an older and classic problem in information technology described by Leslie Lamport, Robert Shostak and Marshall Pease in their 1982 paper, ”The Byzantine Generals Problem”. In this report, a description and analysis of the relationship between topics like the Byzantine Generals Problem, Byzantine Fault Tolerance, consensus and Blockchain is presented.}, apice = {BftBct}, author = {Nicola Santolini}, howpublished = {Distributed Systems, A.Y. 2017/2018}, month = aug, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Byzantine Fault Tolerance and Blockchain}, type = {Standard Project}, year = 2018 }
@courseproject{vertxmom-sd1718, apice = {VertxMom}, author = {Martina Magnani and Mattia Vandi}, howpublished = {Distributed Systems, A.Y. 2017/2018}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Vert.x come MOM per Sistemi Distribuiti}, type = {Standard Project}, year = 2018 }
@courseproject{smarthometucson-sd1617, apice = {SmarthomeTucson}, author = {Maestri, Luca and Masini, Gioele and Pruccoli, Andrea}, howpublished = {Distributed Systems, A.Y. 2016/2017}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Smarthome Framework}, type = {Standard Project}, url = {https://bitbucket.org/GioeleMasini/progetto-sistemi-distribuiti/src/master/}, year = 2018 }
@courseproject{gomathrosamazzini-sd1617, apice = {GomathRosamazzini}, author = {Edoardo Rosa and Lisa Mazzini}, howpublished = {Distributed Systems, A.Y. 2016/2017}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {GoMath}, type = {Standard Project}, year = 2017 }
@courseproject{trademas-sd1617, abstract = {Questo progetto si pone come obiettivo quello di realizzare un Sistema Multi Agente (sviluppato con il framework JADE) per l’organizzazione del trasporto di merci su strada; da una parte sono presenti gli attori che offrono il servizio di trasporto (spedizioniere, chiamato in seguito shipper), dall’altra avremo coloro che richiedono uno spostamento di merci (contraente, chiamato in seguito buyer). Le due tipologie di soggetti saono in competizione tra di loro e sar\`{a} compito del sistema a trovare soluzioni che riescano, tendenzialmente, a massimizzare gli obiettivi ed i vincoli dei partecipanti.}, apice = {TradeMas}, author = {Massimiliano Giunchi}, howpublished = {Distributed Systems, A.Y. 2016/2017}, month = aug, sort = {classic}, supervisor = {Omicini, Andrea}, title = {TradeMAS -- Trade Multiagent System}, type = {Standard Project}, year = 2017 }
@courseproject{quidditchcesariosasso-sa1617, abstract = {Lo scopo di questo progetto \`{e} quello di modellare e di implementare un sistema multi-agente in grado di simulare una partita del gioco magico del Quiddich. L’obiettivo della simulazione non \`{e} quello di costruire un ambiente che simuli la realt\`{a}, bens\`{i} di analizzare il comportamento globale dei giocatori che emerge, avendo modellato solo comportamento locali. Durante questa breve relazione metteremo in risalto aspetti fondamentali della teoria che abbiamo cercato di applicare nella simulazione La tecnologia scelta per la parte implementativa del progetto \`{e} NetLogo Questi sono i passi che abbiamo seguito per lo studio di simulazione: Analisi del sistema reale, con l’obiettivo di comprenderne le caratteristiche Costruzione di un modello dal sistema reale, evitando aspetti non rilevanti per la simulazione Costruzione di una rappresentazione eseguibile del modello Analizzare gli output della simulazione comparandoli con il sistema reale}, apice = {QuidditchCesariosasso}, author = {Lisa Cesario and Greta Sasso}, howpublished = {Autonomous Systems, A.Y. 2016/2017}, month = jul, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Il Quidditch}, type = {Standard Project}, year = 2017 }
@courseproject{rabbitmq-sd1617, abstract = {Le fasi per la realizzazione della ricetta sono Analisi e realizzazione di un web service (API RESTFul - ROA) che comunica con servizi dedicati, tramite un sistema di messaggistica a code. Analisi e realizzazione dell’ infrastruttura per lo scambio di messaggi, utilizzando RabbitMQ (http://www.rabbitmq.com/getstarted.html). Realizzazione di micro-servizi distribuiti (SOA), al fine di rispondere alle richieste effettuate dalle API tramite messaggi. Considerazioni sui risultati ottenuti, confrontandoli con un’architettura non distribuita evidenziandone i vantaggi e gli svantaggi.}, apice = {Rabbitmq}, author = {Martina Gabellini}, howpublished = {Distributed Systems, A.Y. 2016/2017}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Messaggi, Code, API e RabbitMQ: ingredienti per una ricetta veloce di un’architettura distribuita}, type = {Standard Project}, year = 2017 }
@courseproject{semanticmatchmaking-sd1516, abstract = {The project aims at experimenting with the Mini-ME semantic matchmaking engine for ubiquitous computing. In order to do that, it is necessary to firstly get acquainted with the problem domain, that is, semantic matchmaking. Then, it is possible to experiment with the Mini-ME engine, in particular, with the goals of using it from Java on both laptops and Android devices, and (ii) investigate the expressiveness gap (if any) w.r.t. the most common reasoning engines for the semantic web—e.g. Pellet, JFact, or HermiT}, apice = {Semanticmatchmaking}, author = {Missere, Mattia}, howpublished = {Distributed Systems, A.Y. 2015/2016}, keywords = {Semantic Web of Things, Reasoners, Web Ontology Language OWL, Mini-ME, Protege}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Semantic matchmaking on resource-constrained devices}, type = {Standard Project}, year = 2017 }
@courseproject{crawlingraspi-sd1516, abstract = {The project aims at building a distributed web crawling infrastructure, whose functionality is to fetch publications' metadata from the APICe online repository, provided a set of keywords are given for searching. As far as non-functional properties are concerned, the infrastructure should be: distributed and open, that is, any number of web crawlers may be deployed on any number of networked machines, possibly even at run-time fault-tolerant to disconnections and crashes, that is, both disconnections and crashes should be detected as soon as possible and (ii) properly managed -- e.g., crawling tasks of the disconnected/crashed crawler re-assigned -- resource-efficient, that is, the infrastructure should be able to execute smoothly on resource-constrained devices—e.g., RasPi systems Usage of either the TuCSoN middleware for coordinating crawlers, or (ii) the JADE framework for programming crawlers is mandatory. Usage of both is considered a plus.}, apice = {CrawlingRaspi}, author = {Ramilli, Elisabetta and Benedetti, Riccardo}, howpublished = {Distributed Systems, A.Y. 2015/2016}, keywords = {WebCrawler, MAS, Distributed, Fault-tolerance, Resource-efficient, Raspberry Pi, Tucson, Jade, T4J}, month = may, sort = {classic}, supervisor = {Mariani, Stefano}, title = {Distributed, Fault-tolerant Web Crawling with RasPi}, type = {Standard Project}, year = 2017 }
@courseproject{dnsjade-sd1617, abstract = {* Replicazione e consistenza dei dati: gli agenti server si assicurano di avere dati coerenti rispetto agli altri e comunicano tempestivamente cambiamenti della tabella dei nomi tramite appositi behaviours; Trasparenza dei dati e del servizio: verranno implementate strutture dati diverse per i server che detengono le tabelle di nomi e il client non si accorger\`{a} da quale server ha ottenuto l'informazione desiderata; Situatedness: i server avranno tempi di latenze diverse per client diversi; Apertura del sistema: i nuovi agenti server potranno unirsi al naming system e divengono operativi solo quando avranno completato i behaviour di inizializzazione al fine di allineare le loro tabelle con quelle dei server presenti, oltre ai client che usufruiranno del servizio in maniera standard; Fault tolerance: implicita nella replicazione, introducendo inoltre per le stesse aree geografiche server di pari responsabilit\`{a} e livello, al fine di garantire il funzionamento del sistema anche a fronte di errori.}, apice = {DnsJade}, author = {Campobasso, Michele}, howpublished = {Distributed Systems, A.Y. 2016/2017}, month = mar, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Sistema DNS geograficamente distribuito: studio delle problematiche di apertura del sistema, reperibilit\`{a}, disponibilit\`{a} e coerenza dati attraverso il middleware JADE}, type = {Standard Project}, year = 2017 }
@courseproject{trama2-sd1617, abstract = {Il progetto ha lo scopo di creare un sistema multi-agente per la gestione “intelligente” di un incrocio stradale. Nel caso preso in considerazione verranno controllati i vari componenti dell’incrocio (semafori, telecamere di monitoraggio etc.) e l’interazione tra essi al fine di ottimizzare il flusso del traffico. Il software dovr\`{a} essere modellato per poter eventualmente essere esteso a un contesto cittadino pi\`{u} ampio e articolato (pi\`{u} incroci anche di diverso tipo). La simulazione avverr\`{a} utilizzando dei Raspberry Pi 2 su cui verr\`{a} installata la piattaforma JADE.}, apice = {Trama2}, author = {Alessio Addimando and Antonini, Edoardo}, howpublished = {Distributed Systems, A.Y. 2016/2017}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Traffic MAnagement Multi-Agent system}, type = {Standard Project}, year = 2017 }
@courseproject{comunicazioneapticamonti-sd1516, apice = {ComunicazioneapticaMonti}, author = {Lorenzo Monti}, howpublished = {Distributed Systems, A.Y. 2015/2016}, month = dec, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Progettazione di un'architettura software per la comunicazione sociale aptica tra persone affette da sordocecit\`{a} in ottica distribuita}, type = {Standard Project}, year = 2016 }
@courseproject{robotwar-sa1516, abstract = {Il progetto consiste nella realizzazione di un MAS (la cui tecnologia di riferimento scelta \`{e} Jason) costituito da un agente Robot associato al giocatore, possibilmente dotato di caratteristiche configurabili, e da una moltitudine di agenti Robot dotati di capacit\`{a} belliche inferiori (ad esempio una minore longevit\`{a}, una capacit\`{a} offensiva inferiore ecc.), i quali tuttavia sono in grado di attuare varie forme di cooperazione (supporto e aggregazione ad esempio) per cercare di sconfiggere il Robot del giocatore. Tali robot sono di tipologie diverse, per cui sono specializzati in certi compiti: si prevede di realizzare robot di supporto, robot attaccanti e robot protettivi. Scopo del gioco \`{e} cercare di realizzare una configurazione del robot lato giocatore in grado di eliminare tutti gli altri robot.}, apice = {RobotWar}, author = {Delvecchio, Matteo}, howpublished = {Autonomous Systems, A.Y. 2015/2016}, month = sep, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Robot War }, type = {Standard Project}, year = 2016 }
@courseproject{masfornetworkmanagement-sd1516, apice = {MASforNetworkManagement}, author = {Roberti, Michele}, howpublished = {Distributed Systems, A.Y. 2015/2016}, month = sep, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Multi-Agent Systems for Network Management: State of the Art}, type = {Standard Project}, year = 2016 }
@courseproject{farmagotchi-sa1516, abstract = {Lo scopo di questo progetto \`{e} quello di dimostrare il concetto di autonomia all’interno di un MAS ed utilizzarla nelle diverse parti che lo compongono attraverso l’impiego della simulazione come mezzo per testarne l’efficacia e la correttezza. Il tema scelto \`{e} quello dell’implementazione di un gioco di tipo life-simulator dove i protagonisti sono degli animali (entit\`{a} autonome) all’interno di una fattoria. Questa tipologia di gioco (ad es. Tamagochi) si concentra sulla gestione e cura delle entit\`{a} principali e possiede aspetti sia di autonomia da un lato che di interazione con l’utente (osservatore) dall’altro. La simulazione che scaturisce \`{e} semplificata ma mira a seguire un modello comportamentale che emula quello degli animali da cortile. La tecnologia scelta per lo sviluppo di questo lavoro \`{e} NetLogo, un linguaggio di programmazione basato ad agenti dotato del suo IDE di sviluppo che permette anche un agile implementazione della parte grafica dell’applicazione.}, apice = {Farmagotchi}, author = {Matteo Bocchetti and Francesco Maughelli}, howpublished = {Autonomous Systems, A.Y. 2015/2016}, month = dec, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Farmagotchi}, type = {Standard Project}, year = 2015 }
@courseproject{fantacalcioadagenti-smalm1112, abstract = {Lo scopo del progetto \`{e} la ralizzazione di un sistema ad agenti per la gestione di una squadra del Fantacalcio, cio\`{e} un sistema che all'inizio del campionato cerca su internet informazioni (statistiche sui gol fatti, ammonizioni, voti presi durante i passati campionati...) relative a tutti i calciatori (magari con la possibilit\`{a} di esprimere delle preferenze sui calciatori che si vogliono avere in squadra). In base alle informazioni raccolte il sistema decide qual \`{e} la squadra "ottimale" scegliendo i giocatori con le migliori prestazioni. Bisogna anche rispettare un certo budget, avere un certo numero di portieri, difensori, centrocampisti e attaccanti.}, apice = {FantacalcioAdAgenti}, author = {Silvia Franci}, howpublished = {Multi-Agent Systems LM, A.Y. 2011/2012}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Fantacalcio ad agenti: creazione automatica di una squadra}, type = {Standard Project}, year = 2014 }
@courseproject{hoveringinfo-smalm1213, apice = {HoveringInfo}, author = {Bellavista, Daniele}, howpublished = {Multi-Agent Systems (2nd Cycle), A.Y. 2012/2013}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Hovering Information: a MAS implementation}, type = {Standard Project}, year = 2013 }
@courseproject{astoryengine-lmc1112, apice = {aStoryEngine}, author = {Arnoffi, Andrea}, howpublished = {Computational Models and Languages L-M, A.Y. 2011/2012}, month = oct, sort = {classic}, supervisor = {Viroli, Mirko}, title = {aStoryEngine: Linguaggio e Interprete per Librigame}, type = {Standard Project}, year = 2013 }
@courseproject{droneexplorer-sdlm1213, abstract = {Il progetto consiste in un sistema distribuito composto da un'entit\`{a} master che si occupa di guidare un'entit\`{a} drone i cui dati di navigazione sono visualizzati da altre entit\`{a} passive. Pi\`{u} precisamente i compiti del master sono: impostare direzione del drone ricevere i dati di navigazione del drone costruire una mappa del reticolo in cui viaggia il drone, tramite i dati ricevuti I compiti del drone sono: ricevere comandi dal master eseguire tali comandi riguardanti la navigazione inviare i dati di navigazione contenenti i dati del reticolo esplorato (tramite ricezione dati dai sensori) Infine, il compito delle entit\`{a} passive di visualizzazione sono limitate alla sola ricezione dei dati di navigazione del drone e visualizzarli. Da notare come venga simulata la ricezione dati da parte del drone dai propri sensori tramite un reticolo preimpostato che il drone man mano andr\`{a} a controllare per verificare la presenza di ostacoli sul percorso (di fatto interrogazioni su una collezione dati presente nel drone, in modo da avere un simulatore). La comunicazione viene effettuata tramite rete utilizzando json per la formattazione dei dati. Il tutto viene comunicato tra le varie entit\`{a} tramite un web service on-line costituito da apposite pagine php e un database dedicato.}, apice = {DroneExplorer}, author = {Foschini, Federico and Braggion, Stefano and Maestri, Luca and Delvecchio, Riccardo}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = aug, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Drone Explorer}, type = {Standard Project}, year = 2013 }
@courseproject{slotmachines-sdlm1213, abstract = {Lo scopo del progetto consiste nella realizzazione di un sistema di slot machine il quale \`{e} distribuito su diverse piattaforme di gioco. Le piattaforme di gioco comprendono sale slot e siti per scommesse. È identificata come organizzazione una singola sala slot o un singolo sito di scommesse. Le varie piattaforme di gioco offrono una vincita regolare garantita e due forme di Jackpot: il Jackpot locale, ottenuto dall’accumulo di un fondo all’interno della singola organizzazione; il Jackpot nazionale ottenuto dall’accumulo di un fondo di tutte le organizzazioni affiliate. Ogni singola postazione di gioco \`{e} un client che regolarmente si interfaccia ad un server locale (che gestisce il Jackpot locale) e ad un server globale (che gestisce il Jackpot nazionale). Gli incassi di ogni postazione di gioco sono cos\`{i} suddivisi: 75%: vincita diretta garantita; 10%: tassa statale; 5%: Jackpot locale: 4%: Jackpot immediato; 1%: fondo per ripartenza Jackpot; 5%: Jackpot nazionale: 4%: Jackpot immediato; 1%: fondo per ripartenza Jackpot; 5%: compenso fornitore del servizio: 2%: esercente (in caso di sala slot); 3%: erogatore del servizio (es: sisal). Sar\`{a} utilizzata un’infrastruttura Jade per quel che riguarda la computazione, la coordinazione tra client e server. Tutti i dati saranno memorizzati all’interno di un database MySQL.}, apice = {SlotMachines}, author = {Lo Iacono, Luca and Pavllo, Andi and Magnani, Antonio}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = aug, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Sistema di gestione slot machine}, type = {Standard Project}, year = 2013 }
@courseproject{moktextmining-smalm1213, abstract = {La domanda a cui il progetto intende rispondere \`{e} come possono essere sfruttate le tecniche di Text Mining all’interno di sistemi che hanno come obiettivo principale l’auto-organizzazione della conoscenza? Il progetto prevede la implementazione di un sistema di clustering per articoli scientifici in lingua inglese, sfruttando tecniche e algoritmi di Text Mining. Come infrastruttura di coordinazione si \`{e} scelto di utilizzare TuCSoN (Tuple Centres Spread over the Network) che \`{e} un modello per la cordinazione di processi distribuiti (agenti) che sfrutta i centri di tuple. All’interno del progetto sono stati realizzati due algoritmi di clustering uno ideato da me ideato e un’altro che implemanta un algoritmo preso dalla letteratura. Del secondo sono state implementate due varianti una prevede un calcolo poco distribuito ( solo pochi agenti ) mentre l’altra prevede una fortissima distribuzione del calcolo ( un agente per articolo ). Utilizzando questi algoritmi sono stati realizzati quindi molti e vari esperimenti, sia per la taratura dei parametri, che per tracciare la dipendenza degli algoritmi da questi. I risultati ottenuti verranno poi confrontati e analizzati nel dettaglio.}, apice = {MoKTextMining}, author = {Pratiffi, Michele}, howpublished = {Multi-Agent Systems (2nd Cycle), A.Y. 2012/2013}, month = jul, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Applicazione delle tecniche di Text Mining all’interno di algoritmi di clustering per articoli scientifici}, type = {Standard Project}, year = 2013 }
@courseproject{skiddingcontroller-sdlm1213, abstract = {The system, to be implemented in a JADE environment, has the purpose to move forward a remotely controlled rover,remaining transparent to the human control of the robot and allowing, at the same time, the maximum yield of the wheels during the movement. To do this an autonomous agent will be given to each wheel, in turn controlled by a central agent, who will be responsible to communicate with the user and the wheels to give effect to the commands "STOP" and "GO".}, apice = {SkiddingController}, author = {Cavalazzi, Marco Carlo and Mattia Castrichino}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = jul, sort = {classic}, supervisor = {Mariani, Stefano}, title = {Automated Agent-Oriented Real-Time Skidding Controller}, type = {Standard Project}, year = 2013 }
@courseproject{echat-sdlm1213, abstract = {Design and implement a distributed chat, integrated with Facebook, on the JADE platform, to deploy on Android devices.}, apice = {eChat}, author = {Tomas Fedeli and Gianessi, Davide}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = jul, sort = {classic}, supervisor = {Mariani, Stefano}, title = {eChat: Facebook integrated chat using JADE on Android}, type = {Standard Project}, year = 2013 }
@courseproject{mobilesemanticapice-sdlm1213, apice = {MobileSemanticApice}, author = {Buscarini, Andrea and Nompleggio, Pietro Antonio and Zaccheroni, Marco}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = jun, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Mobile Semantic XWiki: APICe as a Case Study}, type = {Standard Project}, year = 2013 }
@courseproject{sbaam-sdlm1213, abstract = {Scopo del progetto presentato \`{e} delineare una possibile soluzione al problema di gestione trasporti pubblici cittadini (i.e. viabilit\`{a} degli autobus), sia da un punto di vista gestionale per un'ipotetica azienda del settore sia nell'ottica di un coinvolgimento degli utenti finali (maggiori servizi e richieste di feedback), sfruttando il paradigma ad agenti. In particolare si vuole valutare la possibilit\`{a} di realizzare un sistema come quello desiderato per mezzo della tecnologia Jade e Jade Leap, per mostrare possibili applicazioni del paradigma ad agenti nel mondo mobile. Per l'intera fase di progettazione facciamo completo riferimento alla relazione stesa parallelamente alla fase realizzativa del modello esemplificativo. Demandiamo a quest'ultima anche una pi\`{u} attenta descrizione di motivazioni, considerazioni generali e conclusioni dell'intera soluzione proposta.}, apice = {Sbaam}, author = {Amati, Michele and Corfiati, Matteo and Fucci, Federico and Masini, Fabrizio}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = may, sort = {classic}, supervisor = {Mariani, Stefano}, title = {Smart Buses: Agent Aided Management}, type = {Standard Project}, year = 2013 }
@courseproject{jadeweb-sdlm1213, apice = {JADEWeb}, author = {Diego Alicata}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Indicizzazione di siti Web in JADE}, type = {Standard Project}, year = 2013 }
@courseproject{prodlogics-sdlm1213, abstract = {Goal Gli obbiettivi del progetto sono quelli di gestire un processo di trasformazione di prodotti, i quali vengono assegnati a determinati agenti software i quali coordinati i processi e l’utilizzo delle risorse. Gli agenti sostanzialmente fungono da pianificatori dei prodotti, per permettere di farli trattare tra le varie fase, approvigionando i vari prodotti di cui ha bisogno e tra le risorse di cui necessita. Use Case Il progetto nasce dall’idea di provare a rappresentare una realt\`{a} operativa, come potrebbe essere quella di una fabbrica. Tra le tante attivit\`{a} che si richiedono di definire all’interno di una catena di produzione, una fase molto dispendiosa dal punto di vista delle risorse umane \`{e} quella di configurare l’associazione tra prodotto e risorse interne, i quali devono interagire per eseguire trasformazioni sul prodotto stesso. In sostanza, lo scopo del progetto \`{e} quello di permettere alle risorse di configurarsi autonomamente, associandosi tra loro in base alla loro disponibilit\`{a}, scaricando l’operatore di questo gravoso compito. In particolare, l’automatizzazione potrebbe essere rappresentata tramite i due principali capisaldi del corso, cio\`{e} sistemi distribuiti ed agenti software. All’interno di questo progetto mi sarebbe piaciuto dare particolare risalto alla condivisione di risorse nei processi che intervengono nella creazione di un prodotto finale. In uno schema logico che mi sono mentalmente creato, immagino che l’input del processo sia quello di creare un prodotto finale: tale prodotto necessita per\`{o} di una serie di altri sotto-prodotti necessari alla creazione di quello finale. La trasformazione di un prodotto segue logiche come possono essere la creazione di eventuali sotto prodotti, i quali, assieme, andranno a comporre il prodotto finale. Inoltre, la creazione di un prodotto nasce dalla necessit\`{a} di unire altri prodotti, che, una volta trattati da una serie di eventuali trasformazioni, danno come prodotto quello finale. Le trasformazioni impiegano un determinato numero di altre risorse, come possono essere macchinari. I macchinari possono essere quelli che servono per trasformare il prodotto fisicamente, ma anche spostarlo. Quindi, dal momento in cui si decide di creare un particolare prodotto, il sistema definisce automaticamente quali saranno i passi per la realizzazione del compito dato. Sostanzialmente, questo tipo di operazione viene definita in azienda configurando manualmente tutte le risorse che andranno ad intervenire all’interno del processo, cercando magari di definire, per ogni risorsa, tempi e modalit\`{a} di utilizzo. Nel sistema che si andrebbe a creare, una soluzione potrebbe essere quella di gestire autonomamente da parte degli agenti le risorse di cui si necessita per la lavorazione. Un possibile scenario potrebbe essere il dare ad un agente la creazione di un prodotto C; il prodotto C per essere creato necessita di A e B. Magari A \`{e} disponibile in magazzino, mentre B me lo devo creare dalle risorse C e D, le quali dovranno essere lavorate insieme da un macchinario che presenta determinate caratteristiche. La decisione di quale macchinario utilizzare verr\`{a} presa dall’agente controllando tra le varie risorse disponibili, quali di queste permettono la lavorazione del prodotto secondo le esigenze previste. Requirements I requisiti del progetto, estrapolati dalla presentazione, sono sostanzialmente rivolti alla gestione delle risorse. Un utente deve poter definire un prodotto finale; da questo prodotto, il sistema deve avere la conoscenza di quali altri prodotti ha bisogno e a quali fasi di trasformazione deve essere sottoposto. Ogni fase di trasformazione dovr\`{a} essere accompagnata da una serie di risorse hardware, dove la loro gestione sar\`{a} demandata direttamente ad appositi agenti software pianificatori. Ogni agente, una vola che dispone di tutti i prodotti necessari, inizier\`{a} i suoi compiti per eseguire la trasformazione. Ogni prodotto di cui si chiede l’utilizzo potrebbe essere presente in magazzino, oppure, potrebbe essere ricavato anch’esso da trasformazioni.}, apice = {ProdLogics}, author = {Bragagni, Cristiano}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = apr, sort = {classic}, supervisor = {Mariani, Stefano}, title = {Logiche di Produzione con Sistemi Distribuiti}, type = {Standard Project}, year = 2013 }
@courseproject{jadehomeautomation-sdlm1213, abstract = {Questo progetto intende proporre un architettura che risolva il problema dell’automazione domestica (domotica), utilizzando approcci multiagente tramite l'uso del framework JADE. Il nostro obiettivo \`{e} poter interagire con dei dispositivi hardware fisici, come sensori ed attuatori, astraendo il pi\`{u} possibile da ogni aspetto di interfacciamento con l'hardware, considerando ognuno di questi dispositivi come un agente. Le tecnologie utilizzate saranno: piattaforma JADE, per sviluppare software con un approccio multiagente; La piattaforma Arduino, per realizzare delle schede con sensori ed attuatori, che simulino dei dispositivi realmente presenti dentro una abitazione. applicazione Android (con agenti JADE), per permettere all'utente di controllare con il sistema. Lo scopo di questa sperimentazione \`{e} quello di valutare quanto la piattaforma JADE sia adatta a modellare realt\`{a} come quella presa in esame e valutarne i limiti.}, apice = {JadeHomeAutomation}, author = {Zoffoli, Alessandro and Baldani, Mattia}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Jade Home Automation}, type = {Standard Project}, year = 2013 }
@courseproject{jadesharedservices-sdlm1213, abstract = {Il progetto ha come argomento la coordinazione tra agenti. Lo scopo \`{e} quello di permettere la condivisione di servizi presenti su uno o pi\`{u} dispositivi partecipanti ad una sessione. È stata implementata una architettura che gestisce gli agenti (client/server) di modo che ogni host dell’architettura pu\`{o} usufruire di un servizio proposto (client), oppure offrire esso stesso un servizio (server). L’architettura proposta usa Jade come mezzo principale di comunicazione e coordinazione tra agenti. Come caso di studio \`{e} stato implementato un servizio di chat. Esso serve soprattutto come esempio di utilizzo della piattaforma e pu\`{o} essere usato come pattern di sviluppo di eventuali servizi aggiuntivi: condivisione di stream multimediali, file sharing, file transfer, etc. La struttura dell'architettura \`{e} tale da permettere l'aggiunta delle seguenti funzionalit\`{a}: Caricamento di servizi (classi java) da client a server a run-time Scaricamento di servizi (classi java) da server a client per permettere al dispositivo del client di usufruire del servizio, oppure di avviare un server proprio RBAC integration}, apice = {JadeSharedServices}, author = {Moisuc, Cornel}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = mar, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Condivisione di servizi con JADE}, type = {Standard Project}, year = 2013 }
@courseproject{crowdevacuationjadetucson-sdlm1213, abstract = {Discussing and possibly implementing a crowd evacuation scenario combining JADE agent mobility and TuCSoN distributed tuple centres}, apice = {CrowdEvacuationJadeTucson}, author = {Pagliarani, Andrea and Pasini, Karin and Battelli, Alessandro and Matteini, Michele}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = feb, sort = {classic}, supervisor = {Mariani, Stefano}, title = {Self-Organisation and Adaptation within MAS: the crowd evacuation example in Jade and TuCSoN}, type = {Standard Project}, year = 2013 }
@courseproject{bdirobot-smalm1112, apice = {BDIRobot}, author = {Contoli, Chiara and Santandrea, Giuliano}, howpublished = {Multi-Agent Systems LM, A.Y. 2011/2012}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Programmazione di robot con linguaggi ad agenti basati su architettura BDI}, type = {Standard Project}, year = 2013 }
@courseproject{urbanews-sdlm1213, apice = {UrbaNews}, author = {Buccelli, Emanuele and Degli Angeli, Francesco and Leali, Marco}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = dec, sort = {classic}, supervisor = {Mariani, Stefano}, title = {UrbaNews}, type = {Standard Project}, year = 2012 }
@courseproject{augur-lmc1112, abstract = {Nel progetto viene fornita una prima implementazione di un modello per il calcolo del gradiente in una rete di nodi che evolve dinamicamente usando come linguaggio il Graph Transition Systems. Il modello \`{e} stato successivamente analizzato usando la tecnica dell'approximative unfolding. A questo scopo viene utilizzato un tool chiamato Augur 2 nel quale viene imlementata tale tecnica. L'obiettivo che si \`{e} cercato di raggiungere \`{e} stato quello di iniziare a creare un buon modello del sistema da analizzare prendendo atto di quelle che sono le possibilit\`{a} e i limiti del linguaggio GTS, della tecnica dell'aproximative unfolding e di Augur 2. Il lavoro \`{e} stato diviso in due parti: una prima parte in cui vengono mostrati i passi per una corretta installazione e configurazione del software e una seconda parte in cui viene affrontata la modellazione e l'analisi del sistema da modellare. Sono state inoltre fatte alcune considerazioni riguardo ai tempi di analisi e sui possibili sviluppi futuri.}, apice = {augur}, author = {Cicora, Saverio}, howpublished = {Computational Models and Languages L-M, A.Y. 2011/2012}, month = dec, sort = {classic}, supervisor = {Viroli, Mirko}, title = {Modellazione e analisi di un graph transformation systems mediante la tecnica dell'approximative unfolding e Augur 2}, type = {Standard Project}, year = 2012 }
@courseproject{pdi-sdlm1213, abstract = {In generale si tratta di creare dei coordinatori (agenti) in Jade che gestiscono le richieste concorrenti dei navigatori auto ed inoltre devono catalogare le informazioni sui PDI. La soluzione proposta \`{e} specifica per i PDI delle stazioni di servizio, ma pu\`{o} essere adattata a qualsiasi tipo di PDI. Sistema per ottimizzare la ricerca delle stazioni di servizio per Navigatore Auto. Problema: determinare il distributore di carburante pi\`{u} conveniente, considerando oltre al prezzo del carburante, la spesa per raggiungere il distributore. Si tiene conto anche dell’affollamento delle stazioni di servizio, cercando di limitare le code di attesa. Bisogna anche verificare gli orari di apertura e chiusura. Il sistema prevede che i distributori siano tutti registrati presso un coordinatore, che avr\`{a} il compito di fornire il servizio al navigatore delle automobili che lo interrogano. Il sistema prevede n coordinatori, uno per regione (considerando l’ltalia). Volendo si pu\`{o} aggiungere San Marino. E’ necessario anche un coordinatore centrale che sar\`{a} il gestore dei coordinatori regionali, confrontando i risultati fra regioni limitrofe. Ogni coordinatore ha il controllo dei distributori presenti nella zona. Ogni distributore deve indicare il prezzo dei carburanti , il numero di postazioni, l’orario di apertura e chiusura e la sua posizione (coordinate gps). Il software del navigatore, alla richiesta di una stazione di servizio, dovr\`{a} sapere dove si trova il distributore pi\`{u} conveniente e calcolare il percorso per raggiungerla. 1. L’autista richiede al navigatore che vuole raggiungere la stazione di rifornimento. 1. Il navigatore richiama il servizio del coordinatore centrale. 1. Il coordinatore restistuir\`{a} le coordinate gps della stazione di servizio. 1. Calcolo del percorso. Il coordinatore centrale richiama il coordinatore regionale in base alla richiesta ricevuta. La richiesta deve indicare la posizione attuale del veicolo. Se la posizione ha due regioni limitrofe (direi entro 10 km) allora deve restituire la stazione pi\`{u} conveniente tra le due regioni. Il coordinatore regionale gestisce il servizio. Quindi riceve le richieste concorrenti: 1. Per ogni richiesta, si crea una lista dei possibili distributori nel raggio di 10 km (si esclude il distributore se ha pi\`{u} di 5 richieste in coda lo e se sar\`{a} chiuso all’arrivo). 1. Per ogni distributore si leggono i prezzi applicati del carburante richiesto (la richiesta deve indicare il tipo di carburante: benzina, diesel o gpl) e la distanza dalla posizione richiesta. 1. Per ogni distributore si fa un calcolo: si calcolano quanti litri di carburante servono per raggiungere la stazione e si moltiplicano per il prezzo al litro + il costo del rifornimento richiesto. Per ogni distributore otterr\`{o} la spesa. 1. Si sceglie la stazione pi\`{u} conveniente, cio\`{e} dove si spende meno. Come gestire l’uso concorrente delle postazioni dei distributori? L’accesso alle postazioni ha la seguente politica, chi prima arriva si serve, gli altri si mettono in coda. Le richieste dei navigatori vengono registrate in un buffer limitato per non eccedere con le richieste contemporanee alla stessa risorsa. Il valore limite del buffer potrebbe essere di 5 richieste. Quindi esiste una specie di prenotazione della postazione che riserva la postazione per un certo utente in certo istante. La macchina impiega 5 min per raggiungerla, 2 minuti prima di arrivare, segnala il suo arrivo, mette una richiesta in coda. Il primo che arriva , se ci sono postazioni libere, si serve, e cancella la richiesta di rifornimento; altrimenti si mette in coda. Ogni distributore quindi deve indicare il proprio stato (numero di richieste in corso, aperto o chiuso). Problemi Un’auto potrebbe mettere la richiesta nel buffer , ma non arrivare mai nella stazione di rifornimento. Quindi la sua richiesta rimarebbe sospesa nel buffer per sempre. E’ necessario fissare un tempo massimo di validit\`{a} della richiesta. Se per qualche motivo, il distributore richiesto non \`{e} pi\`{u} attivo (ad esempio ha finito il carburante), deve segnalare al coordinatore regionale il suo cambio di stato. Al suo cambio di stato, deve partire una segnalazione ai navigatori, che faranno il ricalcolo della stazione di servizio pi\`{u} conveniente. Potrebbe anche accadere che il distributore sia preso d’assalto da tanti utenti che non utilizzano questo sistema, in questo caso, potrebbe essere necessario segnalarlo al coordinatore regionale, che bloccher\`{a} le prossime richieste su questa stazione.}, apice = {PDI}, author = {Morganti, Stefano}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Ricerca ottimizzata dei PDI (Punti d'Interesse)}, type = {Standard Project}, year = 2012 }
@courseproject{smartshelfpiemonte2005-sidls0405, abstract = {L'obiettivo del progetto \`{e} realizzare un sistema software per l’ottimizzazione delle vendite all’interno di un negozio. Il sistema deve essere “distribuito” e dotato di una propria “intelligenza”}, apice = {SmartshelfPiemonte2005}, author = {Gianluca Piemonte}, howpublished = {Distributed Intelligent Systems LS, A.Y. 2004/2005}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Smart Shelf}, type = {Standard Project}, year = 2012 }
@courseproject{semanticcoordrdfjena-smalm1112, apice = {SemanticcoordRdfJena}, author = {Gabriele Manduchi}, howpublished = {Multi-Agent Systems LM, A.Y. 2011/2012}, month = oct, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Costruzione di un framework semantico tuple-based Rdf-Jena per la coordinazione tra agenti}, type = {Standard Project}, year = 2012 }
@courseproject{compagniatrasporti-sd1011, abstract = {Il progetto si basa sulla gestione in tempo reale di una rete di trasporto pubblico, quale pu\`{o} essere ad esempio una compagnia di treni, autobus o aerei. Nello specifico si vuole sviluppare un progetto secondo le casistiche e le necessit\`{a} di una compagnia di autobus. L'obiettivo del sistema \`{e} quello di aggiornare e monitorare, in tempo reale, la posizione, i ritardi, gli autisti e ed eventuali altri dati che l'azienda intende controllare di ogni singolo automezzo disponibile, offrendo i propri servizi agli amministratori dell'azienda, che sono cos\`{i} in grado di monitorare sia i propri dipendenti e mezzi, sia l'utilizzo delle proprie linee, avendo quindi un mezzo per monitorare ed eventualmente migliorare il servizio reso ai propri clienti. In futuro si potr\`{a} espandere il progetto per gestire la clientela stessa(infatti il server \`{e} strutturato in modo da poter essere ampliato); essi avranno la possibilit\`{a} in tempo reale di sapere la capienza e la posizione dei mezzi. Il sistema dovr\`{a} prevedere 4 componenti principali: Il sistema centrale, che si appoggia su un database che immagazzina le informazioni, e un'apposito sistema che gestisce il flusso delle stesse fra i vari componenti esterni. Un componente per gli amministratori dell'azienda, che avr\`{a} il compito di prelevare informazioni utili, inserire e/o alterare le stesse, e fare tutte quelle procedure di controllo e mantenimento richieste ad un generico database. un sistema di localizzazione GPS, per poter individuare in tempo reale la posizione del mezzo(emulato da noi con un componente java) inviata periodicamente dal mezzo e in caso di necessit\`{a} recuperata in maniera attiva dalla centrale. il componente dovr\`{a} periodicamente comunicare al server la sua posizione, aggiornando i dati nello stesso In futuro si potr\`{a} migliorare il sistema aggiungendo : Un componente mobile per ogni singolo automezzo, che potr\`{a} prevedere un'interfaccia, dalla quale i dipendenti dell'azienda dovranno registrare il proprio turno sul mezzo stesso Un componente utilizzabile da un generico cliente, non registrato al sistema (al contrario degli altri due), che dia lo status in tempo reale della rete di trasporto in modo da conoscere l'esatta posizione di tutti i mezzi in circolazione.}, apice = {CompagniaTrasporti}, author = {Laddaga, Michele}, howpublished = {Distributed Systems, A.Y. 2010/2011}, month = sep, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Sistema di gestione e monitoraggio per compagnia di trasporti}, type = {Standard Project}, year = 2012 }
@courseproject{estensione-vanilla-lmc1112, abstract = {Il progetto consiste nell'analisi del meta-interprete Vanilla, dei suoi limiti, e nella realizzazione di una sua estensione che sia in grado di meta-interpretare correttamente il predicato CUT. La prima parte del progetto, \`{e} volta all'analisi del meta-interprete Vanilla, e dei suoi limiti intrinseci. Si procede poi con l'analisi delle caratteristiche richieste e di alcuni miglioramenti che permettono di estendere le funzionalit\`{a} del meta-interprete. Seguono all'analisi la fase di realizzazione della proposta di soluzione e una successiva fase ti test, per verificare che i requisiti iniziali fossero rispettati. Infine \`{e} stato creato e commentato un benchmark per verificare la differenza di performance tra l'interpretazione con "Vanilla++" e quella fatta con il motore prolog.}, apice = {estensione-vanilla}, author = {Massimo Fornari}, howpublished = {Computational Models and Languages L-M, A.Y. 2011/2012}, month = jun, sort = {classic}, supervisor = {Viroli, Mirko}, title = {Progetto metainterpreta Vanilla++}, type = {Standard Project}, year = 2012 }
@courseproject{pepa-lmc1112, abstract = {Il progetto consiste nell'analisi del linguaggio PEPA, un'algebra di processo utile per descrivere sistemi complessi al fine di ricavarne misure di performance. All'interno dell'elaborato ne viene descritta la sintassi e la semantica ed \`{e} presentato un caso di studio realizzato con il plugin Eclipse per PEPA, in modo da mostrare tutto quello che \`{e} possibile fare con questo plugin. Viene poi descritta la tecnica di fluid flow approximation, prima dal punto di vista strettamente matematico e poi viene usata in un caso di studio, sempre realizzato tramite il plugin Eclipse per PEPA, per mostrarne le potenzialit\`{a}.}, apice = {pepa}, author = {Polverelli, Enrico}, howpublished = {Computational Models and Languages L-M, A.Y. 2011/2012}, month = may, sort = {classic}, supervisor = {Viroli, Mirko}, title = {PEPA}, type = {Standard Project}, year = 2012 }
@courseproject{msr-lmc1112, abstract = {MSR(C) is a tool to model-check infinite state systems, extending Petri Nets ideas. The goal of this project is to verify properties of given algorithms for self-organising networks. We will explore the main aspect of the MSR(C) specification and with the help of some example we want to test this tool to expose strengths and weaknesses and propose alternatives if necessary.}, apice = {Msr}, author = {Bulzacchi, Alessandro}, howpublished = {Computational Models and Languages L-M, A.Y. 2011/2012}, month = apr, sort = {classic}, supervisor = {Viroli, Mirko}, title = {Verify algorithms' properties with the MSR(C) prototype}, type = {Standard Project}, year = 2012 }
@courseproject{masroutinginman-smalm1011, abstract = {Supporting mobility in a multi hop wireless environment like the MANET still remains a point of research, especially in the context of time-constrained applications. This project aims to simulate a MANET environment where any agent is able to communicate at any time with any other agent connected to the network, which lacks a central control and is subject to continuos changes over time. The simulation will show the evolution of such network by the implementation of a proactive routing protocol. Supporting mobility in a multi hop wireless environment like the MANET still remains a point of research, especially in the context of time-constrained applications. This project aims to simulate a MANET environment where any agent is able to communicate at any time with any other agent connected to the network, which lacks a central control and is subject to continuos changes over time. The simulation will show the evolution of such network by the implementation of a proactive routing protocol.}, apice = {MasRoutingInMan}, author = {Paolo Piagnani}, howpublished = {Multi-Agent Systems LM, A.Y. 2010/2011}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Multi-Agent Routing in Mobile Ad-hoc Networks}, type = {Standard Project}, year = 2012 }
@courseproject{progetto-bdd-lmc1112, abstract = {Il progetto descrive i principali concetti relativi ai Binary Decision Diagrams(BDD), una compatta struttura per la rappresentazione di funzioni booleane. Viene spiegato cosa sono, le caratteristiche e propriet\`{a} che presentano, come crearli, le principali operazioni possibili con essi e il loro impiego nel model checking. Inoltre viene fornita un'implementazione in Prolog dell'algoritmo di creazione proposto, in modo da poter testare le caratteristiche discusse. L'algoritmo fornisce la possibilit\`{a} creare un BDD partendo da una formula booleana contenente gli operatori logici negazione, implicazione, or e and.}, apice = {progetto-bdd}, author = {Leoni, Andrea}, howpublished = {Computational Models and Languages L-M, A.Y. 2011/2012}, month = feb, sort = {classic}, supervisor = {Viroli, Mirko}, title = {Binary Decision Diagrams}, type = {Standard Project}, year = 2012 }
@courseproject{smamagazzino-smalm1011, abstract = {Un S.M.A che si occupa di organizzare i flussi di merci entranti e uscenti da un magazzino e di gestire gli stoccaggi, in particolare gli agenti si preoccupano di scaricare i veicoli in arrivo, posizionare i vari pallet sugli scaffali in maniera dinamica e infine reperire le merci richieste e caricarle sui veicoli in partenza, evitando collisioni con gli ostacoli presenti nel magazzino e con gli altri agenti presenti nell'ambiente.}, apice = {SmaMagazzino}, author = {Claudio Giardini and Polverelli, Enrico}, howpublished = {Multi-Agent Systems LM, A.Y. 2010/2011}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {S.M.A. per l’automatizzazione di entrate, stoccaggi e uscite di merci in un magazzino}, type = {Standard Project}, year = 2012 }
@courseproject{metamaude-ctmc-lmc1112, abstract = {Il progetto consiste nello sviluppo di un framework in Maude per poter definire, simulare e verificare modelli Continous Time Markov Chain (CTMC). Il simulatore deve essere realizzato con l'ausilio del meta-livello di Maude, in modo da poter avere la massima libert\`{a} nella definizione di stato del sistema, rate di transizione e condizioni di transizione. La verifica di propriet\`{a} del sistema deve avvenire con la tecnica Approximate Probabilistic Model Checking (APMC) per rendere il problema trattabile.}, apice = {metamaude-ctmc}, author = {Bellavista, Daniele}, howpublished = {Computational Models and Languages L-M, A.Y. 2011/2012}, month = feb, sort = {classic}, supervisor = {Viroli, Mirko}, title = {Framework per la simulazione e la valutazione di modelli CTMC utilizzando Maude e Approximate Probabilistic Model Checking}, type = {Standard Project}, year = 2012 }
@courseproject{mcltl-lmc1112, abstract = {Scopo del progetto \`{e} stata la realizzazione di un Model Checker che si occupasse della verifica di regole LTL su un modello dato in ingresso. Per fare questo \`{e} stata realizzata una libreria, quasi interamente scritta in Prolog, completa di tutte le funzioni necessarie per effettuare il checking.Inoltre viene fornito un manuale (in inglese) per aiutare nella comprensione del linguaggio che l'utente dovr\`{a} usare per sottoporre il codice delle proprie applicazioni al MC. Gli allegati sottostanti comprendono: un file jar in cui la libreria \`{e} stata aggiunta a quelle disponibili con il tool tuProlog per testare subito l'applicazione, i codici sorgenti, il file .class della libreria, il manuale utente,la relazione del progetto e inoltre un file pdf contenente i benchmark utilizzati durante lo sviluppo.}, apice = {mcltl}, author = {Manuel Bartolini and Guerra, Luca}, howpublished = {Computational Models and Languages L-M, A.Y. 2011/2012}, month = feb, sort = {classic}, supervisor = {Viroli, Mirko}, title = {Model Checker LTL}, type = {Standard Project}, year = 2012 }
@courseproject{agvcollision-smalm1011, abstract = {Nella vita di tutti i giorni (quando camminiamo, guidiamo, ...) ci muoviamo con l'attenzione di evitare collisioni con chi o cosa ci circonda. Allo stesso modo sarebbe importante (soprattutto nell'ambito AGV) che un agente autonomo, collocato in uno spazio, assieme ad altri agenti, fosse in grado di percepire il moto delle entit\`{a} attorno a se e capire come perseguire il proprio scopo muovendosi, senza per questo collidere con altri. Per questo abbiamo pensato alla possibilit\`{a} che agenti dotati di intelligenza possano interagire fra di loro, nel caso prevedano il coinvolgimento in uno scontro, e attraverso un protocollo di negoziazione possano stabilire le rispettive traiettorie da intraprendere; dal momento che non tutte le entit\`{a} devono avere lo stesso grado di intelligenza i protocolli dovranno adattarsi a tali evenienze. Per questo l'obiettivo \`{e} quello di simulare un magazzino, nel quale dei muletti autonomi si occupino di stoccare della merce arrivata ai dock di input e di evadere degli ordini prelevando dagli scaffali il materiale e portandolo ai dock di output. Per modellare diversi gradi di intelligenza, e quindi diversi approcci alla negoziazione, si \`{e} pensato alla possibilit\`{a} che i muletti possano perdere parte della merce durante il tragitto; in tal caso alcune persone (dotati di un carrello manuale) si preoccuperanno del recupero della merce dispersa, al fine di ripristinare la normalit\`{a}. I pallet e le persone non potranno interagire con i veicoli come visto in precedenza: la merce non ha possibilit\`{a} di spostarsi e comunicare, cos\`{i} come un essere umano non ha l'abilit\`{a} di concordare tempestivamente una soluzione (normalmente ci si limita a scappare); per questo motivo sar\`{a} necessario studiare delle soluzioni differenti che garantiscano comunque la sicurezza.}, apice = {AgvCollision}, author = {Manuel Bartolini and Contessi, Paolo and Guerra, Luca}, howpublished = {Multi-Agent Systems LM, A.Y. 2010/2011}, month = dec, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Collision Prediction and Avoidance throught Negotiation}, type = {Standard Project}, year = 2011 }
@courseproject{orainonda-sd1011, abstract = {* Descrizione Glossario Casi d'uso Requisiti non funzionali Architettura generale del sistema Architettura dei componenti del sistema Server Side Notifiche Remote Mobile Application Side Il modello dei dati del sistema DB Side Mobile Application Side Tecnologie di riferimento Sviluppo e Deployment del sistema Note critiche e possibili sviluppi futuri Conclusioni}, apice = {OraInOnda}, author = {Zoffoli, Alessandro}, howpublished = {Distributed Systems, A.Y. 2010/2011}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {OraInOnda}, type = {Standard Project}, year = 2011 }
@courseproject{mortemale-sd1011, abstract = {1 Idea 2 Comparison of possible approaches 3 Analysis of system openness 4 Model 5 Technological background 6 Engineering problems 7 Implementation and encountered issues 8 Source code 9 Binaries 10 Conclusions}, apice = {Mortemale}, author = {Mella, Luca and Orlovski, Svetlozar Nikolov and Santandrea, Federico}, howpublished = {Distributed Systems, A.Y. 2010/2011}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Mortemale: the cracking society}, type = {Standard Project}, year = 2011 }
@courseproject{advanced-dcg-lmc0910, abstract = {Scopo del progetto \`{e} stato quello di realizzare una libreria per tuProlog che si occupi di fornire un supporto alla realizzazione dei primi due passi del processo di compilazione (tokenizing e parsing), ispirandosi a librerie esistenti, come JavaCC. Il risultato \`{e} stata la creazione di due librerie una per il tokenizer e una per il parser, la prima \`{e} scritta quasi interamente in prolog, fatta eccezione per tre predicati scritti in java, la seconda, invece, \`{e} interamente in prolog. Oltre a semplici esempi presenti in JavaCC \`{e} stato prodotto un esempio di implementazione del Parser di Java per la versione 1.6, secondo le regole specificate nella "Java Language Specifications".}, apice = {advanced-dcg}, author = {Andrea Boccacci}, howpublished = {Computational Models and Languages L-M, A.Y. 2009/2010}, month = nov, sort = {classic}, supervisor = {Viroli, Mirko}, title = {Advanced Dcg}, type = {Standard Project}, year = 2011 }
@courseproject{beachsimulation-smalm1011, abstract = {Il progetto si propone di realizzare un sistema di simulazione dell'evoluzione di una zona balneare, dove: l'ambiente pu\`{o} essere la zona balneare gli artefatti possono essere gli stabilimenti balneari gli agenti sono di due tipi: gestori del bagno utenti del bagno I gestori degli stabilimenti balneari hanno l'obiettivo di guadagnare denaro attraverso i servizi offerti. Gli utenti hanno ognuno il proprio obiettivo e le proprie caratteristiche, ad es: utente che vuole solo prendere il sole utente che vuole solo fare sport utente che usufruisce solo dell'area bar utente che usufruisce di tutti i servizi esistenti Gli utenti tenderanno ad andare in uno stabilimento balneare piuttosto che in un altro In base ai servizi che esso offre. I proprietari degli stabilimenti hanno come obiettivo quello di guadagnare il pi\`{u} possibile, quindi i modi per farlo possono essere tanti, ad esempio: migliorare i servizi che fanno fruttare di pi\`{u} eliminare spese eccessive in caso di situazione economica scarsa ecc... ecc... L'obiettivo del progetto \`{e} quello di studiare il comportamento del sistema degli stabilimenti balneari modificando i parametri in gioco, ad esempio: cosa succede se viene montata una spiaggia libera piena di campi da gioco vicino ai bagni? di conseguenza come faranno cambiare gli stabilimenti i proprietari? come si comporteranno i clienti? cosa succede quando i proprietari fanno modifiche al bagno ad esempio aggiungendo campi da gioco o lettini per prendere il sole? come si comportano i clienti? In questo modo gli agenti manifesteranno un comportamento autonomo e adattivo in base a come evolve l'ambiente. Inoltre gli artefatti possono essere creati, modificati ed usati dagli agenti, rispettivamente possono essere creati dai gestori, modificati dai gestori (eventualmente si potrebbe pensare allo stato di usura di certe strutture, che in quel caso si traducono in modifiche da parte degli agenti utenti) ed usati dagli agenti utenti. La gestione come artefatto dello stabilimento balneare pu\`{o} per\`{o} portare a pensare che esso possa essere composto da altri artefatti (strutture di servizio), oppure che i servizi siano semplici operazioni messe a disposizione dall'artefatto.}, apice = {BeachSimulation}, author = {Gramellini, Enrico and Magnani, Fabio}, howpublished = {Multi-Agent Systems LM, A.Y. 2010/2011}, month = oct, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Simulazione dell'evoluzione di una zona balneare con tecnologia ad agenti}, type = {Standard Project}, year = 2011 }
@courseproject{visage-sd1011, abstract = {* Descrizione Glossario Casi d'uso Requisiti non funzionali Architettura generale del sistema Architettura dei componenti del sistema Server Side Client Side Piani di collaudo Il modello dei dati del sistema DB Side Application Side Diagramma dell'interazione MobileClient - Server Sviluppo mobile client Tecnologie di riferimento Sviluppo e Deployment del sistema Note critiche e possibili sviluppi futuri Conclusioni}, apice = {Visage}, author = {Montesi, Stefano and Mencarini, Niccolò and Tamanti, Michael and Baldani, Mattia}, howpublished = {Distributed Systems, A.Y. 2010/2011}, month = sep, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Visage}, type = {Standard Project}, year = 2011 }
@courseproject{smartkitchen-smalm1011, abstract = {The aim of the project is to create an application that can make easier the organization of the main activities witch are carried out daily in a kitchen. In particular, the multi-agent system, it will be able to offer user several recipes that can be made with ingredients and tools already available at home. To do this, we have to: Define an ontology to describe the recipes and ingredients so you can search online or even in different languages or different naming Be aware about the food and the tools available to the user, and decide whether a recipe can be made or not in the available time Be able to understand the tastes of the user according to him choices about the past suggested recipes The system will be placed on mobile devices, allowing a more user friendly use of the service, and on devices within the home, such as smart fridge and cupboards.}, apice = {SmartKitchen}, author = {Amaducci, Matteo and Lorenzo Garattoni and Davide Dusi}, howpublished = {Multi-Agent Systems LM, A.Y. 2010/2011}, month = aug, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Smart kitchen: MAS application for home computing}, type = {Standard Project}, year = 2011 }
@courseproject{mindstorms-smals0910, abstract = {Si vogliono analizzare alcuni modelli di coordinazione ed interazione multi-agente sperimentati su robot LEGO Mindstorms e confrontarli con modelli utilizzati nei robot da competizione della RoboCup, per poter valutare una possibilit\`{a} di integrazione ed applicazione di tali pattern. Ci si pone quindi, quindi, l’obiettivo di ipotizzare poi un particolare tipo di scenario di utilizzo di questi sistemi di coordinazione ad agenti collaudati in laboratorio su robot usati in ambito agonistico per disputare la RoboCup.}, apice = {Mindstorms}, author = {Alberto Pini}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = jul, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Modelli multi-agente per robot LEGO Mindstorms applicati a soccer robot per RoboCup}, type = {Standard Project}, year = 2011 }
@courseproject{mashealthcarefundaro2011-smals0910, apice = {MashealthcareFundaro2011}, author = {Alessandro Fundarò}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = jun, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Sistemi multi-agente nell’Healthcare}, type = {Standard Project}, year = 2011 }
@courseproject{agletsimpa-smals0910, abstract = {Il paradigma ad agenti \`{e} un modello sviluppatosi intorno alla met\`{a} degli anni novanta volto alla risoluzione di problemi complessi. La sua adozione in ambito industriale \`{e} stata ostacolata da molti fattori tra cui il diffondersi del paradigma object-oriented, la mancanza di un’unico filone di pensiero che accomuni i principi enunciati in tale modello e soprattutto dalla completa assenza di efficaci piattaforme operative in grado di produrre sistemi funzionanti agent-based. Il principale scopo di questa tesina \`{e} quello di effettuare un confronto fra due delle soluzioni proposte agli sviluppatori per produrre sistemi ad agenti: la prima, Simpa, \`{e} in continua evoluzione e supportata dal team di ricerca universitario aliCE, mentre la seconda, IBM Aglets, nasce verso la fine dello scorso millennio negli IBM Labs e al momento sta attraversando un periodo di stasi.}, apice = {Agletsimpa}, author = {Simone Vignodelli}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = jun, sort = {classic}, supervisor = {Omicini, Andrea}, title = {simpA e IBM Aglets: piattaforme ad agenti a confronto}, type = {Standard Project}, year = 2011 }
@courseproject{aandasmartm3-smalm1011, abstract = {The aim of this project is to accomplish the need for adaptivity and context-awareness in smart environment applications, combining agent-oriented programming with ontological reasoning. This concretises in the realization of Jason Semantically Aware (JaSA) agents, that will show their potentiality using JaCa-smart, an extension of the Jason-CArtAgO framework, to act in the Smart-M3 computational environment. Outline Introduction Towards semantically aware agents Interaction model for Smart Environment Applications Agent-Oriented Programming is the way Use of BDI agents in Smart Environment Systems Integrating BDI agents in Smart-M3 Smart-M3: an open source platform within SOFIA project JaCa-smart Goal of this work JaSA agents Working of a Jason agent Needed Modifications Modifications to the belief base Modifications to the Plan Library Modifications to the "overall agent architecture" Further Modifications JaSA project From JASDL to JaSA From CArtAgO to CArtAgO-DL Artifact manuals as OWL ontologies A new artifact to interact with Smart-M3 SIB(s) New artifact operations interfaces SIB events handling How to build a JaSA MAS - the thermostat example Problem: controlling the temperature of a room Setting up the MAS configuration file: thermo.mas2j MAS thermo artifacts MAS thermo agents Conclusions & future work Acknowledgements References}, apice = {AandASmartM3}, author = {Alice Grandi}, howpublished = {Multi-Agent Systems LM, A.Y. 2010/2011}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {JaSA: semantically aware agents to improve adaptivity and context-awareness of smart environments}, type = {Standard Project}, year = 2011 }
@courseproject{risikomas-smalm1011, abstract = {Our work it's intended to develop a smart agent-based bot capable of doing autonomously and smartly a large amount of choices as required in Risk game. Specifically, multi-agent architecture provides a service, exploited by the bot to execute the different game phases and take decisions accordingly to the particular game situation. The bot is developed following the structure given by Sillysoft [1], producer of the platform LuxDelux, that provides the game environment and Risk constraints. With reference to Risk Wikipedia page [2], "Risk is a strategic board game. It's a turn-based game for two to six players. The standard version is played on a board depicting a political map of the Earth, divided into forty-two territories, which are grouped into six continents. The primary object of the game is "world domination," or "to occupy every territory on the board and in so doing, eliminate all other players."Players control armies with which they attempt to capture territories from other players, with results determined by dice rolls." Multi-agent system for bot's reasoning is realized integrating functionalities of Jason [3] and CArtAgO [4]. The integration of the two technologies allows the creation of the environment for the agent-based decision system. Moreover, CArtAgO implements the interface between game and the MAS, interpreting the role of bridge. Strategies implementation follows a thesis work, MARS, that exploits multi-agent architecture for the creation of a Risk bot. This structure was freely extended and revised, for the creation of a new bot called Attila.}, apice = {RisikoMas}, author = {Cristian Arcaroli and Marco Lazzarini and Federico Molari}, howpublished = {Multi-Agent Systems LM, A.Y. 2010/2011}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Using JaCA technologies for a multi-agent based Risk bot}, type = {Standard Project}, year = 2011 }
@courseproject{masgps-smalm1011, abstract = {La georeferenziazione \`{e} attualmente eseguita attraverso i segnali provenienti dai satelliti GPS. La limitazione di questa tecnica \`{e} legata all'effettiva ricezione di tali informazioni: infrastrutture e ambienti chiusi rappresentano infatti un problema. Per poter ovviare a tale inconveniente si usano attualmente tecniche di IPS (Indoor Positioning System) e A-GPS (Assisted GPS), dove delle antenne georeferenziate a priori, sono in grado di propagare il segnale verso i dispositivi. Scopo del progetto \`{e} l'implementazione di sistemi GPS "intelligenti", in grado in ogni momento di ricostruire la propria posizione, indipendentemente dalla presenza o meno di segnale satellitare. I ricevitori GPS saranno perci\`{o} entit\`{a} attive, pertanto denominati dispositivi, in grado di riconoscere l'assenza di satelliti necessari alla triangolazione: essi provvederanno quindi a contattare altri ricevitori al fine di poter portare a termine la determinazione della propria posizione, senza la necessit\`{a} di introdurre entit\`{a} statiche di propagazione di quest'ultima. La georeferenziazione sar\`{a} possibile tramite un numero inferiore di satelliti, aggiungendo dispositivi GPS in modo tale da diminuire la latenza di inizializzazione grazie alla modellazione ad agenti, e cos\`{i} migliorarne le capacit\`{a} di georeferenziazione.}, apice = {MasGps}, author = {Casanova, Cristiana}, howpublished = {Multi-Agent Systems LM, A.Y. 2010/2011}, month = mar, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Sistemi multi agente per la georeferenziazione dinamica in assenza di segnale GPS}, type = {Standard Project}, year = 2011 }
@courseproject{agata-smals0910, apice = {Agata}, author = {Luca Domeniconi}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = mar, sort = {classic}, supervisor = {Ricci, Alessandro and Santi, Andrea}, title = {A.G.A.T.A.: Automatic Group-buy And Trade Agents}, type = {Standard Project}, year = 2011 }
@courseproject{algebraic-petri-nets-lmc1011, abstract = {Scopo del progetto \`{e} stato l'approfondimento e lo studio delle rete di Petri algebriche: comparate con le reti di Petri standard, si sono sottolineate le potenzialit\`{a} di questo formalismo, facendo riferimento a casi di studio presi in letteratura e ideando problematiche che mettessero in luce l'espressivit\`{a} di queste reti. Sono stati inoltre studiati i principali tools e model checker atti alla loro modellazione e verifica: il principale, AlPiNA, \`{e} stato utilizzato per la costruzione e testing dei casi proposti, nonch\'{e} per la validazione delle propriet\`{a} principali.}, apice = {algebraic-petri-nets}, author = {Casanova, Cristiana}, howpublished = {Computational Models and Languages L-M, A.Y. 2010/2011}, month = feb, sort = {classic}, supervisor = {Viroli, Mirko}, title = {Algebraic Petri Nets}, type = {Standard Project}, year = 2011 }
@courseproject{trafficcontrolmas-smals0910, apice = {Trafficcontrolmas}, author = {Luigi Guagneli}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Approcci multi-agente al controllo del traffico aereo}, type = {Standard Project}, year = 2011 }
@courseproject{transportsystemsmas-smals0910, abstract = {Questo approfondimento ha lo scopo di investigare i meccanismi che portano alle decisioni da parte di entit\`{a} computazionali dette agenti nell’ambito della mobilit\`{a} urbana. Il controllo di un sistema aperto, di larga scala e distribuito composto da molti autonomi agenti che interagiscono tra loro con lo scopo di avere alcune propriet\`{a} globali desiderate (prima fra tutte la sicurezza) non \`{e} un compito banale. Essendo troppo complesso per un processo decisionale centralizzato allora l’unica via praticabile \`{e} la distribuzione del controllo e della decisione. Sfortunatamente la decomposizione genera altri problemi. Quindi in un primo momento si andr\`{a} a vedere quali possono essere e su cosa si basano le infrastrutture di coordinazione. In seguito si passer\`{a} ad analizzare i metodi che portano alle decisioni e come vengono viste all’interno di un ambiente unico ma distribuito.}, apice = {Transportsystemsmas}, author = {Manuel Guagneli}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Sistemi di trasporto con tecnologia multi-agente}, type = {Standard Project}, year = 2010 }
@courseproject{meetingscheduling-smals0910, apice = {Meetingscheduling}, author = {Jimmy Ciccolini}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = sep, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Architettura multi-agente per la risoluzione di problemi di meeting-scheduling}, type = {Standard Project}, year = 2010 }
@courseproject{securesimulator-smals0910, apice = {Securesimulator}, author = {Zagnoli, Andrea}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Secure Agent Simulator}, type = {Standard Project}, year = 2010 }
@courseproject{aea-smals0910, abstract = {In questa relazione si parte illustrando l’evoluzione dei linguaggi di programmazione, dalle origini fino alla programmazione ad agenti. Si prosegue nel capitolo 2 dove si fornisce una panoramica sul meta-modello A&A, in cui \`{e} presente l’astrazione di artefatto. Nel capitolo 3 si illustra come gli artefatti oltre a modellare l’ambiente e la coordinazione in un workspace, possano essere usati in maniera naturale anche per il monitoraggio di un sistema MAS. Concludiamo nel capitolo 4 fornendo un elenco di tecnologie disponibili e proponendo un piccolo esempio pratico.}, apice = {Aea}, author = {Castori, Alberto}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, keywords = {Metamodello A&A • Artefatto • Monitoraggio}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Meta modello A&A e utilizzo artefatti per monitoraggio di MAS}, type = {Standard Project}, year = 2010 }
@courseproject{rocs-smals0910, abstract = {The ROCS project aims to explore the complex word of ontologies starting from the definition to the description of its relevance in the world of Multi Agent Systems (MAS). For long time every work focuses on the syntax of language more than the semantics that it has. Now, with the introduction of new programming paradigms (like the agents), the growing of networks, the heterogeneity of data and informations, it is necessary to move toward a system where semantics has a crucial role. In the following report it’s going to be described how an ontology can be represented (RDF, OWL, Wordnet) and various methods useful to compare them (W4, Hmatch,SOSTuS).}, apice = {Rocs}, author = {Virruso, Sascia}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = apr, sort = {classic}, supervisor = {Omicini, Andrea}, title = {ROCS: The role of ontology in coordination systems}, type = {Standard Project}, year = 2010 }
@courseproject{mastrafficsignals-smals0910, apice = {Mastrafficsignals}, author = {Qiao Xin}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Urban Traffic Signal Control Based on Multi-Agent Systems}, type = {Standard Project}, year = 2010 }
@courseproject{garbagedump-smals0809, apice = {Garbagedump}, author = {Maria Teresa Roccia}, howpublished = {Multi-Agent Systems LS, A.Y. 2008/2009}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Garbage Dump}, type = {Standard Project}, year = 2010 }
@courseproject{mesmas-smals0910, abstract = {La simulazione \`{e} oggi sempre pi\`{u} utlilizzata sia come appoggio alla sperimentazione fisica sia come strumento nella fase di testing di sistemi software complessi. Per questo l’M&S (Modeling and Simulation) viene ormai considerato una scienza a tutti gli effetti. La presente relazione analizzer\`{a} le interconnesioni tra i MAS ed il mondo del M&S. In tale settore, infatti, i MAS possono essere impiegati sia come paradigma per la modellazione del sistema reale, sia come paradigma per l’implementazione del simulatore. Nella prima parte si riporter\`{a} un framework concettuale per l’analisi del processo di modellazione e simulazione e verranno analizzati pregi e difetti dell’utilizzo dei MAS in tale contesto. Nella seconda parte si prensenteranno due possibili approcci alla complessit\`{a} realizzativa di un simulatore agent-based.}, apice = {Mesmas}, author = {Andrea Tosi}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Modelling & Simulation using MAS}, type = {Standard Project}, year = 2010 }
@courseproject{bdiweb-smals0910, abstract = {Il seguente elaborato, realizzato per il corso di Sistemi Multiagente LS, si pone lo scopo di motivare, descrivere e spiegare l’utilizzo di un modello di programmazione ad agenti nell’ambito delle applicazioni Web lato client. Esso \`{e} da considerarsi come la naturale continuazione della tesi di laurea triennale da me realizzata e dal titolo “Un Modello di Programmazione ad Agenti per Applicazioni Web 2.0 e 3.0” e del successivo articolo scientifico “An Agent-Based Programming Model For Developing Client-Side Concurrent Web 2.0 Applications” presentato presso la conferenza WEBIST di Lisbona, 2009. Rispetto ai precedenti lavori, in questo elaborato si cercher\`{a} di focalizzarsi maggiormente sulle motivazioni che hanno portato a proporre l’utilizzo di agenti nell’ambito del Web 2.0 e di agenti intelligenti nell’ambito del Web 3.0 o Web Semantico. La trattazione sar\`{a} suddivisa in tre capitoli. Nel primo si cercher\`{a} di riproporre una veloce panoramica sui concetti fondamentali che portano alla definizione di Web 2.0 e 3.0, cercando di fare particolare attenzione a quegli aspetti che porteranno poi a motivare le scelte che verranno fatte. Il secondo capitolo sar\`{a} invece dedicato alla discussione pi\`{u} specifica dei pregi e dei difetti che l’utilizzo di un modello di programmazione ad agenti pu\`{o} apportare nello sviluppo di una applicazione Web 2.0. In esso vi sar\`{a} anche un confronto con le tecniche oggi pi\`{u} utilizzate in questi ambiti, come AJAX e GWT. Il terzo ed ultimo capitolo sar\`{a} infine dedicato alle implicazioni che l’uso di questo modello, ed in particolare una sua estensione che faccia uso di agenti intelligenti, puo` portare in relazione alla visione ed alle prospettive offerte dal Web 3.0 o Web Semantico.}, apice = {Bdiweb}, author = {Mattia Minotti}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Progettare e programmare un'applicazione Web 2.0 e 3.0 con agenti BDI, come e perch\'{e}?}, type = {Standard Project}, year = 2010 }
@courseproject{selforgmas-smals0910, abstract = {Questo articolo ha come obbiettivo quello di approfondire i concetti legati all’auto-organizzazione nei multi-agent system, e di mostrare come questa caratteristica possa essere introdotta direttamente dentro la fase di sviluppo tramite metodologie e modelli mirati. L’articolo si suddivide in 3 capitoli. Nel primo si cercher\`{a} di fornire tutte le conoscenze necessarie per comprendere al meglio il ruolo della self-organizazion nei sistemi complessi e tutti i sotto aspetti ad essa legati. Verranno introdotti concetti base come quelli della stigmergia, dei fenomeni emergenti, e verranno illustrati esempi biologici dai quali questi concetti si ispirano. Dopo aver fornito un discreto background concettuale, nel secondo capitolo motiveremo la scelta del paradigma ad agenti per progettare SOS, e i vari approcci studiati per aggiungere proprieta` self-organazing ai sistema, a seconda del meccanismo da cui nascono queste propriet\`{a} di auto-organizzazione. Infine, nel terzo capitolo mostreremo alcune metodologie e metodi di sviluppo(alcuni pi\`{u} astratti, altri basati su casi studio specifici), e vedremo i vari problemi che devono essere affrontati quanto si vuole sviluppare, controllare e valutare un SOS. Chiuderemo l’articolo con una breve conclusione nel quale discuteremo del lavoro svolto e di possibili lavori futuri relativi a questo ambito.}, apice = {Selforgmas}, author = {Pronti, Giacomo}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Metodologie e architetture per l'autoorganizzazione nei MAS}, type = {Standard Project}, year = 2010 }
@courseproject{agentnetworkmanagement-smals0910, apice = {Agentnetworkmanagement}, author = {Roberto Morini}, howpublished = {Multi-Agent Systems LS, A.Y. 2009/2010}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Agenti mobili per il network management}, type = {Standard Project}, year = 2010 }
@courseproject{masswarmbot-smals0708, apice = {Masswarmbot}, author = {Colantonio, Edoardo}, howpublished = {Multi-Agent Systems LS, A.Y. 2007/2008}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Sistemi Multiagente Swarm-Bot}, type = {Standard Project}, year = 2008 }
@courseproject{maspatternsmaroni2007-smals0607, apice = {MaspatternsMaroni2007}, author = {Andrea Maroni}, howpublished = {Multi-Agent Systems LS, A.Y. 2006/2007}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Utilizzo di Patterns nella progettazione di Sistemi Multiagente}, type = {Standard Project}, year = 2007 }
@courseproject{storagesystem-sdla0607, abstract = {Realizzazione un sistema di gestione delle giacenza in magazzino di un sito di e-Commerce.}, apice = {StorageSystem}, author = {Raniero Gasperini and Nicola Eusebi}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = jun, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Storage System}, type = {Standard Project}, year = 2007 }
@courseproject{confezionamentovino-sdla0607, abstract = {Gestione della catena per l'imbottigliamento del vino.}, apice = {ConfezionamentoVino}, author = {Alessandro Tarroni and Claudio Reggiani and Matteo Ruscelli}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Confezionamento vino}, type = {Standard Project}, year = 2007 }
@courseproject{ristorante-sdla0607, abstract = {Realizzazione di un sistema di gestione delle ordinazioni (al tavolo e take-away) per un ristorante.}, apice = {Ristorante}, author = {Desanti, Matteo and Montalti, Alessandro and Santarelli, Marco and Zagnoli, Andrea}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Ristorante}, type = {Standard Project}, year = 2007 }
@courseproject{blackgold-sdla0607, abstract = {Si richiede di progettare e realizzare un sistema di controllo remoto di un serbatoio.}, apice = {BlackGold}, author = {Frens Tedeschini and Castori, Alberto and Luca Battistini}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Black Gold}, type = {Standard Project}, year = 2007 }
@courseproject{contatore-sdla0607, abstract = {Una ditta deve gestire e monitorare lo stoccaggio dei rifiuti prodotti dalla sua attivit\`{a}. I rifiuti vengono mano a mano imballati in casse (che ne contengono una quantit\`{a} fissata) e stoccati in un magazzino, di capienza limitata a 19 casse. Poich\'{e} questi rifiuti sono altamente infiammabili, quando nel magazzino si trovano pi\`{u} di 13 casse la ditta deve, per legge, attuare delle norme di sicurezza per evitare incendi. Quando invece si aggiunge una cassa a magazzino pieno, il magazzino stesso viene svuotato e tutte le casse caricate un camion che le porta alla discarica della citt\`{a}. L'attivit\`{a} dell'azienda si alterna costantemente fra 2 fasi, sperimentazione e produzione, durante le quali lo stoccaggio avviene in modo diverso: durante la sperimentazione le casse vengono spostate da operai addetti e possono entrare e uscire a seconda delle necessit\`{a}. Durante la produzione invece lo stoccaggio \`{e} totalmente automatizzato e regole interne vietano di reinserire nel ciclo produttivo i rifiuti prodotti. Lo sviluppo del sistema si basa su un accordo fra l'azienda, la discarica locale e l'ente di gestione dell'elettricit\`{a} (ENEL): la ditta deve essere in grado di tener traccia dello stato del proprio magazzino, la discarica deve controllare il numero di casse per ottimizzare i propri percorsi di raccolta rifiuti , mentre l'ENEL deve monitorare costantemente l'azienda per sapere quando applicare le norme di restrizione contro gli incendi. Per fare tutto questo, azienda, ENEL e discarica devono essere dotati di due tipi di display: uno che sia in grado di mostrare il numero di casse, uno lo stato di allarme.}, apice = {Contatore}, author = {Battarra, Marco}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Contatore}, type = {Standard Project}, year = 2007 }
@courseproject{incrociostradale-sdla0607, abstract = {Si vuole gestire il sistema semaforico di un incrocio stradal edove sia possibile, per un eventuale pedone, effettuare la richiesta di attraversamento pedonale, premendo un apposito pulsante.}, apice = {IncrocioStradale}, author = {Francesco Bakken and Filippo Bruschi and Mattia Manfroni}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Incrocio stradale}, type = {Standard Project}, year = 2007 }
@courseproject{messagepassingframework-sdla0607, abstract = {Obiettivo primario \`{e} realizzare un framework volto alla fornitura di un servizio di message-passing, il pi\`{u} possibile riusabile nello sviluppo di progetti futuri. Ci siamo prefissati questo obiettivo poich\`{e} se ne \`{e} presentata la necessit\`{a} in altri ambiti, spingedoci a separare la progettazione dei due sistemi, per massimizzarne le peculiarit\`{a} di riuso ed efficienza.}, apice = {MessagePassingFramework}, author = {Desanti, Matteo and Montalti, Alessandro and Santarelli, Marco and Zagnoli, Andrea}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Message-passing Framework}, type = {Standard Project}, year = 2007 }
@courseproject{rover-sdla0607, abstract = {Realizzare un robot rover in grado di potersi muovere a comando nelle quattro direzioni Avanti-Indietro-Destra-Sinistra. Esso sar\`{a} dotato di una telecamera che fornir\`{a} dati in tempo reale ad una regia remota, la quale avr\`{a} un display per visualizzare l'immagine della web-cam e potr\`{a} comandare gli spostamenti del rover. La telecamera potr\`{a} ruotare intorno ad un asse verticale, per visualizzare la panoramica circostante mediante la realizzazione di una apposita procedura automatica. Infine il rover dovr\`{a} essere pilotato da un solo utente per volta per non pi\`{u} di 5 minuti.}, apice = {Rover}, author = {Brighi, Denis and Vichi, Davide and Alessandro Musto and Morri, Luca}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Rover}, type = {Standard Project}, year = 2007 }
@courseproject{confezionamentonoccioline-sdla0607, abstract = {L'obiettivo principale dell'esercitazione \`{e} quello di adattare al mondo reale il contatore colorato con display, creato nel corso di Ingegneria del Software. Adattare il contatore vuol dire trovare un ambiente nel quale possa venire sfruttato al meglio in tutte le sue funzionalit\`{a}. Oltre ad adattare il nostro progetto alla realt\`{a}, naturalmente dobbiamo cercare di collocarlo all'interno di un sistema distribuito. E' per questo che abbiamo deciso di implementare il tutto in una struttura che si occupa del confezionamento di noccioline. Il nostro contatore risulta cos\`{i} applicato al mondo reale e soprattutto gestito in distribuito (vedesi Analisi per le specifiche).}, apice = {ConfezionamentoNoccioline}, author = {Chiara Schiumarini and Giacomo Orlati}, howpublished = {Distributed Systems L-A, A.Y. 2006/2007}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Confezionamento noccioline}, type = {Standard Project}, year = 2007 }
@courseproject{biopatternsmas-sdlm1213, abstract = {Analizzare i patterns Gossip, Gradient, e Digital Pheromones, studiandone le possibili applicazioni nel contesto MAS e contestualizzandole tramite le tecnologie JADE / TuCSoN.}, apice = {BiopatternsMas}, author = {Pietro Brunetti and Croatti, Angelo and Marchi, Francesca}, howpublished = {Distributed Systems, A.Y. 2012/2013}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Bio-inspired Design Patterns in MAS}, type = {Standard Project}, year = 2007 }
@courseproject{masssosnanni2007-smals0607, apice = {MasssosNanni2007}, author = {Davide Nanni}, howpublished = {Multi-Agent Systems LS, A.Y. 2006/2007}, month = feb, sort = {classic}, supervisor = {Omicini}, title = {Self-Organizing MAS}, type = {Standard Project}, year = 2007 }
@courseproject{sodacasestudytufano2007-smals0607, apice = {SodacasestudyTufano2007}, author = {Giacomo Tufano}, howpublished = {Multi-Agent Systems LS, A.Y. 2006/2007}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {SODA -- caso di studio: le vie di segnalazione intracellulare}, type = {Standard Project}, year = 2007 }
@courseproject{sosmasgiorgini2007-smals0607, apice = {SosmasGiorgini2007}, author = {Marco Giorgini}, howpublished = {Multi-Agent Systems LS, A.Y. 2006/2007}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Self-Organizing MAS}, type = {Standard Project}, year = 2007 }
@courseproject{perceptionvernocchi2006-smals0607, apice = {PerceptionVernocchi2006}, author = {Francesco Vernocchi}, howpublished = {Multi-Agent Systems LS, A.Y. 2006/2007}, month = dec, sort = {classic}, supervisor = {Omicini, Andrea}, title = {L’impatto delle percezioni: simpA e CArtAgO}, type = {Standard Project}, year = 2006 }
@courseproject{aclburnacci2006-smals0607, apice = {AclBurnacci2006}, author = {Paolo Burnacci}, howpublished = {Multi-Agent Systems LS, A.Y. 2006/2007}, month = dec, sort = {classic}, supervisor = {Omicini, Andrea}, title = {La comunicazione nei MAS: ACL e non solo}, type = {Standard Project}, year = 2006 }
@courseproject{rsscavina2006-smals0607, apice = {RssCavina2006}, author = {Cavina, Lorenzo}, howpublished = {Multi-Agent Systems LS, A.Y. 2006/2007}, month = dec, sort = {classic}, supervisor = {Omicini, Andrea}, title = {RSS content management & distribution}, type = {Standard Project}, year = 2006 }
@courseproject{contractnetlombardi2006-smals0607, apice = {ContractnetLombardi2006}, author = {Fabio Lombardi}, howpublished = {Multi-Agent Systems LS, A.Y. 2006/2007}, month = nov, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Utilizzo di Fipa come specifica di comunicazione fra agenti e realizzazione del protocollo ContractNet nella proposizione di un caso specifico con JADE}, type = {Standard Project}, year = 2006 }
@courseproject{busbookingburnacciramilli-sdla0405, apice = {BusBookingBurnacciramilli}, author = {Paolo Burnacci and Marco Ramilli}, howpublished = {Distributed Systems L-A, A.Y. 2004/2005}, month = may, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Servizio prenotazione autobus}, type = {Standard Project}, year = 2005 }
@courseproject{reputationbendoni2005-sidls0405, abstract = {Il mio obbiettivo \`{e} costruire un meccanismo di controllo della reputazione per evitare che, all'arrivo di un agente, questo prenda in carico un eccessivo numero di lavori che non \`{e} poi in grado di portare a termine con successo. Il meccanismo \`{e} implementato nel centro di tuple. La reputazione si crea all'interno del sistema osservandone il comportamento, non si acquisiscono informazioni direttamente dall'agente o da un “organismo” esterno. Il sistema \`{e} aperto all'arrivo di agenti provenienti dall'esterno e ci sono vari agenti che forniscono servizi al centro. Vi \`{e} un controllo sul grado di affidabilit\`{a} dell'agente ed uno sulle sue prestazioni. Una volta terminata questa fase il progetto pu\`{o} essere ampliato creando un agente “intelligente” che \`{e} in grado di valutare le scuse fornite dagli agenti che terminano il lavoro in ritardo.}, apice = {ReputationBendoni2005}, author = {Luca Bendoni}, howpublished = {Distributed Intelligent Systems LS, A.Y. 2004/2005}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {La reputazione}, type = {Standard Project}, year = 2005 }
@courseproject{bargellinimsg2005-sidls0405, abstract = {Partendo da un agente gi\`{a} esistente e funzionante (agente SMS_Sender), il cui task \`{e} quello di offrire un servizio di invio di sms, si vogliono estendere le sue funzionalit\`{a} introducendo alcune migliorie e qualche nuovo servizio. In particolare: Sviluppo di un comportamento reattivo a fronte di una richiesta di un invio multiplo Sviluppo di un servizio a fronte di una richiesta di un invio differito (Eventuale) sviluppo di un servizio a fronte di una richiesta di invio (multiplo) tramite passaggio all'agente SMS_Sender di una “rubrica”.}, apice = {BargelliniMsg2005}, author = {Bargellini, Mattia}, howpublished = {Distributed Intelligent Systems LS, A.Y. 2004/2005}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Estensione di un servizo di messaggistica per telefonia mobile}, type = {Standard Project}, year = 2005 }
@courseproject{2pjadeinterfacetarabusi2004-sdls0304, abstract = {Il fulcro del lavoro \`{e} stato quello di creare un'implementazione Java che permetta l'utilizzo delle funzionalit\`{a} di {{tuprolog/}} all'interno del Framework di JADE 3.0b.}, apice = {2pjadeinterfaceTarabusi2004}, author = {Christian Tarabusi}, howpublished = {Distributed Systems LS, A.Y. 2003/2004}, month = feb, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Implementazione di un'interfaccia tra tuProlog e JADE}, type = {Standard Project}, year = 2004 }
@courseproject{agentcommunicationtaxonomycirolli2004-sdls0304, abstract = {In questo progetto si \`{e} considerato un sistema di agenti che impiegano delle tassonomie per descrivere i contenuti dei loro oggetti e per formulare ad altri agenti del sistema delle queries basate sulla semantica. Poich\'{e} ogni agente pu\`{o} usare la sua tassonomia, gli agenti sono dotati di un procedimento di mapping delle tassonomie per poter effettuare i tasks di traduzione richiesti. Questi agenti sono in grado di creare o revisionare il mapping su richiesta e run-time. Per questo motivo verr\`{a} introdotto un metodo di articolazione apparente (ostensive articulation) e verr\`{a} specializzato nel caso di tassonomia. Inoltre \`{e} stato considerato il caso in cui nel sistema arriva un agente ’esterno’ che vuole mettersi in comunicazione con uno o piu` agenti presenti nel sistema. Poich\'{e} non sar\`{a} dotato di un dominio comune con gli altri agenti (condizione necessaria per l’ostensive articulation) si \`{e} predisposto nel sistema un mediatore in grado di fare da tramite affinch\'{e} possa avvenire la comunicazione.}, apice = {AgentCommunicationTaxonomyCirolli2004}, author = {Carla Cirolli}, howpublished = {Distributed Systems LS, A.Y. 2003/2004}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {La comunicazione tra agenti basati su tassonomia}, type = {Standard Project}, year = 2004 }
@courseproject{adhocwirelessgossiptavelli2004-sdls0304, abstract = {Il progetto si basa sull'idea di applicare il Gossip a reti di tipologia wireless Ad Hoc potesse risolvere problemi legati alla sovrabbondanza dei messaggi di segnalazione spesso inutilmente generati. Il funzionamento si basa sull'idea che i nodi della rete effettuino Gossip in modo costruttivo. Cos\`{i} come per le persone vi \`{e} una sorta di propagazione casuale dell'informazione all'interno della rete, che permette di trovare impostando opportuni parametri, il percorso tra un nodo sorgente ed un nodo destinazione.}, apice = {AdhocwirelessgossipTavelli2004}, author = {Emanuele Tavelli}, howpublished = {Distributed Systems LS, A.Y. 2003/2004}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Gossip Algorithm in reti wireless di tipologia Ad Hoc}, type = {Standard Project}, year = 2004 }
@courseproject{domoticagentspavolucci2004-sdls0304, abstract = {D.A.S. (Domotic Agent System) \`{e} un sistema adibito all’automazione dei dispositivi presenti in un edificio civile, ad esempio la gestione centralizzata della temperatura oppure la gestione degli accessi a determinate aree e stanze dell’edificio. Questo sistema \`{e} realizzato con una tecnologia basata sul concetto d’agente, entit\`{a} software che collaborano insieme attraverso aree comuni di deposito informazioni.}, apice = {DomoticagentsPavolucci2004}, author = {Eugenio Pavolucci}, howpublished = {Distributed Systems LS, A.Y. 2003/2004}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {D.A.S. (Domotic Agent System)}, type = {Standard Project}, year = 2004 }
@courseproject{cooperativewirelesslancoletto2004-sdls0304, abstract = {L’Intelligenza Artificiale \`{e} tutt’oggi utilizzata nella gestione di sistemi di telecomunicazioni, per suddividere i problemi di controllo su risorse distribuite e fornire differenti servizi in reti di grandi dimensioni. Molte di queste applicazioni sono state effettuate su reti fisse ma lo stesso concetto pu\`{o} essere esteso anche alle reti wireless, le quali presentano altri problemi tra i quali: alti e frequenti errori sui bit causati dal rumore in collegamenti via etere, grandi burst di errore causati da interferenza multipercorso, perdita o variazione dell’ordine dei pacchetti dovuta all’handoffs, piccola dimensione massima dei pacchetti per supportare servizi in real-time tipo traffico voce, scarsa banda di frequenze da utilizzare, dove il pi\`{u} rilevante \`{e} l’allocazione delle frequenze radio, in sistemi multiutente, per evitare congestioni o degradazione del Quality of Service (QoS)}, apice = {CooperativewirelesslanColetto2004}, author = {Stefano Coletto}, howpublished = {Distributed Systems LS, A.Y. 2003/2004}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {Negoziazione cooperativa per la gestione di una rete Wireless LAN}, type = {Standard Project}, year = 2004 }
@courseproject{networksecuritygramellini2004-sdls0304, abstract = {Negli ultimi anni Internet ha drasticamente cambiato il modo di acquisire, sfruttare ed inviare le informazioni. Specialmente ha avuto un notevole sviluppo nell’ambito del commercio elettronico (e-commercio). E’ cambiato il modo di fare affari e di gestire il lavoro, in quanto Internet permette di abbattere le barriere geografiche ed inoltre aumenta notevolmente la velocit\`{a} di trasmissione di dati e delle normali transazioni finanziare che vengono fatte nel mondo degli affari. Affinch\'{e} siano incluse le transazioni monetarie, ed inoltre per mantenere la riservatezza e la segretezza di particolari informazioni, \`{e} fondamentale la sicurezza. Un nuovo strumento software per lo scambio d’informazione sono gli AGENTI MOBILI definiti come sofisticate entit\`{a} software che posseggono un’intelligenza artificiale che autonomamente viaggiano attraverso un ambiente di rete e prendono complesse decisioni per conto degli utenti. L’impiego degli agenti mobili permette di diminuire notevolmente il consumo della banda di rete, evitando inoltre gli eccessivi traffici di informazione che possono intasare la rete. L’utilizzo di questi agenti mobili ha per\`{o} introdotto notevoli problemi di sicurezza che andremo ad esaminare di seguito.}, apice = {NetworksecurityGramellini2004}, author = {Maria Chiara Gramellini}, howpublished = {Distributed Systems LS, A.Y. 2003/2004}, month = jan, sort = {classic}, supervisor = {Omicini, Andrea}, title = {La sicurezza in rete}, type = {Standard Project}, year = 2004 }
@courseproject{conti2324-ethicsofai20232024, abstract = {The aim of this final project is to inspect and compare dif- ferent techniques and tools available for Non-linear model explainability. The final objective is to explore the effectiveness of LIME [4], SHAP [1] and PSyKE [5] in returning comprehensive explanations for different types of machine learning algorithms; utilizing both images and tabular data. The effectiveness of these methods will be determined by assessing their consistency, comprehensibility and reliability. The comparison will be made with respect to different algorithms, studying their ability to learn similar information.}, apice = {Conti2324}, author = {Alessio Conti}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Comparative Analysis of Explainability Techniques for Non-linear Models}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/conti2324} }
@courseproject{giordanopittiglio2425-ethicsofai20242025, abstract = {Deepfake technology, which uses artificial intelligence to generate fake videos, presents significant ethical and social challenges. These manipulated videos can be used to spread disinformation, undermining public trust in the media. This project aims to explore deepfake detection methods by analyzing vari- ous approaches. We will start with well-established CNN-based baselines (e.g., Xception [1]) and may also investigate more recent solutions, applying them to publicly available datasets. Based on this analysis, we will develop a pro- totype system capable of detecting whether a video is real or not. The goal is to contribute to addressing the ethical challenges in AI, such as promoting transparency and preventing the malicious use of emerging technologies.}, apice = {GiordanoPittiglio2425}, author = {Roberto Giordano and Alessio Pittiglio}, howpublished = {Ethics of AI, A.Y. 2024/2025}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Deepfake Video Detection: A Comparative Study}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/giordanopittiglio2425} }
@courseproject{wysockimeira2324-ethicsofai20232024, abstract = {This project involves the development of a machine learning model designed to predict football players’ transfer values using a dataset that includes player names, ages, nationalities, positions, originating leagues, market values, and changes in market values (delta value 1 and delta value 2). The dataset will be complemented by actual transfer amounts for players who have been bought, allowing the model to be trained on real-world data. The primary aim is to examine potential biases and fairness issues within the model, especially focusing on variables such as nationality, age, and league. We plan to analyze how these biases manifest and propose strategies to mitigate them.}, apice = {WysockiMeira2324}, author = {Franciszek Wysocki and Gabriel Meira}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Fairness in Football Player Transfer Value Prediction}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/wysockimeira2324} }
@courseproject{stamenov2425-ethicsofai20242025, abstract = {This project focuses on developing a predictive model using real-world hiring data from AKKODIS to investigate and address salary-related stereotypes and potential biases in recruitment processes. The objective is to analyze historical hiring data to identify patterns that may indicate bias in salary offers (RAL) and to develop models that promote fairness and transparency. By leveraging machine-learning techniques, we aim to detect underlying trends that may not be immediately apparent through traditional analysis. The findings of this study can help organizations implement data-driven policies to mitigate bias and ensure an equitable distribution of salaries.}, apice = {Stamenov2425}, author = {Lyudmil Stamenov}, howpublished = {Ethics of AI, A.Y. 2024/2025}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Predictive Modeling on Real Hiring Data: Exploring Salary Stereotypes and Bias Mitigation}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/stamenov2425} }
@courseproject{biaginifusconi2324-ethicsofai20232024, abstract = {Face recognition technology has become very important today, from unlocking our phones to keeping places secure trough surveillance. Be- cause of this, it is crucial to have models that are both efficient and fair. We will focus on FaceNet [1], one of the top models for face recognition, and look at how it might be biased. We will analyze these biases and then try to improve the model by using techniques to mitigate them. Our goal is to make FaceNet more accurate and fair for everyone. By fine-tuning the model and implementing bias mitigation strategies, we aim to ensure that FaceNet performs well across different groups of people, providing a more reliable and inclusive face recognition system. This will help in making the technology more trustworthy and useful in various real-world applications.}, apice = {BiaginiFusconi2324}, author = {Matteo Fusconi and Biagini, Guglielmo}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Bias Mitigation in Face Recognition Models}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/biaginifusconi2324} }
@courseproject{haugevarnes2425-mas2425, abstract = {Our goal is to improve AI-driven development in large codebases—where a single agent often loses context and hallucinates. We are solving this with a multi-agent system that automates generation, review, and testing. To achieve this, we will compare two state-of-the-art tools for building multi- agent systems: the OpenAI Agent SDK and Google’s ADK. We will evaluate both platforms in terms of capabilities, features, and ease of integration, then choose the one best suited for our goals. We will use Python for scripts, JSON for message schemas, virtual environments (venv) with pip for dependency management, and Docker for deploying and testing our agents.}, apice = {HaugeVarnes2425}, author = {Ake Sjursen Hauge and Eirik Varnes}, howpublished = {Multi-Agent Systems, A.Y. 2024/2025}, month = may, sort = {classic}, supervisor = {Calegari, Roberta}, title = {I-driven development in large codebases: a MAS approach}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/haugevarnes2425}, year = 2025 }
@courseproject{carboni2324-ethicsofai20232024, abstract = {Artificial Intelligence (AI) has become an invaluable tool across nu- merous aspects of our lives, profoundly influencing various fields, includ- ing healthcare. Within healthcare, disciplines such as dermatology stand to benefit significantly from the adoption of automated techniques to sup- port the visual examination of patients. However, these advancements are challenged by the diverse presentations of skin diseases across dif- ferent skin tones, underscoring the need for diverse datasets to train AI models effectively and strategies to mitigate the risk of misdiagnosis. Ad- ditionally, building a general-use dataset is particularly difficult due to the varying regulations on the use of medical images, which often restrict data sharing and impose ethical and legal constraints. This study aims to conduct a systematic literature review to evaluate the current state of the art in this critical area.}, apice = {Carboni2324}, author = {Ilenia Carboni}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Automatic Skin Disease Prediction: A Review}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/carboni2324} }
@courseproject{palliterzi2324-ethicsofai20232024, abstract = {We want to test some local and global explainability techniques on classic ML models, such as LIME, DiCE, and SHAP. These tests will be useful to verify the fairness of the trained models and the importance of each feature in generating the output. The models will also be tested through Data Augmentation to generate a greater number of examples for the underrepresented classes. Finally, Adversarial Models will be in- troduced to test the validity of the obtained explainability results and to verify their robustness.}, apice = {PalliTerzi2324}, author = {Nicola Palli and Terzi Angelo}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Analysis of Explainability ML Techinques against Adversarial Models}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/palliterzi2324} }
@courseproject{nurfirdausi2425-ethicsofai20242025, abstract = {As artificial intelligence becomes increasingly integrated into mental health diagnostics, ensuring fairness and transparency is critical—particularly in sensitive applications such as depression detection. This project explores fairness-aware deep learning using raw EEG signals from the MODMA (Multi- modal Open Dataset for Mental-disorder Analysis) dataset [1]. Three deep neural architectures are developed and evaluated: a Convolutional Neural Network (CNN) as a baseline model, a CNN combined with Long Short-Term Memory (CNN-LSTM), and a CNN combined with Gated Recurrent Units and Attention mechanism (CNN-GRU-Attention). To address potential biases, five mitigation techniques are applied across three stages: preprocessing, in-processing, and post-processing. The models are evaluated using both performance metrics (accuracy, precision, recall, F1-score) and fairness metrics (disparate impact, statistical parity, equal opportunity, average odds, and equalized accuracy).}, apice = {Nurfirdausi2425}, author = {Annisaa Fitri Nurfirdausi}, howpublished = {Ethics of AI, A.Y. 2024/2025}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Fairness in EEG-Based Depression Detection}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/nurfirdausi2425} }
@courseproject{guizzetti2324-ethicsofai20232024, abstract = {Law enforcement agencies in the United States use predictive policing algorithms to analyze past crime data and identify high-risk areas where officers are directed to patrol during each shift. This project aims to develop a predictive algorithm using a US criminological dataset and to identify and mitigate biases that may disproportionately affect marginalized communities. The focus is on evaluating the model’s performance and fairness both before and after implementing bias mitigation techniques. By addressing these biases, the goal is to understand how a more equitable crime prediction model that provides unbiased insights and predictions can be developed, ultimately contributing to fairer decision-making processes in algorithmic policing.}, apice = {Guizzetti2324}, author = {Thomas Guizzetti}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Developing and Analyzing Fairness in Algorithmic Policing}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/guizzetti2324} }
@courseproject{castagnari2324-ethicsofai20232024, abstract = {This work addresses the critical need for transparency in AI used in decision-making processes, particularly in clinical diagnosis. While large language models (LLMs) are increasingly utilized in various applications, their opacity often limits their effectiveness and trustworthiness in clinical settings. The aim is to enhance the explainability of LLMs without compromising their perfor- mance, thereby enabling clinicians to make better, more personalized, and targeted diagnoses. Inspired by clinical guidelines and studies on Deep Reinforcement Learning (DRL) for optimal diagnostic sequences, this research approaches diagnosis as a sequential decision-making problem. Open-source LLMs, such as LLaMA-3 [lla] and Mistral7B v0.3 [JSM+23], are leveraged to learn the most efficient diagnostic pathways from Electronic Health Records (EHRs). By employing advanced prompting techniques and chain-of-thought reasoning [MTS+24], the ap- proach ensures that the AI’s decision-making process is transparent and interpretable. This ex- plainable AI model allows doctors to understand and evaluate the rationale behind each step, fostering trust and enabling safer, more effective clinical applications.}, apice = {Castagnari2324}, author = {Elisa Castagnari}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Explainability of Large Language Models (LLMs) for Anemia Diagnosis}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/castagnari2324} }
@courseproject{crociatisonno2425-ethicsofai20242025, abstract = {Generative Text-to-Image (T2I) models have gained more and more popularity, enabling users to easily produce detailed images from textual prompts. However, these models often encode and reproduce the social or cultural biases present in their training data. Such biases can influence people perception and reinforce stereotypes. In this project we aim to explore and identify patterns of bias in six of the current popular T2I models.}, apice = {CrociatiSonno2425}, author = {Davide Crociati and Davide Sonno}, howpublished = {Ethics of AI, A.Y. 2024/2025}, month = may, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Investigating Bias in Generative Text-to-Image AI Models}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/crociatisonno2425}, year = 2025 }
@courseproject{pivikiliancreurer2324-ethicsofai20232024, abstract = {This project aims to investigate biases in Large Language Models (LLMs) when processing resumes. Specifically, we focus on examining potential biases related to gender, ethnicity, and age. By evaluating vari- ous LLMs of various sizes we seek to uncover any disparities in how they handle resume data based on these factors. This research contributes to a better understanding of biases inherent in LLMs and their implications for fair recruitment and employment practices.}, apice = {PiviKilianCreurer2324}, author = {Pivi, Francesco and Kilian Tiziano Le Creurer}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Evaluation of Hiring Bias in Large Language Models}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/pivikiliancreurer2324} }
@courseproject{carolimongiello2324-ethicsofai20232024, abstract = {Large Language Models (LLMs) have revolutionized the landscape of natural language processing, finding applications across diverse domains. However, the issue of political biases encoded within these models—which can influence outputs and perpetuate ideolog- ical leanings—is often underrated. A recent study, ChatGPT vs. Google: A Comparative Study of Search Performance and User Experience by Xu et al.[1], sheds light on how users perceive and interact with LLM-powered chatbots com- pared to traditional search engines. Their findings reveal that while tools like ChatGPT enhance efficiency and user satisfaction by de- livering concise and accessible information, they may inadvertently encourage overreliance and fail to expose users to diverse perspec- tives, particularly in tasks requiring fact-checking or critical evalu- ation. Building on these insights, this project aims to conduct a systematic literature review (SLR) on political bias in LLMs, focusing on its identification, measurement, and mitigation.}, apice = {CaroliMongiello2324}, author = {Giacomo Caroli and Luca Mongiello}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Unveiling Political Bias in Artificial Intelligence: A Systematic Literature Review}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/carolimongiello2324} }
@courseproject{maranzana2324-ethicsofai20232024, abstract = {Bias in candidate selection is a critical issue that can undermine fair- ness and equity in hiring processes. This study investigates biases related to gender, age, and location using two real-world datasets produced by Adecco. The research employs a structured pipeline consisting of data ex- ploration, preprocessing, bias detection, and bias mitigation. The analysis will explore biases related to gender, age, and location within the datasets, emphasizing the need for effective detection and mitigation strategies.}, apice = {Maranzana2324}, author = {Mattia Maranzana}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Identifying and Mitigating Biases in Recruitment}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/maranzana2324} }
@courseproject{folloninapolitanosolime2324-ethicsofai20232024, abstract = {Computer vision models aim to extract useful information from images or videos but can be easily deceived by adversarial attacks at various stages of the pipeline. This is especially concerning in critical domains such as medical image classification. In this paper, we explore the vulnerabilities of a medical image classification model to adversarial attacks, including data and model poisoning, inversion and extraction attacks, and the fast gradient sign method. By conducting these attacks, we highlight potential weaknesses in the model. We then apply various techniques to enhance the model’s robustness and reliability, comparing the model’s performance before and after these interventions.}, apice = {FolloniNapolitanoSolime2324}, author = {Alessandro Folloni and Daniele Napolitano and Marco Solime}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Breaking and Fixing: A Study on Neural Network Vulnerabilities and Robustness in the medical field}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/folloninapolitanosolime2324} }
@courseproject{kocaknunes2324-ethicsofai20232024, abstract = {Deep learning models (DLMs) are susceptible to malicious manipulations known as adversarial attacks, one of which is Fast Gradient Sign Method (FGSM). This attack generates tiny alterations in input data, leading the target model to misclassify it. This paper aims to provide a comprehensive explanation of how FGSM works, including a detailed analysis of its underlying principles and the mathematical formulation of the attack. Furthermore, we will explore countermeasures designed to mitigate the impact of FGSM attacks. These defenses range from adversarial training and input preprocessing techniques to more advanced methods like defensive distillation and gradient masking.}, apice = {KocakNunes2324}, author = {Oğuz Kağan Koçak and Clara Nunes}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Defense Algorithms Against A Fast Gradient Sign Method Attack}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/kocaknunes2324} }
@courseproject{galavotti2425-mas2425, abstract = {This project presents a multi-agent hospital simulation developed in Unity which models the complex interactions between healthcare staff and patients in a dynamic medical environment. The system features autonomous agents representing doctors, nurses, janitors, and patients, whose behaviours collectively maintain hospital operations. The simulation implements realistic healthcare workflows including patient diagnosis and treatment, equipment maintenance, infection control, and staff fatigue management. Key features include a queue-based task system where medical staff handles patients based on disease severity, dynamic equipment failure and repair mechanisms, disease transmission modeling with protective measures, and resource allocation constraints reflecting real-world hospital limitations.}, apice = {Galavotti2425}, author = {Angelo Galavotti}, howpublished = {Multi-Agent Systems, A.Y. 2024/2025}, month = may, sort = {classic}, supervisor = {Calegari, Roberta}, title = {MAS-Hospital: A multi-agent hospital simulation}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/galavotti2425}, year = 2025 }
@courseproject{doremarongiumurgia2425-ethicsofai20242025, abstract = {Providing formal guarantees on the behavior of machine learning models remains a central chal- lenge for their deployment in safety-critical domains. The SMLE framework, recently proposed by Matteo Francobaldi and Michele Lombardi, introduces an architecture and training procedure that ensures compliance with designer-specified input-output properties through conservative overap- proximation and counterexample-guided training [FL24]. In this project, under the supervision of Prof. Michele Lombardi, we aim to extend SMLE’s contributions by exploring the framework’s robustness when implemented without special archi- tectural accommodations (e.g., regularization). Our methodology will involve training standard SMLE architectures and systematically searching for counterexamples by implementing exact ver- ification methods, in contrast to the looser verification methods described in [FL24]. We will focus on binary classification tasks and quantify the occurrence of false positives (i.e., instances where a ”false” counterexample is detected) across different configurations. This comprehensive evaluation will help assess the effectiveness of SMLE’s verification mechanisms and identify patterns that may guide the design of safer neural models with stronger formal guarantees. Additionally, we will study the system’s performance as parameters and hyperparameters are varied.}, apice = {DoreMarongiuMurgia2425}, author = {Mauro Dore and Gian Mario Marongiu and Riccardo Murgia}, howpublished = {Ethics of AI, A.Y. 2024/2025}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Formal Safety Assessment of Neural Networks under Adversarial Attacks}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/doremarongiumurgia2425} }
@courseproject{capacchionetrambaiollo2324-ethicsofai20232024, abstract = {Predicting recidivism is critical in the criminal justice system to make informed decisions about sentencing and parole. The COMPAS dataset includes predictions about the likelihood of a person re-offending (recidivism), which can influence these decisions. However, classic machine learning models can inadvertently favor or discriminate against certain demographic groups, raising concerns about fairness. In this project, we use Autoencoders and Gaussian Mixture Models (GMM) on the COMPAS Recidivism dataset to identify and analyze potential biases. By implementing techniques such as adversarial debiasing and fairness constraint mitigation techniques, we reduce disparities between sensitive groups. Findings reveal the im- portance of integrating fairness techniques into machine learning pipelines to balance ethical considerations with predictive performance. The results highlight the need for transparency and accountability in deploying such models in high-stakes environments like criminal justice.}, apice = {CapacchioneTrambaiollo2324}, author = {Luca Trambaiollo and Davide Capacchione}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Fairness in Recidivism Detection Using Autoencoders and Gaussian Mixture Models}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/capacchionetrambaiollo2324} }
@courseproject{maiolinoxia2425-ethicsofai20242025, abstract = {Natural example-based explainability methods aim at finding representative samples drawn from the training set of the model. The rationale behind these methods is that human intuition and reasoning is heavily based on concepts built upon examples, making these approaches an ideal candidate for enhancing explainability. In this project, we experiment with this class of methods and apply them on image, text, and tabular data in a post-hoc data-agnostic classification setup. We experiment with different models and search hyperparameters to analyze the outcomes in different embedding spaces. From the experimental results, we found out that examples provide insights on how the model behaves. In particular, our main findings are that: examples can provide information on how the model is classifying a sample by giving an idea of the form of the embedding space and the decision boundaries; each class has preferred recurrent axes in the embeddings which allow identifying patterns and biases in the dataset; and examples provide information that can be useful to analyze misclassified samples and to detect simple adversarial attacks.}, apice = {MaiolinoXia2425}, author = {Claudia Maiolino and Tian Cheng Xia}, howpublished = {Ethics of AI, A.Y. 2024/2025}, month = may, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Exploring Natural Example-Based Local and Global Explainability Across Different Data Types}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/maiolinoxia2425}, year = 2025 }
@courseproject{deluca2425-ethicsofai20242025, abstract = {This project explores the ethical implications of explainability and model reliability in the med- ical AI domain, focusing on the CheXpert chest X-ray dataset. After an initial analysis of the dataset, three pre-trained models from the torchxrayvision library are evaluated and compared in terms of diagnostic performance. The models in question are XRV-ResNet-resnet50-res512-all, XRV-DenseNet121-densenet121-res224-all and jfhealthcare-DenseNet121, their performances are listed in the official torchxrayvision’s official Git repository in the CheXpert section. To deepen the understanding of each model’s behavior, two explainable AI (XAI) methods—Grad-CAM and SHAP—are applied, allowing for both visual and quantitative analysis of model attention. Building on these insights, ensemble strategies are tested to improve diagnostic performance through prediction aggregation. Finally, a novel XAI-guided aggregation method is proposed: an encoder trained with contrastive loss is used to embed visual explanations and estimate per-class prediction confi- dence based on their similarity to learned class-level centroids. This approach aims to make ensemble decisions more interpretable and trustworthy by grounding them in the visual reasoning patterns of the models themselves.}, apice = {DeLuca2425}, author = {Eugenio De Luca}, howpublished = {Ethics of AI, A.Y. 2024/2025}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Toward Trustworthy Diagnosis: Model Comparison and XAI-Guided Ensembling on the CheXpert Dataset}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/deluca2425} }
@courseproject{venturoli2324-ethicsofai20232024, abstract = {In recent years we are moving towards systems that have to be consid- ered moral agents: they need to make choices with ethical consequences. Machine ethics is a field of AI that deal with the question of how to imbued systems with ethical values. Allen [4] identify mainly three approaches to machine ethics: top-down, bottom-up and hybrid approach. In light of this classification this project propose a systematic literature review of the main approaches for machine ethics, presenting some architectures and analyzing them.}, apice = {Venturoli2324}, author = {Elisa Venturoli}, howpublished = {Ethics of AI, A.Y. 2023/2024}, month = jul, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Machine Ethics: approaches and architectures}, type = {Standard Project}, year = 2024 }
@courseproject{luise2324-ethicsofai20232024, abstract = {This project aims to analyze the compromise of performance vs. explainabil- ity typical between Symbolic and Sub-symbolic approaches, tackling a dataset used to estimated the median value of owner-occupied homes. After comparing the performance of two interpretable and two non-interpretable models, their respective results will be explained using only the features of the model for the former, and LIME for the latter. These will be evaluated by human subjects in a double-blind trial.}, apice = {Luise2324}, author = {Alberto Luise}, howpublished = {Ethics of AI, A.Y. 2023/2024}, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Comparison of performance & explainability for Symbolic and Sub-symbolic methods}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/luise2324} }
@courseproject{sunzhang2425-ethicsofai20242025, abstract = {In explainable artificial intelligence (XAI), counterfactual explanations (CEs) act as an efficient post-hoc method to provide actionable insights by identifying the minimal changes to input features that would alter a model’s prediction, thereby illuminating its decision boundaries and enhancing transparency. Large language models (LLMs) emerges as a powerful tool for CEs generation due to its strong capability and good common sense. In standard CEs generation process we need an Oracle to evaluate the CEs generated by LLMs. But the Oracle itself can be inaccurate and brings uncertainty. Hence in this work we aim to design various metrics to evaluate CEs generated by different LLMs given the truth that the Oracle is not reliable all the time.}, apice = {SunZhang2425}, author = {Chang Sun and Xiaofeng Zhang}, howpublished = {Ethics of AI, A.Y. 2024/2025}, month = may, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Robustness in Counterfactual Explanations Generation using LLMs}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/sunzhang2425}, year = 2025 }
@courseproject{erz2425-ethicsofai20242025, abstract = {The increasing use of AI algorithms in financial services has raised urgent concerns about algorithmic fairness, especially in credit risk assessment and loan approval. These systems can unintentionally perpetuate historical biases, disadvantaging protected groups, including women, older applicants, and ethnic minorities. In this project, we will investigate and mitigate such biases in AI-powered loan approval models using the German Credit Dataset from the UCI Machine Learning Repository. This dataset is a widely used benchmark for fairness and discrimination analysis. We will use this dataset to train standard classification models, such as Logistic Regression, Random Forest, and Gradient Boosting, and apply fairness auditing tools, like the IBM AI Fairness 360 (AIF360) toolkit. This will enable us to quantify disparate impacts across sensitive features (e.g., age and sex) and evaluate the effectiveness of bias mitigation strategies.}, apice = {Erz2425}, author = {Eleasar Erz}, howpublished = {Ethics of AI, A.Y. 2024/2025}, month = may, sort = {classic}, supervisor = {Calegari, Roberta}, title = {Detecting and Mitigating Bias in AI-Powered Loan Approval Systems}, type = {Standard Project}, url = {https://dvcs.apice.unibo.it/pika-lab/courses/ai-ethics/projects/erz2425}, year = 2025 }
mostra tutti i 328 (28 in più, più lento)