Software Engineering Techniques Research Articles

Mining extremely small data sets with application to software reuse

AbstractA serious problem encountered by machine learning and data mining techniques in software engineering is the lack of sufficient data. For example, there are only 24 examples in the current largest data set on software reuse. In this paper, a recently proposed machine learning algorithm is modified for mining extremely small data sets. This algorithm works in a twice‐learning style. In detail, a random forest is trained from the original data set at first. Then, virtual examples are generated from the random forest and used to train a single decision tree. In contrast to the numerous discrepancies between the empirical data and expert opinions reported by previous research, our mining practice shows that the empirical data are actually consistent with expert opinions. Copyright © 2008 John Wiley & Sons, Ltd.

Complex game development throughout the college curriculum

This case study discusses the incorporation of game development throughout the Daniel Webster College computer science curriculum. During the freshman year all computer science majors develop complex games in C#.net while participating in an instructional game motif method we call the GM method. This freshman educational method combines agile software engineering techniques with an inquiry based, neo-Socratic classroom. The GM method provides freshmen with the core skills necessary to develop complex games throughout their college career. This freshman program of study is followed by more traditional project courses which begin with an encryption system project in the sophomore year. XNA 2-D and XNA 3-D game development soon follow and a C++ game engine development capstone project is undertaken in the senior year.

Sufficient Evidence: Making the Case for Safety

Sufficient Evidence: Making the Case for Safety

An adaptive automata operational semantic

This work presents a model of software of the semantics for the adaptive automata (AA) in terms of sequences of messages between objects. The elaboration of the model is based on the formularization proposal of J.J. Neto citeneto:aa:2001 as primary origin of the class objects and its respective behaviors. Several techniques of software engineering had been used throughout the work for the elaboration of the model, such as the domain modeling, behavior specification and design patterns. The resultant model complements the original formularization providing an operational semantics for the AA.

WS-CONTRACT ESTABLISHMENT WITH QOS: AN APPROACH BASED ON FEATURE MODELING

Electronic contracts describe inter-organizational business processes in terms of supply and consumption of electronic services (commonly Web services). The establishment of e-contracts in a particular business domain usually involves a set of well-defined common and variable properties. These properties are not fully exploited by the existing e-contract establishment approaches. Feature modeling is a software engineering technique that has been widely used for capturing and managing commonalities and variabilities of product families in the context of software product line. This paper presents a feature-based approach to support Web services e-contract (WS-contract) establishment. The approach aims at improving the information structure and reuse of WS-contracts, including the QoS attributes. Features are used to represent possible WS-contract elements in order to drive WS-contract template instantiation, thus acting as a configuration space manager. A toolkit named FeatureContract was developed to automatically support the proposed approach. A case study was carried out within the telecom context to show the approach feasibility.

GrInvIn in a nutshell

GrInvIn (Graph Invariant Investigator) is a software framework for teaching graph theory and for research in graph theory and graph theoretic chemistry. It enables users to construct graphs, compute invariants (e.g. topological indices in chemistry) and investigate relations between these concepts. The design of GrInvIn emphasizes easy usage and makes use of software engineering techniques that enable the user to easily extend the system (e.g. by adding new topological indices to investigate).

Formal add to traditional methods in software engineering

Traditional, informal techniques in software engineering reach their limits when complex systems are to be developed efficiently. The Institute for Formal Methods in Computer Science of the Universitat Stuttgart states: Tools like IDEs, automatic code generation from graphical descriptions, visualization techniques like UML diagrams, and others are certainly necessary. However, they often lack the ability to support detailed and provably sound reasoning about complex systems. Formal methods in software engineering provide approaches to close that gap.

Chemotherapy ordering and delivery: Rigorously defining and analyzing a complex process employing software engineering techniques

