waashk/dblp huggingface dataset:
an experimental evaluation of selective mutation. mutation testing is a technique for unit-testing software that, although powerful, is computationally expensive. the principal expense of mutation is that many variants of the test program, called mutants, must be repeatedly executed. selective mutation is a way to approximate mutation testing that saves execution by reducing the number of mutants that must be executed. the authors report experimental results that compare selective mutation testing to standard, or nonselective, mutation testing. the results support the hypothesis that selective mutation is almost as strong as nonselective mutation. in experimental trials, selective mutations provide almost the same coverage as nonselective mutation, with significant reductions in cost
fuzzy logic based interactive recovery of software design. this abstract presents an approach to semi-automatically detect pattern instances and their implementations in a software system. design patterns are currently best practice in software development and provide solutions for nearly all granularity of software design and makes them suitable for representing design knowledge. the proposed approach overcomes a number of scalability problems as they exist in other approaches by using fuzzy logic, user interaction and a learning component.
experiences of software quality management using metrics through the life-cycle. many software quality metrics to objectively grasp software products and process have been proposed in the past decades. in actual projects, quality metrics has been widely applied to manage software quality. however, there are still several problems with providing effective feedback to intermediate software products and the software development process. we have proposed a software quality management using quality metrics which are easily and automatically measured. the purpose of this proposal is to establish a method for building in software quality by regularly measuring and reviewing. the paper outlines a model for building in software quality using quality metrics, and describes examples of its application to actual projects and its results. as the results, it was found that quality metrics can be used to detect and remove problems with process and products in each phase. regular technical reviews using quality metrics and information on the change of the regularly measured results was also found to have a positive influence on the structure and module size of programs. further, in the test phase, it was found that with the proposed model, the progress of corrective action could be quickly and accurately grasped.
towards pattern-based design recovery. a method and a corresponding tool is described which assist design recovery and program understanding by recognising instances of design patterns semi-automatically. the approach taken is specifically designed to overcome the existing scalability problems caused by many design and implementation variants of design pattern instances. our approach is based on a new recognition algorithm which works incrementally rather than trying to analyse a possibly large software system in one pass without any human intervention. the new algorithm exploits domain and context knowledge given by a reverse engineer and by a special underlying data structure, namely a special form of an annotated abstract syntax graph. a comparative and quantitative evaluation of applying the approach to the java awt and jgl libraries is also given.
object-oriented reengineering patterns. the rapid growth of object-oriented development overthe past twenty years has given rise to many object-orientedsystems that are large, complex and hard to maintain. thesesystems exhibit a range of problems, effectively preventingthem from satisfying the evolving requirements imposedby their customers. in our tutorial, we addressproblem of understanding and reengineering such object-orientedlegacy systems. the material is presented as aof "reengineering patterns" ¿ recurring solutions that expertsapply while reengineering and maintaining object-orientedsystems. the patterns distill successful techniquesin planning a reengineering project, reverse-engineering,problem detection, migration strategies and software redesign.the principles and techniques described have beenobserved and validated in a number of industrial projects,and reflect best practice in object-oriented reengineering.
deriving executable process descriptions from uml. in the recent past, a relevant effort has been devoted to the definition of process modeling languages (pmls). the resulting languages and environments -although technically successful-did not receive much attention from industry. on the contrary, researchers and practitioners have recently started experimenting with the usage of uml as a pml. being so popular and widely used, uml has an important competitive advantage compared to any specialized pml. however, it has also a main limitation. while most pmls are executable by some process engine, uml was conceived as a non-executable, semi-formal language. the work described here aims at assessing the possibility of employing a subset of uml as an executable pml. the article proposes a formalization of the semantics of the uml subset and presents the translation of uml process models into code, which can be enacted in the opss process-centered environment. the paper also presents a case study to validate the approach. we expect that process modeling by means of uml is easier and available to a larger community of software process managers. moreover, process enactment makes the process more efficient, reliable, predictable and controllable, as widely shown by previous research.
conducting empirical software engineering research in nigeria: the posing problems. empirical software engineering research has advanced in many parts of the world especially the western nations, but little has been contributed in this research domain by the developing nations such as nigeria, the well-acclaimed 'giant of africa'. the fast growing software industry in the country suggests that we need to incorporate solid software engineering studies into the various software process activities of the stakeholders in the industry, if at all quality software products must be turned out into the ever-competing global market. recent survey of the nigeria software industry shows that the industry is just coming into limelight, and that the industry is beset with 'software process compromise'. this short article takes a cursory look into the state of software engineering research in nigeria with particular reference to the nature of the nation's software industry and the student/academic environment as well as their posing problems. the article concludes with some cogent recommendations.
workshop on software quality. in the recent years, software products have increased in size and complexity, becoming a critical and strategic asset in the organizations' business. in this scenario it is a challenge to obtain software products of quality under the time and resources constraints established in projects. standards, methodologies and techniques to promote software quality assurance have been continually proposed by the researchers and used by software engineers in the industry. the workshop on software quality (wosq) aims at bringing 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.
the community workbench. community is a formal approach to software architecture with a strict separation of the computation, coordination, and distribution aspects. the approach is based on a parallel design language with state, which facilitates the specification of computations compared to the process calculi used by other formal approaches, and on category theory, which provides an intuitive yet precise graph-based semantics for the configuration of components and connectors. the community workbench is being developed as a proof of concept of the community framework, providing a graphical integrated development environment to write components, draw configurations, and execute the resulting system.
building product populations with sofware components. two trends have made reuse of embedded software for consumer electronics an urgent issue: the software of individual products becomes more and more complex, and the market demands a larger variety of products at an increasing rate. for that reason, various business groups within philips organize their products as product families. a third trend is the integration of functions that until now were only found in separate products (e.g. a tv with dolby digital sound and a built-in dvd player). this requires software reuse between product families, which - when organized systematically - leads to a product population approach.we have set up such a product population approach, and applied it in various business groups within our organization. we use a component technology that stimulates context independence, and allows the composition of new products out of existing parts. we use an architectural description language to explicitly describe the architecture, and also to generate efficient bindings. we have aligned our development process and organization with the new 'compositional' way of working. this paper outlines our approach and reports on our experiences with it.
a flexible approach to decentralized software evolution. reducing the costs and risks associated with changing complex software systems has been a principal concern of software engineering research and development. one facet of this effort concerns decentralized software evolution (dse), which, simply stated, enables third-parties to evolve a software application independent of the organization that originally developed it. popular approaches to dse include application programming interfaces or apis, software plug-ins, and scripting languages. application vendors employ dse as a means of attracting additional users to their applications-and, consequentially, increasing their market share-since it opens up the possibility that a third-party modified version of the application would satisfy the needs of end-users unsatisfied with the original version. this benefits everyone involved: the original application vendor sells more product since customization constitutes use; third-party developers deliver a product in less time and with lower cost by reusing software as opposed to building it from scratch; and customers receive a higher quality product, customized to suit their needs, in less time and with lower cost. by increasing the opportunity for buying and customizing software instead of building it from scratch, dse attacks brook's "essential" difficulties of software development.
architecture-based runtime software evolution. continuous availability is a critical requirement for an important class of software systems. for these systems, runtime system evolution can mitigate the costs and risks associated with shutting down and restarting the system for an update. we present an architecture-based approach to runtime software evolution and highlight the role of software connectors in supporting runtime change. an initial implementation of a tool suite for supporting the runtime modification of software architectures, called archstudio, is presented
tools for real-time system design. this paper describes the development of a toolset that supports the specification and design of large real time systems. the starting point is the evolution of a method suitable for use in practical environments; for example in the specification of telecommunication systems. the characteristics that are required of a good specification method for real time systems are discussed and a method based upon the ccitt sdl notation is described which aims to satisfy these characteristics. the component parts in the toolset to support this method are described.
an empirical comparison of dynamic impact analysis algorithms. impact analysis ¿ determining the potential effects ofchanges on a software system ¿ plays an important rolein software engineering tasks such as maintenance, regressiontesting, and debugging. in previous work, two new dynamicimpact analysis techniques, coverageimpact andpathimpact, were presented. these techniques performimpact analysis based on data gathered about program behaviorrelative to specific inputs, such as inputs gatheredfrom field data, operational profile data, or test-suite executions.due to various characteristics of the algorithms theyemploy, coverageimpactand pathimpactare expectedto differ in terms of cost and precision; however, there havebeen no studies to date examining the extent to which suchdifferences may emerge in practice. since cost-precisiontradeoffs may play an important role in technique selectionand further research, we wished to examine these tradeoffs.we therefore designed and performed an empirical study,comparing the execution and space costs of the techniques,as well as the precisions of the impact analysis results thatthey report. this paper presents the results of this study.
icse workshop on remote analysis and measurement of software systems (ramss). the goal of this one-day workshop was to bring together researchers and practitioners interested in exploring how the characteristics of today's area of computing (e.g., high connectivity, substantial computing power for the average user, higher demand for and expectation of frequent software updates) can be leveraged to improve software quality and performance.
second icse workshop on remote analysis and measurement of software systems (ramss). the goal of this workshop is to bring together researchersand practitioners interested in exploring how the characteristicsof todayýs area of computing (e.g., high connectivity,substantial computing power for the average user, higher demandfor and expectation of frequent software updates) canbe leveraged to improve software quality and performance.
software development engineer in microsoft: a subjective view of soft skills required. this paper is a position statement. there are important requirements on software development engineers that go beyond the normal academic qualifications and technical skills, and which quite often receive a lower priority in education and training.
hyper/j: multi-dimensional separation of concerns for java. hyper/j supports a new approach to constructing, integrating and evolving software, called multi-dimensional separation of concerns. developers can decompose and organize code and other artifacts according to multiple, arbitrary criteria (concerns) simultaneously&mdash;even after the software has been implemented&mdash;and synthesize or integrate the pieces into larger-scale components and systems. hyper/j facilitates several common development and evolution activities non-invasively, including: adaptation and customization, mix-and-match of features, reconciliation and integration of multiple domain models, reuse, product line management, extraction or replacement of existing parts of software, and on-demand remodularization. hyper/j works with standard java software, not requiring special compilers or environments. this demonstration will show it in action in a number of software engineering scenarios at different stages of the software lifecycle.
toolpack - an experimental software development environment research project. this paper discusses the goals and methods of the toolpack project and in this context discusses the architecture and design of the software system being produced as the focus of the project. toolpack is presented as an experimental activity in which a large software tool environment is being created for the purpose of general distribution and then careful study and analysis. the paper begins by explaining the motivation for building integrated tool sets. it then proceeds to explain the basic requirements that an integrated system of tools must satisfy in order to be successful and to remain useful both in practice and as an experimental object. the paper then summarizes the tool capabilities that will be incorporated into the environment. it then goes on to present a careful description of the actual architecture of the toolpack integrated tool system. finally the toolpack project experimental plan is presented, and future plans and directions are summarized.
lightweight vs. heavyweight processes: is this even the right question? interest in the use of processes to provide assistance in software development activities remains at a high level. but the focus of attention has shifted in recent years. early work emphasizing the study of languages for defining processes was rapidly eclipsed by process evaluation and improvement work, most notably the capability maturity model (cmm). as process improvement has matured as a strategy and philosophy it has also given rise to a strong reaction to the perception that it is unduly ponderous and constraining. movements such as extreme programming (xp) have cast themselves as lightweight alternatives, emphasizing the primacy of freedom and flexibility. both philosophies and communities continue to grow in size, development, and depth of understanding.the goal of this panel will be to explore the differences between these major approaches to the use of process in software development by bringing together leading articulate exponents of the approaches. each panelist will be charged with presenting a very concise characterization of the approach being represented. but the focus of the panel will be on understanding the nature of the differences in approach, and the reasons for these differences. similarities will be sought as well.an underlying hypothesis of the panel is that the differences in approach arise in large measure from differences in objective and differences in assumptions about the software development context. thus, for example, one approach may be intended to support very long range organizational objectives, while the other may be more tactically oriented. one approach may assume that evolvability is an overriding objective, while another may be more focused on speed to market. one may make stronger assumptions about the skills and training of project personnel. the panel will attempt to delve into these issues to see if it may be possible to suggest criteria for suggesting which approach (and possible adaptation) should be selected for a given development situation.in a larger sense, the goal of this panel is to suggest the possibility of a discipline of software process engineering. insofar as the panel is able to suggest that development situations can be used to guide the selection of process approaches to the provision of assistance, might this then be an indication that process formalisms could play a role in subsequent specification of detailed processes, and evaluation of their effectiveness?the panel will react to this and related questions. while lively interchanges among the panelists will be stimulated and expected, similar interchanges with the audience will also be cultivated.
lime: linda meets mobility. lime is a system designed to assist in the rapid development of dependable mobile applications over both wired and ad hoc networks. mobile agents reside on mobile hosts and all communication takes place via transiently shared tuple spaces distributed across the mobile hosts. the decoupled style of computing characterizing the linda model is extended to the mobile environment. at the application level, both agents and hosts perceive movement as a sudden change of context. the set of tuples accessible by a particular agent residing on a given host is altered transparently in response to changes in the connectivity pattern among the mobile hosts. in this paper we present the key design concepts behind the lime system.
new software engineering faculty symposium. new software engineering faculty face many challenges and tremendous pressures today. the icse community is committed to helping these young faculty members survive in academia. this symposium will bring together faculty who have survived their early years with potential, new, and junior faculty. the attendees can work together on strategies for success and shop from the best ideas and experiences of their colleagues.
developing mobile computing applications with lime. mobile computing defines a very dynamic and challenging scenario for which software engineering practices are still largely in their initial developments. lime is a middleware designed to enable the rapid development of dependable applications in the mobile environment. the model underlying lime allows for coordination of physical and logical mobile units by exploiting a reactive, transiently shared tuple space whose contents changes according to connectivity. in this demonstration, we report about initial experiences in developing applications for physical mobility using lime.
conceptual modeling through linguistic analysis using lida. despite the advantages that object technology can provide to the software development community and its customers, the fundamental problems associated with identifying objects, their attributes, and methods remain: it is a largely manual process driven by heuristics that analysts acquire through experience. while a number of methods exist for requirements development and specification, very few tools exist to assist analysts in making the transition from textual descriptions to other notations for object-oriented analysis and other conceptual models. in this paper we describe a methodology and a prototype tool, linguistic assistant for domain analysis (lida), which provide linguistic assistance in the model development process. we first present our methodology to conceptual modeling through linguistic analysis. we give an overview of lida's functionality and present its technical design and the functionality of its components. we also provide a comparison of lida's functionality with that of other research prototypes. finally, we present an example of how lida is used in a conceptual modeling task.
a software reliability assessment based on a structural and behavioral analysis of programs. this paper deals with the problem of assessing the reliability of programs written using structured programming techniques and having undergone a certain amount of testing. a program is said to be verified if, for a given set of tests it can be shown that every case of interest has been tested. as this end is, however, unattainable, we will consider, in the following, that a program is verified if one can prove that all the logic paths in the program flow graph have been traversed. therefore, we will consider that a certain degree of verification is attained with a given set of tests, according to the number of paths actually traversed. this degree of verification, which is a non-decreasing function of the number of tests can be considered as an assessment of program reliability. the degree of verification attained through experiments can then be deduced from the images of experiments in the program flow graph. this paper defines a practical procedure to perform such an evaluation.
software visualisation for object-oriented program comprehension. software visualisation is the process of modellingsoftware systems for comprehension [6]. thecomprehension of software systems both during and afterdevelopment is a crucial component of the softwareprocess [8]. the complex interactions inherent in theobject-oriented paradigm make visualisation a particularlyappropriate comprehension technique, and the largevolume of information typically generated duringvisualisation necessitates tool support.