Skip to main content

IBM Leadership Seminars

Seminar Navigation

IBM Programming Languages and Development Environments Seminar 2010
IBM Research - Haifa
April 14, 2010


Deconstructing Java
Gilad Bracha

Over the past fifteen years, the Java programming language has been used on a massive scale. In this talk, we conduct a critical examination of the language in light of that experience. We draw lessons for programming language design and, moving beyond mere criticism, offer constructive alternatives which inform our current work.

PHP: Lessons in Language Design and Implementation
Zeev Suraski, Zend

PHP has evolved from a hackers' project into one of the world's most popular languages, and has done so without committees, clear sets of rules – and some would argue without planning. Interestingly, every major version fixed a substantial architectural deficiency of its predecessor. In this talk, we'll review some of these architectural errors, how they were fixed, and the impact of PHP's popularity – both by those using it, but also among those developing it.



Tracing Garbage Collection on Highly Parallel Platforms
Kathy Barabash and Erez Petrank, Technion IIT

The pervasiveness of multiprocessor and multicore hardware and the rising level of available parallelism are radically changing the computing landscape. Can software deal with tomorrow’s potential higher parallelism? In this paper, we study this issue from the garbage collection perspective. In particular, we investigate the scalability of parallel heap tracing, which stands at the core of the garbage collection activity. Heap shapes can be sequential in nature, and prevent the collector from scaling the trace. We start by proposing the idealized trace utilization as a scalability measure for evaluating the scalability of a given heap shape. We then examine standard Java benchmarks and evaluate the existence of non-scalable object-graph shapes in their execution. Next, we propose and implement a prototype of garbage collection techniques that attempt to ameliorate the object-graph shape problem. Finally, we measure and report their efficacy.

Cedalion: A Language-Oriented Programming Language
David Lorenz and Boaz Rosenan, The Open University of Israel

Implementations of language-oriented programming (LOP) are typically either language workbenches, which facilitate the development of external domain-specific languages (DSLs) with projectional editors, or host languages for internal DSLs that are parsed. In this work, we present Cedalion -- a novel approach to LOP, along with a prototyped programming language and workbench implementing our approach, which uses internal DSLs in conjunction with projectional editing. To the best of our knowledge, Cedalion is the first language workbench to combine internal DSLs and projectional editing successfully.

Refactoring in Multiple Representations: Code and Statecharts

Moria Abadi and Yishai A. Feldman, Tel Aviv University and IBM Research  Haifa

The development of large systems usually involves many different languages and technologies. Refactoring tools need to be aware of these multiple representations, since information in one form may affect refactorings done in other forms. Furthermore, some refactorings need to modify code in several representations simultaneously.
This paper demonstrates the relationships that refactoring tools must recognize between code in a conventional programming language and behavior specified using statecharts. Conventional code refactorings may need to modify some of the statecharts. Statecharts may be refactored as well, and these refactorings can also affect the code. Perhaps the most interesting refactorings are those that move functionality between the code and the statechart specifications; we show how such refactorings can be used in a legacy modernization context to replace a state machine in procedural code with a statechart.

A Persistent Programming Language for the Semantic Web

Yaron Kanza and Vadim Eisenberg, Technion IIT

The impedance mismatch problem that occurs when relational data is being used by object-oriented (OO) programs, also occurs when OO programs process RDF data, on the Semantic Web. The impedance mismatch problem is caused by the differences between RDF and the data model of OO languages. In this paper, we present a solution to this problem. Essentially, we modify an OO language so that RDF resources will become first-class citizens in the language, and objects of the language will become first-class citizens in RDF. Three important benefits that follow from this modification are: (1) it becomes natural to use the language as a persistence programming language, (2) the language supports implicit integration of data from multiple data sources, and (3) SPARQL queries and inference can be applied to objects during the run of a program. We present principles of languages that support our solution, and we describe an implementation of our approach, by an extension of the Ruby programming language.

Ownership and Immutability in Generic Java (OIGJ)

Yoav Zibin, Alex Potanin, Paley Li, Mahmood Ali, and Michael Ernst, Victoria University, MIT, and Washington University

