waashk/dblp huggingface dataset:
challenges in automotive software engineering. developing and integrating automotive embedded software is a complex undertaking. the software is large. it is developed by many contributors. it is distributed over many control units connected by a variety of in-vehicle buses. often much of the equipment or functions in a car are optional and regulatory requirements also vary between markets, leading to large combinatorial variations of software features. targets running the software have to be cheap. errors can be extremely expensive. new software and system features are demanded by the market and also by governmental regulations. model-based design (mbd) of functional behaviour has been a big help in the recent past on the one hand, and on the other hand has by itself created new complexity by allowing relatively quick development of ever more features, especially when combined with autocoding. all this creates new challenges that did not exist a few years ago when feature development was slow. major new challenges now are to tame all the complexity, get a system view on top of the individual functions, and to leverage executable system models to put more comprehensive testing into early phases of a development. tools are required which really help those engineers and software developers. their needs may not ask for a lot of computer science glamour. they can be quite basic and sophisticated concepts from computer science may find it difficult to find acceptance outside some niches. this presentation will outline the achievements, the current challenges and will point to upcoming tools and approaches that help meeting those challenges.
cooperative and human aspects of software engineering (chase 2008). the chase 2008 workshop is concerned with exploring the cooperative and human aspects of software engineering, and providing a forum for discussing high-quality resarch. accepted papers reflect the diversity of the field of software engineering--ranging from requirements to testing, and from ethnographic research to experiments. moreover, the background of attendees reflects the diversity of researchers in this domain, ranging from sociology to psychology, from informatics to software engineering. chase 2008 met its goals in presenting high-quality research and building community through a mixture of presentations, discussions, posters, and social activities.
on the automation of fixing software bugs. software testing can take up to half of the resources of the development of new software. although there has been a lot of work on automating the testing phase, fixing a bug after its presence has been discovered is still a duty of the programmers. techniques to help the software developers for locating bugs exist though, and they take name of automated debugging. however, to our best knowledge, there has been only little attempt in the past to completely automate the actual changing of the software for fixing the bugs. therefore, in this paper we propose an evolutionary approach to automate the task of fixing bugs. the basic idea is to evolve the programs (e.g., by using genetic programming) with a fitness function that is based on how many unit tests they are able to pass. if a formal specification of the buggy software is given, more sophisticated fitness functions can be designed. moreover, by using the formal specification as an oracle, we can generate as many unit tests as we want. hence, a co-evolution between programs and unit tests might take place to give even better results. it is important to know that, to fix the bugs in a program with this novel approach, a user needs only to provide either a formal specification or a set of unit tests. no other information is required.
a state coverage tool for junit. we present a junit test runner that informs users of missing behavior checks in their tests. the tool tracks variable updates and definitions over the course of a test execution and determines which variables influence which assertions via dynamic taint analysis. the program statements that set outputs which do not influence the outcome of any test assertions are reported as state coverage inadequacies. with traditional code coverage tools, users can ensure that tests execute all program statements; with this tool, they can additionally ensure that program output is checked, in one way or another, by a test.
using software engineering technology to improve the quality of medical processes. in this paper, we describe some of the key observations resulting from our work on using software engineering technologies to help detect errors in medical processes. in many ways, medical processes are similar to distributed systems in their complexity and proneness to contain errors. we have been investigating the application of a continuous process improvement approach to medical processes in which detailed and semantically rich models of the medical processes are created and then subjected to rigorous analyses. the technologies we applied helped improve understanding about the processes and led to the detection of errors and subsequent improvements to those processes. this work is still preliminary, but is suggesting new research directions for medical process improvement, software engineering technologies, and the applicability of these technologies to other domains involving human-intensive processes.
sixth workshop on software quality. software quality has been a major challenge throughout information technology projects. whether it is in software development, in software integration or whether it is in the implementation or customization of shrink-wrapped software, quality is regarded as a major issue. in the last couple of decades, much software engineering research has focussed on standards, methodologies and techniques for improving software quality, measuring software quality and software quality assurance. most of this research is focused on the internal/development view of quality. more recent studies have made attempts to understand the stakeholder view of quality. with globalisation, many new challenges affect software quality. not only do we need to understand the many stakeholder views of quality, we now need to consider the cultural issues, and the outsourcing issues. the sixth workshop on software quality aims to bring together academic, industrial and commercial communities interested in software quality topics to discuss the different technologies being defined and used in the software quality area.
techniques and tools for the automatic generation of optimal test data at code, model and interface level. this article presents two different tools automating the generation of optimized test data for unit, model-based and integration testing by maximizing the coverage and minimizing the number of test cases required. to cope with these conflicting goals, hybrid self-adaptive and multi-objective evolutionary algorithms were applied. the efficiency was demonstrated by evaluating fault detection capability by mutation testing. thanks to the effort reduction offered, the approach is particularly suitable for the verification of complex, safety-relevant software systems.
analyzing dynamic call graphs enhanced with program state information for feature location and understanding. in this paper we present a prototype tool for locating and understanding features in unfamiliar source code of complex c/c++ software systems. the key concepts of the analysis tool are (1) combining dynamic function call graphs with information on the functions' containment within hierarchically structured modules and (2) providing means of gathering program state information on user-defined locations within the call graph. starting from a typically huge dynamic call graph logged during feature execution, developers narrow their search for functions implementing the feature's core functionality by successively pruning the graph from feature-irrelevant functions. the assessment whether a function contributes to a feature is performed on various levels of abstraction, namely on (1) module containment, (2) on the function's call relations, and (3) on the way it modifies data. having sorted out feature-irrelevant functions this way, users are able to analyze the remaining, probably highly feature-relevant functions with other heavy-weight analysis techniques, such as debugging techniques, to get a deep understanding of the feature implementation.
a code provenance management tool for ip-aware software development. in this paper we introduce a code provenance management tool which can track the provenance of source code and generate provenance reports to facilitate best practices for managing intellectual property (ip) throughout the software development lifecycle. we present the ip-aware process supported by the tool and explain how it reduces both the cost and the risk of code ip management. results from three pilots are analyzed to illustrate the effectiveness of cost and risk reduction.
role-based trust management security policy analysis and correction environment (rt-space). this paper presents rt-space, a tool suite for authoring, verifying, and correcting rt access control policies. rt is a role-based trust management framework well suited for use in systems that must protect the interests of multiple stakeholders in a decentralized environment.
advancing test automation technology to meet the challenges of model-driven software development: report on the 3rd workshop on automation of software test. the third workshop on automation of software test (ast 2008) at the 30th interna¬tional conference on software engineering (icse 2008) sets a special theme on model-based software testing. nine full research papers and six short papers will be presented in four sessions at the workshop. this report summarizes the organization of the workshop as well as the sessions and papers to be presented at the workshop.
seams 2008: software engineering for adaptive and self-managing systems. the software engineering for adaptive and self-managing systems (seams) workshop aims at consolidating the interest in the software engineering community on self-adaptive and self-managing systems. seams provides a forum for researchers and practitioners to share new results, discuss challenging issues, raise awareness, and promote collaboration within the community. the seams 2008 workshop builds on the success of seams 2006 at icse in shanghai and seams 2007 at icse in minneapolis.
workshop on comparison and versioning ofsoftware models (cvsm08). comparison and versioning of software models is an urgent theoretical and practical problem area in the context of model-driven software development. a range of detailed issues are addressed by the contributions to cvsm08. this workshop summary introduces important research areas and categorizes the contributions of the workshop.
early aspects at icse 2008: workshop on aspect-oriented requirements engineering and architecture design. the "early aspects @ icse'08" is the 13th edition of the workshop on early aspects [1]. early aspects focuses on the identification, modularization, representation and composition of crosscutting concerns during the requirements engineering and architecture derivation activities. the specific aim of the present workshop is twofold: (a) to stimulate integration of the work on early development activities for product lines with the work for early aspects, and (b) to initiate creation of a product lines application demonstration with early aspects.
designing a prosthetic memory to support software developers. about their activities and the resulting artifacts which helps them remain oriented, avoid omissions, and correctly use artifacts. when stored only in the developer's organic memory, this knowledge may degrade and cannot directly be shared with others. its consistent externalization, however, is currently limited by production costs, indirect returns, and its limited saliency in contexts where it could be useful. in this work we propose a memory aid which strives to overcome these barriers, and reduce the resulting problems. developers will provide short and raw subjective notes which will be associated with the code context but stored separately from it, allowing us to increase saliency via two novel presentations. the first, designed after human episodic memory, chronologically interleaves these subjective notes with an automatically-gathered record of the developer's objective activities. it virtually extends shorter-term memory, aiding with orientation and increasing the saliency of recent knowledge and reminders. the second, a contextual view, uses static dependencies and historical records to present notes which may be relevant to the developer's current context.
3rd international workshop on advances and applications of problem frames. michael jackson's problem frames are a highly promising approach to early life-cycle software engineering. their focus moves the engineer back to the problem to be solved rather than forward to the software and solving a poorly defined problem. by applying the problem frames approach, the software engineer can understand the problem context and how it is to be affected by the proposed software, and ultimately work towards the right solution for the problem. the influence of the problem frames approach and related work is spreading in the fields of domain modelling, business process modelling, requirements engineering, software architecture as well as software engineering in general.
model-driven configuration of os-level mandatory access control: research abstract. trust and assurance of mobile platforms is a prime objective when considering their use in security-critical scenarios like in healthcare or e-government. currently, several complementary approaches can be found in literature, ranging from purely hardware based to operating system level and application level solutions. together, they build a "trusted and secured" technology stack. however, the complex policy configuration mechanisms at every single layer also represent the biggest stumbling block for a rapid adoption. we propose a practicable and efficient solution for leveraging operating system level and application level security mechanisms to realize security-critical applications and services.
mining early aspects from requirements with ea-miner. aspect-oriented requirements engineering (aore) aims at bringing the benefits achieved by separation of concerns (e.g., improved modularity, reusability and maintainability) to requirements engineering. in order to cope with costly tasks performed during aore such as identifying concerns and structuring requirements in different models, tool support is vital to effectively reduce the burden of performing these various tasks. this demonstration describes how the ea-miner tool provides automated support, based on natural language processing techniques, for mining various types of concerns from a variety of early stage requirements documents. the tool is implemented as an eclipse plug-in and enables several features such as visualizing and editing the models and generating specification documents.
4th international workshop on predictor models in se (promise 2008). the promise workshop seeks to deliver to the software engineering community useful, usable, verifiable, and repeatable models. to provide a sound and realistic basis for creating predictive models, and to allow researchers to conduct repeatable software engineering experiments, we maintain the promise repository, a growing collection that now contains 57 empirically-based data sets.
pkm: knowledge management tool for environments centered on the concept of the experience factory. this paper presents pkm - a web-based tool for knowledge management in an environment centered on the concept of the experience factory. the tool focuses on managing explicit knowledge, most of which is collected in an automated way using non-invasive plug-ins and probes. it provides customizable metric views, metric interpretation and abstraction capabilities, helps in extraction and evaluation of metric progress models.
codecity: 3d visualization of large-scale software. codecity is a language-independent interactive 3d visualization tool for the analysis of large software systems. based on a city metaphor, it depicts classes as buildings and packages as districts of a "software city". by offering consistent locality and solid orientation points we keep the viewer oriented during the exploration of a city. we applied our tool on several large-scale industrial systems.
an aspect-oriented approach for improving architecture design efficiency. major issues in software engineering today are the ever increasing size and complexity of systems with, at the same time, high demands for quality. software architectures are a means for coping with size and complexity of systems and also for assuring required qualities. the processes of creating architectures, however, remain affected by these issues. since, in practice, architectures have to be constructed iteratively, the number of established architectural strategies and the number of inter-related models heavily increase over time. hence, the impact analysis of newly introduced quality strategies during later stages becomes highly effort-intensive and error-prone. with our approach we aim at the mitigation of effort needed for such quality impact analyses by enabling efficient separation of concerns. for achieving efficiency, we introduce an aspect-oriented approach that enables the automatic weaving of quality strategies into architectural artifacts. by doing so, we are able to conduct selective quality impact evaluations with significantly reduced effort.
the future of end user programming? one of the holy grails of computer science for many decades has been to make the power of computer programming accessible to more and more people. the earliest "high level" languages, fortran and cobol, were intentionally designed to be written and understood by specific communities of users with problems to solve, namely the scientific/engineering and business communities. as computing became more accessible to more people, the number of dedicated full time programmers mushroomed and formed a community unto itself, who largely created languages and tools by and for themselves to use. the end users, the people with the non-computing problems to solve, became isolated from the computer itself and were forced have their business problems encoded in the increasingly esoteric script of a powerful new programmer priesthood. but even throughout these "dark ages", a small number of valiant dissenters survived and flourished in distant monasteries and hermitages, dedicating their lives and technical prowess to liberate computing from its raised floor temples. resistance was stiff, but not futile, as every decade or so breakthroughs like spreadsheets, hypercard, 4gls and html empowered more and more "non-programmers" to create their own computing solutions. now, well into the second era of the web, consumer-oriented websites like flickr and youtube routinely offer end users "snippets" of javascript code to reuse in their own software creations, their facebook and myspace pages. projects like ibm's coscripter have achieved programming by demonstration for end users. mashup tools abound, and the web is filled with billions of customized applications, most created by end users themselves. have we finally achieved the goals of those happy few who dreamed of a world where programming was as common as dialing a telephone? have we finally arrived at the long tail of programming? and if we have built it, did they come? this talk will assess the current state of end user programming and present a heretical perspective about the future of this endeavor from a confessed true believer.
runtime failure detection. we propose a model-driven methodology to generate and automatically deploy runtime failure detectors that enable self-healing software to deal with functional failures. the methodology rests on addressing key research challenges: (1) identifying classes of properties specified in end-user requirements, which can be associated with typical integration failures. (2) designing runtime efficient detectors for these failures. (3) defining mappings of entities between the domain of end-user requirements and the design model.
continuous software quality supervision using sourceinventory and columbus. several tools and methods for source code quality assurance based on static analysis finally reached a state when they are applicable in practice and recognized by the industry. however, most of these tools are used in an isolated manner and very rarely as organic parts of the quality assurance process. furthermore, little or no help is provided in interpreting the outputs of these tools. this paper presents sourceinventory, a system for source code-based software quality assessment and monitoring, which is able to collect, store and present measurement data including metrics, coding problems and other kinds of data like bug numbers and test coverage information. it helps software developers, architects and managers to take control over their software's quality by performing continuous code scans, fault detection, coding style verification, architecture violation detection, and automatic report generation considering metric baselines.
test case generator for guitar. as guis become more popular, the need for gui testing tools becomes greater. many current gui test generation techniques require proprietary tools and can be hard to use to their fullest potential. this paper outlines a new test case generation strategy, which enables testers to automatically produce cases in a widely used format. we hope that this strategy will encourage more complete gui testing.
the role of abstraction in software engineering. this workshop focuses on the concept of abstraction in software engineering. the aim is to explore the role of abstraction in dealing with complexity in the software engineering process, to discuss how the use of different levels of abstraction may facilitate performance of different activities, and to examine whether abstraction skills can be taught.
a runtime architecture-based approach for the dynamic evolution of distributed component-based systems. dynamic evolution of distributed component-based systems (dcs) is an important task in software engineering. several challenges are posed in this process. for example, how to preserve consistency during evolution and how to reflect the abstract evolution specification in the concrete reconfiguration implementation. having observed the generality of software architecture, researchers have proposed various architectural description languages (adls), enabling evolution techniques, etc. to investigate the problem. these approaches typically employ the formal semantics of dynamic adls at the incremental levels of refinement in the design phase or the explicit maintenance of software architecture at runtime. however, different adls usually address different concerns and the lack of runtime support for the causal relation between adls and the running system easily leads to the mismatch between them, thus inevitably sacrifices their usability. we propose an approach based on a runtime architecture which is visually generated from an attributed type graph meta-model, exists through the lifecycle of dcs, establishes the causal relation between architectural topology and system configuration, and directs the dynamic evolution.