Enhancing Performance And Reliability of Rule Management Platforms

ABSTRACT RulE Management Platforms (REMPs) enable software engineers to represent programming logic as conditional sentences that relate statements of facts. A key benefit of REMPs is that they make software adaptable by burying the complexity of rule invocation in their engines, so that programmers can concentrate on business aspects of highly modular rules. Naturally, rule-driven applications are expected to have excellent performance, since REMP engines should be able to invoke highly modular rules in parallel in response to asserting different facts. In reality, it is very difficult to parallelize rule executions, since it leads to the loss of reliability and adaptability of rule-driven applications. We created a novel solution that is based on obtaining a rule execution model that is used at different layers of REMPs to enhance the performance of rule-driven applications while maintaining their reliability and adaptability. First, using this model, possible races are detected statically among rules, and we evaluate an implementation of our abstraction of algorithms for automatically preventing races among rules. Next, we use the sensitivity analysis to find better schedules among simultaneously executing rules to improve the overall performance of the application. We implemented our solution for JBoss Drools and we evaluated it on three applications. The results suggest that our solution is effective, since we achieved over 225% speedup on average

Composing Integrated Systems Using GUI-Based Applications

Abstract-Integrated systems are composed of components that exchange information (i.e., interoperate [5]). These components include Graphical User Interface (GUI) APplications (GAPs) and web services. It is difficult to make GAPs interoperate, especially if they are closed and monolithic. Unlike GAPs, web services are applications that are designed to interoperate over the Internet. We propose a novel generic approach for creating integrated systems by composing GAPs with each other and web services efficiently and non-invasively. This approach combines a nonstandard use of accessibility technologies for accessing and controlling GAPs in a uniform way with a visualization mechanism that enables nonprogrammers to compose integrated systems by performing point-and-click, drag-and-drop operations on GAPs and web services. We built a tool based on our approach, and using this tool we created an integrated application that controls two closed and monolithic commercial GAPs and third-party web services. Our evaluation suggests that our approach is effective, and it can be used to create nontrivial integrated systems by composing GAPs with each other and web services

Creating Web Services From GUI-Based Applications

are ubiquitous and provide various services. However, it is difficult to make GAPs exchange information (i.e., interoperate) especially if they are closed and monolithic. Unlike GAPs, web services are applications that are designed to interoperate over the Internet. Thus a fundamental problem of interoperability is how to reengineer GAPs into web services efficiently and non-invasively. We propose a novel generic approach for creating web services from GAPs. This approach combines a nonstandard use of accessibility technologies for accessing and controlling GAPs in a uniform way with a visualization mechanism that enables nonprogrammers to create web services by performing point-and-click, drag-and-drop operations on GAPs. We built a tool based on our approach and created web services that control two closed and monolithic commercial GAPs with this tool. Our evaluation suggests that our approach is effective and it can be used to create web services from nontrivial GAPs. I

Design and analysis of interoperating components

Components are modular units (e.g., objects, modules, or programs) that interact by exchanging data. Two or more components interoperate when they exchange information [16]. It is conservatively estimated that the cost of programming errors in component interoperability just in the capital facilities industry in the U.S. alone is $15.8 billion per year. A primary driver for this high cost is fixing flaws in incorrect data exchanges between interoperating components [17]. Interoperating components are difficult to design, build, and evolve. We propose an approach for the design and analysis of interoperating components. The core of our approach is an abstraction in which foreign objects (i.e., objects that are not defined in a host programming language) are abstracted as graphs and abstract operations access and manipulate them. These operations navigate to data elements, read and write data, add and delete data elements, and load and save data. We offer different uses for the proposed abstraction. We build a framework called Reification Object-Oriented Framework (ROOF) which uses our abstraction to reduce the multiplicity of platform API calls to a small set of operations on foreign objects that are common to all platforms [48]. With ROOF, we hide the tremendously ugly, hard-to-learn, hard-to-maintain, and hard-to-evolve code that programmers must write or generate today, i.e., we simplified code of interoperating components, making it scalable and easier to write, maintain, and evolve. Our abstraction makes the task of static checking of interoperating components tractable by reducing the multiplicity of platform APIs to a small set of operations on foreign objects that are common to all platforms. By introducing a simple extension to grammars of object-oriented languages, we enable the collection of information about foreign objects at compile time. Static type checking uses this information to find possible errors that could otherwise be detected only at the runtime. We designed Foreign Object REification Language (FOREL), an extension for object-oriented languages that provides a general abstraction for foreign component access and manipulation based on ROOF. FOREL type checking coupled with a conservative static analysis mechanism reports potential errors when referencing foreign components. While ROOF and FOREL offer new approaches for developing interoperating components, many components are still written using low-level platform API calls. We use our abstraction to design and build a tool called a Verifier for Interoperating cOmponents for finding Logic fAults (Viola) that finds errors in components exchanging XML data. Viola creates models of the source code of components by extracting abstract operations and computing approximate specifications of the data (i.e., schemas) that these components exchange. With these extracted models, Viola’s static analysis mechanism reports potential errors for a system of interoperating components.Computer Science

PERFECTION OF TECHNOLOGY AND EQUIPMENT FOR PRODUCTION OF PISTON RINGS SLUGS IN VERTICAL STACK MOLDS

Perfection of technology and the equipment for production of piston rings in vertical stack molds is shown

Search in Source Code Based on Identifying Popular Fragments

Abstract. When programmers write new code, they are often interested in finding definitions of functions, existing, working fragments with the same or similar functionality, and reusing as much of that code as possible. Short fragments that are often returned by search engines as results to user queries do not give enough information to help programmers determine how to reuse them. Understanding code and determining how to use it, is a manual and time-consuming process. In general, programmers want to find initial points such as relevant functions. They want to easily understand how the functions are used and see the sequence of function invocations in order to understand how concepts are implemented. Our main goal is to enable programmers to find relevant functions to query terms and their usages. In our approach, identifying popular fragments is inspired by PageRank algorithm, where the “popularity ” of a function is determined by how many functions call it. We designed a model based on the vector space model by which we are able to establish relevance among facts which content contains terms that match programmer’s queries. The result is an ordered list of relevant functions that reflects the associations between concepts in the functions and a programmer’s query