bluuebunny/crossref_metadata_2025 huggingface dataset:
Recovering system specific rules from software repositories
Authors: Williams Chadd C. , Hollingsworth Jeffrey K.
Published: November 2005

One of the most successful applications of static analysis based bug finding tools is to search the source code for violations of system-specific rules. These rules may describe how functions interact in the code, how data is to be validated or how an API is to be used. To apply these tools, the developer must encode a rule that must be followed in the source code. The difficulty is that many of these system-specific rules are undocumented and "grow" over time as the source code changes. Most research in this area relies on expert programmers to document these little-known rules. In this paper we discuss a method to automatically recover a subset of these rules, function usage patterns, by mining the software repository. We present a preliminary study that applies our work to a large open source software project.
Error detection by refactoring reconstruction
Authors: Görg Carsten , Weißgerber Peter
Published: November 2005

In many cases it is not sufficient to perform a refactoring only at one location of a software project. For example, refactorings may have to be performed consistently to several classes in the inheritance hierarchy, e.g. subclasses or implementing classes, to preserve equal behavior.In this paper we show how to detect incomplete refactorings - which can cause long standing bugs because some of them do not cause compiler errors - by analyzing software archives. To this end we reconstruct the class inheritance hierarchies, as well as refactorings on the level of methods. Then, we relate these refactorings to the corresponding hierarchy in order to find missing refactorings and thus, errors and inconsistencies that have been introduced in a software project at some point of the history.Finally. we demonstrate our approach by case studies on two open source projects.
Software repository mining with Marmoset
Authors: Spacco Jaime , Strecker Jaymie , Hovemeyer David , Pugh William
Published: November 2005

Most computer science educators hold strong opinions about the "right" approach to teaching introductory level programming. Unfortunately, we have comparatively little hard evidence about the effectiveness of these various approaches because we generally lack the infrastructure to obtain sufficiently detailed data about novices' programming habits.To gain insight into students' programming habits, we developed Marmoset, a project snapshot and submission system. Like existing project submission systems, Marmoset allows students to submit versions of their projects to a central server, which automatically tests them and records the results. Unlike existing systems, Marmoset also collects finegrained code snapshots as students work on projects: each time a student saves her work, it is automatically committed to a CVS repository.We believe the data collected by Marmoset will be a rich source of insight about learning to program and software evolution in general. To validate the effectiveness of our tool, we performed an experiment which found a statistically significant correlation between warnings reported by a static analysis tool and failed unit tests.To make fine-grained code evolution data more useful, we present a data schema which allows a variety of useful queries to be more easily formulated and answered.
Mining student CVS repositories for performance indicators
Authors: Mierle Keir , Laven Kevin , Roweis Sam , Wilson Greg
Published: November 2005

Over 200 CVS repositories representing the assignments of students in a second year undergraduate computer science course have been assembled. This unique data set represents many individuals working separately on identical projects, presenting the opportunity to evaluate the effects of the work habits captured by CVS on performance. This paper outlines our experiences mining and analyzing these repositories. We extracted various quantitative measures of student behaviour and code quality, and attempted to correlate these features with grades. Despite examining 166 features, we find that grade performance cannot be accurately predicted; certainly no predictors stronger than simple lines-of-code were found.
Toward mining "concept keywords" from identifiers in large software projects
Authors: Ohba Masaru , Gondow Katsuhiko
Published: November 2005

We propose the Concept Keyword Term Frequency/Inverse Document Frequency (ckTF/IDF) method as a novel technique to efficiency mine
concept keywords
from identifiers in large software projects. ckTF/IDF is suitable for mining concept keywords, since the ckTF/IDF is more lightweight than the TF/IDF method, and the ckTF/IDF's heuristics is tuned for identifiers in programs.We then experimentally apply the ckTF/IDF to our educational operating system udos, consisting of around 5,000 lines in C code, which produced promising results; the udos's source code was processed in 1.4 seconds with an accuracy of around 57%. This preliminary result suggests that our approach is useful for mining concept keywords from identifiers, although we need more research and experience.
Source code that talks
Authors: Ying Annie T. T. , Wright James L. , Abrams Steven
Published: November 2005

