This paper introduces novel quantitative metrics for evaluating the performance of occupant identification and tracking models in multi-building smart spaces. We evaluate two state transition system models: the Centralized State Transition System (CSTS) and the Distributed State Transition System (DSTS). Both are probabilistic models characterized by events, state transition functions, and states. Events abstract biometric recognition, transition functions capture state changes, and states provide the foundation for information retrieval. To systematically compare these models, we introduce two figures of merit, for comparing event-level and state-level behavior, respectively. Experimental results indicate that CSTS outperforms DSTS in their figures of merit, demonstrating greater accuracy, however, DSTS remains a viable alternative in scenarios where building-specific structure and reduced state update complexity offer advantages. Our findings emphasize that both models have their strengths, and also that different scenarios may require different metrics for a more nuanced understanding of system performance and comparison.

Abstract Finite‐state models are extensively used for discrete systems and they have also been adopted for the analysis and verification of concurrent systems. Programs that have a repetitive cycle, such as event‐driven servers and controllers, lend themselves to finite‐state modeling. In this article, we use the termmodel extractionto refer to the construction of a finite‐state model from an execution trace of a Java program and a set of key attributes, that is, a subset of the fields of the objects in the program execution. By choosing different sets of attributes, different finite‐state models (or views) of the execution can be obtained. Such models aid program comprehension and they can also be used in debugging a program. We present algorithms for model extraction and also formodel abstractionin order to reduce the size of the extracted models so that they are amenable to visualization. For long executions, we show how to minimize the overhead of execution trace collection through a bytecode instrumentation technique; and, for large models, which are not amenable to visualization, we show how key properties of the extracted model can be checked against declarative specifications. We have implemented our techniques in the context of JIVE, an Eclipse plugin that supports runtime visualization and analysis of Java program executions. We illustrate our techniques through a collection of case studies of varying size and complexity, from classic problems of concurrency control to a medium‐size protocol for authorization (OAuth2.0 protocol) to a large‐scale software that underlies web applications (Apache Tomcat server).

The context of this work is a practical, open-source visualization system, called JIVE, that supports two forms of runtime visualizations of Java programs – object diagrams and sequence diagrams. They capture, respectively, the current execution state and execution history of a Java program. These diagrams are similar to those found in the UML for specifying design–time decisions. In our work, we construct these diagrams at execution time, thereby ensuring continuity of notation from design to execution. In so doing, a few extensions to the UML notation are proposed in order to better represent runtime behavior. As sequence diagrams can become long and unwieldy, we present techniques for their compact representation. A key result in this paper is a novel labeling scheme based upon regular expressions to compactly represent long sequences and an O(r2) algorithm for computing these labels, where r is the length of the input sequence, based upon the concept of ‘tandem repeats’ in a sequence. Horizontal compaction greatly helps minimize the extent of white space in sequence diagrams by the elimination of object lifelines and also by grouping lifelines together. We propose a novel extension to the sequence diagram to deal with out-of-model calls when the lifelines of certain classes of objects are filtered out of the visualization, but method calls may occur between in-model and out-of-model calls. The paper also presents compaction techniques for multi-threaded Java execution with different forms of synchronization. Finally, we present experimental results from compacting the runtime visualizations of a variety of Java programs and execution trace sizes in order to demonstrate the practicality and efficacy of our techniques. Copyright © 2016 John Wiley & Sons, Ltd.

A major challenge in engineering education today in India is preparing students with the skill set needed for a global industry. This paper describes an innovative partnership between two institutions of higher education in India and USA and a multinational corporation to address this challenge. The collaborative manner in which the industry and institutions internationalized the curriculum is a key feature of this program. This unique approach has resulted in the employees of a multinational company in India being able to get two high quality Masters-level degrees in engineering, customized to their current and future requirements at a very affordable price point. This paper looks at cost savings, collaborative course development between industry and international academia, using technology to deliver courses and on-the-job professional development program for employees while keeping the employees motivated. But there are also interesting lessons learnt regarding teaching in English, adjusting to the local cultural context and the overall integration into the Indian academic setting. The process innovation described here would be of great interest to academia, industry and education policy makers and has the potential to be replicated in the entire field of non-engineering and interdisciplinary academic programs.

