257 research outputs found

    A Multi-Agent Distributed Scripting System for COTS-Based Distributed Software Integration

    Get PDF
    [[abstract]]This paper presents an approach to distributed commercial off-the-shelf (COTS) based software integration by using the concepts of a multi-agent system and the distributed scripting mechanism. COTS software products are increasingly used to be software components in large-scale systems. Most organisations try to gain the promises of rapidly development and lower cost from reusing COTS components. Nevertheless, COTS-based software system development needs an efficient and useful integration approach. We developed a multi-agent system as an execution platform for distributed COTS software products. Instead of an RPC-like invocation approach, we adopt mobile agents to interoperate COTS software. We also developed a scripting mechanism for helping the software integrator to write a gluer. By using our scripting language constructs and the associated rules, a software integrator can easily write various scripts in various styles. To illustrate this multi-agent system, a distributed CPU-utilisation data collection system, is experimented in our study. Finally, we also successfully developed a graphical user interface tool that would be beneficial and useful for software integrator to edit, debug and display script programs and results.[[notice]]補正完畢[[journaltype]]國際[[incitationindex]]EI[[countrycodes]]TW

    Proceedings of the ICSE 99 Workshop on Engineering Distributed Objects, May 1999, Los Angeles, California

    Get PDF

    LEGOS: Object-based software components for mission-critical systems. Final report, June 1, 1995--December 31, 1997

    Full text link

    Developing Legacy System Migration Methods and Tools for Technology Transfer

    Get PDF
    This paper presents the research results of an ongoing technology transfer project carried out in coopera- tion between the University of Salerno and a small software company. The project is aimed at developing and transferring migration technology to the industrial partner. The partner should be enabled to migrate monolithic multi-user COBOL legacy systems to a multi-tier Web-based architecture. The assessment of the legacy systems of the partner company revealed that these systems had a very low level of decompos- ability with spaghetti-like code and embedded control flow and database accesses within the user interface descriptions. For this reason, it was decided to adopt an incremental migration strategy based on the reengineering of the user interface using Web technology, on the transformation of interactive legacy programs into batch programs, and the wrapping of the legacy programs. A middleware framework links the new Web-based user interface with the Wrapped Legacy System. An Eclipse plug-in, named MELIS (migration environment for legacy information systems), was also developed to support the migration process. Both the migration strategy and the tool have been applied to two essential subsystems of the most business critical legacy system of the partner company

    An Adaptive Integration Architecture for Software Reuse

    Get PDF
    The problem of building large, reliable software systems in a controlled, cost-effective way, the so-called software crisis problem, is one of computer science\u27s great challenges. From the very outset of computing as science, software reuse has been touted as a means to overcome the software crisis issue. Over three decades later, the software community is still grappling with the problem of building large reliable software systems in a controlled, cost effective way; the software crisis problem is alive and well. Today, many computer scientists still regard software reuse as a very powerful vehicle to improve the practice of software engineering. The advantage of amortizing software development cost through reuse continues to be a major objective in the art of building software, even though the tools, methods, languages, and overall understanding of software engineering have changed significantly over the years. Our work is primarily focused on the development of an Adaptive Application Integration Architecture Framework. Without good integration tools and techniques, reuse is difficult and will probably not happen to any significant degree. In the development of the adaptive integration architecture framework, the primary enabling concept is object-oriented design supported by the unified modeling language. The concepts of software architecture, design patterns, and abstract data views are used in a structured and disciplined manner to established a generic framework. This framework is applied to solve the Enterprise Application Integration (EM) problem in the telecommunications operations support system (OSS) enterprise marketplace. The proposed adaptive application integration architecture framework facilitates application reusability and flexible business process re-engineering. The architecture addresses the need for modern businesses to continuously redefine themselves to address changing market conditions in an increasingly competitive environment. We have developed a number of Enterprise Application Integration design patterns to enable the implementation of an EAI framework in a definite and repeatable manner. The design patterns allow for integration of commercial off-the-shelf applications into a unified enterprise framework facilitating true application portfolio interoperability. The notion of treating application services as infrastructure services and using business processes to combine them arbitrarily provides a natural way of thinking about adaptable and reusable software systems. We present a mathematical formalism for the specification of design patterns. This specification constitutes an extension of the basic concepts from many-sorted algebra. In particular, the notion of signature is extended to that of a vector, consisting of a set of linearly independent signatures. The approach can be used to reason about various properties including efforts for component reuse and to facilitate complex largescale software development by providing the developer with design alternatives and support for automatic program verification

    An agent-based service-oriented approach to evolving legacy software systems into a pervasive computing environment.

    Get PDF
    This thesis focuses on an Agent-Based Service-Oriented approach to evolving legacy system into a Pervasive Computing environment. The methodology consists of multiple phases: using reverse engineering techniques to comprehend and decompose legacy systems, employing XML and Web Services to transform and represent a legacy system as pervasive services, and integrating these pervasive services into pervasive computing environments with agent based integration technology. A legacy intelligent building system is used as a case study for experiments with the approach, which demonstrates that the proposed approach has the ability to evolve legacy systems into pervasive service environments seamlessly. Conclusion is drawn based on analysis and further research directions are also discussed

    Evaluating Legacy System Migration Technologies through Empirical Studies

    Get PDF
    We present two controlled experiments conducted with master students and practitioners and a case study conducted with practitioners to evaluate the use of MELIS (Migration Environment for Legacy Information Systems) for the migration of legacy COBOL programs to the web. MELIS has been developed as an Eclipse plug-in within a technology transfer project conducted with a small software company [16]. The partner company has developed and marketed in the last 30 years several COBOL systems that need to be migrated to the web, due to the increasing requests of the customers. The goal of the technology transfer project was to define a systematic migration strategy and the supporting tools to migrate these COBOL systems to the web and make the partner company an owner of the developed technology. The goal of the controlled experiments and case study was to evaluate the effectiveness of introducing MELIS in the partner company and compare it with traditional software development environments. The results of the overall experimentation show that the use of MELIS increases the productivity and reduces the gap between novice and expert software engineers

    Applying Component Technology to Improve Global Supply Chain Network Management

    Get PDF
    A key requirement of supply chain management strategies is information sharing. Component technology facilitates information sharing by providing a means for integrating heterogeneous information systems into virtual information systems. The component environment makes possible new strategies to reshape and improve supply chain networks. These strategies include modularization and encapsulation, plug-and-play component development, enterprise specialization, dynamic supply chain network configuration, and cross- industry enterprise integration. We show how these strategies can be applied to the supply chain network management using the order fulfillment process as an illustration

    Two Case Studies of Subsystem Design for General-Purpose CSCW Software Architectures

    Get PDF
    This paper discusses subsystem design guidelines for the software architecture of general-purpose computer supported cooperative work systems, i.e., systems that are designed to be applicable in various application areas requiring explicit collaboration support. In our opinion, guidelines for subsystem level design are rarely given most guidelines currently given apply to the programming language level. We extract guidelines from a case study of the redesign and extension of an advanced commercial workflow management system and place them into the context of existing software engineering research. The guidelines are then validated against the design decisions made in the construction of a widely used web-based groupware system. Our approach is based on the well-known distinction between essential (logical) and physical architectures. We show how essential architecture design can be based on a direct mapping of abstract functional concepts as found in general-purpose systems to modules in the essential architecture. The essential architecture is next mapped to a physical architecture by applying software clustering and replication to achieve the required distribution and performance characteristics
    corecore