scala

This study investigates how object-oriented programming (OOP) and functional programming (FP) influence key software architecture characteristics to inform paradigm selection decisions. Method: Using a controlled experiment, we implemented an identical digital wallet system in Kotlin (OOP) and Scala (FP). We employed a mixed-methods approach: reflexive ethnography—observing developers’ coding and code-reading activities—and a structured survey (N=42), complemented by quantitative code metrics and architectural feature assessments. Contribution/Results: FP demonstrated superior module boundary clarity and state predictability, whereas OOP excelled in incremental extensibility and intuitive domain modeling. Readability differences were context-dependent. Crucially, this work provides the first hybrid empirical evidence on paradigm impact from both *writing* and *understanding* perspectives, offering actionable, data-driven insights for architectural trade-offs and team-level technology adoption decisions.

To address the absence of native Aspect-Oriented Programming (AOP) support in the Julia ecosystem, this paper designs and implements AspectJulia—a lightweight, runtime-friendly AOP framework. Leveraging Julia’s metaprogramming capabilities and AST-level macro system, AspectJulia enables declarative aspect definition and dynamic weaving without compiler or runtime modifications. It is the first native, low-overhead solution for encapsulating and decoupling cross-cutting concerns—such as logging, caching, and parallelization—in Julia. Experimental evaluation demonstrates that AspectJulia significantly reduces module coupling, improves code reusability, and maintains seamless compatibility with existing Julia packages. Its effectiveness is validated across scientific computing, high-performance computing (HPC), and commercial applications, yielding measurable improvements in software maintainability, adaptability, and development efficiency.

This study systematically evaluates performance differences among Java, Python, and Scala for end-to-end ETL workloads on Apache Spark integrated with Apache Iceberg. We conduct controlled experiments across varying data scales (5 MB–1.6 GB) and operation complexities (basic transformations vs. complex merge operations), all within a uniform CSV→Spark→Iceberg pipeline. To our knowledge, this is the first standardized ETL benchmark enabling direct cross-language comparison under native Iceberg support. Results reveal nonlinear interactions among programming language, data volume, and operation type: Python exhibits superior throughput on small-scale data; performance converges across all three languages at medium scale (1.6 GB); and Scala significantly outperforms both Java and Python in high-complexity merge-intensive workloads. The findings provide empirical guidance for language selection in big-data ETL systems, along with a principled trade-off framework grounded in workload characteristics.

This work addresses the challenge of schema drift in data pipelines, which often manifests at runtime, causing errors and increasing maintenance overhead. The authors propose a lightweight framework built on Scala 3 that enforces structural contracts between producers and consumers at compile time. By leveraging the type system and compile-time metaprogramming, the framework automatically derives Spark DataFrame schemas from shared contracts and validates actual data structures prior to ingestion. It combines compile-time guarantees with policy-aware runtime comparators to support nested and optional fields as well as subset semantics, thereby ensuring both forward and backward compatibility. Empirical evaluation demonstrates the framework’s effectiveness in end-to-end workflows, with reproducible benchmarking conducted across two distinct environments.

This work addresses the limitations of existing join pattern implementations, which often rely on domain-specific languages and exhibit rigid, inflexible matching algorithms that hinder integration into general-purpose programming ecosystems. To overcome these challenges, we propose and implement JoinActors—a modular and extensible join pattern matching library built on Scala 3. JoinActors is the first library to support join patterns natively within a general-purpose language, offering an intuitive API powered by metaprogramming and incorporating fair join semantics. Its key innovation lies in enabling plug-and-play support for multiple matching algorithms, facilitating direct performance comparisons. Experimental results demonstrate that the new implementation significantly improves performance while preserving matching correctness, thereby providing an efficient coordination mechanism for complex message-passing systems and establishing a reusable experimental platform for future research on join patterns.

Existing languages typically relegate refinement types to secondary annotations or separate specifications, hindering seamless integration with core language features such as subtyping, type inference, and pattern matching, thereby limiting their practical utility. This work presents the first integration of refinement types as first-class citizens in Scala 3, leveraging dependent function types, bounded polymorphism, recursion, and union/intersection types to deeply embed logical predicates into the type system. Building upon a partial correctness semantics, we develop a fuel-bounded semantic type system, formalize a core calculus, and prove its type safety. Furthermore, we implement a prototype extension of the Scala 3 compiler that combines Rocq-based verification with a lightweight e-graph-based predicate solver, enabling practical and scalable lightweight program verification.

This work addresses the lack of precise semantic definitions and static error checking in the Vega visualization language, which often leads users to produce erroneous or ambiguous visualizations. For the first time, the paper formalizes Vega’s reactive dataflow mechanism by introducing a graph-based operational semantics and designing a complementary type system that precisely captures its streaming data transformation behavior. This approach enables static type analysis capable of preventing a wide range of common errors. The authors implement a type checker and formally verify its soundness with respect to the proposed semantics, thereby establishing the first formal framework for declarative visualization languages that combines rigorous semantics with strong static guarantees.

This work addresses the performance overhead incurred by intermediate object creation in consecutive map() and filter() operations of the Java Stream API. The authors propose a compile-time optimization technique that transforms such operation chains into a single mapMulti() invocation via bytecode rewriting, thereby eliminating intermediate objects. This approach overcomes limitations of existing tools in handling lambda escape and stream variable assignments, and notably does not rely on loop unrolling. Experimental evaluation shows that the method significantly outperforms Streamliner on 2 out of 9 benchmarks while matching its performance on the rest. Furthermore, it successfully passes all 31,799 unit tests in Apache Kafka, demonstrating both correctness and practical applicability.

This work enhances the expressiveness of protocol modeling in message-passing programs by extending the strongly-typed framework Effpi with novel support for multi-channel external choice branches and timeout handling mechanisms. Building upon behavioral types and a variant of CCS encoding, the approach integrates a compiler plugin to enforce type-safe verification. The proposed extension substantially enriches the expressivity of protocol types, enabling the type-safe modeling and verification of complex interaction protocols such as the Raft consensus algorithm. This demonstrates the practical applicability and effectiveness of the framework in real-world distributed systems.