The JAVA language has no support for the important notions of ownership (an object owns its representation to prevent unwanted aliasing or modifications) and immutability (the division into mutable, immutable, and read-only data and references). Programmers are prone to design errors such as representation exposure or violation of immutability contracts. This paper presents Ownership Immutability Generic Java (OIGJ), a backward-compatible purely static language extension supporting ownership and immutability. We formally defined the OIGJ typing rules and proved them sound. We also implemented OIGJ and performed case studies of 33,000 lines of code.
OIGJ is the first type system to unify the two main variants of ownership: owner-as-dominator, which restricts aliasing, and owner-as-modifier, which restricts modifications. Thus, the programmer has the flexibility to choose whether the representation of an object cannot leak (the object dominates the representation) or whether it may be freely shared as read-only (but only the owning object can modify it).
OIGJ builds on previous work on ownership (OGJ) and immutability (IGJ), and extends them with scoped regions, existential owners, and other enhancements stemming from intricacies between ownership and immutability. For example, ownership information eases creation of immutable cyclic data-structures. OIGJ is easy for a programmer to use, and it is easy to implement (flow insensitive, using only 15 rules). Yet, OIGJ is more expressive than previous ownership languages, because it can type-check more good code. OIGJ can express the factory and visitor patterns, and OIGJ can type-check Sun’s java.util collections (excluding the clone method) without refactoring and with only a small number of annotations. Previous work required major refactoring of existing code in order to fit its ownership restrictions. Forcing refactoring of well-designed code is undesirable because it costs programmer effort, results in worse design, and hinders adoption in the mainstream community.



Fine Slicing for Advanced Method Extraction
Aharon Abadi, Ran Ettinger, and Yishai A. Feldman, IBM Research – Haifa

The potential of the Extract Method refactoring for maintaining high-quality software is well-recognized. It can be useful by itself, or as a building block in larger refactoring tasks. Because it requires a deep analysis of data and control dependences, it is difficult to perform correctly without tools in complicated cases. Unfortunately, refactoring tools do not perform the required analysis, and will fail in or reject such cases. Some very useful cases, such as those involving non-contiguous code, cannot even be expressed using these tools' interfaces.
We present a new refactoring to untangle desired computations from their surrounding code, in preparation for Extract Method. It is based on the concept of fine slicing, which is a method for computing program slices that can be tailored by the removal of some data and control dependencies. Fine slices are executable and extractable from their surrounding code. Fine slices can also be used to compute co-slices, the part of the program that should be left behind when extracting a fine slice. This is crucial to enable the reuse of the extracted slice from the original code.

Perscope Aspects: Decoupling Aspect Instantiation Interface and Implementation
Victor Trakhtenberg and David H. Lorenz, The Open University of Israel

An aspect encapsulates not only crosscutting behavior, but also a crosscutting state. There is therefore a need to define custom aspect instantiation strategies for stateful aspects. Unfortunately, aspect instantiation is a built-in feature of the aspect language. This feature cannot be customized by the application programmer. Specifically, in AspectJ there are only a set of six predefined strategies, each indicated by a special keyword: namely, issingleton, perthis, pertarget, percflow, percflowbelow, pertypewithin. In this work, we decouple aspect instantiation from the compiler implementation. The main contribution is the introduction of a new language feature and keyword ‘perscope’ that can replace all the existing six keywords, as well as future ones.

Granulated Code Generation of Interfering Functionalities
Igor Gelfgat, Shmuel Tyszberowicz, and Amiram Yehudai, Tel Aviv University and the Academic College of Tel Aviv Yaffo

The Model-Driven Software Development approach is becoming widely used as powerful model-driven tools are becoming available for the developer. Its primary goals are portability, interoperability, and reusability, through architectural separation of concerns. Yet, it is not suitable for modeling, and therefore for generating the code, for all the aspects handled in the development stage. As a result, Model-Driven Software Development is not as widely used as it could.
In this paper, we present a technique that extends the capabilities of model-driven engineering with behavioral aspects, by modeling concerns and using them in code generation. Common concerns can be defined for design patterns, software infrastructures, and other common aspects. Software architects are advised to apply those common concerns to their system models and also to create system-specific concerns and apply them at the modeling stage. We name it enriching a model with concerns. With the help of code definition for each concern, our tool automatically generates code for the enriched model. Thus, at the end of the modeling stage the developers will have all the structure of the code and all the glue code ready, so they will have only to fill the business logic in the manual implementation methods created for them. They will also maintain the enriched model and not the code they would otherwise write manually. We argue that our technique decreases the required development effort and increases the quality of the software.