17514 Background: Software engineering tools offer a novel approach to the definition and analysis of complex and defect-prone healthcare processes such as chemotherapy ordering and delivery. Methods: Software engineering researchers and oncologists, nurses, and pharmacists collaboratively defined the processes necessary to order and deliver a first cycle of adjuvant chemotherapy. Discrete procedure steps were precisely defined employing Little-JIL, a language originally created to define software development processes. Process defects were then sought through finite-state verification (using the PROPEL tool to encode constraints on event sequences for specific properties, followed by analysis employing the FLAVERS finite-state verifier), algorithmically evaluating pathways through the process model to determine if any execution of the process violates a pre-specified system property. Results: The chemotherapy order and delivery process is large–more than 250 steps described in Little-JIL notation. Medical processes were often described by terms (“verify”, “confirm”, “check”, etc.) that were used loosely and with different meanings in different contexts, resulting in inconsistency. Consequently, a precise naming glossary was created to reduce ambiguity. Little-JIL uncovered process errors and weaknesses, particularly inconsistencies between articulated and actual processes, as well as medical process guidelines that were insufficiently detailed to handle exception and atypical scenarios. Finite-state verification helped to identify missing/misplaced steps, and helped healthcare professionals think of high-level safety and regulatory goals rather than failure anecdotes and simplistic descriptions. Errors arising from unconventional treatment plans, stale patient parameters, and deadlock scenarios were revealed. Conclusions: Rigorously defining and analyzing healthcare processes led to improved insights into healthcare processes, with errors, inconsistencies, and failure to anticipate and handle exceptions identified. Such robustly-described processes may then be evaluated by other testing approaches, such as fault-tree analysis and discrete event simulation. No significant financial relationships to disclose.

Ultralarge Systems: Redefining Software Engineering?

The harbingers of systems are indeed emerging, although their elements seem contradictory to the ultralarge concept. ULS design will have to move beyond computer science and electrical and electronics engineering-based methodologies to include building blocks from seven major research areas: human interaction; computational emergence; design; computational engineering; adaptive system infrastructure; adaptable and predictable system quality; and policy, acquisition, and management. We need to integrate these more novel approaches with the tools and techniques of traditional software engineering, especially with regard to formal methods and to dealing with predictability and uncertainty in high-integrity software systems. Our view is not so much that we are 'redefining' software engineering but rather that we're looking to extend established software engineering tools and techniques in novel and useful ways.

Développements formels d'interfaces multimodales fondés sur la preuve et le raffinement. Scénarios de développement

The software architecture models of interactive systems are based on the separation of the functional core from the interface itself. The development of this two modules implies the use of several different software engineering techniques and approaches. Due to the resulting heterogeneity, the validation of the system may become a hard task.ln the context of the RNRT Verbatim project, the study of different development scenarios for multimodal human interfaces has been conducted within the formal event B method. Refinement of specifications is put into practice in order tu structure developments and proofs for establishing the relevant properties of the system. The main interest of this paper is the link between both functional core and interface modules. Four different development scenarios are studied and compared.

A knowledge-based tool for multi-agent domain engineering

Ontologies provide an unambiguous terminology that can be shared by all involved in a software development process. They can also be as generic as needed allowing its reuse and easy extension. These features turn ontologies useful for representing the knowledge of software engineering techniques and methodologies, and an appropriate abstraction mechanism for the specification of high-level reusable software artifacts like domain models, frameworks and software patterns. This work describes ONTOMADEM, a conceptualization of MADEM (“multi-agent domain engineering methodology”), a software development methodology for multi-agent domain Engineering. The ontology is used as a knowledge-based tool for capturing and representing the products of a multi-agent domain engineering process, created through the instantiation of its hierarchy of classes.

Effective requirements traceability: Models, tools, and practices

The complexity of telecom systems and their production, coupled with today's globalization of markets, customers, and development teams, have made it critical to define and institutionalize an effective strategy for requirements traceability. Being able to trace the life of requirements from their origin, through their allocation to components, to the finished product provides a basis for collaboration and control of functionality, quality, and changes. With the benefits of current software engineering techniques and tools, organizations can cost-effectively implement traceability aligned with the organization's business goals, software engineering maturity, project attributes, and team culture. Within Alcatel-Lucent, several business units have engaged in implementing traceability and our team has developed an automated traceability environment. Based on these experiences we present a framework of guidelines for designing effective traceability strategies and tools.

On the secure software development process: CLASP, SDL and Touchpoints compared

Development processes for software construction are common knowledge and mainstream practice in most development organizations. Unfortunately, these processes offer little support in order to meet security requirements. Over the years, research efforts have been invested in specific methodologies and techniques for secure software engineering, yet dedicated processes have been proposed only recently. In this paper, three high-profile processes for the development of secure software, namely OWASP’s CLASP, Microsoft’s SDL and McGraw’s Touchpoints, are evaluated and compared in detail. The paper identifies the commonalities, discusses the specificity of each approach, and proposes suggestions for improvement.

First-principles computation of the electronic and dynamical properties of solids andnanostructures with ABINIT (abstract only)

