H. James Hoover

InTml: a description language for VR applications

We present the Interaction Technique Markup Language (InTml), a profile on top of the core X3D that describes 3D interaction techniques (InTs) and hardware platforms. InTml makes 3D InTs easier to understand, compare, and integrate in complete virtual reality (VR) applications. InTml can be used as a front end for any VR toolkit, so InTml documents that plug together 3D InTs, VR objects, and devices can be fully described and executed.

Application framework issues when evolving business applications for electronic commerce

Abstract When an organization embarks on e-commerce it rarely has a chance to re-engineer its existing business applications. However, if these business applications were built using an application framework, then one might hope to reuse many of the existing legacy applications in the new e-commerce context. How much of the original application can be reused, and how much does the original application framework have to evolve in order to support this reuse? This paper describes our experience with evolving our framework for building engineered-product business applications so that these applications can be delivered over the Internet. We discuss the general issues created by migrating applications to e-commerce, and identify architectural concerns for application frameworks that must support e-commerce.

Intml: A dataflow oriented development system for virtual reality applications

This paper presents our research on the Interaction Techniques Markup Language (InTml). Our final goal in this work is to find ways to evolve and fit virtual reality (VR) applications over heterogeneous hardware platforms, a process we call retargeting. Toward this goal, we have developed a hardware-independent, component-based, formal model that describes the execution of VR applications; an XML language for describing complex and implementation-independent VR applications; a methodology for InTml-based development; a manual way to isolate and replace interaction techniques as a contribution to VR retargeting; and a set of tools for development support. This paper describes these topics and states future directions of our research.

Efficient comparison of platform alternatives in interactive virtual reality applications

Virtual reality applications consist of an integrated combination of elements, such as hardware devices, interaction techniques, and content, in different modalities and qualities. Designers of virtual reality applications select combinations of such elements that allow users to accomplish their tasks, and it is feasible that more than one combination of such values will satisfy the users needs. Unfortunately, current development environments, methodologies, and techniques in the field of virtual reality often preclude the exploration of the design alternatives, due to coverage or cost limitations. A limited number of options are covered by any given software development environment, and the development cost of new prototypes in such development platforms is too high to be considered as an evaluation tool. In this paper, we present a methodology for partial (i.e. hardware and interaction techniques alternatives) exploration of the design space of a virtual reality application, based on the creation of reusable components and a standard evaluation of alternatives. Since the cost of developing several versions of an application can be reduced by reusing elements from others, this method allows designers to evaluate the performance and user preferences of several implementations. As a proof of concept, we developed four versions of a simple matching application in different virtual reality platforms. Results of this study show how users react to each prototype and how the different solutions can be compared, no matter how different in technology they are.

Multidisciplinary students and instructors: a second-year games course

Computer games are a multi-billion dollar industry and have become an important part of our private and social lives. It is only natural, then, that the technology used to create games should become part of a computing science curriculum. However, game development is more than a massive programming endeavor. Todays games are largely about generating content within multidisciplinary teams. CMPUT 250 is a new computing science course at the University of Alberta that emphasizes creating games in multidisciplinary teams. This paper describes our experiences with the course, emphasizing the issues of multidisciplinary interactions: teaching, teamwork, and evaluation.

Towards automatic exception safety verification

Many programming languages provide exceptions as a structured way for detecting and recovering from abnormal conditions. However, using exceptions properly is non-trivial. Programmers are often careless when handling exceptions, and exception related mistakes are common in software products. We present a technique for verifying that exceptions are used in a safe way. This technique integrates static analysis with model checking to visit all possible exception-raising execution paths. To demonstrate the potential utility of our approach, we applied it to two open source Java applications.

Code convention adherence in evolving software

