The goal of our research is to model complex systems using a compositional approach. We are exploring a declarative variant of the traditional paradigm called 'constrained objects'. This paradigm is being developed at Buffalo, and is useful in high-level modeling of engineering and biological systems, as well as in other domains. A constrained object is one whose state is governed by laws of behavior, or constraints. When several such objects are combined together to form a complex system, the emergent behavior is determined by a process of constraint satisfaction. Constrained objects can model static as well as dynamic systems, and can also be combined with domain-specific visualizations that enable the end-user to interact with the underlying model in a natural medium. Research topics include: modeling language design, efficient execution, analysis of model inconsistency, domain-specific visualizations, modeling dynamic and hybrid systems, integrating powerful solvers, etc.
P. Tambay and B. Jayaraman, Methodology and Implementation of Constrained
Objects, ACM Transactions on Software Engineering and Modeling, submitted,
2007.
P. Tambay, Constrained Objects for Modeling Complex Systems,
Ph.D. dissertation, University at Buffalo, 2004.
P. Tambay and B. Jayaraman, The Cob Programmer's Manual,
CSE Dept TR 2003-1, University at Buffalo, 2003.
Y. Zhang, Case Studies in Constrained Objects, M.S. Thesis,
University at Buffalo, 2004.
R.J. Raux and B. Jayaraman, Modeling Dynamic Systems with Constrained Objects,
CSE Dept TR 2004-05, University at Buffalo, 2004.
B. Jayaraman and P. Tambay, Implementation Techniques for Constrained Objects.
CSE Dept TR 2004-04, University at Buffalo, 2004.
B. Jayaraman and P. Tambay,
Compositional Semantics for Diagrams using Constrained Objects,
Proc. Second International Conference on Theory and Application
of Diagrams, April 2002.
B. Jayaraman and P. Tambay,
Modeling Engineering Structures with Constrained Objects
Proc. International Symposium on Practical Applications of
Declarative Languages, Portland, OR, pp. 28-46, Springer-Verlag,
January 2002.
B. Jayaraman and P. Tambay,
Constrained Objects for Modeling Complex Structures,
Proc. ACM Conference on Object-Oriented Programming,
Systems, and Applications, Minneapolis, October 2000.
B. Jayaraman, T. McKernan, S. Raghavan, and S. Shanker,
CobWeb: Constraint-Based XML for the Web, Technical Report,
CSE Department, U at Buffalo Environments, December 2001.
Traditional debugging is "procedural" in that a programmer has to proceed step-by-step and object-by-object in order to uncover the cause of an error. In contrast, 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). While querying source code is a fairly common feature, the ability to query the execution history is a novel feature of our approach. Examples include finding all values assigned to a variable over its life-time; why a certain variable was assigned a certain value; when an invariant was first violated; etc.
We propose a methodology for formulating queries in a visual manner, so that the end-user is not confronted with the task of writing queries in SQL or similar language. We depict run-time information in two ways: (i) the current state is depicted through an enhanced object diagram; and (ii) the history of states is depicted by a time-sequence diagram. Thus queries about run-time can be formulated either using the source code, the object diagram, or the sequence diagram; and answers can be shown by highlighting and annotating such diagrams.
This methodology is being incorporated in an experimental system, called JIVE, which is being developed as an Eclipse plug-in. We propose to display object and sequence diagrams at different levels of granularity, and also support reverse stepping as well as jumping. The input to JIVE can be any Java program; no special syntax or preprocessing is required, and we use the standard Java compiler and JVM. The key to our approach is to use the Java Platform Debugger Architecture (JPDA) in order to link the execution engine and the visualization/debugging engine. In this manner, we can access the program state and capture necessary information.
J.K. Czyz and B. Jayaraman, Declarative and Visual Execution Environments
in Eclipse, Eclipse Technology Workshop, submitted, 2007.
H.Z. Girgis and B. Jayaraman,
JavaDD: Logic Based Debugging of Java Programs,
Proc. ICLP Workshop of Logic Programming Environments,
August 2006.
H. Girgis, B. Jayaraman, P.V. Gestwicki: Visualizing Errors in
Object Oriented Programs. Proc. ACM Conference on Object
Oriented Programming, Languages, Systems, and Applications, October 2005.
Expanded version available as CSE TR 2004-19.
P.V. Gestwicki: Interactive Visualization of Object Oriented Programs.
Ph.D. dissertation, CSE Department, June 2005. Available as: TR 2005-15.
P.V. Gestwicki and B. Jayaraman: Methodology and architecture of JIVE. Proc
ACM Symposium on Software Visualization, pp. 95-104, May 2005.
P. Gestwicki and B. Jayaraman, Methodology and Architecture of JIVE, Proc. ACM Conference on Object Oriented Programming, Languages, Systems, and Applications, Vancouver, BC, 2004. Expanded version available as CSE TR 2004-20.
P. Gestwicki and B. Jayaraman,
Interactive Visualization of Java Programs,
Proc. IEEE Symposium on Human Centric Computing, Languages and
Environments, Washington DC, Springer-Verlap, Sept. 2002.
P. Gestwicki, B. Jayaraman, A. Garg, From Class Diagrams to Object Diagrams: A
Systematic Approach, CSE 2004-21, December 2004.
B. Jayaraman, P. Gestwicki, and A. Garg, Interactive Program Visualization and Graph Drawing, Proc. International Conference on Discrete Mathematics and Applications, December 2004. Also available as: CSE 2004-21.
H. Girgis et al, Visual Queries in Interactive Execution of Java Programs,
CSE TR 2004-19, December 2004.
We are developing a programming paradigm based upon both constraints and preferences. While constraints specify the mandatory requirements of a problem, preferences specify optional or desired requirements and serve as a basis for determining optimal solutions to the constraints. There are numerous applications of this approach, including combinatorial optimization, database querying, and natural language parsing. Essentially, in this framework we can: (a) designate certain predicates as optimization predicates, and state the criteria for determining their optimal solutions; and (b) designate which optimization predicates are to be relaxed and state the criteria for relaxation. These criteria are understood using the concept of preference and hence we call this framework preference logic programming. In joint work with S. Mantha and K. Govindarajan, we have developed the foundations of such a language, and we are presently interested in applications and implementation techniques.
K. Govindarajan, B. Jayaraman and S. Mantha,
Logic Programming with Constraints and Preferences, 1998.
Expanded version of a paper which appeared in: Proc. 23rd ACM Symposium on Principles of Programming Languages, pp. 91-105, St. Petersburg, FL.
K. Govindarajan, B. Jayaraman, and S. Mantha,
Preference Queries in Deductive Databases,
New Generation Computing, 19(1), 2000.
B. Jayaraman, K. Govindarajan, and S. Mantha,
Preference Logic Grammars,
Computer Languages, 24:179--196, 1998.
K. Govindarajan, B. Jayaraman and S. Mantha,
Preference Logic Programming,
Proc. International Conference on Logic Programming, pp. 731-745,
MIT Press, 1995.
The focus of this research is on sets, which are central in applications of database query languages and logical specifications of problems. Our programming paradigm encompasses three kinds of program clauses: subset, equational, and relational clauses. Using these clauses, we can program solutions to a broad range of problems of interest in logic programming and deductive databases. This paradigm supports Prolog-like setof operations, as well as transitive closures, monotonic aggregation, and incremental and lazy enumeration of sets. This paradigm is called subset-logic programming, and the language SuRE, which stands for Subsets, Relations, and Equations, is an example of a subset-logic language. To wit, SuRE is the affirmative answer to the question, "Can programming be declarative and practical?" We have implemented the paradigm using a variant of the Warren Abstract Machine for Prolog, and shown that the language has very good performance for set-oriented problems. A natural generalization of subset-logic programming is partial-order programming, a paradigm that is already incorporated in the SuRE language. When the partial-order is known to be a total-order, there are some very efficient computations that can be performed, including lazy evaluation and relaxation. This work grew out of joint research with David Plaisted in the late 1980's, and has been developed further by Devashis Jana, Kyonghee Moon, and Mauricio Osorio.
B. Jayaraman and K. Moon,
Subset Logic Programs and Their Implementation,
Journal of Logic Programming,
41(2):71--110, 2000.
M. Osorio, B. Jayaraman, and J.C. Nieves,
Declarative Pruning in a Functional Query Language,
Proc. International Conference on Logic Programming,
pp. 588--602, 1999, MIT Press.
D. Jana and B. Jayaraman,
Set Constructors, Finite Sets, and Logical Semantics ,
Journal of Logic Programming,
38(1):55--77, 1999.
M. Osorio, B. Jayaraman, and D.A. Plaisted,
Theory of Partial Order Programming,
Science of Computer Programming,
34(3):207--238, 1999.
M. Osorio and B. Jayaraman,
Aggregation and Negation as Failure,
New Generation Computing,
17(3):255--284, 1999.
Given a context-free grammar (CFG) and a finite set of sentence-meaning pairs, the goal is to construct a definite-clause grammar (DCG) that will compute the meanings of all sentences. It is not obvious how to do this systematically, but, thanks to the principle of compositionality and the unification procedure for typed lambda-terms, this can be done---and it was recently done by Juergen Haas, in his recent dissertation (1993). Haas built a tool that does this sort of "learning from examples". Several conceptual and practical issues remain: (a) Prove that a finite number of examples suffice and show how these examples can be constructed. (b) Show how to incorporate contextual knowledge (needed for pronouns). (c) Build a simple machine translation system that translates from one language to another by giving their respective grammars and sample sentence-meaning pairs--we started to do this for English-German, and the work needs to be continued. (d) Enhance the tool to allow other types of grammars as the starting point---joint work with Veronica Dahl, Simon Fraser University. (e) Explore the connection between DCG synthesis and program synthesis from schemas and examples.
J. Haas and B. Jayaraman, From Context Free to Definite Clause Grammars: A Type-Theoretic Approach, Journal of Logic Programming, 30(1):1-23. J. Andrews, V. Dahl, and B. Jayaraman, Logic Grammars, Compositionality, and Overgeneration, Proc. Workshop on Natural Language Understanding and Logic Programming, December 1999.
In collaboration with Prof. Raghav Rao and Raghu Santhanam, School of Management, we are interested in visual programming and graphical environments for modeling organizational (or business) processes. We support agent-centric as well as activity-centric modeling. In this framework, agents can be structured into teams or pools, and have incentives and priorities for their activities; workflows consist of activities ordered by control-flow or data-flow relationships; information specifies the datatypes of interest; and, decision rules primarily specify the operating constraints for agents and activities. Visual programming is natural in this context: while graphical user interfaces (GUIs) provide the means for specifying the details of agents, activities, etc., workflows can be thought of as executable diagrams. We permit the model components to be given modularly, and we synthesize these components to drive a simulation engine which will display the effects of various design choices. This system is being implemented in Java, and is being applied to analyze the sales organizational processes for a large equipment manufacturing firm.
T.S. Raghu, B. Jayaraman, and H.R. Rao, Agent Centric and Activity Centric Modeling of Organizational Processes, Information Systems Research, submitted. R. Santanam, H.R. Rao, B. Jayaraman, A. Chaudhury, Computational Modeling of Business Processes: A Simulation Testbed (research-in-progress), Proc. Intl. Conf. on Information Systems, (ICIS 97), Atlanta, December 1997.