The field of first-principles simulation of materials and nanosystems has seen anamazing development in the past twenty years. Using the density-functional theoryand complementary approaches, like many-body perturbation theory, it is nowpossible to compute both basic quantities, like crystalline lattice parameters,and more involved properties, like optical or phonon spectra. New and improvedconcepts, approximations, algorithms, and numerical techniques appear every year.In order to cope with the increasing software complexity, it became apparentover a decade ago that software engineering techniques and a group collaborativeeffort would be major ingredients of a successful first-principles project. The opensource ABINIT project was launched in 1997; as of now, there are more than1000 members on the main mailing list, over 40 active contributors, and morethan 200 articles have been published in international journals using ABINIT.I will present the overall structure of the package, and its main and most excitingcapabilities. Specific recent examples of projects will demonstrate some of the full palette offeatures in ABINIT. These projects are often carried out in close collaborationwith experimentalists, and ABINIT is also used by or for a number of industrialpartners.

On Hybrid Hw/Sw Components for Embedded System Design

Embedded Systems are increasing in complexity, requiring the use of an adequate design methodology in their conception. These methodologies must deal with several metrics associated with the design of embedded systems. In order to attend these metrics, several software engineering techniques are being applied in embedded system design, as component-based design. Moreover, a design based on higher-level abstraction enable a better design space exploration between several hardware and software compositions. We define hybrid components as a development artifact that can be deployed by different combinations of hardware and software elements. Nevertheless, devising the proper interface for such component is certainly not a straightforward task. This paper presents a strategy to handle the construction of those hybrid components that delivers architectural transparency to clients, enabling the achievement of desired design metrics, through an effective design space exploration.

Framework for the development of a personalised recommender system with integrated web-mining functionalities

A challenge for current e-commerce systems is to improve customer satisfaction by providing instruments for the personalised offer of products. Personalised recommender systems are endowed with intelligent mechanisms to search products that users are interested in. In this paper, we integrate software engineering and web mining techniques in the development of an e-commerce recommender system capable of predicting the preferences of its users and present them a personalised catalogue. A data mining model induced by a decision tree algorithm is used to predict clients' preferences. The system also has an internationalisation automatic mechanism that facilitates the visualisation of the user's interface in different languages.

A requirements engineering process for control engineering software

This paper presents a novel approach for the specification of control engineering software. The proposal is based on software engineering techniques which have improved the performance and quality of software processes. Some of the best practices for the building of software products are included. An example of the proposal is given for the requirements specification of the 1992 ACC robust control benchmark.

Fast algorithms, modular methods, parallel approaches and software engineering for solving polynomial systems symbolically

Symbolic methods are powerful tools in scientific computing. The implementation of symbolic solvers is, however, a highly difficult task due to the extremely high time and space complexity of the problem. In this thesis, we study and apply fast algorithms, modular methods, parallel approaches and software engineering techniques to improve the efficiency of symbolic solvers for computing triangular decomposition, one of the most promising methods for solving non-linear systems of equations symbolically.

A survey study of critical success factors in agile software projects

While software is so important for all facets of the modern world, software development itself is not a perfect process. Agile software engineering methods have recently emerged as a new and different way of developing software as compared to the traditional methodologies. However, their success has mostly been anecdotal, and research in this subject is still scant in the academic circles. This research study was a survey study on the critical success factors of Agile software development projects using quantitative approach. Based on existing literature, a preliminary list of potential critical success factors of Agile projects were identified and compiled. Subsequently, reliability analysis and factor analysis were conducted to consolidate this preliminary list into a final set of 12 possible critical success factors for each of the four project success categories – Quality, Scope, Time, and Cost. A survey was conducted among Agile professionals, gathering survey data from 109 Agile projects from 25 countries across the world. Multiple regression techniques were used, both at the full regression model and at the optimized regression model via the stepwise screening procedure. The results revealed that only 10 out of 48 hypotheses were supported, identifying three critical success factors for Agile software development projects: (a) Delivery Strategy, (b) Agile Software Engineering Techniques, and (c) Team Capability. Limitations of the study are discussed together with interpretations for practitioners. To ensure success of their projects, managers are urged to focus on choosing a high-caliber team, practicing Agile engineering techniques and following Agile-style delivery strategy.

Verification and validation of an intelligent tutorial system

This paper presents the results of a verification and validation process for an intelligent system. The system being studied is an Intelligent Tutorial that employs fuzzy logic and multiagent systems. Software engineering techniques were used in the verification process, while the validation exploited both qualitative and quantitative techniques.