IBM Programming Languages and Development Environments Seminar 2011
November 21, 2011
Organized by IBM Haifa Research Lab
Abstracts
Keynote: Liquid Metal: Programming in the Age of Heterogeneous Machines
David Bacon, IBM Research – Watson
The goal of the Liquid Metal project is to allow a heterogeneous system of conventional processors, GPUs, and reconfigurable hardware (FPGAs) to be programmed in a single language with transparent, dynamic execution across the aggregate computing resources — to "JIT the hardware." Achieving this goal requires significant innovation across the entire system: language design, compiler technology, hardware synthesis, the run-time system, and hardware protocols. I will give an overview of the Liquid Metal language and the tool chain we have built, present some initial results, and describe challenges for the future.
David F. Bacon is a Research Staff Member at IBM's T.J. Watson Research Center. He led the Metronome project, which pioneered hard real-time garbage collection, opening the use of high-level languages like Java for time-critical systems in financial trading, aerospace, defense, video gaming, and telecommunications.
Dr. Bacon's algorithms are included in most compilers and run-time systems for modern object-oriented languages, and his work on Thin Locks was selected as one of the most influential contributions in the 20 years of the Programming Language Design and Implementation (PLDI) conference. His recent work focuses on programming language design, game-theoretic approaches to software development, and reconfigurable hardware. He received his Ph.D. in computer science from the University of California, Berkeley and his A.B. from Columbia University. He is a member of the IBM Academy of Technology, has served on the governing boards of ACM SIGPLAN and SIGBED, and is a Fellow of the ACM.
A Review of Research in Behavioral Programming
David Harel, Assaf Marron, Smadar Szekely, Gera Weiss, Weizmann Institute of Science and Ben-Gurion University
Behavioral programming is an approach for non-intrusive incremental software development. Introduced through scenario-based programming in the language of live sequence charts (LSC), it is now implemented also in Java and in the functional programming language Erlang. Behavioral programming calls for constructing systems from threads of behavior, each of which independently represents (a part of) an allowed, desired, or forbidden operating scenario of the final system. The collective execution of behavior threads is coordinated in a way that generates a combined sequence of events, which constitutes integrated system behavior. This approach allows for natural incremental development and maintenance where new modules are aligned with new requirements and are added with little or no changes to existing code. We review behavioral programming principles, the BPJ package for behavioral programming in Java, the PlayGo IDE for the LSC language, and some of the recent research in our group including model-checker-assisted development in Java, flow visualization and comprehension, and adaptive behavioral programs.
Towards Proactive Event-Driven Computing
Yagil Engel and Opher Etzion, IBM Research – Haifa
Event driven architecture is a paradigm shift from traditional computing architectures which employ synchronous, request-response interactions. In this paper we introduce a vision and conceptual architecture for what can be considered the next phase of that evolution: proactive event-driven computing. Proactivity refers to the ability to mitigate or eliminate undesired future events, or to identify and take advantage of future opportunities, by applying prediction and automated decision making technologies. We investigate an extension of the event processing conceptual model and architecture to proactive event-driven applications, and propose the main building blocks of a novel architecture. In essence, we extend the event processing agent model to include two more type of agents: predictive agents that may derive future uncertain events based on prediction models, and proactive agents that compute the best proactive action that should be taken.
Semantic Model Differencing for Software Evolution
Shahar Maoz, Jan Oliver Ringert, Bernhard Rumpe, RWTH Aachen University
Model-driven engineering promotes the use of models throughout a software system's lifecycle. Due to iterative development methodologies, changing requirements, and bug fixes, these models continuously evolve during system's design, development, and maintenance phases. Fundamental building blocks for an analysis of their evolution are differencing operators one can use to compare two versions of a model.
Existing approaches to model differencing concentrate on heuristics matching between model elements and on finding and presenting differences at a concrete or abstract syntactic level. While showing some success, these approaches are also limited: models that are syntactically very similar may induce very different semantics (in the sense of `meaning'), and vice versa, models that semantically describe the same system may have rather different syntactic representations. Thus, a list of syntactic differences, although accurate, correct, and complete, may not be able to reveal the real implications these differences may have on the correctness and potential use of the models involved. In other words, such a list, although easy to follow, understand, and manipulate (e.g., for merging), may not be able to expose and represent the semantic differences between two versions of a model, in terms of the bugs that were fixed or the features (and new bugs...) that were added.
We present our vision and recent results on developing semantic diff operators for model comparisons: operators whose input consists of two models and whose output is a set of diff witnesses, instances of one model that are not instances of the other. Diff witnesses serve as concrete proofs for the real change between one version and another and its effect on the meaning of the models involved.
We demonstrate our vision using two concrete diff operators, CDDiff for class diagrams and ADDiff for activity diagrams. CDDiff accepts two class diagrams as input and outputs a set of diff witnesses, each of which is an object model that is an instance of the first class diagram and not of the second. ADDiff accepts two activity diagrams as input and outputs a set of diff traces, each of which is an execution trace possible in the first activity diagram and not possible in the second. CDDiff and ADDiff are presented with motivating examples, formal definitions, algorithms, prototype implementations, and initial evaluations.
Finally, we discuss advanced topics and challenges emerging from the semantic differencing vision.
Keynote: Watson Wins Jeopardy!
Dafna Sheinwald, IBM Research – Haifa
Watson is an application of advanced natural language processing, information retrieval, knowledge representation and reasoning, and machine learning technologies to the field of open domain question answering. Watson is built on IBM's DeepQA technology for hypothesis generation, massive evidence gathering, analysis, and scoring. Watson runs on a cluster of 90 IBM Power 750 servers in 10 racks with a total of 2880 POWER7 processor cores and 16 Terabytes of RAM. The POWER7 processor's massively parallel processing capability is an ideal match for Watsons IBM DeepQA software, enabling it to respond within less than 3 seconds.
As a test of its abilities, Watson competed on the renowned television quiz show Jeopardy! The competition aired in three Jeopardy! episodes dedicated to this IBM Challenge on February 14–16, 2011. The program attracted millions of viewers, at home and at numerous "watch parties" across North America. Watson competed against Ken Jennings, the record holder for the longest championship streak, and Brad Rutter, the current biggest all-time money winner on Jeopardy!. Watson passed the test and emerged victorious.
In this talk, I will tell more about the challenge, Watson's architecture and technologies, IBM Haifa's contributions to them, and anecdotes from the grand match. I will also describe some of the methodologies and software development tools employed in the project.
For more background information on Watson and the grand challenge, see clips on YouTube, such as http://www.youtube.com/watch?v=seNkjYyG3gI
Dafna Sheinwald is a member of the Information Retrieval department in IBM Research - Haifa. She earned her D.Sc. from the Technion - Israel Institute for Technology. She subsequently joined IBM and has worked at the IBM Research Lab in Haifa, and for two years, at the IBM Almaden Research Center. Dafna has worked on data compression for computer systems, and in recent years on information retrieval in the enterprise, directly contributing to several related IBM products. Dafna has taught the introductory course to information theory at the Computer Science Department of Haifa University. She has served on the program committee of the annual IEEE Data Compression Conference and the committee of the IEEE Conference on Software Science, Technology and Engineering.
Classification of Software Metrics
Yossi Gil, Maayan Goldstein, Dany Moshkovich, Technion IIT and IBM Research – Haifa
Software metrics computation and presentation are considered an important feature of many software design and development tools, such as the System Grokking technology. However, it is often difficult to choose between metrics to focus on and to present in the tools. In this paper, we describe a taxonomy of 36 metrics and propose a method for their classification based on statistical criteria. Analysis of the metric values on a large corpus of software artifacts based on the suggested criteria shows that there are only a few metrics we can recommend to include in the tools.
Code-Motion for API Migration: Fixing SQL Injection Vulnerabilities in Java
Aharon Abadi, Yishai Feldman, Mati Shomrat, IBM Research – Haifa and Tel Aviv University
Refactoring often requires the reordering of code fragments; such is the case when migrating from one API to another. Performing such reordering manually is complex and error-prone. A specific example in the security domain involves database query execution, in which some of the parameters come from untrusted sources. In Java, the Statement API provides opportunities for SQL injection attacks. The recommended remedy is to replace it with the secure Prepared Statement API; however, that sometimes requires changing the order in which the query is built. We present an algorithm that performs this migration, moving code as necessary to preserve functionality while changing the structure
of the original code as little as possible.
Model Correctness Patterns as an Educational Instrument: An Experience Report
Azzam Maraee, Mira Balaban, and Arnon Sturm, Ben-Gurion University
Models are the backbone of the emerging Model Driven Engineering (MDE) approach, whose major theme is development of software via repeated model transformations. The quality of models used in such a process affects not only the final result, but also the development process itself. In order to achieve high quality, it is important to have educated modelers, who are sensitive to model quality. This work describes an actual experiment of using an anti-patterns modeling catalog for correctness and quality problems in class diagram design for teaching modeling. The work also discusses the catalog's role as an educational instrument, for improving class diagram modeling.
An Overview of PathLP: A Logic Programming Language of Path Expressions
Igal Khitron, Michael Kifer, and Mira Balaban, Ben Gurion University and Stony Brook University
PathLP is a logic programming language of guarded path expressions. It is inspired by F-logic and developed to support model-driven software development. Its path expressions can include internal guards whose components can be typed. PathLP supports facts, rules, constraints, and queries. It is implemented within the XSB tabling Prolog engine.
PathLP is an underlying language for the F-OML object modeling language, which can be used for extending UML diagrams, reasoning about them, defining design patterns, testing UML models, specifying Domain Specific Modeling Languages, and meta-modeling. This wide range of F-OML applications stems from several features inherent in the PathLP language, such as polymorphism, multi-level modeling, and model instantiation.
PathLP is also useful for many other purposes, especially graph processing.
In this short overview we informally describe the main constructs of PathLP and provide an example for F-OML support. Formal definitions and additional details are found in the full paper.
Pragmatic Modeling with Object-Process Programming
Arieh Bibliowicz and Dov Dori, Technion – Israel Institute of Technology
The Model-driven Engineering initiative gives many promises but it lacking a full round-trip engineering environment where it can be applied. We propose a new visual programming language called the Object-Process Programming language where MDE can be applied in a pragmatic way, drawing models when they are more useful than code, and writing code when it is more useful than modeling.
Adding Quantitative Aspects to a Conceptual Model: Simulink as an OPM Computational Subcontractor
Aharon Renick and Dov Dori, Technion – Israel Institute of Technology
In systems engineering, an important stage of designing a complex system is modeling it. Similarly, when aiming to research and understand existing systems, it is common to do so by modeling the system under study. Quantitative aspects of complex systems may be difficult to model, making it harder for users to deeply understand their intricate behavior. We offer to address the quantitative aspects of a conceptual model by representing complex quantitative behavior using Simulink as part of an Object Process Methodology (OPM) model. This allows for a sufficiently rich representation of the system's dynamics while keeping the holism and simplicity of the modeling methodology. As a running example, we present an OPM model of a Climate Control system and the use of Simulink as a "computational subcontractor".
A Review of Research in Behavioral Programming
David Harel, Assaf Marron, Smadar Szekely, and Gera Weiss, Weizmann Institute of Science and Ben-Gurion University
Behavioral programming is an approach for non-intrusive incremental software development. Introduced through scenario-based programming in the language of live sequence charts (LSC), it is now implemented also in Java and in the functional programming language Erlang. Behavioral programming calls for constructing systems from threads of behavior, each of which independently represents (a part of) an allowed, desired, or forbidden operating scenario of the final system. The collective execution of behavior threads is coordinated in a way that generates a combined sequence of events, which constitutes integrated system behavior. This approach allows for natural incremental development and maintenance.
where new modules are aligned with new requirements and are added with little or no changes to existing code. We review behavioral programming principles, the BPJ package for behavioral programming in Java, the PlayGo IDE for the LSC language, and some of the recent research in our group including model-checker-assisted development in Java, flow visualization and comprehension, and adaptive behavioral programs.
Code-Motion for API Migration:Fixing SQL Injection Vulnerabilities in Java
Aharon Abadi, Yishai Feldman, and Mati Shomrat, IBM Research – Haifa and Tel Aviv University
Refactoring often requires the reordering of code fragments; such is the case when migrating from one API to another. Performing such reordering manually is complex and errorprone. A specic example in the security domain involves database query execution, in which some of the parameters come from untrusted sources. In Java, the Statement API provides opportunities for SQL injection attacks. The recommended remedy is to replace it with the secure Prepared Statement API; however, that sometimes requires changing the order in which the query is built. We present an algorithm that performs this migration, moving code as necessary to preserve functionality while changing the structure of the original code as little as possible.
Show-and-Tell Play-In: Combining Natural Language with User Interaction for Specifying Behavior
Michal Gordon and David Harel, Weizmann Institute of Science
In search of improving the ways to create meaningful systems from requirements specifications, this paper combines the showing and telling of how a system should behave. Using scenario-based programming and the language of ive sequence charts, we suggest how user interaction with the system and user written requirements in natural language can interleave to create specifications through an interface that is both natural and agile.
BMOCK - C++ Mocking Framework
Leonid Frenkel
The BMOCK library is a C++ library supporting Mock Objects. It is tightly integrated with the Boost.Test unit testing library. C++ does not support reflection (unlike Java and C#), which challenged the creation of an extensive mocking framework. Despite the challenge, some frameworks such as Mockpp, Google Mock and MockItNow were made. The BMOCK library is quite different from other C++ libraries primarily because BMOCK does not enforce the developer to work within a pure Object-Oriented paradigm, which makes it suitable for C code as well as C++. BMOCK was developed using the link-time resolution approach: if a mock version of some function is needed then it is supplied at link time. Another major advantage is the minimum code intervention: to mock a function one needs to insert only one line of macro at the beginning of a function. The same function can be used for the production code simply by turning off a preprocessor flag.
For example:
int foo(int x)
{
MOCK(1, (IN(x)); //line of macro to be added to a functions
//actual function code
}
BMOCK's gives a lot of flexibility for the developer. For each test or group of tests the developer can decide which functions should be mocked and which should use their actual code. This is accomplished by a simple command, for example: BMOCK_CREATE_FUNCTION_MOCK(Numbers::*) will use all the functions under the Numbers namespace as mocks.
Make Your Build System DRY
Yossi Zach, NDS
Build systems are too often neglected in our software projects. We apply all kinds of good practices in order to keep our source code lean and mean, but what about the poor build scripts? They are subjected to monkey patching and disorder. The results of this situation are plainly visible in the later stages of the project, when build scripts grow and multiply wildly. However it gets worse: the collection of build scripts often starts to fall apart. And by this time in the project, we don't have the resources to rewrite it. In this demo I will suggest a new architecture for a C/C++ build system that is aimed to handle complex build scenarios and yet keep the build scripts DRY (Don't Repeat Yourself) and maintainable.
Tool Support for Enforcing Security Policies on Databases
Jenny Abramov, Clint Feher, Peretz Shoval, and Arnon Sturm, Ben-Gurion University
Data is the most valuable asset for an organization as its survival depends on the correct management, security, and confidentiality of the data. In order to protect the data, organizations must secure the data processing, transmission and storage. However, security aspects are not always considered during the development process of information systems, in particular not in the early stages of the process.
We developed a methodology that guides database application developers in weaving securing concerns (in particular, access control) into the entire development lifecycle. The methodology incorporates ideas from two areas of expertise: in the area of methodologies for system development, we adopt the principle of integrating data and functional modeling at the early stages of the development, following the Functional Object-Oriented Methodology (FOOM). In the area of domain engineering, we adopt the principles suggested by the Application Based Domain Modeling (ADOM) approach. ADOM supports building reusable assets on the one hand and representing and managing knowledge in specific domains on the other hand. This knowledge guides the development of various applications in that domain and serves as a verification template for their correctness and completeness.
The developed methodology is supported by a software tool entitled Security Modeling Tool (SMT), which enables the modeling of security patterns and enforces their correct use during application development. The knowledge captured in the security patterns is used to automatically verify that the application models that consider security aspects are indeed secured according to the defined patterns. Having a verified model, secure database schemata can be automatically generated.