A programmer performing a change task to a system can benefit from accurate comments on the source code. As part of good programming practice described by Kernighan and Pike in the book
The Practice of Programming
, comments should "aid the understanding of a program by briefly pointing out salient details or by providing a larger-scale view of the proceedings." In this paper, we explore the widely varying uses of comments in source code. We find that programmers not only use comments for describing the actual source code, but also use comments for many other purposes, such as "talking" to colleagues through the source code using a comment "Joan, please fix this method." This kind of comments can complicate the mining of project information because such team communication is often perceived to reside in separate archives, such as emails or newsgroup postings, rather than in the source code. Nevertheless, these and other types of comments can be very useful inputs for mining project information.
Improving evolvability through refactoring
Authors: Ratzinger Jacek , Fischer Michael , Gall Harald
Published: November 2005

Refactoring is one means of improving the structure of existing software. Locations for the application of refactoring are often based on subjective perceptions such as "bad smells", which are vague suspicions of design shortcomings. We exploit historical data extracted from repositories such as CVS and focus on change couplings: if some software parts change at the same time very often over several releases, this data can be used to point to candidates for refactoring. We adopt the concept of bad smells and provide additional
change smells.
Such a smell is hardly visible in the code, but easy to spot when viewing the change history. Our approach enables the detection of such smells allowing an engineer to apply refactoring on these parts of the source code to improve the evolvability of the software. For that, we analyzed the history of a large industrial system for a period of 15 months, proposed spots for refactorings based on change couplings, and performed them with the developers. After observing the system for another 15 months we finally analyzed the effectiveness of our approach. Our results support our hypothesis that the combination of change dependency analysis and refactoring is applicable and effective.
Linear predictive coding and cepstrum coefficients for mining time variant information from software repositories
Authors: Antoniol Giuliano , Rollo Vincenzo Fabio , Venturi Gabriele
Published: November 2005

This paper presents an approach to recover time variant information from software repositories. It is widely accepted that software evolves due to factors such as defect removal, market opportunity or adding new features. Software evolution details are stored in software repositories which often contain the changes history. On the other hand there is a lack of approaches, technologies and methods to efficiently extract and represent time dependent information. Disciplines such as signal and image processing or speech recognition adopt frequency domain representations to mitigate differences of signals evolving in time. Inspired by time-frequency duality, this paper proposes the use of Linear Predictive Coding (LPC) and Cepstrum coefficients to model time varying software artifact histories. LPC or Cepstrum allow obtaining very compact representations with linear complexity. These representations can be used to highlight components and artifacts evolved in the same way or with very similar evolution patterns. To assess the proposed approach we applied LPC and Cepstral analysis to 211 Linux kernel releases (i.e., from 1.0 to 1.3.100), to identify files with very similar size histories. The approach, the preliminary results and the lesson learned are presented in this paper.
Mining version histories to verify the learning process of Legitimate Peripheral Participants
Authors: Huang Shih-Kun , Liu Kang-min
Published: November 2005

Since code revisions reflect the extent of human involvement in the software development process, revision histories reveal the interactions and interfaces between developers and modules.We therefore divide developers and modules into groups according to the revision histories of the open source software repository, for example, sourceforge.net. To describe the interactions in the open source development process, we use a representative model, Legitimate Peripheral Participation (LPP) [6], to divide developers into groups such as core and peripheral teams, based on the evolutionary process of learning behavior.With the conventional module relationship, we divide modules into kernel and non-kernel types (such as UI). In the past, groups of developers and modules have been partitioned naturally with informal criteria. In this work, however, we propose a developer-module relationship model to analyze the grouping structures between developers and modules. Our results show some process cases of relative importance on the constructed graph of project development. The graph reveals certain subtle relationships in the interactions between core and non-core team developers, and the interfaces between kernel and non-kernel modules.
Towards a taxonomy of approaches for mining of source code repositories
Authors: Kagdi Huzefa , Collard Michael L. , Maletic Jonathan I.
Published: November 2005

Source code version repositories provide a treasure of information encompassing the changes introduced in the system throughout its evolution. These repositories are typically managed by tools such as CVS. However, these tools identify and express changes in terms of physical attributes i.e., file and line numbers. Recently, to help support the mining of software repositories (MSR), researchers have proposed methods to derive and express changes from source code repositories in a more source-code "aware" manner (i.e., syntax and semantic). Here, we discuss these MSR techniques in light of what changes are identified, how they are expressed, the adopted methodology, evaluation, and results. This work forms the basis for a taxonomic description of MSR approaches.
A framework for describing and understanding mining tools in software development
Authors: German Daniel M. , Cubranić Davor , Storey Margaret-Anne D.
Published: November 2005

