Skip to main content
    Israel [change]    Terms of use
    Home    Products    Services & solutions    Support & downloads    My account    
IBM Research

Programming Languages & Development Environments Seminar 2005

IBM Haifa Labs

Invitation Program Demonstrations Registration Abstracts

November 30, 2005
Organized by IBM Research Lab in Haifa, Israel

Keynote: Model-driven and Service-oriented Development using Eclipse, J2EE, and Web Services

Kyle Brown, Senior Technical Staff Member, IBM Software Services for WebSphere

The use of models for automating the design and development of enterprise applications is well-established, especially in large enterprises that have standardized on J2EE™. The Eclipse Project has aggressively embraced modeling, middleware (primarily J2EE), and metadata frameworks to enable the development of tools and applications based on industry modeling standards. Now being used by vendors as diverse as Borland, SAP, IBM, Intel, and Unisys, these tools now cover the range of practitioner roles ranging from business analyst, software architect, data architect, developer, tester, deployer and project manager. Eclipse enables collaboration across these roles. The OMG MDA initiative is leading the charge in defining a set of open standards anchored in UML, UML testing profile, MOF, and XML to enable the design, development, testing, and deployment of applications for the enterprise.

This talk will describe how key projects at anchor an open application lifecycle management platform. We will also show how these technologies are being pragmatically used by IBM and members of the Eclipse consortium to build an integrated software development platform that closes the gap that exists between business analysts, IT architects, J2EE developers, testers, and system administrators. The role of EMF models, UML profiles, MOF metamodels, and domain-specific languages/metamodels used for representing and sharing information across a range of technical and business stakeholders will be discussed. How the corresponding reusable software assets can be created, distributed, and managed will also be examined.

Speaker Bio
Kyle Brown is a Senior Technical Staff Member with IBM Software Services for WebSphere. Kyle has provided consulting services, education, and mentoring on SOA and J2EE technologies to many of IBM's largest clients. He is an author or co-author of seven books, including Enterprise Java Programming with IBM WebSphere, the WebSphere AEs 4.0 Workbook for Enterprise Java Beans, 3rd Edition, Java Testing Patterns, Enterprise Integration Patterns, and The Design Patterns Smalltalk Companion. He is also the author of over 40 articles and a frequent conference speaker on topics in SOA, J2EE, Patterns and Object-Oriented Design.

Keynote: HyperFlow: An Integrated Visual Query and Dataflow Language for End-user Information Analysis

Ron Pinter, Technion - Israel Institute of Technology

This talk presents HyperFlow, a novel visual language for information analysis that combines features from visual dataflow and visual query languages into a unified framework based on views. HyperFlow is designed to make it easier for users to retrieve, filter, and manipulate information, using databases alongside Web services, for example, in a transparent, intuitive, reproducible, and traceable manner. HyperFlow features strong expressive power and allows users to visually design and execute information analysis processes in an effective manner. This talk presents HyperFlow's design and constructs, describes its development environment, and demonstrates its application to the domain of bioinformatics.

This is joint work with Dolev Dotan.

This research was supported in part by an IBM Faculty Award.

Speaker Bio
Ron Y. Pinter is an Associate Professor of Computer Science at the Technion - Israel Institute of Technology. Before joining the Technion in 2001, he was the Vice President for Research and Development at Compugen Ltd., and previously the Program Manager for Computer Science at the IBM Research Lab in Haifa, Israel and a member of the IBM Academy of Technology. His research interests include bioinformatics, data integration, high performance computing, and programming languages design and implementation. Dr. Pinter has published extensively in technical journals, and presented his work at international conferences. He also holds several patents. He has organized and chaired conferences in the areas of bioinformatics, software systems, and programming languages, and served on many programming committees of such events. He is a founding council member of the Israeli Society for Bioinformatics and Computational Biology and a co-principal investigator of the National Knowledge Center for Bioinformatics Infrastructure in Israel.

Compile-time Verification of Properties of Heap Intensive Programs

Mooly Sagiv, Tel Aviv University, Israel

Existing programs contain runtime errors such as buffer overruns, dangling dereferences, and memory leaks. These errors cause unpredictable behavior and system crashes and are exploited by hackers to break existing systems.

This work is part of an attempt to catch these runtime errors at compile-time. The methods used are sound (conservative), i.e., whenever the compiler issues no warnings, it is guaranteed that no runtime error will ever occur. However, these methods can issue "false alarms", i.e., warnings against potential runtime errors that can never occur. This is in line with the undecidability of checking these properties.

In this work, methods are developed for summarizing dynamically allocated storage and pointers by tracking only the "shape" of the heap. These summarizations are used for proving the absence of runtime errors.

These methods can automatically prove properties ranging from the absence of null dereference and memory leaks to partial and total correctness. The algorithms were implemented and applied to C and Java programs. They have very few false alarms, but are rather expensive. This talk will also sketch several methods that may be used to scale this method to larger programs.

This is a joint work with Thomas Reps from the University of Wisconsin and Reinhard Wilhelm from the Saarland University:

Business Processes: Connecting the Design-time to the Run-time

Joshua Fox, Director and Principal Software Architect, Mercury Interactive

In Model-driven Architecture (MDA), UML static models, integrated with dynamic business process models, are automatically translated into software code for behavior, messaging, and persistence.