Round-Trip Modeling Using OPM/PL
Mayer Goldberg and Guy Wiener, Ben-Gurion University

In this work, we present OPM/PL, a suite of modeling tools based on the Object-Process Methodology (OPM) and implemented in Prolog. OPM/PL includes tools for model authoring, querying, and visualization, as well as code parsing and code generation. OPM/PL aims at integrating the information from the source code, models, and requirements of a software project into a single database. This approach extends the role of a modeling tool to include a representation of the code and its relations to the model. The OPM/PL database contains both model elements and information from code parsing. This combined representation allows developers to flesh out a model from existing code, and update the code according changes in the model. Thus, OPM/PL provides a system for round-trip modeling.

MATCON – Method-Based Approach and Tools for CONsultants
Natalia Razinkov and Elad Fein, IBM Research – Haifa

A typical business transformation project using packaged applications, such as SAP or Oracle, comprises a complex set of activities and the creation of hundreds of deliverables. To date, there has been no integrated tool suite to manage all phases of a project and its deliverables. We present a Method-based Approach and Tools for CONsultants (MATCON), to help business consultants perform business transformation projects (e.g., based on a packaged application). MATCON produces a Jazz-based Web 2.0 tool suite (Consultant Assistant) that uses a method-driven and model-based approach to capture strategy documents, requirements, and business process documentation. MATCON allows users to adapt the method and semi-automatically create a method-based supportive environment, where the user can select relevant components of industry-specific process hierarchies, reuse documents from past engagements, collaboratively author and publish requirements in a document-based format, create use cases from requirements, and generate test cases for those use cases. These documents further are published to an asset repository for future reuse.

Management of Correctness Problems in UML Class Diagrams – Towards a Pattern-based Approach

Mira Balaban, Azzam Maraee, and Arnon Sturm, Ben-Gurion University

UML is now widely accepted as the standard modeling language for software construction. The class diagram is its core view, having well-formed semantics and providing the backbone for any modeling effort. Class diagrams are widely used for purposes such as software specification, database and ontology engineering, meta-modeling, and model transformation. The central role played by class diagrams emphasizes the need for strengthening UML modeling tools with features such as recognition of erroneous models and the detection of errors’ sources.
Correctness of UML class diagrams refers to the capability of a diagram to denote a finite but not empty reality. This is a natural, unquestionable requirement. Nevertheless, incorrect diagrams are often designed, due to the interaction of contradicting constraints and the limitations of current tools. In this research, we propose a pattern-based approach for identifying situations in which correctness problems occur, and for providing explanations and repair advices.

Ink The Blot Language
Lior Schachter, Atzmon Hen-Tov, and David H. Lorenz, The Open University of Israel

The goal of the Ink language is to provide a core virtual machine for DSL-based development. Strict separation of structure and behavior lays the foundation for declarative composition. Object graphs can be declaratively constructed and injected into the application; and the structure and state can be expressed using external DSLs.

Towards Optimal Runtime Integrity Checking of OCL
Gil Kaspi and Mira Balaban, Ben-Gurion University

Model Driven Engineering approaches aim at promoting the role of models in the process of software evolution. OCL class invariants which are imposed at the class diagram level are transformed into a run-time integrity checking mechanism. In this work, we define the completeness and being focused properties of procedures for integrity checking of class invariants. With respect to these properties, we suggest an optimal runtime integrity checking approach, and present an implementation that fulfills this approach.

Communicating Transactional State Machines – A Paradigm for Enterprise Data Processing Applications

Uri Shani and Aviad Sela, IBM Research – Haifa

We propose an application development paradigm for enterprise massive data processing applications. The paradigm first defines firstly a logical layer based on the state machine pattern, separated from the deployment of the logical entities of that layer into a physical layout of computing resources. The logical design imbeds transaction control into the state machine structure to facilitate the required reliability of the solution. Within the state machine pattern, the developer inserts actions that operate within that pattern as in a framework. Each action answers well-defined functional requirements and is aware of the transactional nature of the framework in which it operates. State machines can implement various behaviors, such as what we term "poller", "worker", "manager", "collector", "daemon", and so forth.

Leadership Seminars by year