We propose a framework for describing, comparing and understanding tools for the mining of software repositories. The fundamental premise of this framework is that mining should be done by considering the specific needs of the users and the tasks to be supported by the mined information. First, different types of users have distinct needs, and these needs should be taken into account by tool designers. Second, the data sources available, and mined, will determine if those needs can be satisfied. Our framework is based upon three main principles: the type of user, the objective of the user, and the mined information. This framework has the following purposes: to help tool designers in the understanding and comparison of different tools, to assist users in the assessment of a potential tool; and to identify new research areas. We use this framework to describe several mining tools and to suggest future research directions.
SCQL
Authors: Hindle Abram , German Daniel M.
Published: November 2005

Source Control Repositories are used in most software projects to store revisions to source code files. These repositories operate at the file level and support multiple users. A generalized formal model of source control repositories is described herein. The model is a graph in which the different entities stored in the repository become vertices and their relationships become edges. We then define SCQL, a first order, and temporal logic based query language for source control repositories. We demonstrate how SCQL can be used to specify some questions and then evaluate them using the source control repositories of five different large software projects.
Developer identification methods for integrated data from various sources
Authors: Robles Gregorio , Gonzalez-Barahona Jesus M.
Published: November 2005

Studying a software project by mining data from a single repository has been a very active research field in software engineering during the last years. However, few efforts have been devoted to perform studies by integrating data from various repositories, with different kinds of information, which would, for instance, track the different activities of developers. One of the main problems of these multi-repository studies is the different identities that developers use when they interact with different tools in different contexts. This makes them appear as different entities when data is mined from different repositories (and in some cases, even from a single one). In this paper we propose an approach, based on the application of heuristics, to identify the many identities of developers in such cases, and a data structure for allowing both the anonymized distribution of information, and the tracking of identities for verification purposes. The methodology will be presented in general, and applied to the GNOME project as a case example. Privacy issues and partial merging with new data sources will also be considered and discussed.
Collaboration using OSSmole
Authors: Conklin Megan , Howison James , Crowston Kevin
Published: November 2005

This paper introduces a collaborative project
OSSmole
which collects, shares, and stores comparable data and analyses of free, libre and open source software (FLOSS) development for research purposes. The project is a clearinghouse for data from the ongoing collection and analysis efforts of many disparate research groups. A collaborative data repository reduces duplication and promote compatibility both across sources of FLOSS data and across research groups and analyses. The primary objective of OSSmole is to mine FLOSS source code repositories and provide the resulting data and summary analyses as open source products. However, the OSSmole data model additionally supports donated raw and summary data from a variety of open source researchers and other software repositories. The paper first outlines current difficulties with the typical quantitative FLOSS research process and uses these to develop requirements for such a collaborative data repository. Finally, the design of the OSSmole system is presented, as well as examples of current research and analyses using OSSmole.
An analysis of data sets used to train and validate cost prediction systems
Authors: Mair Carolyn , Shepperd Martin , Jørgensen Magne
Published: November 2005

OBJECTIVE - to build up a picture of the nature and type of data sets being used to develop and evaluate different software project effort prediction systems. We believe this to be important since there is a growing body of published work that seeks to assess different prediction approaches.METHOD - we performed an exhaustive search from 1980 onwards from three software engineering journals for research papers that used project data sets to compare cost prediction systems.RESULTS - this identified a total of 50 papers that used, one or more times, a total of 71 unique project data sets. We observed that some of the better known and easily accessible data sets were used repeatedly making them potentially disproportionately influential. Such data sets also tend to be amongst the oldest with potential problems of obsolescence. We also note that only about 60% of all data sets are in the public domain. Finally, extracting relevant information from research papers has been time consuming due to different styles of presentation and levels of contextural information.CONCLUSIONS - first, the community needs to consider the quality and appropriateness of the data set being utilised; not all data sets are equal. Second, we need to assess the way results are presented in order to facilitate meta-analysis and whether a standard protocol would be appropriate.
Longitudinal analysis of long-timescale open source repository data
Authors: Massey Bart
Published: November 2005

