Danny Soroker

Tolerating faults in hypercubes using subcube partitioning

The authors examine the issue of running algorithms on a hypercube which has both node and edge faults, and they assume a worst-case distribution of the faults. It is proven that for any constant c, an n-dimensional hypercube (n-cube) with n/sup c/ faulty components contains a fault-tree subgraph that can implement a large class of hypercube algorithms with only a constant factor slowdown. In addition, the approach yields practical implementations for small numbers of faults. For example, it is shown that any regular algorithm can be implemented on an n-cube that has at most n-1 faults with slowdowns of at most two for computation and at most four for communication. This is the first result showing that an n-cube can tolerate more than O(n) arbitrarily placed faults with a constant factor slowdown. >

Using XForms to simplify Web programming

The difficulty of developing and deploying commercial web applications increases as the number of technologies they use increases and as the interactions between these technologies become more complex. This paper describes a way to avoid this increasing complexity by re-examining the basic requirements of web applications. Our approach is to first separate client concerns from server concerns, and then to reduce the interaction between client and server to its most elemental: parameter passing. We define a simplified programming model for form-based web applications and we use XForms and a subset of J2EE as enabling technologies. We describe our implementation of an MVC-based application builder for this model, which automatically generates the code needed to marshal input and output data between clients and servers. This marshalling uses type checking and other forms of validation on both clients and servers. We also show how our programming model and application builder support the customization of web applications for different execution targets, including, for example, different client devices.

Extension mechanisms in Montana

Montana is a new C++ programming environment being developed at IBM. Montana aims to improve the software development experience by providing rapid incremental builds, rapid complete builds, and a tightly integrated user interface driven from a single source of information. Montana uses a program representation (CodeStore) to achieve these aims, with compilation proceeding directly from the database. APIs for accessing information about programs from the CodeStore are also made available for tool builders. In this paper we focus on the extension mechanism in Montana, which enables integration of existing tools and creation of new sophisticated, tightly integrated tools.

Embedding cube-connected cycles graphs into faulty hypercubes

We consider the problem of embedding a cube-connected cycles graph (CCC) into a hypercube with edge faults. Our main result is an algorithm that, given a list of faulty edges, computes an embedding of the CCC that spans all of the nodes and avoids all of the faulty edges. The algorithm has optimal running time and tolerates the maximum number of faults (in a worst-case setting). Because ascend-descend algorithms can be implemented efficiently on a CCC, this embedding enables the implementation of ascend-descend algorithms, such as bitonic sort, on hypercubes with edge faults. We also present a number of related results, including an algorithm for embedding a CCC into a hypercube with edge and node faults and an algorithm for embedding a spanning torus into a hypercube with edge faults. >

An authoring technology for multidevice Web applications

The rapid proliferation of mobile computing devices has increased the complexity and cost of cross-platform application development. Multidevice authoring technology (MDAT) lets developers build a generic application common to multiple devices and customize it for specific devices. We developed MDAT an end-to-end development methodology and toolset, to reduce the complexity of creating interactive, form-based Web applications that execute on heterogeneous devices. Web application refers to conventional, servlet-based Web applications as well as portlet applications. A portlet is a Web application component that a Web portal server aggregates with other portlets.

Tooling and system support for authoring multi-device applications

This paper presents a development model, tooling environment, and system support for building and deploying applications targeted to run on multiple heterogeneous end-user devices. Our approach is based on a device-independent application model and consists of three elements: (1) an automated process of specialization, by which device-specific versions of the application are generated, (2) support for hand-customization of generated applications, a process we call tweaking, both within our workbench and using external editors, and (3) a designer-in-the-loop process of generalization, by which a generic model is inferred from concrete interface artifacts such as HTML pages. We argue that this approach is cost-effective and results in usable applications that run on a variety of devices.

Subtree isomorphism is random NC

Abstract Given two trees, a guest tree G and a host tree H , the subtree isomorphism problem is to determine whether there is a subgraph of H that is isomorphic to G . We present a randomized parallel algorithm for finding such an isomorphism, if it exists. The algorithm runs in time O(log 3 n ) on a CREW PRAM, where n is the number of nodes in H . The number of processors required by the algorithm is polynomial in n . Randomization is used (solely) to solve each of a series of bipartite matching problems during the course of the algorithm. We demonstrate the close connection between the two problems by presenting a log-space reduction from bipartite perfect matching to subtree isomorphism. Finally, we present some techniques to reduce the number of processors used by the algorithm.

Transitive compaction in parallel via branchings

Abstract We study the following problem: given a strongly connected digraph, find a minimal strongly connected spanning subgraph of it. Our main result is a parallel algorithm for this problem, which runs in polylog parallel time and uses O ( n 3 ) processors on a PRAM. Our algorithm is simple and the major tool it uses is computing a minimum-weight branching with zero-one weights. We also present sequential algorithms for the problem that run in time O ( m + n · log n ).

Combining Handcrafting and Automatic Generation of User-Interfaces for Pervasive Devices

Application development for multiple pervasive devices requires a methodology that requires less development and management effort than simply rewriting the application for each device. We describe an approach that combines the advantages of automated generation from a single model-based UI description, with handcrafting of interfaces for specific devices. We discuss the infrastructure required to support a hybrid automated generation and handcrafting system, with particular attention to the issues that arise during application evolution.

Pegboard: a framework for developing mobile applications

Tool support for mobile application development can significantly improve programmer productivity and software quality. Pegboard is a novel tooling framework that extends the Eclipse integrated development environment to support the development of mobile distributed applications. Its extensible design supports multiple application models and the orchestration of external tooling components throughout the development cycle. In this paper we describe Pegboards architecture and implementation, and show how it improves the development experience through organization, visualization, simplification and guidance. We also discuss insights gained from interviewing software developers, including early users of Pegboard.