Abstract: With the recent explosive growth of sensors and instruments, data-driven stream applications are emerging as a new field. Query optimization for such high performance stream applications has not been extensively studied, especially its core component, the cost model. We observe that the cost model for stream query processing should consider two aspects: output rate and computation cost. However, most existing work on evaluating stream queries uses only one or the other. In this paper, we propose a multi-model based optimization framework by leveraging both aspects. Further, we extend it from the centralized environment to the distributed environment by introducing distributed metrics and an algorithm for query plan decomposition. keywords: stream data, query optimization, distributed stream processing

Abstract: XML is the de facto standard for exchanging data between aribtrary applications. There are many efforts to integrate XML into object-oriented programming languages reaching from the simple document object model (DOM) to XML class generators or even to the introduction of new programming languages. Another as desired feature as XML is persistency. The integration of persistency into object-oriented programming languages has been realized with database programming languages as well as current frameworks like Hibernate or approaches like EJB. Nevertheless, the integration of XML suffers from mapping problems or, if at all, efficient static typechecking mechanisms, in particular concerning update operations. Additionally, existing persistency integration concepts are often intransparent and support limited object-oriented concepts. This paper introduces a holistic, transparent approach concerning the integration of statically typechecked XML and persistency aspects into the object-oriented programming language Java. It is shown that this can be achieved without syntax changes.

Abstract: In this paper, we propose an approach for the verification of a state model against use cases written in natural language. An objective of this approach is to provide a quick way to ensure that requirements modeling proceeds in the right direction in the context of iterative development. The approach consists of extracting logical statements from use cases and verifying these statements with corresponding statements obtained from state machines. We are able to detect some requirement violations symptomatic of wrong assumptions.

Abstract: Java Data Objects (JDO) is a specification for object persistence that enables application developers to deal with persistent objects in a transparent fashion. Since JDO is designed as a lightweight persistence approach, it neither supports user authentication nor role-based authorization. In order to remedy this situation, JDOSecure has been developed in order to introduce a fine-grained access control mechanism to the JDO persistence layer. By implementing the Java Authentication and Authorization Service, JDOSecure allows the definition of role-based permissions. Moreover, since JDOSecure is based on the dynamic proxy approach, the collaboration with any JDO implementation is ensured.

Abstract: Everyone concur today that business, scientific, medical, or any application’s data is increasingly translated into XML in order to be easily exchanged between organizations. However, document structure (e.g. DTD, XML Schema) are not standardized in any of these domains. Therefore, a process of data transformation is unavoidably required before performing any exchange. Currently, developers are responsible to understand the semantic similarities between two representations and to create an executable translation that ensures data conversion and data filtering. This involves domain knowledge expertise and technical skills for performing these tasks. In this work, we are interested in reducing human effort and technical skills required for enabling data exchange. We provide a general framework to perform automatic matching and transformations between data representations. ASMADE platform enables a semantic matching process followed by a visual mapping process to optimize the translation process between exchanged documents.

Abstract: XML (eXtensible Markup Language) transformations and queries are crucial operations for interpreting XML databases. XSLT (eXtensible Stylesheet Language Transformations) is a prominent XML technology for these operations, but XQuery (XML Query Language) can query a broad spectrum of XML information sources, including both databases and documents. In this paper, we present our approach to translate XSLT to XQuery. We illustrate our approach as a set of rules or templates which translates an XSLT document into XQuery. We also discuss grouping operations for both XSLT and XQuery. Keywords: XSLT, XQuery, Xpath, XML Databases 1. plements the FLWR (For, INTRODUCTION XML is becoming as a standard for the exchange of many data sources. The reason for the use of XML databases for database integration is, principally, together with W3C recommended query languages, such as XPath [3] and XQuery [4], and other techniques like XSLT [9] and SOAP (Simple Object Access Protocol), that XML helps to overcome most technical heterogeneities of diverse databases. In addition, XML databases can be transmitted and stored as text files with schema information transported using XML schemas or Document Type Definition files, unlike relational databases, though there may be speed degradation with very large text based databases. In order to extract information from XML databases, one solution would be to extend a knowledge modeling tool by implementing a set of new classes or functions in a language such as Java, though this can be a rather difficult and time consuming task. Another solution would be to use XSLT or XQuery for transforming XML documents. An advantage of this approach is that, even though an XSLT is written independently of any programming language, it can be

Abstract: Clustering has the following challenges: 1) clusters with arbitrary shapes; 2) minimal domain knowledge to determine the input parameters; 3) scalability for large data sets. Density-based clustering has been recognized as a powerful approach for discovering clusters with arbitrary shapes. However, the other two challenges still remain in most existing clustering algorithms. In this paper, we explore a hierarchical and iterative densitybased clustering method for large data sets with clusters in different densities. We meet the second challenge by reducing input parameters and solve the third challenge by means of hashing techniques and a vertical data structure, P-tree1 . Our experiments with three different data sets show that our approach is more efficient and robust than DBSCAN, TURN*, and K-means with better clustering qualities.

