Papers by Bharat Jayaraman
Cameras are becoming ubiquitous. Technological advances and the low cost of such sensors enable d... more Cameras are becoming ubiquitous. Technological advances and the low cost of such sensors enable deployment of large-scale camera networks in metropolises such as London and New York. Applications including video-based surveillance and emergency response exploit such camera networks to detect anomalies in real time and reduce collateral damage. A well-known technique for detecting such anomalies is spatiotemporal analysis -an inferencing technique employed by domain experts (e.g., vision researchers) to answer spatiotemporal queries. Performing spatio-temporal analysis in real-time for a largescale camera network is challenging. It involves continuously analyzing the images from distributed cameras to detect signatures, generating an event by comparing the detected signature against a database of known signatures, and maintaining a state transition table that show the spatio-temporal evolution of people movement through the distributed spaces. Being inherently distributed, computationally demanding, and dynamic in terms of resource requirements, such applications are well-positioned to exploit smart cameras and cloud computing resources. However, developing such complex distributed applications is a daunting task for domain experts. In this paper, we propose a distributed framework to facilitate the development and deployment of spatio-temporal analysis applications on large-scale camera networks and backend computing resources. The framework requires the domain experts to provide a set of handlers that perform the domain-specific analyses (e.g., signature detection, event generation, and state update). The runtime system invokes these handlers automatically in the distributed environment consisting of smart camera networks and cloud computing resources. We make the following contributions: (a) a distributed programming framework for spatio-temporal analysis, (b) a careful investigation of the computation/communication costs associated with the large-scale spatio-temporal analysis to arrive at the scalable system architecture, (c) automatic resource configuration to cope with the dynamic workload, (d) a detailed performance evaluation of our system with a view to supporting scalability and quality of service.
Our goal is to develop 'smart indoor environments' that are monitored unobtrusively by biometric ... more Our goal is to develop 'smart indoor environments' that are monitored unobtrusively by biometric capture devices, such as video cameras, microphones, etc. Such environments will keep track of their occupants and be capable of answering queries about the occupants' whereabouts. In order to develop a unified model that is applicable across diverse biometric modalities, we propose an abstract state transition framework in which different recognition steps are abstracted by events, and the reasoning necessary to effect state transitions is abstracted by a transition function. We define the metrics of 'precision' and 'recall' of a smart environment to evaluate how well it tracks its occupants. We show how the overall performance of our smart environment can be improved through the use of spatiotemporal knowledge of the environment. A prototype based upon our proposed abstract framework indicates that integrating recognition and reasoning capabilities substantially improves the overall performance of the environment
Lecture Notes in Computer Science, Aug 12, 2008
We present an abstract framework for 'smart indoor environments' that are monitored unobtrusively... more We present an abstract framework for 'smart indoor environments' that are monitored unobtrusively by biometrics capture devices, such as video cameras, microphones, etc. Our interest is in developing smart environments that keep track of their occupants and are capable of answering questions about the whereabouts of the occupants. We abstract the smart environment by a state transition system: Each state records a set of individuals who are present in various zones of the environment. Since biometric recognition is inexact, state information is probabilistic in nature. An event abstracts a biometric recognition step, and the transition function abstracts the reasoning necessary to effect state transitions. In this manner, we are able to accommodate different types of biometric sensors and also different criteria for state transitions. We define the notions of 'precision' and 'recall' of a smart environment in terms of how well it is capable of identifying occupants. We have developed a prototype smart environment based upon our proposed concepts, and provide experimental results in this paper. Our conclusion is that the state transition model is an effective abstraction of a smart environment and serves as a basis for integrating various recognition and reasoning capabilities.
arXiv (Cornell University), Sep 10, 1998
The inclusion of universal quantification and a form of implication in goals in logic programming... more The inclusion of universal quantification and a form of implication in goals in logic programming is considered. These additions provide a logical basis for scoping but they also raise new implementation problems. When universal and existential quantifiers are permitted to appear in mixed order in goals, the devices of logic variables and unification that are employed in solving existential goals must be modified to ensure that constraints arising out of the order of quantification are respected. Suitable modifications that are based on attaching numerical tags to constants and variables and on using these tags in unification are described. The resulting devices are amenable to an efficient implementation and can, in fact, be assimilated easily into the usual machinery of the Warren Abstract Machine (WAM). The provision of implications in goals results in the possibility of program clauses being added to the program for the purpose of solving specific subgoals. A naive scheme based on asserting and retracting program clauses does not suffice for implementing such additions for two reasons. First, it is necessary to also support the resurrection of an earlier existing program in the face of backtracking. Second, the possibility for implication goals to be surrounded by quantifiers requires a consideration of the parameterization of program clauses by bindings for their free variables. Devices for supporting these additional requirements are described as also is the integration of these devices into the WAM. Further extensions to the machine are outlined for handling higher-order additions to the language. The ideas presented here are relevant to the implementation of the higher-order logic programming language λProlog.
This paper discusses the benefits of a temporal data model for debugging and run-time visualizati... more This paper discusses the benefits of a temporal data model for debugging and run-time visualization of object-oriented software. Current debugging models generally only provide access to the current program state and support manual exploration of the state to uncover the cause of program errors. However, often the cause of an error lies in distant previous states, and a more comprehensive view of the execution history is necessary to uncover such errors. This is achieved through our proposed temporal data model and query language. This paper also shows the benefits of UML-like object and sequence diagrams for representing respectively the current run-time state and execution history. The main contribution of this paper lies in showing that declarative temporal queries and (run-time) object/sequence diagrams work in a symbiotic manner to achieve a more effective debugging system: queries help the user to focus on specific regions of the diagrams, while the diagrams provide a framework for reporting the answers to queries. Since run-time visualizations become unwieldy for large executions, we propose two broad classes of techniques to achieve compact sequence diagrams: folding operations, for nested calls and also a sequence of calls; and filtering operations, to remove unnecessary or irrelevant calls relative to a debugging task. We introduce a refinement of the sequence diagram to account for missing calls, and regular-expression labels for compacted execution sequences. Together, these techniques have proven to be effective and they form part of Jive, a state-of-the-art debugging system for Java.
arXiv (Cornell University), Jan 17, 2007
This paper presents a logic based approach to debugging Java programs. In contrast with tradition... more This paper presents a logic based approach to debugging Java programs. In contrast with traditional debugging we propose a debugging methodology for Java programs using logical queries on individual execution states and also over the history of execution. These queries were arrived at by a systematic study of errors in object-oriented programs in our earlier research. We represent the salient events during the execution of a Java program by a logic database, and implement the queries as logic programs. Such an approach allows us to answer a number of useful and interesting queries about a Java program, such as the calling sequence that results in a certain outcome, the state of an object at a particular execution point, etc. Our system also provides the ability to compose new queries during a debugging session. We believe that logic programming offers a significant contribution to the art of object-oriented programs debugging.
This paper presents a declarative approach to the debugging of object-oriented programs and illus... more This paper presents a declarative approach to the debugging of object-oriented programs and illustrates the methodology through an extension of a novel interactive visualization system for Java developed in our previous research. Unlike traditional "procedural" debugging, we use the term "declarative debugging" to refer to a flexible set of queries on individual execution states and also over the entire history of execution (or portion of the history). Examples include queries to find all values assigned to a variable over its life-time; which variable has a certain value; the calling sequence that results in a certain outcome; whether a certain statement was executed; etc. These queries were arrived at by a systematic study of errors in objectoriented programs in our previous research. Our proposed system, JavaDD, maintains the execution history as a relational database of salient events, such as method call/return, thread start/end, variable assignment, etc. An important property of our approach is that these queries can be posed interactively (at any step of execution), and there is no need to develop a compiler to instrument the source code, as in related research projects. Furthermore, we also sketch a visual interface so that both queries and answers can be composed using inituitive object and sequence diagrams. We believe such an approach is a significant contribution to the art of program debugging. We present the architecture of JavaDD, a detailed catalog of our queries and their translation, and several examples illustrating the approach. We also compare our approach related research efforts in the area of query-based analysis of object-oriented programs.
Proceedings IEEE 2002 Symposia on Human Centric Computing Languages and Environments
In 2001 the German State launched a huge multimedia initiative "New Media in Education" in order ... more In 2001 the German State launched a huge multimedia initiative "New Media in Education" in order to exploit the potentials connected with the use of innovative media for universities and to serve the growing demand for interactive learning environments. Within this framework, an interdisciplinary project "New Statistics" involving 10 universities was funded up to October 2003 (for details, see www.dialekt.cedis.fuberlin.de). The interdisciplinary project aims at providing a multimedia-based and web-supported virtual environment for learning and t eaching statistics in economics, social sciences, medicine and other disciplines. The pillars of the modular structured project are Java applets designed for trying out statistical concepts by means of interactive experiments, Flash animations for explaining statistical theory, and a learning laboratory based on the programming language R, the free version of S, for performing statistical calculations based on self-selected data sets. The modular approach gives maximal flexibility and supports very different use scenarios. The Java applets may, for example, be employed independently from other project components as a supplement to traditional lecturing or for self-study purposes. This paper focuses on Java applets as one of the pillars of the project "New Statistics". The applets represent a particularly suitable starting-point for improved international cooperation in Statistics education. The project already covers a library containing over 60 Java applets which could be used online as well as offline. The applets visualize basic concepts in descriptive statistics, probability theory and inferential statistics. An example layout is illustrated in Figure by means of an applet dealing with the geometric distribution.
Formal specification and verification of vehicular handoff using π-calculus
Proceedings of the 1st International Conference on Wireless Technologies for Humanitarian Relief, 2011
Vehicular networking is an important emerging area having immense applications, ranging from road... more Vehicular networking is an important emerging area having immense applications, ranging from road-safety to emergency communications in disaster situations. As more applications begin to take advantage of vehicular networks, correctness of the underlying protocols must be subjected to rigorous analysis. The π-calculus is a formal language for specifying mobile systems and has been applied in wide range of settings, from
Modeling Engineering Structures with Constrained Objects
Lecture Notes in Computer Science, 2001
We present a novel programming language based on the concept of constrained objects for compositi... more We present a novel programming language based on the concept of constrained objects for compositional and declarative modeling of engineering structures. A constrained object is an object whose internal state is governed by a set of (declarative) constraints. When several constrained objects are aggregated to form a complex object, their internal states might further have to satisfy interface constraints. The
Journal of Systems Architecture, 2011
We propose a novel method to construct user-space internet protocol stacks whose security propert... more We propose a novel method to construct user-space internet protocol stacks whose security properties can be formally explored and verified. The proposed method allows construction of protocol stacks using a C++ subset. We define a formal state-transformer representation of protocol stacks in which the protocol stack is specified in terms of three primary operations, which are constructed from sub-operations, in a compositional manner. We also define a Kripke model that captures the sequencing and attributes of stack operations. We propose a novel approach, called split verification, which combines theorem-proving and model-checking to establish properties for a protocol stack specification. In split verification, properties to be established for the stack are expressed as a combination of properties for primitive operations to be established via theorem-proving as well as temporal properties on operation sequencing, called promotion conditions, to be established via model-checking on the stack operations model. We use abstract Z specifications to represent operation properties and computational tree logic (CTL) formulae to represent promotion conditions. Operation properties are established by checking whether the operation(s) under consideration are correct refinements of the abstract Z specification(s). Our conclusion is that split verification: (a) avoids scalability issues caused by state-space explosion in model-checking and long unwieldy proofs in theorem-proving, and, (b) lowers cost of proof maintenance for localized changes in the stack.
Journal of Functional Programming, 1992
The integration of functional and logic programming languages has been a topic of great interest ... more 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 theoryas a common basis for functional and logic programming. Our integrated language remains essentially within the functional paradigm. The logic programming capability is provided byset 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...
Specification and computation of optimization problems
Computers & Industrial Engineering, 1997
ABSTRACT
A novel approach to the runtime visualization and analysis of object-oriented programs is present... more A novel approach to the runtime visualization and analysis of object-oriented programs is presented and illustrated through a prototype system called JIVE: J ava I nteractive V isualization E nvironment. The main contributions of JIVE are: multiple concurrent representations of program state and execution history; support for forward and reverse execution; and graphical queries over program execution. This model facilitates program understanding and interactive debugging. Our visualization of runtime states clarifies the important point that objects are environments of execution. The history of object interaction is displayed via sequence diagrams, and in this way we help close the loop between design-time and run-time representations. Interactive execution is made possible by maintaining a runtime history database, which may be queried for information on variable behavior, method executions, and object interactions. We illustrate the capabilities of this system through examples. JIVE is implemented using the Java Platform Debugger Architecture and supports the Java language and libraries, including multithreaded and GUI applications.
This dissertation addresses the problem of incorporating into lazy higher-order functional progra... more This dissertation addresses the problem of incorporating into lazy higher-order functional programming the relational programming capability of Horn logic. The language design is based on set abstraction, a feature whose denotational semantics has until now not been rigorously defined. A novel approach is taken in constructing an operational semantics directly from the denotational description. The main results of this dissertation are: (i) Relative set abstraction can combine lazy higher-order functional programming with not only first-order Horn logic, but also with a useful subset of higherorder Horn logic. Sets, as well as functions, can be treated as first-class objects. (ii) Angelic powerdomains provide the semantic foundation for relative set abstraction. (iii) The computation rule appropriate for this language is a modified paralleloutermost, rather than the more familiar left-most rule. (iv) Optimizations incorporating ideas from narrowing and resolution greatly improve the...
Lecture Notes in Computer Science, Dec 9, 2019
We revisit the Generalised Dining Philosophers problem through the perspective of feedback contro... more We revisit the Generalised Dining Philosophers problem through the perspective of feedback control. The result is a modular development of the solution using the notions of system and system composition (the latter due to Tabuada) in a formal setting that employs simple equational reasoning. The modular approach separates the solution architecture from the algorithmic minutiae and has the benefit of simplifying the design and correctness proofs. Three variants of the problem are considered: N=1, and N > 1 with centralised and distributed topology. The base case (N=1) reveals important insights into the problem specification and the architecture of the solution. In each case, solving the Generalised Dining Philosophers reduces to designing an appropriate feedback controller.
Proceedings of the fourth international conference on Functional programming languages and computer architecture - FPCA '89, 1989
This paper addresses the declarative and computational issues of incorporating set abstraction in... more This paper addresses the declarative and computational issues of incorporating set abstraction into functional and logic programming languages. The main results are the following: (i) Relative set abstraction can combine a lazy higher-order functional programming with not only first-order Horn logic, but also with a useful subset of higher-order Horn logic. Sets, as well as functions, can be treated as first-class objects. (ii) Angelic powerdomains provide the semantic foundation. These are compatible with lazy evaluation and are well-defined over elements from even non-flat (higher-order) domains. (iii) A new computation rule, more efficient than the parallel-outermost rule, is developed and shown to be a correct computation rule. (A simple left-most rule is not adequate for this language.) (iv) Optimizations incorporating ideas from narrowing and resolution greatly improve the efficiency of the interpreter, while maintaining correctness.
Business process reengineering has been the focus of attention of businesses since the early 1990... more Business process reengineering has been the focus of attention of businesses since the early 1990s (Hammer and Champy 1993). To an extent, existing business process modeling tools (Spurr et al. 1994) provide features to analyze business processes. However, the decision support provided by these tools is often too limited (Yu et al. 1996). For instance, many modeling tools based on IDEF, DFD, etc. lack the necessary means to support the representation of time and resource constraints and most ignore the human and behavioral aspects of reengineering (Davenport and Stoddard 1994). This research depicts the critical aspects of business processes in terms of a four dimensional framework composed of workflow structure, decision structure, information structure, and agency structure. The framework is used to develop a simulation test bed that allows computational modeling of interdependencies among agents, activities, and resources in a business process.
Uploads
Papers by Bharat Jayaraman