IBM Israel
Skip to main content
 
Search IBM Research
   Home  |  Products & services  |  Support & downloads  |  My account
Select a Country Select a country
IBM Research Home IBM Research Home
IBM Haifa Labs Homepage IBM Haifa Labs Home
IBM Haifa Labs Homepage IBM Haifa Labs Leadership Seminars

Programming Languages and Development Environments Seminar 2004

Invitation
Program
Abstracts
Pictures
Registration
Visitors information
Feedback


Abstracts
Keynote: Two Techniques for Software Engineering: Reactive Animation and Smart Play-Out (Abstract)
David Harel, Weizmann Institute of Science

The talk will revolve around two new ideas we have been working on as part of an ongoing effort to supply methods and tools for engineering large and complex reactive systems:
  1. Reactive Animation: A method to enrich models of reactive systems with an animated, interactive and intuitive front-end. The method harnesses and combines the available strength of state-of-the-art tools and languages for reactive system design and tools for animation.
  2. Smart Play-Out: A particularly unusual aspect of our play-in/out approach to scenario-based programming and specification, whereby a "smart" play-out mode is employed for program execution. How to proceed is pre-computed using model-checking. Thus, we employ formal verification techniques to help run programs, rather than to prove them correct.
While both methods appear to be very broadly applicable, we shall demonstrate them in the context of modeling biological systems.


Aspects and their Potential Harm (Abstract)
Shmuel Katz, The Technion

Aspect-Oriented Programming (AOP) can add needed functionality to a system by augmenting or changing the existing code in a manner that cross-cuts the usual class or process hierarchy. However, sometimes aspects can invalidate some of the already existing desirable properties of the system. This talk reviews the AOP paradigm and shows the design and implemented elements of an analysis tool to automatically identify such potentially harmful situations. The use of regression testing for aspects is considered, and regression verification is recommended instead, using a combination of static analysis, deductive proofs, and aspect validation based on software model checking.


AspectJ2EE = AspectJ + J2EE (Abstract)
Yossi Gil and Tal Cohen, The Technion

Enterprise applications make the world go around: Banks, government organizations, large corporations and even universities depend on these in every aspect of their operations. Yet, despite their tremendous importance, such applications are sometimes ignored by mainstream computer science research---perhaps because the business logic of such applications is simple, often even trivial: add a number here, subtract a number there is all that is required to implement a money transfer. The challenge is in an implementation which obeys strict security, performance, monitoring and other highly demanding "contextual" requirements.

In this talk, we describe a new programming language which marries the emerging "Aspect Oriented" programming paradigm (AOP), with Java 2 Enterpise Edition (J2EE), the leading modern platform for implementing enterprise applications. In doing so, we also offer a new perspective on AOP, showing that it can be embedded within the traditional, object oriented programming model.


A Model for Evaluating the Cost-Effectiveness of Software Reuse Alternatives (Abstract)
Amir Tomer, Rafael Ltd, Leah Goldin, Golden Solutions, Tsvi Kuflik, ILTAM, Esther Kimchi, Tadiran Electronics Systems Ltd., and Stephen R. Schach, Vanderbilt University

We propose a model that enables software developers to systematically evaluate and compare all possible alternative reuse scenarios. The model supports the clear identification of the basic operations involved, and associates a cost component with each basic operation in a focused and precise way. The model is a practical tool that assists developers to weigh and evaluate different reuse scenarios, based on accumulated organizational data, and then to decide which option to select in a given situation. The model has been used at six different companies for cost-benefit analysis of alternative reuse scenarios; a case study illustrates its use in practice.


Manage the Application Chaos: Impact Analysis for Cross Domain Enterprise Applications (Abstract)
Iftach Ragoler, Sara Porat, Avi Yaeli, Sharif Mograbi, Shiri Dori, Guy Rosman, IBM Haifa Research Lab

Modern enterprise applications are very complex. They may contain modern technologies such as Java/J2EE, C/CPP, combined with legacy applications such as COBOL and CICS and use middlewares such as Databases and Message Queues. The applications may reside in heterogenous platforms such as Windows, Linux and z/OS and coordinate between its parts in various ways for example by using a shared database or message queue and by standard protocols.

WebSphere Studio Asset Analyzer (WSAA) is an Impact Analysis and program understanding tool that helps in reasoning on the complexity of applications by scanning the enterprise Source Configuration Management system and even scanning the runtime environment (e.g, scanning a WebSphere Application Server environment). WSAA then analyzes the enterprise code using language specific analyzers and visualizes the structure of the found applications along with possible impact resulted from a certain change. A challenging issue in impact analysis is the ability to handle cross domain impact analysis, in which for example a change in modern code may affect parts of the legacy code and vice versa.