One of the more unique features of open source software development is the continuity of projects over large time scales and incremental development efforts. For this reason, the open development process provides an interesting environment for investigation of the software development process. The problems of data collection and analysis of two particular long-running repositories, the X Window System and the Nickle Programming Language, are considered here as instructive examples. The use of uniform software tools (CVS/RCS) with open formats and interfaces makes it possible to collect data that provide unique analysis opportunities.
Towards predictor models for large libre software projects
Authors: Herraiz Israel , Robles Gregorio , Gonzalez-Barahona Jesus M.
Published: November 2005

Libre (free/open source) software provides an ample range of publicly available data sources about its development, which can be retrieved and analyzed. Consequently, it offers a good opportunity to build predictive estimation and evolution models. The main challenge to understand libre software development is that its development nature is radically different from 'classical' in-house software development, common in industry in the last decades. Developers and other human resources are generally a mixture of a few hired developers and many volunteers whose contribution (in number of hours per week and in total time devoted to the project) is not foreseeable in advance. This paper is a first step in finding predictive models in the libre software world. We have studied three data repositories (versioning system, mailing lists and bug tracking system) of GNOME, a large libre software project with several thousand contributors and several millions of lines of code, measuring activity and participation in it during the last years. Results and correlations for these sources allow us to adventure some first estimations of how participation and activity will evolve in the future.
Baselines in requirements tracing
Authors: Sundaram Senthil Karthikeyan , Hayes Jane Huffman , Dekhtyar Alexander
Published: November 2005

We summarize the results of our requirements tracing work to date, focusing on our empirical results with open source datasets. Specifically, we describe the problem of after-the-fact requirements tracing for Verification and Validation (V&V) analysts, we provide a brief overview of Information Retrieval methods we have applied as well as measures used to evaluate them, we describe our tracing tool, and we present the results of a number of empirical studies. Two of the open source datasets that we have used are available to the research community at http://promise.site.uottawa.ca/SERepository/.
Simple software cost analysis
Authors: Menzies Tim , Port Dan , Chen Zhihao , Hihn Jairus
Published: November 2005

Delta estimation uses changes to old projects to estimate new projects. Delta estimation assumes that new costs can be extrapolated from old projects. In this study, we show that in certain real-world data sets. there exists attributes where this assumption does not hold. We define here an automatic method to find which attributes can be safely used for delta estimation.
Feature subset selection can improve software cost estimation accuracy
Authors: Chen Zhihao , Menzies Tim , Port Dan , Boehm Barry
Published: November 2005

Cost estimation is important in software development for controlling and planning software risks and schedule. Good estimation models, such as COCOMO, can avoid insufficient resources being allocated to a project. In this study, we find that COCOMO's estimates can be improved via WRAPPER- a feature subset selection method developed by the data mining community. Using data sets from the PROMISE repository, we show WRAPPER significantly and dramatically improves COCOMO's predictive power.
An investigation of the effect of module size on defect prediction using static measures
Authors: Koru A. Günes , Liu Hongfang
Published: November 2005

We used several machine learning algorithms to predict the defective modules in five NASA products, namely, CM1, JM1, KC1, KC2, and PC1. A set of static measures were employed as predictor variables. While doing so, we observed that a large portion of the modules were small, as measured by lines of code (LOC). When we experimented on the data subsets created by partitioning according to module size, we obtained higher prediction performance for the subsets that include larger modules. We also performed defect prediction using class-level data for KC1 rather than the method-level data. In this case, the use of class-level data resulted in improved prediction performance compared to using method-level data. These findings suggest that quality assurance activities can be guided even better if defect prediction is performed by using data that belong to larger modules.
Nearest neighbor sampling for better defect prediction
Authors: Boetticher Gary D.
Published: November 2005

An important step in building effective predictive models applies one or more sampling techniques. Traditional sampling techniques include random, stratified, systemic, and clustered. The problem with these techniques is that they focus on the
class attribute
, rather than the
non-class attributes.
For example, if a test instance's nearest neighbor is from the opposite class of the training set, then it seems doomed to misclassification. To illustrate this problem, this paper conducts 20 experiments on five different NASA defect datasets (CM1, JM1, KC1, KC2, PC1) using two different learners (J48 and Naïve Bayes). Each data set is divided into 3 groups, a training set, and "nice/nasty" neighbor test sets. Using a nearest neighbor approach, "Nice neighbors" consist of those test instances closest to class training instances. "Nasty neighbors" are closest to opposite class training instances. The "Nice" experiments average 94 percent accuracy and the "Nasty" experiments average 20 percent accuracy. Based on these results a new nearest neighbor sampling technique is proposed.
Realising evidence-based software engineering
Authors: Kitchenham Barbara , Budgen David , Brereton Pearl , Linkman Step Hen
Published: November 2005

