multi-topic, publish from gh-pages branch

site/content/cloud-edge/digests/Middleware-2024/index.md

@@ -0,0 +1,147 @@
+---
+title: Middleware 2024 Digest
+venue: Middleware
+year: 2024
+date: '2024-12-02'
+tags:
+- distributed-systems
+- edge-computing
+- cloud
+paper_count: 11
+draft: false
+---
+
+11 papers selected.
+
+---
+
+### Chasing Lightspeed Consensus: Fast Wide-Area Byzantine Replication with Mercury
+
+*Christian Berger 0006, Lívio Rodrigues, Hans P. Reiser, Vinicius Vielmo Cogo *et al.**
+
+**TL;DR** — Mercury is a wide-area Byzantine fault-tolerant replication protocol that minimises latency by exploiting geographic locality and pipelining to approach the theoretical lightspeed bound.
+
+**Why notable** — Achieving near-lightspeed latency in Byzantine replication across wide-area networks has been a long-standing open challenge; Mercury's design demonstrates it is practically attainable. The result raises the bar for what production BFT middleware can deliver in geo-distributed deployments.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700756)
+
+---
+
+### L3: Latency-aware Load Balancing in Multi-Cluster Service Mesh
+
+*Olivier Michaelis, Stefan Schmid 0001, Habib Mostafaei*
+
+**TL;DR** — L3 introduces a latency-aware load-balancing layer for multi-cluster service meshes that dynamically routes requests based on real-time latency measurements rather than static weights.
+
+**Why notable** — Service meshes are now the de-facto inter-service communication fabric in cloud-native stacks, yet most shipped load balancers remain latency-oblivious; L3 shows measurable tail-latency improvements in realistic multi-cluster topologies. Its design integrates cleanly with existing mesh control planes, giving operators a low-friction adoption path.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3654793)
+
+---
+
+### zkStream: a Framework for Trustworthy Stream Processing
+
+*Janwillem Swalens, Lode Hoste, Emad Heydari Beni, Lieven Trappeniers*
+
+**TL;DR** — zkStream applies zero-knowledge proofs to stream processing pipelines so that consumers can cryptographically verify the correctness of aggregated results without re-executing the pipeline.
+
+**Why notable** — Trustworthy stream processing has historically required either trusted execution environments or full result recomputation; zkStream shows that ZK proofs are now practical enough for continuous dataflow workloads. This has direct implications for regulatory-compliance and cross-organisation data sharing scenarios.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700763)
+
+---
+
+### STRATA: Random Forests going Serverless
+
+*Dimitrios Tomaras, Sebastian Buschjäger, Vana Kalogeraki, Katharina Morik *et al.**
+
+**TL;DR** — STRATA decomposes random-forest inference into fine-grained serverless functions, exploiting embarrassing parallelism to cut inference latency while bounding cost.
+
+**Why notable** — Mapping classical ensemble models onto FaaS platforms exposes a new class of ML inference workloads for serverless runtimes, well beyond the simple stateless functions they were designed for. The cost-latency trade-off analysis provides a practical blueprint for teams already operating serverless infrastructure who want to serve ML models without dedicated GPU instances.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3654791)
+
+---
+
+### HORSE: Ultra-low latency workloads on FaaS platforms
+
+*Djob Mvondo, François Taïani, Yérom-David Bromberg*
+
+**TL;DR** — HORSE is a FaaS runtime extension that achieves sub-millisecond cold-start and execution latency for latency-critical functions by pre-warming micro-VMs and bypassing the standard invocation control plane.
+
+**Why notable** — The conventional wisdom that serverless is unsuitable for latency-critical workloads is directly challenged here; the authors achieve latencies competitive with always-on microservices. This opens the door to unifying latency-tolerant and latency-critical workloads under a single FaaS billing model.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700784)
+
+---
+
+### In Serverless, OS Scheduler Choice Costs Money: A Hybrid Scheduling Approach for Cheaper FaaS
+
+*Yuxuan Zhao 0003, Weikang Weng, Rob van Nieuwpoort, Alexandru Uta*
+
+**TL;DR** — The paper quantifies how the Linux kernel scheduler directly inflates FaaS platform costs and proposes a hybrid scheduling policy that cuts CPU billing by significant margins without degrading function latency.
+
+**Why notable** — The finding that OS-level scheduling decisions have a measurable monetary impact on cloud provider bills is surprising and practically important for both FaaS platform operators and tenants. The proposed hybrid scheduler is deployable without changes to user functions or the FaaS API surface.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700757)
+
+---
+
+### Ripple: Large-Scale Service and Configuration Management in the Cloud
+
+*Shuping Ji, Zhen Tang, Wei Wang 0049, Hui Li *et al.**
+
+**TL;DR** — Ripple is a scalable configuration-propagation system for cloud services that guarantees consistency and low-latency delivery of configuration updates across tens of thousands of service instances.
+
+**Why notable** — Configuration drift is a leading cause of production incidents in large-scale microservice deployments; Ripple demonstrates that consistent, fast propagation is achievable at cloud scale without sacrificing availability. The industry provenance of the work suggests it addresses real operational pain points at hyperscaler deployments.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700777)
+
+---
+
+### FLEdge: Benchmarking Federated Learning Applications in Edge Computing Systems
+
+*Herbert Woisetschläger, Alexander Erben, Ruben Mayer, Shiqiang Wang 0001 *et al.**
+
+**TL;DR** — FLEdge provides a comprehensive benchmark suite for federated learning on edge hardware, covering realistic device heterogeneity, network variability, and energy constraints.
+
+**Why notable** — Reproducible evaluation of federated learning at the edge has been hindered by the absence of a standard benchmark; FLEdge fills this gap with a methodology grounded in real edge-device profiles. The benchmark is expected to become a reference point for comparing future edge FL middleware.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700751)
+
+---
+
+### RoleML: a Role-Oriented Programming Model for Customizable Distributed Machine Learning on Edges
+
+*Yuesheng Tan, Lei Yang 0024, Wenhao Li, Yuda Wu*
+
+**TL;DR** — RoleML introduces a role-oriented abstraction that lets developers compose distributed ML training and inference topologies on heterogeneous edge nodes without coupling application logic to a specific communication or aggregation pattern.
+
+**Why notable** — Existing distributed ML frameworks force a tight coupling between the training algorithm and its communication topology, making it hard to adapt to the heterogeneous, dynamic connectivity of edge environments; RoleML's role abstraction decouples these concerns. The model shows how programming-model innovation at the middleware level can substantially reduce the engineering burden of deploying ML at the edge.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700765)
+
+---
+
+### Dexter: A Performance-Cost Efficient Resource Allocation Manager for Serverless Data Analytics
+
+*Anna Maria Nestorov, Diego Marrón, Alberto Gutierrez-Torre, Chen Wang 0039 *et al.**
+
+**TL;DR** — Dexter automatically right-sizes serverless function resources for data-analytics jobs by learning cost and performance models online, reducing cloud spend while meeting latency SLOs.
+
+**Why notable** — Serverless data analytics workloads exhibit highly variable resource needs that defeat static provisioning; Dexter's online learning approach closes the feedback loop between observed performance and resource allocation in a way that is transparent to the user's code. The evaluation on real analytics pipelines shows double-digit cost reductions compared to vendor-default configurations.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700753)
+
+---
+
+### Serverful Functions: Leveraging Servers in Complex Serverless Workflows (industry track)
+
+*Germán T. Eizaguirre, Daniel Barcelona Pons, Aitor Arjona, Gil Vernik *et al.**
+
+**TL;DR** — Serverful Functions extends the serverless programming model with the ability to transparently route parts of a workflow to persistent server processes when stateful or long-running operations make pure FaaS impractical.
+
+**Why notable** — The serverless/serverful boundary is a persistent friction point for workflow authors dealing with state or warm-data locality; this industry paper demonstrates a production-ready hybrid that lets a single workflow span both worlds without application-level awareness. It signals a convergence trend that will shape the next generation of FaaS platforms.
+
+[→ Read paper](https://doi.org/10.1145/3700824.3701095)
+