A modularized electronic payment system for agent-based e-commerce

With the explosive growth of the Internet, electronic-commerce (e-commerce) is an increasingly important segment of commercial activities on the web. The Secure Agent Fabrication, Evolution & Roaming (SAFER) architecture was proposed to further facilitate e-commerce using agent technology. In this paper, the electronic payment aspect of SAFER will be explored. The Secure Electronic Transaction (SET) protocol and E-Cash were selected as the bases for the electronic payment system implementation. The various modules of the payment system and how they interface with each other are shown. An extensible implementation done using JavaTM will also be elaborated. This application incorporates agent roaming functionality and the ability to conduct e-commerce transactions and carry out intelligent e-payment procedures

Invertible Program Restructurings for Continuing Modular Maintenance

When one chooses a main axis of structural decompostion for a software, such as function- or data-oriented decompositions, the other axes become secondary, which can be harmful when one of these secondary axes becomes of main importance. This is called the tyranny of the dominant decomposition. In the context of modular extension, this problem is known as the Expression Problem and has found many solutions, but few solutions have been proposed in a larger context of modular maintenance. We solve the tyranny of the dominant decomposition in maintenance with invertible program transformations. We illustrate this on the typical Expression Problem example. We also report our experiments with Java and Haskell programs and discuss the open problems with our approach.Comment: 6 pages, Early Research Achievements Track; 16th European Conference on Software Maintenance and Reengineering (CSMR 2012), Szeged : Hungary (2012

Development and evaluation of Formula Editor (a tool-based approach to enhance reusability in software product line model checking) on SAFER case study

Although model checking is extensively used for verification of single software systems, currently there is insufficient support for model checking in product lines. The presence of commonalities within the different products in the product line requires that the properties and the corresponding specifications for these properties be verified for every product in the product line. Specification and management of properties for every product in a product line can incur high overhead and make the task of model checking very difficult. It is hence essential to exploit the presence of commonalities to our advantage by providing reusability in model checking of product lines. Since different products in the product line need to be checked for same or similar properties, reuse of properties specified for one product for other products within a product line will significantly reduce the overall property specification and verification time. FormulaEditor is a property specification and management tool for enhancing the reusability of model checking of software product lines. The core of the technique is a product line-oriented user interface to guide users in generating, selecting, managing, and reusing useful product line properties, and patterns of properties for model checking. The previous version of the FormulaEditor tool supports Cadence SMV models, but not the typical CMU-SMV models. This work extends the FormulaEditor tool to allow verification of models written in CMU-SMV. The advantage of providing support to another model checker is twofold: first, it enhances the tool\u27s capability to check design specifications written in different models; and second, it allows users to specify the same design in different modeling languages to detect problems

Multi Domain Design: Integration and Reuse

Design of mechatronic systems is becoming increasingly complex. Companies must continuously reduce time-to-market while increasing the quality, diversity, and functionality of their products. As a result, more and more specialists from various domains are needed to develop such products. To reduce time-to-market, many companies look to reducing the time it takes to design a product. Many focus on the reuse of design objects, leading to libraries of templates and standard components to speed up their design process. However, these reusable design objects are developed and maintained in the specialists’ domains, resulting in communication and integration issues between these domains. This paper discusses these issues and proposes a combined approach for model reuse, design integration, and communication between the designers, design tools, and models involved. A case study at a multi-national company successfully demonstrated that the approach leads to a faster and more consistent design process

ENABLE-S3 – Advanced V&V technologies and methods combined with simulation and testing environments enable the safe and secure development of Autonomous Vehicles

Highly automated and autonomous transport is a technology field that enables safer and cleaner transport and unburdens the driver from boring and/or error prone driving task. The development of automated transport features and vehicles will or have already led to new business opportunities in many technology sectors, like sensor technologies, SW-development or mobility services to name just a few of them. The highly precise sensors and communication technologies as well as the necessary computing power and algorithms within the vehicle plus the digital infrastructure that are necessary to realize the autonomous transport are developing very fast. But this goes also along with new heavy-weight challenges in terms of safety and security aspects. Extensive verification and validation efforts are necessary to make automated systems at least as safe as human-operated systems are nowadays. The ENABLE-S3 project develops verification and validation technologies and methods that will help to tackle this challenge with reasonable efforts and high coverage of test-cases. 71 partners from different transport sectors (automotive, aerospace, rail, maritime, farming) and other industries are creating new knowledge in the areas of testing and simulation methods & technologies as well as the required testing platforms and environments. Research within ENABLE-S3 focuses on: - Test and simulation environments supporting open standards (e.g. Functional Mock-up Interface, OpenSimulationInterface) wherever possible in order to run tests for automated transport seamlessly in different virtual and semi-virtual environments. - Open standards for the definition, management and execution of test cases/testing scenarios like OpenScenario or OpenDrive and their relationship to other existing standards like ASAM-XiL. - Investigation of testing methodologies which are necessary to reduce the number of test cases tremendously, among them are DoE (design of experiments), combinatorial testing, FMEA analysis etc. - Development of sensor models as well as sensor stimuli (physical sensor signal generators). - Generation of test cases out of existing recorded real-world data. The developed methods are applied in different industrial use-cases. This paper will give an overview over the needed building blocks for testing AD functions, including scenario generation, test planning, and test execution and simulation that were already developed within the ENABLE-S3 project and will finally present a practical use case and the application of aforementioned methods to an ACC function of a vehicle. The results gained so far in the project will show that the verification and validation methods combined with simulation and testing technologies for automated vehicles in transport play a major role in reaching the high safety and security levels that end customers and legal authorities will demand for this important technology in order to get acceptance and in order to provide a great step forward in reducing road fatalities and at the same time also CO2 emissions

Safer typing of complex API usage through Java generics

When several incompatible implementations of a single API are in use in a Java program, the danger exists that instances from different implementations may inadvertently be mixed, leading to errors. In this paper we show how to use generics to prevent such mixing. The core idea of the approach is to add a type parameter to the interfaces of the API, and tie the classes that make up an implementation to a unique choice of type parameter. In this way methods of the API can only be invoked with arguments that belong to the same implementation. We show that the presence of a type parameter in the interfaces does not violate the principle of interface-based programming: clients can still completely abstract over the choice of implementation. In addition, we demonstrate how code can be reused between different implementations, how implementations can be defined as extensions of other implementations, and how different implementations may be mixed in a controlled and safe manner. To explore the feasibility of the approach, gauge its usability, and identify any issues that may crop up in practical usage, we have refactored a fairly large existing API-based application suite, and we report on the experience gained in the process