waashk/dblp huggingface dataset:
re-engineering software architecture of home service robots: a case study. with the advances of robotics, computer science, and other related areas, home service robots attract much attention from both academia and industry. home service robots present interesting technical challenges to the community in that they have a wide range of potential applications, such as home security, patient caring, cleaning, etc., and that the services provided by the robots in each application area are being defined as markets are formed and, therefore, they change constantly.without architectural considerations to address these challenges, robot manufacturers often focus on developing technical components (e.g., vision recognizer, speech processor, and actuator) and then attempt to develop service robots by integrating these components. when prototypes are developed for a new application, or when services are added, modified, or removed from existing robots, unexpected, undesirable, and often dangerous side-effects, which are known as feature interaction problem, happen frequently. reengineering of such robots can make a serious impact in delivery time and development cost.in this paper, we present our experience of re-engineering a prototype of a home service robot developed by samsung advanced institute of technology. first, we designed a modular and hierarchical software architecture that makes interaction among the components visible. with the visibility of interactions, we could assign functional responsibilities to each component clearly. then, we re-engineered existing codes to conform to the new architecture using a reactive language esterel. as a result, we could detect and solve feature interaction problems and alleviate the dificulty of adding or updating components.
a history-based test prioritization technique for regression testing in resource constrained environments. regression testing is an expensive and frequently executed maintenance process used to revalidate modified software. to improve it, regression test selection (rts) techniques strive to lower costs without overly reducing effectiveness by carefully selecting a subset of the test suite. under certain conditions, some can even guarantee that the selected test cases perform no worse than the original test suite.but this ignores certain software development realities such as resource and time constraints that may prevent using rts techniques as intended (e.g., regression testing must be done overnight, but rts selection returns two days worth of tests). in practice, testers work around this by prioritizing the test cases and running only those that fit within existing constraints. unfortunately this generally violates key rts assumptions, voiding rts technique guarantees and making regression testing performance unpredictable.despite this, existing prioritization techniques are memoryless, implicitly assuming that local choices can ensure adequate long run performance. instead, we proposed a new technique that bases prioritization on historical execution data. we conducted an experiment to assess its effects on the long run performance of resource constrained regression testing. our results expose essential tradeoffs that should be considered when using these techniques over a series of software releases.
an empirical study of regression test application frequency. regression testing is an expensive maintenance process used to revalidate modified software. regression test selection (rts) techniques try to lower the cost of regression testing by selecting and running a subset of the existing test cases. many such techniques have been proposed and initial studies show that they can produce savings. we believe, however, that issues such as the frequency with which testing is done have a strong effect on the behavior of these techniques. therefore, we conducted an experiment to assess the effects of test application frequency on the costs and benefits of regression test selection techniques. our results expose essential tradeoffs that should be considered when using these techniques over a series of software releases.
restructuring oodesigner: a case tool for omt. this report describes our experience acquired when we restructured oodesigner, a computer aided software engineering (case) tool for object modeling techniques (omt). we had developed the version 1.x of oodesigner during 3 years since 1994. although we had developed this version using omt and c++, we recognized the potential maintenance problem that originated from the ill-designed class architecture. thus we totally restructured the old version of oodesigner during 12 months, and obtained a new version that is much easier to maintain than the old one
web engineering device independent web services. today's web services not only have to be flexible, but also have to be device independent to support mobile devices such as wap and pdas. supporting multiple web formats (e.g., wml, html, etc.) is still an open challenge. most sites have to provide a separate application for every format and reuse is not common. we are working on a methodology and a tool to support the web developer in building flexible, device independent web services.
a flexible software process model. the development of software products is a complex activitywith a large number of factors involved in definingsuccess. as real-world experimentation is difficult andcostly, researchers have used various techniques in an attemptto model the development process. this field of softwareprocess simulation has received substantial attentionover the last twenty years. the aims have been to betterunderstand the software development process and to mitigatethe problems that continue to occur in the industry byproviding support for management decision making.
intellectual property protection for software in the united states and europe (tutorial session): the changing roles of patents and copyrights. this tutorial addresses how both the object management group (omg) specifications and the implementation choices made by middleware providers and application developers affect common object request broker architecture (corba) application scalability. we will cover a range of scalability issues, starting with object request broker (orb) internals and working outward to full-scale applications, addressing issues such as connection management, portable object adapter (poa) scalability features, multithreading, object lifecycle issues, object location, system configuration, maintenance, and management, and common application architectures. this tutorial is not language-centric and is useful to developers using java, c++, or any other language to develop corba-based applications.
sda: a novel approach to software environment design and construction. a software designer's associate (sda) is a workstation-based collection of tools which support: 1) the description, evaluation and comparison of software system architectural designs, and 2) cooperation among, and management of, a team of software designers [ridd87]. each software designer's associate is a specific instance of a generic facility which supports a team member's design activities, cooperation among team members, and overall team management. it provides a framework for the integration of tools supporting the use of various notations within the context of a particular set of technical and managerial methods. these tools, notations and methods may be adapted to support the needs of a particular project or the habits of an individual developer by selecting the particular tools to be added to the generic facility. the software designer's associate project is a joint effort involving a consortium of researchers from academic and industrial organizations in both japan and the united states. this paper describes the concept of software designer's associates and the cooperative, international project which is intended to lead to the realization of that concept.
evidence-based software engineering. objective: our objective is to describe how softwareengineering might benefit from an evidence-basedapproach and to identify the potential difficultiesassociated with the approach.method: we compared the organisation and technicalinfrastructure supporting evidence-based medicine (ebm)with the situation in software engineering. we consideredthe impact that factors peculiar to software engineering(i.e. the skill factor and the lifecycle factor) would haveon our ability to practice evidence-based softwareengineering (ebse).results: ebse promises a number of benefits byencouraging integration of research results with a view tosupporting the needs of many different stakeholdergroups. however, we do not currently have theinfrastructure needed for widespread adoption of ebse.the skill factor means software engineering experimentsare vulnerable to subject and experimenter bias. thelifecycle factor means it is difficult to determine howtechnologies will behave once deployed.conclusions: software engineering would benefit fromadopting what it can of the evidence approach providedthat it deals with the specific problems that arise from thenature of software engineering.
inter-item correlations among function points. the paper reports on an empirical investigation of albrecht function points.the study suggests that function points are not well-formed metrics because there is a correlation between their constituent elements. it also suggests that (for the dataset under investigation) two of the constituent elements were as good at predicting effort as the raw function point count and that the unweighted counts can be reasonable predictors of effort
lessons learnt from the analysis of large-scale corporate databases. this paper presents the lessons learnt during the analysis of the corporate databases developed by ibm global services (australia). ibm is rated as cmm level 5. following cmm level 4 and above practices, ibm designed several software metrics databases with associated data collection and reporting systems to manage its corporate goals. however, ibm quality staff believed the data were not as useful as they had expected. nicta staff undertook a review of ibm's statistical process control procedures and found problems with the databases mainly due to a lack of links between the different data tables. such problems might be avoided by using m3p variant of the gqm paradigm to define a hierarchy of goals, with project goals at the lowest level, then process goals and corporate goals at the highest level. we propose using e-r models to identify problems with existing databases and to design databases once goals have been defined.
industrial-strength software product-line engineering. software product-line engineering is one of the few approaches to software engineering that shows promise of improving software productivity by factors of 5 to 10. there are still few examples of its successful application on a large scale, partly because of the complexity of initiating a product-line engineering project and the many factors that must be addressed for such a project to be successful.this tutorial draws on experiences in introducing and sustaining product-line engineering in lucent technologies and in avaya. the objective is to convey to participants the obstacles involved in transitioning to product line engineering and how to overcome such obstacles, particularly in large software development organizations. participants will learn both technical and organizational aspects of the problem. participants will leave the tutorial with many ideas on how to introduce product line engineering into an organization in a systematic way.
a high level language for specifying graph based languages and their programming environments. the authors describe a high level language for specifying programming environments for programming languages that are based on directed attributed graphs. the high level language allows the specifier to describe views of portions of a program written in such a graph-based language, the editing operations used to create the program, animations of the execution of the program, and sufficient detail of the execution semantics to support the animations. the use of the specification language is demonstrated with a simple example of a graph-based language. the automatic generation of the programming environment is described for such graph based languages from descriptions made in the specification language. the specification language is based on using a grammar to describe the components of the graph based language and using a first-order logic based language to describe state changes in editing, execution, and animation
icse workshop on software variability management. during recent years, the amount of variability that has to be supported by a software artifact is growing considerably and its management is developing as a main challenge during development, usage, and evolution of software artifacts. successful management of variability in software artifacts leads to better customizable software products that are in turn likely to result in higher market success.the aim of this workshop is to study software variability management both from a 'problems' and from a 'solutions' perspective by bringing together people from industrial practice and from applied research in academia to present and discuss their respective experience.issues to be addressed include, but are not limited to, technological, process, and organizational aspects as well as notation, assessment, design, and evolution aspects.
safety critical systems: challenges and directions. safety-critical systems are those systems whose failure could result in loss of life, significant property damage, or damage to the environment. there are many well known examples in application areas such as medical devices, aircraft flight control, weapons, and nuclear systems. many modern information systems are becoming safety-critical in a general sense because financial loss and even loss of life can result from their failure. future safety-critical systems will be more common and more powerful. from a software perspective, developing safety critical systems in the numbers required and with adequate dependability is going to require significant advances in areas such as specification, architecture, verification, and process. the very visible problems that have arisen in the area of information-system security suggests that security is a major challenge also.
an experimental evaluation of simple methods for seeding program errors. this paper describes an experiment in which simple syntactic alterations were introduced into program text in order to evaluate the testing strategy known as error seeding. the experiment's goal was to determine if randomly placed syntactic manipulations can produce failure characteristics similar to those of indigenous errors found within unseeded programs. as a result of a separate experiment, several programs were available, all of which were written to the same specifications and thus were intended to be functionally equivalent. the use of functionally equivalent programs allowed the influence of individual programmer styles to be removed as a variable from the error seeding experiment. each of six different syntactic manipulations were introduced into each program and the mean times to failure for the seeded errors were observed. the seeded errors were found to have a broad spectrum of mean times to failure independent of the syntactic alteration used. we conclude that it is possible to seed errors using only simple syntactic techniques that are arbitrarily difficulty to locate. in addition, several unexpected results indicate that some issues involved in error seeding have not been addressed previously.
a modification request control system. the modification request control system (mrcs) tracks and reports project change requests and resulting activity through interactive input and extraction of change request data from computer files. mrcs is one of the tools available as part of the programmer's workbench (pwb). it was developed to aid in the timely control and coordination of software changes. it provides the capability to: (1) interactively create, update, and print mrs; (2) track and record the flow of the mr through the system development cycle; and (3) provide management with timely mr status information via reports and on-line inquiries. mrcs supports many projects, each project with its own mr data base and commands. it provides, via common control logic, standard operations such as the creation, updating, and printing of mrs, and the extraction of data from them. each project then defines the fields, validity checks, defaults, prompting sequences, and report formats which satisfy its particular requirements, and these are used to produce an mrcs for that project.
eliciting design requirements for maintenance-oriented ides: a detailed study of corrective and perfective maintenance tasks. recently, several innovative tools have found their way into mainstream use in modern development environments. however, most of these tools have focused on creating and modifying code, despite evidence that most of programmers' time is spent understanding code as part of maintenance tasks. if new tools were designed to directly support these maintenance tasks, what types would be most helpful? to find out, a study of expert java programmers using eclipse was performed. the study suggests that maintenance work consists of three activities: (1) forming a working set of task-relevant code fragments; (2) navigating the dependencies within this working set; and (3) repairing or creating the necessary code. the study identified several trends in these activities, as well as many opportunities for new tools that could save programmers up to 35% of the time they currently spend on maintenance tasks.
analysis of the interaction between practices for introducing xp effectively. in this paper, we discuss interactions between xp (extreme programming) practices. we discuss 2 case studies of introducing xp practices selectively from the 13 practices which are defined in xp, and we analyze how to select practices. our analysis is based on interviews with developers. while it is difficult to introduce all the xp practices at once, our knowledge makes it easier to determine more effective combinations of practices.
integrating uml diagrams for production control systems. this paper proposes to use sdl block diagrams, uml class diagrams, and uml behavior diagrams like collaboration diagrams, activity diagrams, and statecharts as a visual programming language. we describe a modeling approach for flexible, autonomous production agents, which are used for the decentralization of production control systems. in order to generate a (java) implementation of a production control system from its specification, we define a precise semantics for the diagrams and we define how different (kinds of) diagrams are combined to a complete executable specification.generally, generating code from uml behavior diagrams is not well understood. frequently, the semantics of a uml behavior diagram depends on the topic and the aspect that is modeled and on the designer that created it. in addition, uml behavior diagrams usually model only example scenarios and do not describe all possible cases and possible exceptions.we overcome these problems by restricting the uml notation to a subset of the language that has a precise semantics. in addition, we define which kind of diagram should be used for which purpose and how the different kinds of diagrams are integrated to a consistent overall view.
modeling aspect mechanisms: a top-down approach. a plethora of aspect mechanisms exist today. all of these diverse mechanisms integrate concerns into artifacts that exhibit crosscutting structure. what we lack and need is a characterization of the design space that these aspect mechanisms inhabit and a model description of their weaving processes. a good design space representation provides a common framework for understanding and evaluating existing mechanisms. a well-understood model of the weaving process can guide the implementor of new aspect mechanisms. it can guide the designer when mechanisms implementing new kinds of weaving are needed. it can also help teach aspect-oriented programming (aop). in this paper we present and evaluate such a model of the design space for aspect mechanisms and their weaving processes. we model weaving, at an abstract level, as a concern integration process. we derive a weaving process model (wpm) top-down, differentiating a reactive from a nonreactive process. the model provides an in-depth explanation of the key subprocesses used by existing aspect mechanisms.
an innovative approach to system requirements analysis by using structural modeling method. as an innovative approach to the system requirements analysis, this paper proposes a computer aided method to develop objectives trees. this method consists of a procedure, algorithms and, a man-machine interactive graphic system. and two typical kinds of applications of the objectives tree in computer applications system planning are described. by this method, working man-hours to develop an objectives tree can be decreased, and quality of communication among system venders, end-users of a computer system, edp managers and top executives, can be highly improved.
experiences of applying spc techniques to software development processes. experiences of applying spc techniques to software development processes are described. several real examples to apply spc in hitachi software are given. measures, control charts, and analysis judgment are given. characteristics of software development processes, their influence on spc, and lessons learned when applying spc to software processes are described. in particular, the importance of self-directed and proactive improvement is discussed.
real-time specification patterns. embedded systems are pervasive and frequently used for critical systems with time-dependent functionality. dwyer et al have developed qualitative specification patterns to facilitate the specification of critical properties, such as those that must be satisfied by embedded systems. thus far, no analogous repository has been compiled for real-time specification patterns. this paper makes two main contributions: first, based on an analysis of timing-based requirements of several industrial embedded system applications, we created real-time specification patterns in terms of three commonly used real-time temporal logics. second, as a means to further facilitate the understanding of the meaning of a specification, we offer a structured english grammar that includes support for real-time properties. we illustrate the use of the real-time specification patterns in the context of property specifications of a real-world automotive embedded system.
a case study in applying a systematic method for cots selection. this paper describes a case study that used and evaluated key aspects of a method developed for systematic reusable off-the-shelf software selection. the paper presents a summary of the common problems in reusable off-the-shelf software selection, describes the method used and provides details about the case study carried out. the case study indicated that the evaluated aspects of the method are feasible, improve the quality and efficiency of reusable software selection and the decision makers have more confidence in the evaluation results, compared to traditional approaches. furthermore, the case study also showed that the choice of evaluation data analysis method can influence the evaluation results.
fifth international workshop on economics-driven software engineering research (edser-5) "the search for value in engineering decisions". the series of edser workshops are a unique forum to discuss and advance the state-of-the-art research and practice in economics driven software engineering. the edser-5 will bring together leading researchers and practitioners to provide further understanding how economic and business considerations affect -- and should affect -- software engineering decisions.