International Journal of Software Engineering and Knowledge Engineering

Security is critical in a home gateway environment. Robust secure mechanisms must be put in place for protecting information transferred through a central location. In considering characteristics for the home gateway environment, this paper proposes a bundle authentication mechanism. We designed the exchange mechanism for transferring a shared secret key. This transports a service bundle safely in the bootstrapping step, by recognizing and initializing various components. In this paper, we propose a bundle authentication mechanism based on a MAC that uses a shared secret key created in the bootstrapping step. In addition, we verify the safety of the key exchange mechanism and bundle authentication mechanism using BAN Logic. From the verified result, we achieved goals of authentication. That is, the operator can trust the bundle provided by the service provider. The user who uses the service gateway can also express trust and use the bundle provided by the operator.

There is an increasing need for high-quality software components. Reusable components and formal specifications are two complementary and promising approaches to achieve this goal. One method for enhancing the reusability of existing components is generalization that creates generic components by parameterizing specific ones. Generalization and instantiation are two methods related respectively to the development for reuse and development with reuse. Generalization, that is the abstraction of existing components, identifies commonalities across a class of entities, while instantiation customizes the general properties under different circumstances. In this paper, we present several generalization and instantiation algorithms for algebraic specifications. A major difficulty during the generalization process is determining the appropriate level of generality. Highly specific components have little chance of being reused. Meanwhile, if a component is too general, its reuse might also be hard. Therefore, we introduce a novel method based on the categorized constructors to control the level of abstraction in generic components with the goal of producing effective reusable components. Through a medium-scale example, the generalization and instantiation operations are illustrated in detail.

With XML adopted as the technology trend on the Internet, and with investment in the current relational database systems, companies must convert their relational data into XML documents for data transmission on the Internet. In the process, to preserve the users' relational data requirements of data constraints into the converted XML documents, we must define a meaningful root element for each XML document. The construction of an XML document is based on the root element and its relevant elements. The root element can be selected from a relational entity table in the existing relational database, which depends on the requirements to present the business behind. The relevant elements are mapped from the related entities, based on the navigability of the chosen entity. The derived root and relevant elements can form a Data Type Definition Graph (DTD-graph) of an XML conceptual schema diagram which can be mapped into a Data Type Definition (DTD) of an XML schema. The result is a translated XML schema with semantic constraints transferred from a relational conceptual schema of an Extended Entity Relationship (EER) model. The data conversion from relational data to the XML documents can be done after the schema translation. The relational data are loaded into XML documents according to the translated DTD.

Genetic Programming (GP) is a powerful software induction technique that can be applied to solve a wide variety of problems. However, most researchers develop tailor-made GP tools for solving specific problems. These tools generally require significant modifications in their kernel to be adapted to other domains. In this paper, we explore the Grammar-Guided Genetic Programming (GGGP) approach as an alternative to overcome such limitation. We describe a GGGP based framework, named Chameleon, that can be easily configured to solve different problems. We explore the use of Chameleon in two domains, not usually addressed by works in the literature: in the task of mining relational databases and in the software testing activity. The presented results point out that the use of the grammar-guided approach helps us to obtain more generic GP frameworks and that they can contribute in the explored domains.

This paper describes two laboratory experiments designed to evaluate a failure-pursuit strategy for system level testing. In the first experiment, two GAs are used to automatically generate test suites that are rich in failure-causing test cases. Their performance is compared to random generation. The resulting test suites are then used to train a series of decision trees, producing rules for classifying other test cases. Finally, the performance of the classification rules is evaluated empirically. The results indicate that the combination of GA-based test case generation and decision tree induction can produce rules with high-predictive accuracy that can assist human testers in diagnosing the cause of system failures.

Recent experiments demonstrated the effectiveness of pair programming in terms of quality and productivity. Growing interest towards global software development is fostering the design of suitable methods and tools for distributing software processes, at any level of detail, from entire subprocesses up to a single activity. Consequently, people placed in different locations could also share programming tasks and related practices, such as pair programming. Unfortunately, distribution might seriously compromise the success of pair programming, due to communication and collaboration issues. We have performed an experiment in order to investigate the impact of distribution on pair programming when performing maintenance tasks. An interesting conjecture stems from the experiment: under certain conditions, distributed pair's components tend to dismiss from each other, stopping the collaborative work. This can be a very expensive risk factor to keep into account when planning tasks of distributed pair programming.