In this talk we describe the impact analysis performed in WSAA, including its extension to cross domain impact analysis. For the purpose of cross domain impact analysis we define a pattern detector language allowing the user to specify the interaction between modern and legacy code. Our analysis is guided by the user-specified patterns; in particular we aim at detecting violations of user-specified patterns.


Keynote: MDA: Concepts and Practice (Abstract)
Alan Brown, Manager, MDD Product Strategy, Rational Software, IBM Software Group

Model Driven Architecture (MDA) is an approach to application modeling and generation that has received a lot of attention in recent months. Championed by the Object Management Group (OMG), many organizations are now looking at the ideas of MDA as a way to organize and manage their application solutions, tool vendors are explicitly referring to their capabilities in terms of “MDA compliance”, and the MDA lexicon of platform-specific and platform-independent models is now widely referenced in the industry.

In spite of this interest and market support, there is little clear guidance on what MDA means, where we are in its evolution, what is possible with today’s technology, and how to take advantage of it in practice. This presentation addresses that need by providing an analysis of how modeling is used in industry today, the relevance of MDA to today’s systems, a classification of MDA tooling support, and examples of its use in the context of IBM Rational's products and technologies.


Data Access Fusion (DAF) design pattern for object oriented information system applications (Abstract)
Eitan Hadar, Netanya Academic College

The implementation of design patterns in Object Oriented (OO) applications is a well known mean for aiding the design process in several perspectives such as: using the best practice solutions; achieving higher understanding of existing code; refactoring legacy systems, and more. Complex design usually involves the combination of several patterns in a single design environment, targeted for a reusable solution. Specifically, in OO Information Systems (IS), patterns are usually implemented for the modification and retrieval of data, such as from a relational database using SQL queries.

This paper presents the Data Access Fusion (DAF) pattern that expands and strengthens the advantages of individual data access patterns, as presented by Fowler [9] and Nock [16], while weakening their relative disadvantages. These merits are adapted to SQL IS implementations, fused and enhanced, thus providing more than the pure summation of several Data Access Patterns. The core of DAF is the modified Data Accessor Pattern, and a centralized SQL query repository. The most significant contribution that the DAF engine provides, is the infrastructure construction for flexible IS applications that can be highly adaptable both to incremental data structure modifications as well as requirements changes.

Feasibility tests of the DAF pattern were performed on 10 IS software projects implementing SQL on a relational database with an evident successful assimilation. The number of classes and methods was significantly reduced, while the team development time was shortened. This paper elaborates the DAF's static and dynamic structure while detailing its elements contributions.


Automatic Discovery of Software Contracts (Abstract)
Yishai Feldman and Leon Gendler, The Interdisciplinary Center, Herzliya

Design by contract is a powerful methodology for producing quality software. By writing class invariants and method pre- and postconditions, programmers elucidate their assumptions about the behavior of their programs and make sure that there are no misconceptions about the semantics of classes or methods. A tool that instruments the contract assertions makes debugging more effective by providing early discovery of errors.

However, writing the contract is a burden that programmers, being optimistic about their code, tend to avoid. We are developing a tool that analyzes existing Java code and produces a draft contract. Parts of the contract express deep semantic knowledge, and these will still have to be supplied by the programmer. However, there are many assertions that can be discovered automatically, such as those dealing with allowed ranges for parameters, whether null values are allowed, etc. This will also be useful for reengineering of existing code that was written without contracts, and can also be used for maintenance of the contract as the code is modified.

We discover method preconditions by percolating preconditions of computations in the method body backwards. These can be simplified using postconditions of other computations. We start with a library of the pre- and postcdonditions of primitive operations; as we discover contracts for new methods, we use those to elaborate the contracts of methods that use them, and so on. We use several heuristics for extracting information from common types of loops.

Postconditions can be discovered using a similar process. The discovery of class invariants requires finding common patterns in pre-and postconditions, but this hasn't been done yet.


From Text to Business System Models with OPM: SMART Model Acquisition from Requirements Text (Abstract)
Dov Dori, Nahum Korda, Avi Soffer, and Shalom Cohen, The Technion

We describe an elaborate experiment to prove that a system model can be acquired through an automated process whose input is a set of technical free text requirement documents and whose output is an OPM model, expressed both graphically, through a set of Object-Process Diagrams, and textually in equivalent Object-Process Language. Both the SMART (System Model Acquisition of Requirements from Text) system architecture and the sample experimental system GRACE are specified using OPM. Our experiment has yielded a high quality system model that required a much smaller effort than what would have been needed in the traditional approach.






























  About IBM  |  Privacy  |  Terms of use  |  Contact