This paper provides an introduction to the papers for the Workshop on Realising Evidence-Based Software Engineering.
The type of evidence produced by empirical software engineers
Authors: Segal Judith , Grinyer Antony , Sharp Helen
Published: November 2005

This paper reports on the research published between the years 1997 and 2003 inclusive in the journal of Empirical Software Engineering, drawing on the taxonomy developed by Glass et al. in [3]. We found that the research was somewhat narrow in topic with about half the papers focusing on measurement/metrics, review and inspection; that researchers were almost as interested in formulating as in evaluating; that hypothesis testing and laboratory experiments dominated evaluations; that research was not very likely to focus on people and extremely unlikely to refer to other disciplines. We discuss our findings in the context of making empirical software engineering more relevant to practitioners.
Software engineering practice versus evidence-based software engineering research
Authors: Rainer Austen , Jagielska Dorota , Hall Tracy
Published: November 2005

In this paper, we review four examples in software engineering practice of the lack of use of empirical evidence. We use these examples to support our claims that practitioners and researchers appear to have different values with regards to empirical evidence, and appear to use different criteria when evaluating the credibility of evidence. From our examples, it seems that practitioners need to be
persuaded
to adopt evidence-based software engineering practices. Consequently, the research community needs to consider strategies for persuading practitioners. Paradoxically for software engineering research, the more effective persuasion strategies may be ones that, initially at least, do not rely on empirical evidence.
Accumulation and presentation of empirical evidence
Authors: Ciolkowski Marcus , Münch Jürgen
Published: November 2005

Understanding the effects of software engineering techniques and processes under varying conditions can be seen as a major prerequisite towards predictable project planning and guaranteeing software quality. Evidence regarding the effects of techniques and processes for specific contexts can be gained by empirical studies. Due to the fact that software development is a human-based and context-oriented activity the effects vary from project environment to project environment. As a consequence, the studies need to be performed in specific environments and the results are typically only valid for these local environments. Potential users of the evidence gained in such studies (e.g., project planners who need to select techniques and processes for a project) are confronted with difficulties such as finding and understanding the relevant results and assessing whether and how they can be applied to their own situation. Thereby, effective transfer and use of empirical findings is hindered. Our thesis is that effective dissemination and exploitation of empirical evidence into industry requires aggregation, integration, and adequate stakeholder-oriented presentation of the results. This position paper sketches major problems and challenges and proposes research issues towards solving the problem.
Evidence-based practice in human-computer interaction and evidence maps
Authors: John Bonnie E.
Published: November 2005

At the onset of evidence-based practice in software engineering, prospective disciples of this approach should inspect and learn from similar attempts in other disciplines. Having participated in the National Cancer Institute's multi-year effort compiling evidence-based guidelines for information-rich web-site design, I bring my personal experiences as a member of that group to the discussions at the workshop. From my experience doing other empirical research, I propose using an
evidence map
to communicate research questions, the available evidence to answer those questions, the relationship between the questions, and the meaning of different paths through the evidence map. I have used this device for several empirical studies, both in HCI and in software engineering, and have found it to be a useful organization tool that could help in pursuing evidence-based software engineering.
Combining software evidence
Authors: Weaver Rob , Despotou Georgios , Kelly Tim , McDermid John
Published: November 2005

Argumentation is an approach which can be used for describing how evidence satisfies requirements and objectives. A structured argumentation notation allows developers to determine the need for individual items of evidence and allows reviewers to determine whether a complete set of evidence satisfies the requirements. This paper introduces an established argumentation notation from the safety critical domain, as well as new research into dependability arguments and assurance of arguments. These techniques and concepts have been applied to the development and certification of safety critical software and it is believed they are both applicable to and beneficial for the wider field of evidence-based software engineering.
Scenarios, state machines and purpose-driven testing
Authors: Alspaugh Thomas A. , Richardson Debra J. , Standish Thomas A.
Published: November 2005

