Guido Salvaneschi
Title
Prof. Ph.D.
Last Name
Salvaneschi
First name
Guido
Email
guido.salvaneschi@unisg.ch
ORCID
25 results
Now showing 1 - 10 of 25
- Some of the metrics are blocked by yourconsent settings
Item type:Publication, Dis/Equality Graphs(Association for Computing Machinery (ACM), 2025-01-07); ; ; E-graphs are a data structure to compactly represent a program space and reason about equality of program terms. E-graphs have been successfully applied to a number of domains, including program optimization and automated theorem proving. In many applications, however, it is necessary to reason about disequality of terms as well as equality. While disequality reasoning can be encoded, direct support for disequalities increases performance and simplifies the metatheory. In this paper, we develop a framework independent of a specific implementation to formally reason about e-graphs. For the first time, we prove the equivalence of e-graphs to the reflexive, symmetric, transitive, and congruent closure of the equivalence relation they are expected to encode. We use these results to present the first formalization of an extension of e-graphs that directly supports disequalities and prove an analytical result about their superior efficiency compared to embedding techniques that are commonly used in SMT solvers and automated verifiers. We further profile an SMT solver and find that it spends a measurable amount of time handling disequalities. We implement our approach in an extension to egg, a popular e-graph Rust library. We evaluate our solution in an SMT solver and an automated theorem prover using standard benchmarks. The results indicate that direct support for disequalities outperforms other encodings based on equality embedding, confirming the results obtained analytically.Type:journal articleJournal:Proceedings of the ACM on Programming LanguagesVolume:9Issue:POPLDOI:10.1145/3704913Scopus© Citations 4 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Consistent Local-First Software: Enforcing Safety and Invariants for Local-First Applications(Institute of Electrical and Electronics Engineers (IEEE), 2025-01); ; Local-first software embraces data replication as a means to achieve scalability and offline availability. A crucial ingredient of local-first software are mergeable data types, like conflict-free replicated data types (CRDTs), which feature eventual consistency by enabling processes to access data locally and later merge it with other replicas in an asynchronous manner. Notably, the merging process needs to adhere to application constraints for correctness. Ensuring such application-level invariants poses a challenge, as developers must reason about the replicated program state and resort to manual synchronization of specific application components to enforce the invariant. This paper introduces ConLoc (Consistent Local-First Software), a novel system designed to automatically enforce safety and maintain invariants in local-first applications. ConLoc effectively addresses the issue of preserving invariants in the execution of programs with replicated data types, including CRDTs. Our approach is able to verify the correctness of many CRDTs examined in the literature and in implementations, such the ones used in the Riak database. ConLoc ensures that applications are automatically synchronized correctly, resulting in substantial latency and throughput improvements when compared to sequential execution, while upholding the same set of invariants.Type:journal articleJournal:IEEE Transactions on Software EngineeringVolume:51Issue:1Scopus© Citations 2 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Decentralizing Infrastructure as CodeInfrastructure as Code (IaC) automates deployments for single teams, falling short of decentralized deployments across groups. We need mature IaC solutions that embrace and consolidate software engineering principles to enable testing and automation advances for decentralized organizations.Type:journal articleJournal:IEEE SoftwareVolume:40Issue:1Scopus© Citations 5 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Prisma: A Tierless Language for Enforcing Contract-Client Protocols in Decentralized Apps(ACM, 2023-09); ; Faust, SebastianDecentralized applications (dApps) consist of smart contracts that run on blockchains and clients that model collaborating parties. dApps are used to model nancial and legal business functionality. Today, contracts and clients are written as separate programs-in di erent programming languages-communicating via send and receive operations. This makes distributed program ow awkward to express and reason about, increasing the potential for mismatches in the client-contract interface, which can be exploited by malicious clients, potentially leading to huge nancial losses. In this paper, we present Prisma, a language for tierless decentralized applications, where the contract and its clients are de ned in one unit and pairs of send and receive actions that "belong together" are encapsulated into a single direct-style operation, which is executed di erently by sending and receiving parties. This enables expressing distributed program ow via standard control ow and renders mismatching communication impossible. We prove formally that our compiler preserves program behavior in presence of an attacker controlling the client code. We systematically compare Prisma with mainstream and advanced programming models for dApps and provide empirical evidence for its expressiveness and performance.Type:journal articleJournal:ACM Transactions on Programming Languages and SystemsVolume:45Issue:3DOI:10.1145/3604629 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Type-Safe Dynamic Placement with First-Class Placed ValuesSeveral distributed programming language solutions have been proposed to reason about the placement of data, computations, and peers interaction. Such solutions include, among the others, multitier programming, choreographic programming and various approaches based on behavioral types. These methods statically ensure safety properties thanks to a complete knowledge about placement of data and computation at compile time. In distributed systems, however, dynamic placement of computation and data is crucial to enable performance optimizations, e.g., driven by data locality or in presence of a number of other constraints such as security and compliance regarding data storage location. Unfortunately, in existing programming languages, dynamic placement conflicts with static reasoning about distributed programs: the flexibility required by dynamic placement hinders statically tracking the location of data and computation. In this paper we present Dyno, a programming language that enables static reasoning about dynamic placement. Dyno features a type system where values are explicitly placed, but in contrast to existing approaches, placed values are also first class, ensuring that they can be passed around and referred to from other locations. Building on top of this mechanism, we provide a novel interpretation of dynamic placement as unions of placement types. We formalize type soundness, placement correctness (as part of type soundness) and architecture conformance. In case studies and benchmarks, our evaluation shows that Dyno enables static reasoning about programs even in presence of dynamic placement, ensuring type safety and placement correctness of programs at negligible performance cost. We reimplement an Android app with ∼ 7 K LOC in Dyno, find a bug in the existing implementation, and show that the app's approach is representative of a common way to implement dynamic placement found in over 100 apps in a large open-source app store.Type:journal articleJournal:Proceedings of the ACM on Programming LanguagesVolume:7Issue:OOPSLA2DOI:10.1145/3622873Scopus© Citations 5 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, TCEP: Transitions in Operator Placement to Adapt to Dynamic Network Environments(2021); Type:journal articleJournal:Journal of Computer and System SciencesVolume:122Scopus© Citations 11 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, A Survey of Multitier Programming(2021); - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Rethinking Safe Consistency in Distributed Object-Oriented Programming(2020); - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in ScalaMultitier programming languages reduce the complexity of developing distributed software by developing the distributed system within a single coherent code base. In multitier languages, the compiler or the runtime takes care of separating the code into the components of the distributed system. This approach enables abstraction over low level implementation details such as data representation, serialization and network protocols. The ScalaLoci programming language allows developers to declare the components of the system and their architectural relation at the type level, enabling static reasoning about distribution and remote communication and guaranteeing static type safety for data transfer across components. As the compiler automatically generates the communication boilerplate among components, data transfer among components can be modeled declaratively, by specifying the data flows in the reactive programming style. In this paper, we report on the ScalaLoci implementation and on our experience with embedding ScalaLoci's language features into Scala as a host language. We show how a combination of Scala's advanced type level programming and of Scala's macro system enable enriching the language with new abstractions for distributed systems. We describe the challenges we encountered for the implementation and report on the solutions we developed. Finally, we outline suggestions for improving the Scala macro system to better support embedding domain-specific abstractions. ACM CCS Software and its engineering → Distributed programming languages; Macro languages; Domain specific languages;Type:journal articleJournal:The Art, Science, and Engineering of ProgrammingVolume:4Issue:3Scopus© Citations 7 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Metamorphic Testing for Infrastructure-as-Code Engines(2026); ; ; Meier, RolandInfrastructure-as-Code (IaC) engines, such as Terraform, OpenTofu, and Pulumi, automate the provisioning and management of cloud resources. They parse IaC specifications and orchestrate the required actions, making them the backbone of modern clouds, and critical to the reliability of both the underlying infrastructure and the software that depends on it. Despite this importance, this class of systems has received little attention: prior work largely targets the correctness of IaC programs rather than the IaC engines themselves. Existing test suites rely on manually written oracles and struggle to expose faults that manifest across multiple executions, leaving a significant reliability gap. We present EMIaC, a metamorphic testing framework for IaC engines. EMIaC defines metamorphic relations as graph-based transformations of IaC programs and checks invariants across executions of the original and transformed programs. A central novelty is our use of e-graphs in software testing, as both a test-input generator and an equivalence oracle. E-graphs compactly represent program equivalences, enabling the systematic generation of large spaces of equivalent IaC programs. To ground these relations, we analyze 43,593 real-world Terraform programs and show that IaC dependency graphs are typically small and sparse, making e-graphs a natural fit. Evaluating EMIaC on Pulumi, Terraform, and OpenTofu, we show that it complements existing test suites by exercising engine-critical code paths and covering 98 previously untested statements in Terraform and 1,313 in Pulumi. EMIaC also uncovers previously unknown issues in all three test suites, improving their adequacy. Three test cases have been merged into Terraform's main branch, and Pulumi has merged a specification fix.Type:conference paper
- «
- 1 (current)
- 2
- 3
- »