Maintainability is a desired property of software, and a variety of metrics have been proposed for measuring it, focusing on different notions of complexity and code readability. Many practices have been proposed to improve maintainability through code refactorings: improving the cohesion, simplification of interfaces, renamings to improve understandability. Code conventions are a body of advice on lexical and syntactic aspects of code, aiming to standardize low-level code design under the assumption that such a systematic approach will make code easier to read, understand, and maintain. We present the first stage in our examination of code-convention adherence practices as a proxy measurement for maintainability. Based on a preliminary survey of software engineers, we identify a set of coding conventions that most relate to maintainability. Then we devise a “convention adherence” metric, based on the number and severity of violations of a defined coding convention. Finally, we analyze several open-source projects according to this metric to better understand how consistent different teams are with respect to adopting and conforming to code conventions.

Towards Specifying Constraints for Object-Oriented Frameworks

Object-oriented frameworks are often hard to learn and use (J. Bosch et al., In: ACM Computing Surveys Symposia on Object Oriented Application Frameworks, 1998; M. Fayad and D.C. Schmidt, Communication of the ACM, Special Issue on Object-Oriented Application Frameworks 1997;40(10)). As a result, software cost rises and quality suffers. Thus the capability to automatically detect errors occurring at the boundary between frameworks and applications is considered crucial to mitigate the problem. This paper introduces the notion of framework, constraints and a specification language, FCL (Framework Constraints Language), to formally specify them. Framework constraints are rules that frameworks impose on the code of framework-based applications. The semantics of FCL is primarily based on first order predicate logic and set theory though the evolving syntax is designed to resemble that of programming languages as much as possible. We take examples from the MFC (Microsoft Foundation Classes) framework (G. Shepherd and S. Wingo, MFC Internals: Inside the Microsoft Foundation Classes Architecture. Reading, MA: Addison Wesley, 1996) demonstrating both the nature of framework constraints and the semantics of FCL. Essentially, framework constraints can be regarded as framework-specific typing rules conveyed by the specification language FCL, and thus can be enforced by techniques analogous to those of conventional type checking.

Real functions, contraction mappings, and P -completeness

Abstract This paper examines the notions of feasible real function and of NC real function. We introduce a uniform framework for describing what it means for a continuous real function to be computed by a Boolean circuit family, and we provide techniques for constructing such functions. As an example we construct a continuous real function that is complete for P , thus showing that the question of wheter NC = P can be reduced to the question of whether the class of feasible real functions equals the class of NC real functions. A corollary of this result is that there exists a family of feasible-size-magnitude polynomials that are complete for P . Finally we look at contraction mappings and ask whether the fixed points of an NC real contraction mapping can be found in NC . We give evidence that this is not the case in general by exhibiting an NC real function which is a contraction mapping over disjoint intervals of the real line, and for which the problem of finding the fixed point of any given interval is complete for P . Thus methods for locating fixed points which are based simply on contraction mappings are not likely to parallelize well.

Choosing an object-oriented domain framework

Object-oriented frameworks [2] enable developers to rapidly produce new applications — provided that the framework is actually suited to the requirements of the new application. Often, previous experience with the framework is used to make this decision, but when application developers are unfamiliar with a new framework they have no experience for deciding whether or not to use it. They may not discover that a framework lacks support for key requirements of an application until well into the development cycle, resulting in substantial redevelopment or discarding of the project altogether. They require a basis for making the initial decision of whether or not to invest time in understanding and using the framework. Our approach is most successful for domain specific object-oriented frameworks. Due to their size and overall generality, this approach may not be as applicable to enterprise frameworks. We have been working with existing frameworks such as HotDraw [6], as well as developing new frameworks in the engineering domain (EAF). Our experience, common to most framework users, is that building up the level of expertise necessary to know in detail what applications a framework can be used for is a time consuming process due to the abstract nature and complexity of most frameworks. How can this expertise be captured and be made available to new users of the framework to help them decide whether or not to use the framework? In other words, how do we describe the applicable domain of the framework? A new application can fall into one of three areas. It can be (1) clearly outside