Testing is a necessary but frequently expensive activity that is needed to ensure software quality. For large, complex systems, testing based on covering all control flow or all data flow paths is intractable. But focusing on tests that are purpose-driven, namely on tests that are derived from system requirements and that test whether requirements goals are met, significantly reduces the size of a "complete" test suite for the system while simultaneously increasing confidence that the system performs as expected.Scenarios and state machines provide a useful framework for modeling and analysis of purpose-driven testing. Scenarios are sequences of events that represent purposeful uses of a system (or of its components, to any desired degree of detail). State machines, in the form of recursive transition diagrams, can model the successive refinement of requirements goals into architectures and implementations, and testing them using purpose-driven scenario-based tests provides early validation of that refinement. Formulating sets of scenarios that capture and represent a complete-enough set of requirements ensures that a test suite covering them explores all important regions of a system's state space. The scenario-based tests will predict with high confidence which system goals have been met, and, certainly, which have not. This position paper sketches elements of our approach to purpose-driven testing using scenarios and state machines.
Story driven testing - SDT
Authors: Geiger Leif , Zündorf Albert
Published: November 2005

In the last years, SCESM community has studied a number of synthesis approaches that turn scenario descriptions into some kind of state machine. In our story driven modeling approach, the statechart synthesis is done manually. Many other approaches rely on human interaction, too. Frequently, the resulting state machines are just the starting point for further system development. The manual steps and the human interaction and the subsequent development steps are subject to the introduction of errors. Thus, it is not guaranteed that the final implementation still covers the initial scenarios. Therefore, this paper proposes the exploitation of scenarios for the derivation of automatic tests. These tests may be used to force the implementation to implement at least the behavior outlined in the requirements scenarios. In addition, this approach raises the value of formal scenarios for requirements elicitation and analysis since such scenarios are turned into automatic tests that may be used to drive iterative development processes according to test-first principles.
Reconciling scenario-centered controller design with state-based system models
Authors: Giese Holger , Kindler Ekkart , Klein Florian , Wagner Robert
Published: November 2005

Scenarios are an effective means for defining the expected behavior of a system during the design and implementation phase. The 'Come Let's Play' approach has demonstrated that scenarios can fully define a system's behavior. In practice, however, the expected behavior defined by scenarios must be achieved in the context of existing components that cannot be changed. Therefore, the scenario-based approach must be reconciled with state-based models. In this paper, we present such an approach for the design of flexible production systems which employs scenarios not only for describing and synthesizing the required system functionality but also for recording observed behavior for analysis or 3D-visualization. We illustrate our approach using an existing material flow system which is a major part of a real production system.
Eliciting requirements and scenarios using the SCTL-MUS methodology
Authors: Pazos-Arias José J. , García-Duque Jorge , López-Nores Martín
Published: November 2005

The development of complex systems demands methodologies that provide convenient support to the stakeholders in the creative tasks. In this paper, we present a methodology for the incremental elicitation of requirements and scenarios, driven by the integration checks performed over a state machine that represents the global behavior of the desired system.
Modeling nonfunctional requirements
Authors: Dinkel Michael , Baumgarten Uwe
Published: November 2005

The management of dynamic systems is an upcoming challenge for software engineers in automotive and other embedded systems. The complexity of current automotive computing systems is already difficult to handle for car makers and the expected growth in the area of electronic devices in vehicles will even intensify this situation. This paper presents a model based approach for enabling automatic configuration of distributed component oriented systems. Nonfunctional requirements and capabilities of software components and platforms are explicitly modeled and provide for well-founded statements whether a component is able to execute on a certain platform or not. With application models and platform models the validity of a configuration is defined in this paper. The models even allow reconfigurations based on information regarding the actual system context like user behavior, backend or environmental sensor information.
A flexible integration strategy for in-car telematics systems
Authors: Bauer Thomas , Herrmann Jens , Liggesmeyer Peter , Robinson-Mallett Christopher
Published: November 2005

This paper presents an approach for the planning of integration tests of automotive telematics systems. To our knowledge no method for the determination of an integration order exists that takes the project and the system environment into account, which in our opinion greatly influence the integration order. Furthermore, most known test generation methods and structural quality measures demand syntactically sound specifications to be applied efficiently. In our projects Message Sequence Charts are often created manually from the scratch with many different tools, and therefore they are of rather low syntactical quality. This paper addresses the determination of an integration strategy, which can easily be adapted to changes in the project or in the system environment, and which can be manually applied to any given specification.
Issues in performance certification for high-level automotive control software
Authors: Weide Bruce W. , Bucci Paolo , Heym Wayne D. , Sitaraman Murali , Rizzoni Giorgio
Published: November 2005