This creates consistency between the codebase or metadata and the business models, but it does not connect the runtime behavior with the models. However, IT managers monitoring their system need to be able to relate anomalous behavior to the metadata and dynamic models that underlie the system. For example, if they notice that their equity-pricing software is producing a list of suspiciously low-priced sales, they might suspect a security failure. However, when they can trace this behavior to business logic that offers discounts to favored customers, their suspicions will be allayed.

This talk will propose a solution to the problem, showing how code annotations, supplemented with external XML mapping files, can link the runtime to the model. Thus, an application-monitoring tool that tracks anomalous behavior, software bugs, or performance bottlenecks can instantly and precisely show not only the lines of code, but even the business-process-model elements that describe the motivation for the code in question.

In this way, IT is connected to the business-the runtime transparently shows its connection to the business processes.

Safety Checks and Semantic Understanding via Program Analysis Techniques

Nurit Dor, Inbal Ronen, and Sara Porat, IBM Haifa Research Lab

Checking that a program is safe, e.g., does not terminate abnormally, or understating the semantic meaning of a program, e.g., which table the program is updating, is a non-trivial task. Furthermore, one needs to formally define such safety checks and semantic meanings. This talk presents a "pattern-language" that enables the definition of safety checks or semantic understanding by expressing method invocations and dependencies between them. In addition, values of interest that need to be resolved for a complete picture of the semantic meaning can be defined.

This talk presents a combination of techniques that enables this type of program mining. The key techniques used are static code analysis enhanced with dynamic analysis where needed. We will demonstrate how the same core techniques are used for two different purposes, safety checks, and semantic understanding. The techniques are implemented and used by the IBM CARDS and SAFE projects. Empirical results of the projects and their advantage over previous work in this domain are shown.

JTL - The Java Tools Language

Tal Cohen, Joseph (Yossi) Gil, and Itay Maman, Technion - Israel Institute of Technology

JTL (the Java Tools Language, pronounced "Gee-tel'') is a universal and high-level query language for selecting program elements. It is designed to serve the development of source code software tools for Java and for programming language extensions.

Applications include definition of joinpoints for aspect-oriented programming, fixing type constraints for generic programming, specification of encapsulation policies, definition of micro-patterns, etc. It is argued that the JTL expression of each of these is more systematic, more concise, and more general, for several reasons.

First, JTL relies on a simply-typed relational database for program representation, rather than an abstract syntax tree. The underlying semantics of the language are queries formulated in first order predicate logic augmented with transitive closure, known as FOPL*.

Second, special effort was taken to ensure terse, yet very readable expression of logical conditions. The JTL pattern "public abstract class", for example, matches all abstract classes that are publicly accessible, while "class { public clone(); }" matches all classes in which the method clone() is public. To this end, JTL relies on a Prolog-like syntax and semantics, enriched with quantifiers and pattern matching that all but entirely eliminate the need for recursive calls.

Third, the sound mathematical model of FOPL*, and the restriction of the evaluation engine to bottom-up computation make it possible to easily derive termination and determinism claims, and employ text-book characterization of queries' equivalence, emptiness, and inference questions.

Rhapsody: A Pragmatic Approach to Model-driven Development

Eran Gery, VP Development, I-Logix Israel

Despite its promise, model-driven development is practiced by a small fraction of software developers.

This talk identifies several key inhibiting factors that prevent model-based approaches from being adopted as a mainstream practice. It then discusses the implementation of this approach in Rhapsody, a UML-based software development platform, designed to support a complete model-based iterative life-cycle.

The talk describes what are referred to as "key principles" for effective model-driven development, including model-code associativity, automated fully functional implementation generation, implementation framework, model-based debugging, and model-based testing.

We will discuss why each of the above principles is instrumental to an effective development of production systems, based on a key observation that the modeling language does not replace the implementation platform, but should be integrated with it in a synergistic manner. This allows the use of modeling for expressing requirements and design abstractions, along with the use of the full power of an implementation language and its supporting platform to specify implementation details. While allowing this flexibility, Rhapsody facilitates full consistency of the modeling and implementation artifacts throughout the life-cycle, and also supports a high level of automation in the implementation and validation of the developed system.

The COMPASS Assessment and Migration Framework

Avi Yaeli, Netta Aizenbud, Jonathan Bnayahu, Nurit Dor, and Sara Porat, IBM Haifa Research Lab

The COMPASS (Code Migration Planning and Assessment Workbench) framework was developed in the IBM Haifa Research Lab to provide a common infrastructure for analysis and assessment tools. These tools can assist service practitioners in reverse-engineering enterprise-scale applications, helping practitioners to understand application inventory, structure, and the relationships between components. The framework helps to identify potential obstacles and migration issues using a domain knowledge base, accumulated from field experience.

From years of experience in building analysis engines, it became clear that a major part of the information gathered about applications is independent of the domain itself. Each domain and language has, however, some characteristics that are unique to it. In light of this, the framework was designed to provide generic support for program analysis and to be extensible to specific domains.

Part of the framework is a data model for capturing analysis results, which persist in a relational database. Similarly to the framework, the data model consists of a generic, domain-independent layer, and possible domain-specific extensions.

This talk presents Compass/VB, a tool built on top of the COMPASS framework to assist specifically in Visual Basic applications modernization scenarios, and demonstrates how it can be used in legacy modernization engagements.


Related Seminar Links
Visitors information  

    About IBMPrivacyContact