Pascal Weisenburger
Title
Dr.
Last Name
Weisenburger
First name
Pascal
Email
pascal.weisenburger@unisg.ch
ORCID
Phone
+41 71 224 7867
27 results
Now showing 1 - 10 of 27
- Some of the metrics are blocked by yourconsent settings
Item type:Publication, Versioned E-Graphs(Association for Computing Machinery, 2026-06-08); ; ; E-Graphs are an efficient encoding for discovering and maintaining sets of equalities, commonly adopted in the context of formal proofs, program analysis, and optimization. In several scenarios, equalities may hold only conditionally, i.e., under certain assumptions. For example, in automated provers the proof is often split into multiple branches, such that each branch considers a different set of equalities. A limitation of traditional e-graphs is that they can only encode a single set of equalities at a time. Conditional equalities are then handled by maintaining multiple e-graphs, e.g., one for each branch in the proof, which is inefficient as equalities shared among branches are simply replicated many times. In this paper, we introduce versioned e-graphs, which efficiently encode multiple equivalence sets at the same time, maximizing shared information among them. We formalize for versioned e-graphs and prove their correctness. We evaluate our solution against widely-adopted solutions which maintain multiple e-graphs and show that versioned e-graphs are up to 5–30 % more memory efficient and up to 4× faster depending on the case study, especially when solution spaces are large both in explored program terms and number of branches.Type:journal articleJournal:Proceedings of the ACM on Programming LanguagesVolume:10Issue:PLDIDOI:10.1145/3808249 - 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 5 - 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 3 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Automated Verification of Fundamental Algebraic LawsAlgebraic laws of functions in mathematics-such as commutativity, associativity, and idempotence-are often used as the basis to derive more sophisticated properties of complex mathematical structures and are heavily used in abstract computational thinking. Algebraic laws of functions in coding, however, are rarely considered. Yet, they are essential. For example, commutativity and associativity are crucial to ensure correctness of a variety of software systems in numerous domains, such as compiler optimization, big data processing, data flow processing, machine learning or distributed algorithms and data structures. Still, most programming languages lack built-in mechanisms to enforce and verify that operations adhere to such properties. In this paper, we propose a verifier specialized on a set of fundamental algebraic laws that ensures that such laws hold in application code. The verifier can conjecture auxiliary properties and can reason about both equalities and inequalities of expressions, which is crucial to prove a given property when other competitors do not succeed. We implement these ideas in the Propel verifier. Our evaluation against five state-of-the-art verifiers on a total of 142 instances of algebraic properties shows that Propel is able to automatically deduce algebraic properties in different domains that rely on such properties for correctness, even in cases where competitors fail to verify the same properties or time out.Type:journal articleJournal:Proceedings of the ACM on Programming LanguagesVolume:8Issue:PLDIDOI:10.1145/3656408Scopus© Citations 7 - 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);
- «
- 1 (current)
- 2
- 3
- »