High-level supervisory control software for automotive applications (e.g., drive-by-wire) presents many challenges to making performance guarantees, which are a necessary part of the software's certification for deployment. The features of such systems demand that a compositional, or modular, approach to reasoning about performance be devised and applied. We discuss one such analytical approach as an alternative to simulation and testing.
Business situation reflected in automotive electronic architectures
Authors: Fröberg Joakim , Sandström Kristian , Norström Christer
Published: November 2005

Automotive vehicle electronic systems are developed facing a complex and large set of inter-related requirements from numerous stakeholders, many of which are internal to the Original Equipment Manufacturer, OEM. The electronic architecture, of the product, or its structure and design principles, form an equally complex construct; including technology and methods, which ultimately should be chosen to optimally support the organization's own business situation.In this paper, we have analyzed the relationship of four automotive electronic architectures to their respective business requirements and business context. The study shows four functionally rather similar products with computer controlled power train, body functions, and instrument. In the light of the business situation, we explain the solutions and why design principles are pursued. The analysis shows that despite a common base of similar vehicle functionality the resulting electronic architectures used by the four organizations are quite different. The reason for this becomes apparent when looking at different business context and business requirements and their affect on the architecture. Differences in business situation drive the use of different methods for integration, different standards, different number of configurations, and different focus in the development effort. Some key parameters in business situation affecting architectural design decisions are shown to be product volume, size of market, and business requirements on openness and customer adaptation.An important lesson from this is that one should be very careful to uncritically apply technical solutions from one industry in another, even when they are as closely related as the applications described in this work. Understanding the requirements from the business case is the key to choosing architectural solutions.
Real-time component integration based on transparent distribution
Authors: Farcas Emilia , Farcas Claudiu , Pree Wolfgang , Templ Josef
Published: November 2005

This paper introduces a real-time component model that offers a separation of concerns which allows a straight-forward integration of independently developed components. So-called transparent distribution forms the backbone of the integration process. Transparent distribution means that (1) the functional and temporal behavior of a system is the same no matter on which node of a distributed system a component is executed and (2) the developer does not have to care about the differences of local versus distributed execution of a component. We first present the concepts of a component model for real time systems that is well suited for transparent distribution. The component model is based on logical execution time, which abstracts from physical execution time and thereby from both the execution platform and the communication topology. Then we discuss the resulting tool chain and integration process. A case study rounds out the paper.
Towards verified automotive software
Authors: Botaschanjan J. , Kof L. , Kühnel C. , Spichkova M.
Published: November 2005

Automotive software is one of the most challenging fields of software engineering: it must meet real time requirements, is safety critical and distributed over multiple processors. With the increasing complexity of automotive software, as for example in the case of drive-by-wire, automated driving and driver assitents, software correctness becomes more and more a crucial issue. In order that these innovations can become reality, it is necessary to be able to
guarantee
software correctness.The presented work aims at verification of automotive software. For this purpose it introduces a verification approach, including a framework of verified modules which assists the verification of the actual application. Feasibility of this approach was validated on a case study that also showed how verification can be integrated into the development process.
DISCOA
Authors: Demir Omer Erdem , Devanbu Prem , Medvidovic Nenad , Wohlstadter Eric
Published: November 2005

Modern distributed systems have greatly benefited from developments such as model-driven development, and architectural description languages. Abstract models of components (
e.g.
, IDL) and models of interconnection (
e.g.
, architectural description languages, or ADLs) provide important software engineering advantages, such as explicit design models, type-checked integration across machine and language boundaries (with generated marshaling and dispatch code), the possibility of third-party components, and automated verification of design artifacts. But, when distributed systems are enhanced to provide security features, many of these advantages do not apply. Security features are hand-written into almost every part of the system; there is no explicit component or architectural model, or separable "security component" security code fragments are scattered and tangled through the different distributed elements of the system, and are often reduced to communicating through lowest-common denominator fragments (like raw bytes) since they are not represented in the model.In this paper, we describe DISCOA, a proposed extension of our earlier work on DADO [23] to handle security features in distributed systems, using explicit architectural models with aspect-oriented extensions.
XacT
Authors: Rits Maarten , De Boe Benjamin , Schaad Andreas
Published: November 2005