Abstract: Requirements elicitation is concerned with the extraction of users’ requirements, which involves cognitive, social, communication, and technical issues. There are many techniques to elicit requirements each having its strengths and weaknesses. However, some of them are misused, others are never used and only a few are applied again and again. The reason is that analysts have a difficulty of deciding what elicitation techniques to use in a particular software development project due to lack of information regarding the available elicitation techniques, their usefulness, and how suitable they are to the project. This paper presents a framework, which will assist analysts in the selection of elicitation techniques that best fit the goal of elicitation session, the project environment and the problem domain. When applied, this framework provides ranked list of elicitation techniques which are suitable for the project.

Abstract: Specification and design in relational databases largely use a domain-specific design approach (e.g., Entity-Relational Model) different from that used in software engineering. In software engineering, the use of UML (Unified Modeling Language) models, design patterns, and the Unified Process are the primary design and development methodology, especially in modern object-oriented software engineering. The application of generic software engineering design patterns to databases allows issues in logical design and in implementation of databases to be more easily connected with similar concerns in software engineering. It can leverage previous experience with software design, make knowledge from database discipline more immediately relevant with software engineering. In this research, we apply the generic software engineering design patterns to the design and implementation of relational databases.

Abstract: Distributed software development processes are hard to manage due to their creative and dynamic character. In particular, interorganizational development processes deal with the coordination of development activities which are carried out by the engineering teams within several organizations. In this paper, we present our management support of interorganizational development processes based on dynamic process views. Process views allow to manage the partial visibility of processes for external organizations. Our approach explicitly addresses the evolution of such process views onto continuously evolving instances of development processes. The proposed concept is implemented within the process management system AHEAD, which addresses the management of dynamic and distributed software development processes.

Abstract: This paper describes a design experience in which UML was used in a non-traditional way, that of modeling an electronic software engineering handbook. The handbook was created by eleven students who took a graduate course in software engineering during Spring 2006 at the University of Nevada, Reno, USA. While all other course projects involved developing software applications, the electronic handbook project required putting together a comprehensive repository of student reviews on significant software engineering articles, thus creating an expandable technical report on the discipline's current landscape and future directions. By accessing this repository, one is able to adequately peruse a plethora of information on various software engineering topics and better comprehend the discipline's vernacular. This paper covers the UML-based specification and design process of the electronic handbook and provides details of the end product. Furthermore, it shows that UML can be used as a powerful modeling tool outside the software development domain. Several pointers to future developments are also presented in the paper.

Abstract: Faster-than-real-time simulation (FRTS) is used when attempting to reach conclusions for the near future. FRTS experimentation phase deals with the complexity and hard real-time requirements imposed by the concurrent execution of the real world system and corresponding simulation model. It is important for the FRTS experiment designer to study timing constraints, thus to set limitations in the execution time of specific activities. As simulation activities and control data flows may be the same in diverse FRTS implementations, a common basis for FRTS system development is introduced based on the Real Time Unified Modeling Language (RT-UML). The proposed approach enables the detailed specification of critical time and synchronization requirements for FRTS components and an overall performance evaluation. The detailed specification for FRTS systems leads to standardized implementations of such systems that meet strict time requirements.

Abstract: With the increasing popularity of data warehouses and data marts, the ability to refresh data in a timely fashion is more important than ever. In this paper, a new approach is proposed to incrementally update materialized summary tables. The advantage of the approach is that a) this method retrieves changes on a predicate level; b) the method utilizes time information hidden in user data. Therefore, the method does not introduce extra cost while the other current approaches do introduce overhead for time tag; c) our method applies changes to summary tables by merge. The merge only updates changed values and inserting new rows into summary table, and it is much more efficient than union. By making use of the above advantages, this method is much faster than other methods, and the same accurateness as state-of-the-art approaches can be achieved. By comparing this method with the state-of-theart over IBM DB2 workstation version, it showed that the proposed method outperforms the state-of-the-art in terms of elapse time,

Abstract: We present hierarchical master-slave architecture for performing parallel raytracing algorithms that can support a large population of participating clients and at the same time maintain fault tolerance at the application level. Our design allows for scalability with minimal data redundancy and maximizes the utilization of each client involved in the raytracing process. Our results show that this three-layer system can survive any type or number of client failures, and any non-concurrent server failures, while maintaining a near linear increase in performance with the addition of each new processing client.

Abstract: Despite advances, debugging remains a drudgery, especially for software without proper documentation. Both top-down visualization-based approaches and bottom-up programmatic automation can improve this process. For a given system under test (SUT), we propose a combined method of: Program trace visualization, with capability to zoom in to method call details (inputs and outputs) Interactive declaration of observables for the internal state of the system Statistical and visual analysis of the collected observable data Programmatic declaration of expected behavior of the system defined through invariant relationships and satisfaction of contracts (Design by Contract) on these observables The ability to modify and repeat these steps without restarting the SUT We report that instrumentation necessary to collect trace data is feasible; large amounts of data can be gathered without significant performance penalty while the visualizer remains responsive to tester interaction. Our personal experience is that the system is very quick to set up, faults are discovered quickly, and inefficient algorithms (which may produce correct results) become obvious through the visualizer. We are setting up humaninteraction experiments to support the claim that our approach improves the efficiency of discovery of fault origin for a given system failure, compared to using a state-of-the-art debugger for Java (Eclipse).