Fast and Lean Immutable Multi-Maps on the JVM based on Heterogeneous Hash-Array Mapped Tries

An immutable multi-map is a many-to-many thread-friendly map data structure with expected fast insert and lookup operations. This data structure is used for applications processing graphs or many-to-many relations as applied in static analysis of object-oriented systems. When processing such big data sets the memory overhead of the data structure encoding itself is a memory usage bottleneck. Motivated by reuse and type-safety, libraries for Java, Scala and Clojure typically implement immutable multi-maps by nesting sets as the values with the keys of a trie map. Like this, based on our measurements the expected byte overhead for a sparse multi-map per stored entry adds up to around 65B, which renders it unfeasible to compute with effectively on the JVM. In this paper we propose a general framework for Hash-Array Mapped Tries on the JVM which can store type-heterogeneous keys and values: a Heterogeneous Hash-Array Mapped Trie (HHAMT). Among other applications, this allows for a highly efficient multi-map encoding by (a) not reserving space for empty value sets and (b) inlining the values of singleton sets while maintaining a (c) type-safe API. We detail the necessary encoding and optimizations to mitigate the overhead of storing and retrieving heterogeneous data in a hash-trie. Furthermore, we evaluate HHAMT specifically for the application to multi-maps, comparing them to state-of-the-art encodings of multi-maps in Java, Scala and Clojure. We isolate key differences using microbenchmarks and validate the resulting conclusions on a real world case in static analysis. The new encoding brings the per key-value storage overhead down to 30B: a 2x improvement. With additional inlining of primitive values it reaches a 4x improvement

User producer interaction in context: a classification

Science, Technology and Innovation Studies show that intensified user producer interaction (UPI) increases chances for successful innovations, especially in the case of emerging technology. It is not always clear, however, what type of interaction is necessary in a particular context. This paper proposes a conceptualization of contexts in terms of three dimensions – the phase of technology development, the flexibility of the technology, and the heterogeneity of user populations – resulting in a classification scheme with eight different contextual situations. The paper identifies and classifies types of interaction, like demand articulation, interactive learning, learning by using and domestication. It appears that each contextual situation demands a different set of UPI types. To illustrate the potential value of the classification scheme, four examples of innovations with varying technological and user characteristics are explored: the refrigerator, clinical anaesthesia, video cassette recording, and the bicycle. For each example the relevant UPI types are discussed and it is shown how these types highlight certain activities and interactions during key events of innovation processes. Finally, some directions for further research are suggested alongside a number of comments on the utility of the classification

Opportunity Creation in Innovation Networks: Interactive Revealing Practices

Innovating in networks with partners that have diverse knowledge is challenging. The challenges stem from the fact that the commonly used knowledge protection mechanisms often are neither available nor suitable in early stage exploratory collaborations. This article focuses on how company participants in heterogeneous industry networks share private knowledge while protecting firm-specific appropriation. We go beyond the prevailing strategic choice perspectives to discuss interactive revealing practices that sustain joint opportunity creation in the fragile phase of early network formation.Center for Business, Technology and La

User producer interaction in context: A classification

Science, Technology and Innovation Studies show that intensified user producer interaction (UPI) increases chances for successful innovations, especially in the case of emerging technology. It is not always clear, however, what type of interaction is necessary in a particular context. This paper proposes a conceptualization of contexts in terms of three dimensions – the phase of technology development, the flexibility of the technology, and the heterogeneity of user populations – resulting in a classification scheme with eight different contextual situations. The paper identifies and classifies types of interaction, like demand articulation, interactive learning, learning by using and domestication. It appears that each contextual situation demands a different set of UPI types. To illustrate the potential value of the classification scheme, four examples of innovations with varying technological and user characteristics are explored: the refrigerator, clinical anaesthesia, video cassette recording, and the bicycle. For each example the relevant UPI types are discussed and it is shown how these types highlight certain activities and interactions during key events of innovation processes. Finally, some directions for further research are suggested alongside a number of comments on the utility of the classification.Innovation, users, interaction, learning, typology of UPI

Revisiting Actor Programming in C++

The actor model of computation has gained significant popularity over the last decade. Its high level of abstraction makes it appealing for concurrent applications in parallel and distributed systems. However, designing a real-world actor framework that subsumes full scalability, strong reliability, and high resource efficiency requires many conceptual and algorithmic additives to the original model. In this paper, we report on designing and building CAF, the "C++ Actor Framework". CAF targets at providing a concurrent and distributed native environment for scaling up to very large, high-performance applications, and equally well down to small constrained systems. We present the key specifications and design concepts---in particular a message-transparent architecture, type-safe message interfaces, and pattern matching facilities---that make native actors a viable approach for many robust, elastic, and highly distributed developments. We demonstrate the feasibility of CAF in three scenarios: first for elastic, upscaling environments, second for including heterogeneous hardware like GPGPUs, and third for distributed runtime systems. Extensive performance evaluations indicate ideal runtime behaviour for up to 64 cores at very low memory footprint, or in the presence of GPUs. In these tests, CAF continuously outperforms the competing actor environments Erlang, Charm++, SalsaLite, Scala, ActorFoundry, and even the OpenMPI.Comment: 33 page