In this paper we describe the eXtreme access control Tool (XacT) which provides an automated way to obtain access control information out of multi-layered applications. We believe that based on this information consistent access control policies can be specified to prevent over-privileged accounts. The main difficulty, that leads to these over-privileged accounts, comes from the distinction that must be made between identifying which users
should
perform a workflow task (resource management) and which users
are allowed
to perform a task (access control), as well as the fact that access control enforcement is typically spread over different layers in applications (e.g. database layer, operating system layer, workflow layer). In this paper, we present an automated way to obtain access control information out of multi-layered applications. We base our observations on recent insights into workflow controlled judicial information systems.
Towards a unifying view on security contracts
Authors: De Win Bart , Piessens Frank , Smans Jan , Joosen Wouter
Published: November 2005

A key property of software component technology is predictability, which means that the properties of an overall system can be deduced from the properties of the individual components. One of the crucial building blocks in component technology is the notion of component contract. In order to leverage predictability for the construction of secure systems, security requirements and properties must be adequately supported by component contracts, which is currently a challenging and open problem. This paper provides an overview of the problem domain by presenting an initial taxonomy of security contracts and their representative security properties.
Risky trust
Authors: Dwaikat Zaid , Parisi-Presicce Francesco
Published: November 2005

Measuring the security of a software system is a difficult problem. This paper presents a model using common security concepts to evaluate the security of a system under design. After providing definitions for all relevant concepts and formalizing some of them, we define security requirements for transactions and provide mechanisms to measure the likelihood of violation of these requirements. Our model is based on individual risks presented by system components. Based on the security policy and individual risks, we calculate violation risk for a certain transaction. Context and other risk factors are considered and can be used to adjust the final risk figure. As part of our discussion, we address trust and risk and their significance to security engineering. Based on the decision process, the same trust assumptions may increase, or decrease, the risk to the system. We model the fact that small individual risks can be transformed into major risks when combined together in a complex attack.
Building security requirements with CLASP
Authors: Viega John
Published: November 2005

Traditionally, security requirements have been derived in an
ad hoc
manner. Recently, commercial software development organizations have been looking for ways to produce effective security requirements.In this paper, we show how to build security requirements in a structured manner that is conducive to iterative refinement and, if followed properly, metrics for evaluation. While requirements specification cannot be a complete science, we provide a framework that is an obvious improvement over traditional methods that do not consider security at all.We provide an example using a simple three-tiered architecture. The methodology we document is a subset of CLASP, a set of process pieces for application security that we have recently published, in conjunction with IBM/Rational.
A framework for testing security mechanisms for program-based attacks
Authors: Breech Ben , Pollock Lori
Published: November 2005

Program vulnerabilities leave organizations open to malicious attacks that can result in severe damage to company finances, resources, consumer privacy, and data. Engineering applications and systems so that vulnerabilities do not exist would be the best solution, but this strategy may be impractical due to fiscal constraints or inadequate knowledge. Therefore, a variety of program and system-based solutions have been proposed to deal with vulnerabilities in a manageable way. Unfortunately, proposed strategies are often poorly tested, because current testing techniques focus on the common case whereas vulnerabilities are often exploited by uncommon inputs.In this paper, we present the
design
of a testing framework that enables the efficient, automatic and systematic testing of security mechanisms designed to prevent program-based attacks. The key insight of the framework is that dynamic compilation technology allows us to insert and simulate attacks during program execution. Thus, a security mechanism can be tested using
any
program, not only those with known vulnerabilities.
A software flaw taxonomy
Authors: Weber Sam , Karger Paul A. , Paradkar Amit
Published: November 2005

Although proposals were made three decades ago to build static analysis tools to either assist software security evaluations or to find security flaws, it is only recently that static analysis and model checking technology has reached the point where such tooling has become feasible. In order to target their technology on a rational basis, it would be useful for tool-builders to have available a taxonomy of software security flaws organizing the problem space. Unfortunately, the only existing suitable taxonomies are sadly out-of-date, and do not adequately represent security flaws that are found in modern software.In our work, we have coalesced previous efforts to categorize security problems as well as incident reports in order to create a security flaw taxonomy. We correlate this taxonomy with available information about current high-priority security threats, and make observations regarding the results. We suggest that this taxonomy is suitable for tool developers and to outline possible areas of future research.