JASMINE: A Java Tool for Multimedia Collaboration on the Internet

Although collaboration tools have existed for a long time [8], Internet-based multimedia collaboration has recently received a lot of attention mainly due to easy accessibility of the Internet by ordinary users. The Java platform and programming language has also introduced yet another level of easy access: platform-independent computing. As a result, it is very attractive to use Java to design multimedia collaboration systems for the Internet. Today there are many systems, which use Java for multimedia collaboration. However, most of these systems require the shared Java application to be re-written according to the collaboration system's Application Programming Interface (API)—a task which is sometimes difficult or even impossible. In this paper, we describe a practical approach for transparent collaboration with Java. Our approach is transparent in that the Java application can be shared as is with no modifications. The main idea behind our system is that user events occurring through the interactions with the application can be caught, distributed, and reconstructed, hence allowing Java applications to be shared transparently. Our architecture allows us to make the huge installed base of Java applications collaborative, without any modification to their original code. We also prove the feasibility of our architecture by implementation of the JASMINE¹ prototype.     

Data compression in multimedia computing — principles and techniques

Integrated multimedia systems process text, graphics, and other discrete media as well as digital audio, and video data. Considerable amounts of graphics, audio and video data in their uncompressed form, especially moving pictures, require storage and digital network capacities that will not be available in the near future. Nevertheless, local, as well as networked, multimedia applications and systems have become realities. In order to cope with these storage and communication requirements in such integrated multimedia systems, compression technology is essential. This papers starts with a brief motivation of the need for compression and subsequently states the essential requirements for these techniques in the scope of multimedia systems and applications. As most of these techniques apply the same principles, namely, the source, entropy, and hybrid coding fundamentals, these are explained in detail. Based on a general framework of the steps encountered in a compression system — data preparation, processing, quantization, and entropy coding — this paper outlines details about the techniques developed by CCITT (H.261, i.e., px64), in the ISO/IEC (JPEG, MPEG) standardization bodies and the proprietary DVI system.     

How to Comprehend Queries Functionally

Compilers and optimizers for declarative query languages use some form of intermediate language to represent user-level queries. The advent of compositional query languages for orthogonal type systems (e.g., OQL) calls for internal query representations beyond extensions of relational algebra. This work adopts a view of query processing which is greatly influenced by ideas from the functional programming domain. A uniform formal framework is presented which covers all query translation phases, including user-level query language compilation, query optimization, and execution plan generation. We pursue the type-based design—based on initial algebras—of a core functional language which is then developed into an intermediate representation that fits the needs of advanced query processing. Based on the principle of structural recursion we extend the language by monad comprehensions (which provide us with a calculus-style sublanguage that proves to be useful during the optimization of nested queries) and combinators (abstractions of the query operators implemented by the underlying target query engine). Due to its functional nature, the language is susceptible to program transformation techniques that were developed by the functional programming as well as the functional data model communities. We show how database query processing can substantially benefit from these techniques.     

Programming in a wide spectrum language: a collection of examples

The paper exemplifies programming in a wide spectrum language by presenting styles which range from non-operative specifications—using abstract types and tools from predicate logic as well as set theory—over recursive functions, to procedural program with variables. Besides a number of basic types, we develop an interpreter for parts of the language itself, an algorithm for applying transformation rules to program representations, a text editor, and a simulation of Backus' functional programming language.     

System Thoughts in Manufacturing

In this paper we present a taxonomy of manufacturing problems, labeled in a general sense as Design, Production, or Distribution problems. One or more basic systems concepts, such as complexity and adaptation, attach themselves to each such problems. By combining the hierarchical Design—Production—Distribution idea with system concepts, we establish the fact that there is, indeed, a significant systems component to most problems of modern manufacturing.     

Symbolic computation in nonlinear dynamics

This paper gives examples of how computer algebra systems can help us to understand nonlinear dynamical systems and their numerical simulations. We caution against naive use of exact arithmetic, but we give examples where elementary use is helpful. We also look at the use of polynomial computations — such as factoring, computation of discriminants, and Gröbner bases — in bifurcation studies.This paper is dedicated to the memory of M. A. H. Nerenberg (1936–1993).     

Feature set and architecture of a multimedia news system over an ATM network

In this paper we discuss a multimedia news system that we have developed in the Multimedia Information Research Laboratory at the University of Ottawa and beyond. We focus on the feature set—that is, the tools and facilities associated with the system. We explain the functionality of each and give some real examples of the system in action. We then outline the architecture—the system consists of a production server for document authoring, a conferencing system for collaborative news article creation, a content database for authors, a hypernews database for hypermedia news documents, a news database server with aging and archiving, and user sites. The goal was to have all components of the system communicating on OCRInet—an R&D ATM network in the Ottawa region. We then introduce the challenges of representing and browsing large video objects and to this end we introduce a novel solution that we call video-tiles. This video tool is an effective way to browse large news videos that are frequently connected with our multimedia news articles.     

