Dynamic lazy loading in Vuex is an effective method for optimizing the performance of large-scale Vue.js applications. This paper proposes a method to simplify the implementation process of dynamic lazy loading in Vuex, enhancing code maintainability and readability. By leveraging Vue's plugin mechanism, the proposed method encapsulates the Vuex module loading process, allowing for the flexible application of techniques such as dynamic imports and code modularization in Vuex state management. This paper outlines the design principles, implementation details, and experimental results of this method, evaluating its performance in a demonstrating Vue.js application. Experimental results demonstrate that using this plugin mechanism for dynamic lazy loading in Vuex effectively reduces initial load times and improves application response speed, thereby enhancing the user experience.

Signals are principal abstraction in reactive programming languages and constitute the basics of reactive computations in modern systems, such as the Internet of Things. Signals sometimes utilize past values, which leads to space leak, a problem where accumulated past values waste resources such as the main memory. Persistent signals, an abstraction for time-varying values with their execution histories, provide a generalized and standardized way of space leak management by leaving this management to the database system. However, the current design of persistent signals is very rudimental. For example, they cannot represent complex data structures; they can only be connected using pre-defined API methods that implicitly synchronize the persistent signal network; and they cannot be created dynamically. In this paper, we show that these problems are derived from more fundamental one: no language mechanism is provided to group related persistent signals. To address this problem, we propose a new language mechanism signal classes. A signal class packages a network of related persistent signals that comprises a complex data structure. A signal class defines the scope of synchronization, making it possible to flexibly create persistent signal networks by methods not limited to the use of pre-defined API methods. Furthermore, a signal class can be instantiated, and this instance forms a unit of lifecycle management, which enables the dynamic creation of persistent signals. We formalize signal classes as a small core language where the computation is deliberately defined to interact with the underlying database system using relational algebra. Based on this formalization, we prove the language’s glitch freedom. We also formulate its type soundness by introducing an additional check of program well-formedness. This mechanism is implemented as a compiler and a runtime library that is based on a time-series database. The usefulness of the language is demonstrated through the vehicle tracking simulator and viewer case study. We also conducted a performance evaluation that confirms the feasibility of this case study.

Extensive research efforts have been devoted to implement a group of type-safe mutually recursive classes; recently, proposals for separating each member of the group as a reusable and composable programming unit have also been presented. One problem of these proposals is verbosity of the source programs; we have to declare a recursive type parameter to parameterize each mutually recursive class within each class declaration, and we have to declare a fixed-point class with empty class body for each parameterized class. Therefore, even though the underlying type system is simple, programs written in these languages tend to be rather complex and hard to understand. In this paper, we propose a language with lightweight dependent classes that forms a simple type system built on top of generic Java. In this language, we can implement each member of type-safe mutually recursive classes in a separate source file without writing a lot of complex boilerplate code. To carefully investigate type soundness of our proposal, we develop X.FGJ, a simple extension of FGJ supporting lightweight dependent classes. This type system is proved to be sound.

One limitation of the well-known family polymorphism approach is that each "family" will be a large monolithic program. In this paper, we introduce a minimal lightweight set of language features that treat each member of a family as a reusable programming unit, while preserving the important feature of scalability. The only one language construct we propose in this paper is type parameter members, which allows type parameters to be referred from the outside of class declarations. To investigate properties of type parameter members in the real programming language settings, we develop a programming language Scalable Java (SJ), an extension of Java generics with type parameter members. To carefully investigate the type soundness of SJ, we develop FGJ#, a core calculus of this extension based on FGJ, a functional core of Java with generics. Furthermore, to explore how to implement this proposal, we define the erasure of FGJ# programs as an extension of the erasure of FGJ programs, which compiles SJ to Java without generics.

We study formulating the ubiquitous cloud (UC) model proposed by Murakami at KDDI [4]. Based on the analysis for Ad Hoc wireless network by Gupta and Kumar [3], we rearrange their setting to an appropriate one for the UC, and then give an evaluation of network capacity called transport capacity. The evaluation takes the form similar to [3], when transmission bit rates are equal in each layer. Also, as a model of the node part in the network, we propose applying a birth-death process in M/M/1 queue, in order to describe the connection and disconnection of the nodes to the network.

Many methods for XML processing have been proposed in the last few years. One popular approach is to process XML documents by using existing programming languages. Another popular approach is to create a new programming language specialized to the domain of XML processing. We propose a new approach of constructing XML processors: embedding XML processing language on Lisp. Owing to this approach, we may seamlessly invoke the functions of XML-specific language from Lisp. The other novel features of our approach are shuffle expression pattern matching and dynamic validation of XML documents. A shuffle expression is an extension of a regular expression; it supports a shuffle (interleave) operator that is useful, for example, to represent unordered records such as bibliography data. Dynamic validation makes it possible to validate XML documents with respect to the schema or patterns at run time.