Events/Connecting Computer Science to Domains: Trivandrum 17-18 December, 2007/Abstracts of talks
From IIITM-k-wiki
Policies and their Analysis: Kathi Fisler, Worcester Polytechnic University
Abstract
Access-control policies play a central role in controlling the dissemination of sensitive data in domains ranging from healthcare to library services. They represent an important but not isolated example of policies or rules that govern the behavior of programs. Developers increasingly separate these policies from the rest of their programs into separate modules written in domain-specific, declarative policy languages.
The subtle nature of these policies suggests this is a natural domain to apply formal methods, while the separation of the policy from the rest of the program affords interesting opportunities. It is, however, unclear that the straightforward application of verification is appropriate or useful. We will discuss these issues, as well as concrete tools and results we've produced and lessons we've learned.
Joint work with Dan Dougherty (WPI) and Shriram Krishnamurthi (Brown).
TeachScheme!: Lessons From Our First Decade: Shriram Krishnamurthi, Brown University and Kathi Fisler, WPI
Abstract
In just over a decade, the TeachScheme! Project has trained over 550 high school teachers and college professors in our novel computing curriculum. In the process we have learned numerous lessons about the structure of languages, programming environments, design methodologies, and curricula. We will discuss some of these lessons.
A Programming Language for the New Web: Shriram Krishnamurthi, Brown University
Abstract
Explicitly or implicitly, programming languages mirror domains. The best languages weave the concerns of a domain through a compatible computational model to offer programmers the best of both worlds. This statement naturally raises the question: What is the appropriate programming language for Web applications in the Ajax style?
Our answer, Flapjax, is layered atop JavaScript. Flapjax demonstrates that the Web has a natural abstraction: event-driven reactivity. After explaining this we will build on it to examine connections to Web services, data binding, and access-control security. I will also cover some highlights of our work in this area on implementation techniques, principles for interfacing to legacy components, program transformations to improve performance, applications, and more.
http://www.flapjax-lang.org/
Speaker Bio
Shriram Krishnamurthi is an Associate Professor of Computer Science at Brown University. His research draws from programming languages, software engineering, computer-aided verification, and security. His recent work focuses on language support for interactive software, and on analyses for security policies. He is a co-author of the DrScheme programming environment, the FASTLINK genetic linkage analysis package, the Continue conference paper server, the Margrave access control policy analysis package, the Flapjax programming language, and the book "How to Design Programs" (MIT Press, 2001). He has more recently written the text "Programming Languages: Application and Interpretation". He also coordinates the decade-old and highly successful TeachScheme! high school computer science outreach program.
Models and Languages for Testing: Padmanabhan Krishnan, Bond University
Abstract
In this presentation I will show how different models and programming languages can help in automating the software testing process. I will focus on testing security properties of web based systems. The key message will be that the benefits of using models including documenting what is being tested and deriving tests automatically from the models. I will also show that to automate the entire testing process one needs to use a variety of languages such as Prolog, OCL and Ruby.
Activity Based Introduction to the Science of Computation: Padmanabhan Krishnan, Bond University
Abstract
In this presentation I will briefly outline an activity based approach based on the Computer Science Unplugged project. This approach aims to introduce Computer Science to primary and secondary school children. The emphasis is on principles of computation and not on ``tinkering with cool devices.
Speaker bio
Paddy Krishnan is a Professor of Computer Science and Head of Department at the School of Information Technology, Bond University. He is also the Director of the Centre for Software Assurance and an Associate Research Fellow at the International Institute for Software Technology, United Nations University. He got his BTech from IIT-Kanpur and MS and PhD from the University of Michigan, Ann Arbor. He has held positions in the US, Denmark, Germany and New Zealand. His research interests are in the area of software engineering with a focus on formal methods. He has also consulted in the areas of rigorous testing, risk estimation and eHealth.
The ABC of next generation networks (Naming, forwarding and routing reconsidered): Sanjiva Prasad, IIT Delhi
Abstract
The de facto service architecture of current communication networks is heterogeneous, complex, ad hoc and not very well understood, which is in sharp contrast to the textbook presentations of network architectures. This prevailing situation provides an opportunity to revisit that architectural model and its invariants of communication networks, and to undertake a formal examination of its basic principles. Concentrating on the issues of naming, forwarding and routing, we provide an axiomatic basis for these fundamental concepts, which can then be used for formal analyses as well as for deriving working prototype implementations. What emerges is a new model of computation/communication, based on the notion of abstract switching elements that rewrite and forward messages. We present a "Universal Forwarding Engine", which is expressed in a simple imperative programming model. The algebraic foundations facilitate the development of an axiomatic basis for communication (ABC) presented as an extension of Hoare Logic.
Speaker Bio
Sanjiva Prasad is a Professor of Computer Science at the Indian Institute of Technology Delhi, and also in the Amar Nath and Shashi Khosla School of IT. He received his B Tech in Computer Science from IIT Kanpur in 1985 and his MS and PhD in Computer Science from SUNY, Stony Brook, USA in 1990 and 1991. His thesis, ``Towards a symmetric integration of concurrent and functional programming includes some of the early research in the design and semantics of higher-order concurrent programming languages with mobile code. He worked in the area of program verification at Odyssey Research Associates in Ithaca, USA from 1990-1992, and then at the European Computer-Industry Research Center (ECRC GmbH) in Munich, Germany from 1992-1994, where he worked on the Facile project based on his thesis work. From 1994 he has been at IIT Delhi, first as an assistant professor and then as an associate professor. In 1998-99, he was a visiting associate professor at BRICS, University of Aarhus, Denmark.
His research interests are primarily in formal methods and programming languages -- in particular, semantics of concurrency, distributed and mobile computation, and verification of network protocols and architectures. Process algebraic approaches to systems biology are a recent interest. He has written several conference and journal papers, and has been an invited speaker at the first DART workshop at Aalborg, Denmark in 1993 and at the first HLCL workshop at the Newton Institute, Cambridge, UK in 1995.
He is a member of the Indian Association for Research in Computer Science and the European Association for Theoretical Computer Science. He has also served on several international conference programme committees (FST TCS, POPL, Fossacs, ASIAN, SEFM, etc.), and as the programme co-chair of FST TCS 2000 and FST TCS 2007.
Towards Declarative and Visual Runtime Debugging Environments: Bharat Jayaraman, University at Buffalo
Abstract
We propose two novel paradigms for debugging object oriented programs: declarative debugging and visual debugging.
Traditional debugging is a procedural process 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. Examples of execution-time queries include: finding all values assigned to a variable over its life-time; finding when an invariant was first violated; finding why a certain statement was executed; 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.
In the area of visual debugging, we depict the current state as an enhanced object diagram showing object and method activations, and we depict the run-time state as a time sequence diagram. We also 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. While such diagrams are used at design time, we construct them automatically at run-time, in an attemp to "close the loop" between design and execution. Thus queries about run-time can be formulated either using the source code, object diagram, or sequence diagram; and answers can be shown by highlighting and annotating such diagrams.
This methodology has been incorporated in an experimental system, called JIVE, which is being developed as an Eclipse Plug-in at Buffalo. JIVE also supports interactive forward as well as reverse stepping over a program. Taken together, this approach to declarative debugging, execution visualization, and interactive forward and reverse stepping is a significant contribution to the art of program debugging. Declarative and procedural debugging are useful for a practical debugger, just as web-searching and web-browsing are both necessary in retrieving information from the web. The talk will also provide a demonstration of the JIVE system.
Constrained Objects for Modeling Complex Systems: Bharat Jayaraman, University at Buffalo
Abstract
Abstract
We present a novel programming language and modeling environment, based on the concept of constrained objects, for compositional and declarative modeling of engineering structures. A constrained object is one 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 resultant behavior of the complex object is obtained by a process of logical inference and constraint satisfaction. Thus, constrained objects are a declarative counterpart of traditional objects (found in object-oriented languages). Our modeling paradigm supports constraints, including quantified and conditional constraints, as well as preferences. We show via several examples that, for many modeling domains, the paradigm of constrained objects is superior to both a pure object-oriented language as well as a pure constraint language. The current prototype includes tools for authoring the constrained-object class definitions using a modeling tool called CUML (Constraint-based UML); a compiler that translates a CUML specification into an executable CLP(R) program; and domain-specific visual interfaces for specific applications. We show that such tools can be used for pedagogic purposes as well as for more advanced modeling applications.
Speaker Bio
Dr. Bharat Jayaraman is Professor and Chair of the CSE Department. He joined the University at Buffalo in 1989 and has been serving as Department Chair since 2002. Dr. Jayaraman received his bachelors and masters degrees from the Indian Institute of Technology, Madras, and his doctorate in Computer Science from the University of Utah in 1981. Prior to joining UB, he was on the faculty at the University of North Carolina at Chapel Hill. His research interests are broadly in the area of Programming Languages and Environments. His current research centers around high-level, declarative, and visual modeling of complex systems, as well as interactive program visualization.
Dr. Jayaraman has published over 75 refereed scientific articles, and he has served in a leadership role for major workshops and conferences in programming languages. He is a Permanent Member of the Editorial Board of the Journal of Functional and Logic Programming. He has given numerous invited and keynote talks at international conferences and workshops, and his research has been funded by the IBM Foundation, Xerox Foundation, National Science Foundation, Office of Naval Research, and National Imagery and Mapping Agency.