Groups are not always the same

The idea of supporting group meetings at the same time and at the same place by computer raises the problem of how salient features of group behaviors are understood in meetings. In this paper we take a critical look at several beliefs about group behaviors in research dealing with electronic meeting systems (EMS). The paper argues based on an empirical study that the concept of a small, cohesive business team, so widely held, in all EMS research is not necessarily a valid starting point in thinking of meeting support. In particular, the paper critically evaluates a number of beliefs of user aspects, group features such as composition, structure and protocols, and task characteristics such as nature, importance and meeting goals. In consequence, if these prominent features can vary markedly all meeting support cannot be designed in ways envisaged in current research. In conclusion we outline some research questions—both of empirical and constructive nature—that need to be addressed if the EMS research wants to address issues in computer support in groups that are not similar with business teams.An earlier version of this paper was presented at 25th HICSS conference, 10–12.1.1993.This research was in part funded by the Academy of Finland.The opinions presented in this work are not official statements of any of the participating organizations.This research was in part funded by the Finnish Technology Development Center     

Semantic Determinism and Functional Logic Program Properties

In modern functional logic languages like Curry or Toy, programs are possibly non-confluent and non-terminating rewrite systems, defining possibly non-deterministic non-strict functions. Therefore, equational reasoning is not valid for deriving properties of such programs. In a previous work we showed how a mapping from CRWL –a well known logical framework for functional logic programming– into logic programming could be in principle used as logical conceptual tool for proving properties of functional logic programs. A severe problem faced in practice is that simple properties, even if they do not involve non-determinism, require difficult proofs when compared to those obtained using equational specifications and methods. In this work we improve our approach by taking into account determinism of (part of) the considered programs. This results in significant shortenings of proofs when we put in practice our methods using standard systems supporting equational reasoning like, e.g., Isabelle.     

A multi-layered architecture for sketch-based interaction within virtual environments

In this article, we describe a multi-layered architecture for sketch-based interaction within virtual environments. Our architecture consists of eight hierarchically arranged layers that are described by giving examples of how they are implemented and how they interact. Focusing on table-like projection systems (such as Virtual Tables or Responsive Workbenches) as human-centered output-devices, we show examples of how to integrate parts or all of the architecture into existing domain-specific applications — rather than realizing new general sketch applications — to make sketching an integral part of the next-generation human–computer interface.     

Avoiding Knotty Structures in Design: Schematic Functional Programming

Designers in general have used diagrams and sketches to help in the process of creation. This is particularly so for system designers whose output is a set of programs. It would seem reasonable that the conversion of diagrams directly into a program would be desirable and yet the work of Green and Petre [3–4, 13] and Citrin [2] has placed doubt on the viability of graphical programming notations. Some of this work is reviewed in this paper. The use of secondary notation and the matc–mismatch hypothesis is reconsidered in the light of functional programming. It is proposed that much of the criticism of graphical notation is due to the imperative (or process orientated) nature of programming. Many of the limitations observed in using graphical notation are lifted when functional programming is used. Eight engineering dimensions and four engineering relationships (coherences) are proposed to describe programming environments (including notation). The source of ‘knotty structures’ is identified as embedded ‘if then else’ or ‘if’ statements. On analysing both imperative and functional programs it was found that imperative programs used an order of magnitude larger number of ‘if’s than functional programs. The key to the success of a functional language as a general representation as well as its coherence with a graphical notation comes from its unique extensibility. Support for these arguments is drawn from examples of a schematic programming language used for industrial scale projects. It is concluded that the marriage between a functional language and its graphical representation overcomes most of the original criticisms of graphical programming. It is demonstrated that this combination makes a viable and expressive tool for industrial-sized applications.     

Integrating linear physical programming within collaborative optimization for multiobjective multidisciplinary design optimization

Multidisciplinary design optimization (MDO) is a concurrent engineering design tool for large-scale, complex systems design that can be affected through the optimal design of several smaller functional units or subsystems. Due to the multiobjective nature of most MDO problems, recent work has focused on formulating the MDO problem to resolve tradeoffs between multiple, conflicting objectives. In this paper, we describe the novel integration of linear physical programming within the collaborative optimization framework, which enables designers to formulate multiple system-level objectives in terms of physically meaningful parameters. The proposed formulation extends our previous multiobjective formulation of collaborative optimization, which uses goal programming at the system and subsystem levels to enable multiple objectives to be considered at both levels during optimization. The proposed framework is demonstrated using a racecar design example that consists of two subsystem level analyses — force and aerodynamics — and incorporates two system-level objectives: (1) minimize lap time and (2) maximize normalized weight distribution. The aerodynamics subsystem also seeks to minimize rearwheel downforce as a secondary objective. The racecar design example is presented in detail to provide a benchmark problem for other researchers. It is solved using the proposed formulation and compared against a traditional formulation without collaborative optimization or linear physical programming. The proposed framework capitalizes on the disciplinary organization encountered during large-scale systems design.     