SUMMARY Hard real‐time systems have stringent timing and resource requirements. As such, debugging and tracing such systems often requires low‐level hardware support, and online debugging is usually precluded entirely. In other areas, however, visual debugging has greatly improved program understanding and late cycle development times for nonreal‐time applications. In this paper, we introduce a visual test and debug framework for hard real‐time Java applications built around theJIVEplatform and realized in the Fiji virtual machine. Our framework, calledJI.FI [" dZIfi], provides high‐level debugging support over low‐level execution traces.JI.FIprovides both powerful visualizations and real‐time centric temporal query support. To ensure preservation of the real‐time characteristics of the application being tested and debugged,JI.FIleverages a real‐time event log infrastructure that logs only relevant application and virtual machine level events, such as synchronization and modifications to priorities or thread state. Our performance results indicate that our logging infrastructure is suitable for hard real‐time systems, as the performance impact is bothuniformandquantifiable. Copyright © 2013 John Wiley & Sons, Ltd.

An important challenge in teaching object-oriented (OO) programming and methodology in introductory Computer Science courses is explaining the run-time of OO programs. This is largely due to the OO methodology, which encourages the use of features such as polymorphism and design patterns, resulting in object interactions and control flow that are hard to grasp, especially for novice programmers. We present an approach to program comprehension in which students use storyboards and visual debugging to build a clear mental model of the dynamic behavior of OO programs. In this context, a storyboard consists of a sequence of figures representing run-time aspects of interest (e.g. states or interactions) and an explanatory narrative in terms of OO concepts and source elements. The selected visual debugger must render execution histories and run-time states using visual notations consistent with the OO methodology (e.g., objects, member fields, method calls within object contexts). Instructors create storyboards using figures exported from the debugger and incorporate them in course materials. Further, storyboards included in specifications of programming assignments alongside test cases provide students with a detailed account of their programs' run-time at interesting points in execution. By executing their programs under the visual debugger, students can compare the observed run-time states with those illustrated in the storyboards and effectively assess the behavioral correctness of their programs. Hence, the combined use of storyboards and visual debugging can benefit students during the coding phase by guiding them towards writing code that closely adheres to the OO methodology from the outset.

This special issue focuses on the security and performance of computer networks and cloud computing. It was inspired by papers presented at a special symposium held on 22 September 2011 in honor of Professor Satish K. Tripathi on the occasion of his 60th birthday and on the eve of his formal investiture as President of the University at Buffalo, the State University of New York. The symposium brought together some 100 participants, including several of Professor Tripathi's current and former collaborators, colleagues and students.

Traditional constraint programming specifies an optimization problem by using a set of constraints and minimizing (or maximizing) objective functions. Unfortunately, general optimization problems may involve compound objectives whose optima are difficult to be represented by a simple minimization (or maximization). Even worse, for many applications, especially those defined over structural domains, it is difficult to specify any objective functions. In this paper we presents a declarative method for specifying generalized optimization problems based on comparison and selection among alternative solutions. The method introduces a formal predicate mode declaration for designating certain predicates as optimization predicates, and uses preference rules for stating the criteria for determining their optimal solutions. We illustrate their uses with two representative examples: one is matrix-chain multiplication from dynamic programming, and the other is ambiguity resolution for recursively-defined grammars. This paper also addresses how to extend a tabled Prolog system with preferences. The execution of logic programs with preferences is achieved in two steps. First, an automatic transformation is applied to embed the preferences into the problem specification to form an executable program. Second, the new program is then evaluated using tabled resolution, while the mode declaration provides a selection mechanism among the alternative solutions. We show that the transformation scheme preserves the semantics for each optimization predicate. Experimental results are shown to indicate that preferences provide a declarative approach without sacrificing efficiency.

Optimization and relaxation are two important operations that naturally arise in many applications involving constraints, e.g., engineering design, scheduling, decision support, etc. In optimization, we are interested in finding the optimal (i.e., best) solutions to a set of constraints with respect to an objective function. In many applications, optimal solutions may be difficult or impossible to obtain, and hence we are interested in finding suboptimal solutions, by either relaxing the constraints or relaxing the objective function. The contribution of this paper lies in providing a logical framework for performing optimization and relaxation in a constraint logic programming language. Our proposed framework is called preference logic programming (PLP), and its use for optimization was discussed in [8]. Essentially, in PLP we can designate certain predicates as optimization predicates, and we can specify the objective function by stating preference criteria for determining the optimal solutions to these predicates. This paper extends the PLP paradigm with facilities to formulate relaxation problems in a natural manner. We introduce the concept of a relaxation goal, and discuss its use for preference relaxation. Our model-theoretic semantics of relaxation is based on simple concepts from modal logic: Essentially, each world in the possible-worlds semantics for a preference logic program is a model for the constraints of the program, and an ordering over these worlds is determined by the objective function. Optimization can then be expressed as truth in strongly optimal worlds, while relaxation becomes truth in suitably-defined suboptimal worlds. We also present an operational semantics for relaxation as well as correctness results. Our conclusion is that the concept of preference provides a unifying framework for formulating optimization as well as relaxation problems.

We discuss fundamental limitations of or-parallel execution models of nondeterministic programming languages. Or-parallelism corresponds to the execution of different nondeterministic computational paths in parallel. A natural way to represent the state of (parallel) execution of a nondeterministic program is by means of an or-parallel tree. We identify three important criteria that underlie the design of or-parallel implementations based on the or-parallel tree: constant-time access to variables, constant-time task creation, and constant-time task switching, where the term constant-time means that the time for these operations is independent of the number of nodes in the or-parallel tree, as well as the size of each node. We prove that all three criteria cannot be simultaneously satisfied by any or-parallel execution model based on a finite number of processors but unbounded memory. We discuss in detail the application of our result to the class of logic programming languages and show how our result can serve as a useful way to categorize the various or-parallel methods proposed in this field. We also discuss the suitability of different or-parallel implemenation strategies for different parallel architectures.

Abstract The integration of functional and logic programming languages has been a topic of great interest in the last decade. Many proposals have been made, yet none is completely satisfactory especially in the context of higher order functions and lazy evaluation. This paper addresses these shortcomings via a new approach: domain theory as a common basis for functional and logic programming. Our integrated language remains essentially within the functional paradigm. The logic programming capability is provided by set abstraction (via Zermelo-Frankel set notation), using the Herbrand universe as a set abstraction generator, but for efficiency reasons our proposed evaluation procedure treats this generator's enumeration parameter as a logical variable. The language is defined in terms of (computable) domain-theoretic constructions and primitives, using the lower (or angelic) powerdomain to model the set abstraction facility. The result is a simple, elegant and purely declarative language that successfully combines the most important features of both pure functional programming and pure Horn logic programming. Referential transparency with respect to the underlying mathematical model is maintained throughout. An implicitly correct operational semantics is obtained by direct execution of the denotational semantic definition, modified suitably to permit logical variables whenever the Herbrand universe is being generated within a set abstraction. Completeness of the operational semantics requires a form of parallel evaluation, rather than the more familiar left-most rule.

EqL, a general-purpose language that combines the capabilities of functional and logic programming languages, is described. A program in EqL consists of a collection of conditional, pattern-directed rules, where the conditions are expressed as a conjunction of equations, and the patterns are terms built up of data-constructors and basic values. The computational paradigm in EqL is equation solving. Examples illustrating the major features of the language, nondeterminism, deferred evaluation of primitives, and logical variables are presented. The aspects of a sequential implementation for EqL, such as compile-time flattening of equations, run-time equation-delaying, and last-equation optimization, are also described.>

The formal semantics of a novel language, called EqL, are presented for first-order functional and Horn logic programming. An EqL program is a set of conditional pattern-directed rules, where the conditions are expressed as a conjunction of equations. The programming paradigm provided by this language may be called equational programming. The declarative semantics of equations is given in terms of their complete set of solutions, and the operational semantics for solving equations is an extension of reduction, called object refinement. The correctness of the operational semantics is established through the soundness and completeness theorems. Examples are given to illustrate the language and its semantics.>