System Embedding. Nonconstructive Modeling

Modeling of the linear dynamic system is considered. The set of systems that are equivalent—in the sense of response to the input actions and initial conditions—was shown to be generated not only by the group operation of multiplication, as it is the case with generation of such systems, but also by the ring operations, that is, addition and multiplication. The material is illustrated by examples.     

Matching typed and untyped realizability

Realizability interpretations of logics are given by saying what it means for computational objects of some kind to realize logical formulae. The computational objects in question might be drawn from an untyped universe of computation, such as a partial combinatory algebra, or they might be typed objects such as terms of a PCF-style programming language. In some instances, one can show that a particular untyped realizability interpretation matches a particular typed one, in the sense that they give the same set of realizable formulae. In this case, we have a very good fit indeed between the typed language and the untyped realizability model — we refer to this condition as (constructive) logical full abstraction.We give some examples of this situation for a variety of extensions of PCF. Of particular interest are some models that are logically fully abstract for typed languages including non-functional features. Our results establish connections between what is computable in various programming languages and what is true inside various realizability toposes. We consider some examples of logical formulae to illustrate these ideas, in particular their application to exact real-number computability.     

Programmable applications: exploring the potential for language/interface symbiosis

Programmable applications are software systems that seek to combine the learnability and accessibility of direct manipulation interfaces with the expressive power and range of programming languages. In this paper we explore techniques for creatively integrating language and interface constructs within programmable applications. Using SchemePaint—a programmable graphics application—as a source of examples, we demonstrate how an interface and language can combine symbolically and thereby provide powerful modes of expression within applications.     

Evolution in architectures and programming methodologies of coarse-grained reconfigurable computing

In order to meet the increased computational demands of, e.g., multimedia applications, such as video processing in HDTV, and communication applications, such as baseband processing in telecommunication systems, the architectures of reconfigurable devices have evolved to coarse-grained compositions of functional units or program controlled processors, which are operated in a coordinated manner to improve performance and energy efficiency.In this survey we explore the field of coarse-grained reconfigurable computing on the basis of the hardware aspects of granularity, reconfigurability, and interconnection networks, and discuss the effects of these on energy related properties and scalability. We also consider the computation models that are being adopted for programming of such machines, models that expose the parallelism inherent in the application in order to achieve better performance. We classify the coarse-grained reconfigurable architectures into four categories and present some of the existing examples of these categories. Finally, we identify the emerging trends of introduction of asynchronous techniques at the architectural level and the use of nano-electronics from technological perspective in the reconfigurable computing discipline.     

Learning Syntax by Automata Induction

In this paper we propose an explicit computer model for learning natural language syntax based on Angluin's (1982) efficient induction algorithms, using a complete corpus of grammatical example sentences. We use these results to show how inductive inference methods may be applied to learn substantial, coherent subparts of at least one natural language — English — that are not susceptible to the kinds of learning envisioned in linguistic theory. As two concrete case studies, we show how to learn English auxiliary verb sequences (such as could be taking, will have been taking) and the sequences of articles and adjectives that appear before noun phrases (such as the very old big deer). Both systems can be acquired in a computationally feasible amount of time using either positive examples, or, in an incremental mode, with implicit negative examples (examples outside a finite corpus are considered to be negative examples). As far as we know, this is the first computer procedure that learns a full-scale range of noun subclasses and noun phrase structure. The generalizations and the time required for acquisition match our knowledge of child language acquisition for these two cases. More importantly, these results show that just where linguistic theories admit to highly irregular subportions, we can apply efficient automata-theoretic learning algorithms. Since the algorithm works only for fragments of language syntax, we do not believe that it suffices for all of language acquisition. Rather, we would claim that language acquisition is nonuniform and susceptible to a variety of acquisition strategies; this algorithm may be one these.     

On static output‐feedback stabilization for multi‐input multi‐output positive systems

This paper revisits the static output‐feedback stabilization problem for positive systems. We first point out that for a class of positive systems whose output matrix has a particular row echelon form, this problem can be completely solved via linear programming. By duality, the result is also valid when the column echelon form of the input matrix has a particular structure. Along this line, by augmenting the output matrix as well as the feedback gain matrix, an iterative convex optimization algorithm is developed for the more general case. Finally, we show that the proposed method has advantages over existing works via several numerical examples. Copyright © 2014 John Wiley & Sons, Ltd.