waashk/dblp huggingface dataset:
information needs in collocated software development teams. previous research has documented the fragmented nature of software development work. to explain this in more detail, we analyzed software developers' day-to-day information needs. we observed seventeen developers at a large software company and transcribed their activities in 90-minute sessions. we analyzed these logs for the information that developers sought, the sources that they used, and the situations that prevented information from being acquired. we identified twenty-one information types and cataloged the outcome and source when each type of information was sought. the most frequently sought information included awareness about artifacts and coworkers. the most often deferred searches included knowledge about design and program behavior, such as why code was written a particular way, what a program was supposed to do, and the cause of a program state. developers often had to defer tasks because the only source of knowledge was unavailable coworkers.
identifying feature interactions in multi-language aspect-oriented frameworks. the simultaneous use of multiple aspect languages has the potential of becoming a significant one, as new aspect-oriented frameworks are developed and existing ones expand to incorporate features of others. a key challenge in combining multiple aspect-oriented languages is identifying and resolving adverse feature interactions. these interactions occur due to the incompatible and inconsistent treatment of aspects, join points, and advice across different languages. in this paper, we analyze the root cause of this feature interaction problem. we classify common features of aspect languages, describe how these features may interact when using different aspect languages in tandem, and concretely illustrate how these interactions may be resolved. our work allows aop users and tool developers to reason about the occurrence of such adverse and unexpected feature interactions, and to apply several patterns for resolving these problems.
hybrid concolic testing. we present hybrid concolic testing, an algorithm that interleaves random testing with concolic execution to obtain both a deep and a wide exploration of program state space. our algorithm generates test inputs automatically by interleaving random testing until saturation with bounded exhaustive symbolic exploration of program points. it thus combines the ability of random search to reach deep program states quickly together with the ability of concolic testing to explore states in a neighborhood exhaustively. we have implemented our algorithm on top of cute and applied it to obtain better branch coverage for an editor implementation (vim 5.7, 150k lines of code) as well as a data structure implementation in c. our experiments suggest that hybrid concolic testing can handle large programs and provide, for the same testing budget, almost 4× the branch coverage than random testing and almost 2× that of concolic testing.
engineering safety and security related requirements for software intensive systems. many software-intensive systems have significant safety and security ramifications and need to have their associated safety- and security-related requirements properly engineered. it has been observed by several consultants, researchers, and authors that inadequate requirements are a major cause of accidents involving software-intensives systems, and poor security requirements prevent the early incorporation of security concerns into the architecture. yet in practice, there is very little interaction between the requirements, safety, and security disciplines and little collaboration between their respective communities. most requirements engineers, safety engineers, and security engineers know little about their respective disciplines. also, safety and security engineering typically concentrates on architectures and designs rather than requirements because hazard and threat analysis typically depends on the identification of hardware and software components, the failure of which can cause accidents and vulnerabilities which can enable successful attacks. this leads to safety- and security-related requirements that are often ambiguous, incomplete, unverifiable, and even missing. this tutorial begins with a single common realistic example of a safety- and security-critical system that will be used throughout to provide good examples of safety- and security-related requirements. the tutorial provides a consistent ontology of safety, security, and requirements concepts and terminology, provides clear definitions and descriptions of the different kinds of safety- and security-related requirements, and finishes with a practical consistent combined process for engineering them.
supporting the investigation and planning of pragmatic reuse tasks. software reuse has long been promoted as a means to increase developer productivity; however, reusing source code is difficult in practice and tends to be performed in an ad hoc manner. this is problematic because poor decisions can be made either to attempt an unwise, overly complex reuse task, or to avoid a reuse task that would have saved time and effort. this paper describes a lightweight tool that supports the investigation and planning of pragmatic reuse tasks. the tool helps developers to identify the dependencies from the source code they wish to reuse, and to decide how to deal with those dependencies. questions about pragmatic reuse are evaluated through a survey of industrial developers. the tool is evaluated through the planning and execution of reuse tasks by industrial developers.
do maintainers utilize deployed design patterns effectively?. one claimed benefit of deploying design patterns is facilitating maintainers to perform anticipated changes. however, it is not at all obvious that the relevant design patterns deployed in software will invariably be utilized for the changes. moreover, we observe that many well-known design patterns consist of three types of programming elements (called participants), and that performing an anticipated change typically entails multiple tasks related to different types of participants. this paper studies empirically whether maintainers utilize deployed design patterns, and when they do, which tasks they more commonly perform. our experiments show that almost all subjects perform the task of adding new concrete participants, fewer perform the tasks involving clients, whereas even fewer perform the tasks involving abstract participants. furthermore, utilizing deployed design patterns (by performing whichever of the corresponding tasks) is found to be statistically associated with the delivery of less faulty codes.
detection of duplicate defect reports using natural language processing. defect reports are generated from various testing and development activities in software engineering. sometimes two reports are submitted that describe the same problem, leading to duplicate reports. these reports are mostly written in structured natural language, and as such, it is hard to compare two reports for similarity with formal methods. in order to identify duplicates, we investigate using natural language processing (nlp) techniques to support the identification. a prototype tool is developed and evaluated in a case study analyzing defect reports at sony ericsson mobile communications. the evaluation shows that about 2/3 of the duplicates can possibly be found using the nlp techniques. different variants of the techniques provide only minor result differences, indicating a robust technology. user testing shows that the overall attitude towards the technique is positive and that it has a growth potential.
very-large scale code clone analysis and visualization of open source programs using distributed ccfinder: d-ccfinder. the increasing performance-price ratio of computer hardware makes possible to explore a distributed approach at code clone analysis. this paper presents d-ccfinder, a distributed approach at large-scale code clone analysis. d-ccfinder has been implemented with 80 pc workstations in our student laboratory, and a vast collection of open source software with about 400 million lines in total has been analyzed with it in about 2 days. the result has been visualized as a scatter plot, which showed the presence of frequently used code as easy recognizable patterns. also, d-ccfinder has been used to analyze a single software system against the whole collection in order to explore the presence of code imported from open source software.
aspect-oriented design in java/aspectj and ruby. this tutorial teaches professional developers design principles for "production-quality", aspect-oriented software, written in java/aspectj and ruby. the discussion starts with a review of the rationale for aspect-oriented software development (aosd), how it solves some key problems in enterprise applications, followed by a discussion of tool options and techniques for both languages. after reviewing some of the problems developers encountered during early attempts at aspect-oriented design (aod), recent strategies for addressing those problems are discussed. the majority of the tutorial then covers extensions to standard object-oriented principles and patterns that support designing and implementing aspect software that is agile, robust, maintainable, testable, and reusable. guidelines for when to use aspects vs. other techniques are covered. the tutorial concludes with a look forward to ways that aspects could improve architectures and frameworks.
managing impacts of security protocol changes in service-oriented applications. we present a software tool and a framework for security protocol change management. while we focus on trust negotiation protocols in this paper, many of the ideas are generally applicable to other types of protocols. trust negotiation is a flexible approach to access control that is well suited to dynamic environments typical of service-oriented applications. however, managing the evolution of trust negotiation protocols is a difficult problem that has not been sufficiently addressed, especially in situations where there are ongoing negotiations. by using our framework, the consequences of changing the protocol that applies to ongoing trust negotiations can be automatically determined. we have also implemented a database-backed gui tool to manage the change process as an extension of an existing system, and we have performed experiments to test the efficiency of our management software. our experimental results show that the techniques proposed can scale to applications with tens of thousands of simultaneous users even on commodity pcs.
design and evaluation of a diagrammatic notation to aid in the understanding of concurrency concepts. is generally accepted that concurrency can be difficult for students to reason about. while some studies provide insight into the nature of these difficulties [6], work remains to be done in understanding the aspects of learning about concurrency that are most difficult, and in developing approaches to dealing with this problem. we have conducted instructor interviews and an observational study of students, identified several key difficulties that students encounter, and developed a diagram that we believe will be an aid to understanding and problem-solving. we present the diagram and results of an initial user evaluation.
cost-benefit analysis of software development techniques and practices. investigations of software development practices, processes, and techniques frequently report separately on the costs and benefits of a phenomenon under study, but rarely adequately address the combined bottomline implications. in particular, tensions between the quality and productivity effects are hard to reconcile, making objective, high-level insights elusive. for example, is a practice that is believed to improve product quality significantly, but incurs a mild developer productivity penalty economically feasible? in other words, do the benefits outweigh the costs? and if they do, under which conditions? such questions can be tackled through synthesizing effects and analyzing the resulting behaviors. in this light, the tutorial presented an approach that leverages well-known and simple economic concepts and models. it is used to wrap empirical findings, and is also applicable to the assessment of software projects. the tutorial was geared towards researchers and practitioners interested in software processes, process improvement, project management, process/project measurement, and empirical software engineering.
a template for real world team projects for highly populated software engineering classes. assigning projects of group work in the context of software engineering courses has become a commonly used practice in several educational institutions. previously reported results examined different aspects of this approach. the problem is that most studies are based on relatively small group sizes. in this article a large scale project template for a class-wide project that is currently in use in the department of computer engineering, boðaziçi university, will be presented.
first workshop on the economics of software and computation. software and the computational behaviors it defines are increasingly important sources of both economic costs and benefits for companies, governments and individuals. nevertheless, our ability to reason about the economics of software and computation to improve decision-making remains primitive. the workshop on the economics of software and computation (esc) provides a forum for research discussions in this area.
variability management in software product line engineering. software product line engineering (sple [2], [6]) has proven to be the paradigm for developing a diversity of similar software applications and software-intensive systems at low costs, in short time, and with high quality. numerous reports document the significant achievements of introducing software product lines in industry [6].
towards reusable components with aspects: an empirical study on modularity and obliviousness. the potential of aspect-oriented programming to represent cross-cutting concerns as reusable components has yet to be fully realized. indeed, authors have detailed significant challenges in creating reusable aspect component libraries. proposed solutions include restricting the power of aspects upfront, inferring concern interaction, and shaping base code to conform to abstract design rules. another proposed strategy is to reduce obliviousness in return for increased modularity by extending aspectj with explicit join points (ejps). this paper presents the results of an empirical case study that aides in the understanding of the tradeoffs between obliviousness and modularity. we present a refactoring of the exception handling concern for three real-life java applications to use ejps instead of oblivious aspects. the empirical differences between this version and an equivalent oblivious version are analyzed. finally, we present guiding principles on how to strike a favorable balance between obliviousness and modularity.
clonetracker: tool support for code clone management. code clones are generally considered to be an obstacle to software maintenance. research has provided evidence that it may not always be practical, feasible, or cost-effective to eliminate certain clone groups through refactoring. this paper describes clonetracker, an eclipse plug-in that provides support for tracking code clones in evolving software. with clonetracker, developers can specify clone groups they wish to track, and the tool will automatically generate a clone model that is robust to changes to the source code, and can be shared with other collaborators of the project. when future modifications intersect with tracked clones, clonetracker will notify the developer, provide support to consistently apply changes to a corresponding clone region, and provide support for updating the clone model. clonetracker complements existing techniques by providing support for reusing knowledge about the location of clones in source code, and support for keeping track of clones when refactoring is not desirable.
6th international workshop on scenarios and state machines: models, algorithms, and tools (scesm07). scenarios and state machines are two of the fundamental modeling perspectives for developing behavioral abstractions of complex, reactive software. scenarios represent a partial view on the interactions between multiple system components; state machines typically model the complete behavior of individual components. both perspectives have advantages .. scenarios are easily understood by stakeholders at all levels, lead naturally to tests and focus on inter-component communication; state machines, on the other hand, provide precise descriptions of component behavior and can be used for generating implementations (either manually or automatically). in particular, uml supports both notations and in uml2.0, scenarios can be modeled in a much more expressive way than with previous versions of uml. this workshop aims to investigate the connection between scenarios and state machines, assess how this connection can be exploited to improve software development, support the evaluation of techniques that exploit the connection and support the showcasing of developer tools based on both views.
fifth international workshop on dynamic analysis (woda 2007). dynamic analysis techniques reason over program executions and deal with data produced at program execution time. at the woda 2007 workshop, we bring together researchers and practitioners working in all areas of dynamic analysis to discuss new issues, share results and ongoing works, and foster collaborations.
reliability analysis of concurrent systems using ltsa. the analysis for software dependability is considered an important task within the software engineering life cycle. however, it is often impossible to carry out this task due to the complexity of available tools, lack of expert personnel and time-to-market pressures. as a result, released software versions may present unverified dependability properties subjecting customers to blind software reliability assessment. in particular, concurrent systems present certain behaviour that require a more complex system analysis not easily grasped at system design and architecture level.
dynamic detection of atomic-set-serializability violations. previously we presented atomic sets, memory locations that share some consistency property, and units of work, code fragments that preserve consistency of atomic sets on which they are declared. we also proposed atomic-set serializability as a correctness criterion for concurrent programs, stating that units of work must be serializable for each atomic set. we showed that a set of problematic data access patterns characterize executions that are not atomic-set serializable. our criterion subsumes data races (single-location atomic sets) and serializability (all locations in one set). in this paper, we present a dynamic analysis for detecting violations of atomic-set serializability. the analysis can be implemented efficiently, and does not depend on any specific synchronization mechanism. we implemented the analysis and evaluated it on a suite of real programs and benchmarks. we found a number of known errors as well as several problems not previously reported.
workshop on software technologies for ultra-large scale systems. given the inevitable trends towards increasing complexity of software-intensive systems, many future software-intensive systems will be ultra-large scale (uls). radical scale-up of systems will be manifested in many dimensions: implementation complexity, distribution, decentralization, networking, storage, and quality-of-service, dependability/security, size and structure of development organizations and methods, complexity of organizations surrounding deployed systems, and so forth. radical increases in scale and complexity will demand new approaches to all aspects of system conception, definition, development, deployment, use, maintenance, evolution, and regulation. this workshop, the first icse workshop on uls systems, has several goals: to raise awareness of uls systems in the icse community; to further our understanding of the characteristics of such systems; to explore the unique research problems of uls systems; to help foster a community who study and build uls systems; and to understand the role and the shortcomings of traditional software engineering concepts, methods, and tools relative to uls systems.
1st workshop on assessment of contemporary modularization techniques (acom.07). a number of new modularization techniques are emerging to cope with the challenges of contemporary software engineering, such as aspect-oriented software development (aosd), feature-oriented programming (fop), and the like. the effective assessment of such emerging modularization technologies plays a pivotal role on: (i) a better understanding of their real benefits and drawbacks when compared to conventional development techniques, and (ii) their effective transfer to mainstream software development. the acom workshop is the first initiative to put together researchers and practitioners with different backgrounds in order to discuss the multi-faceted issues that emerge in the assessment and/or comparison of new modularization techniques. the workshop is strongly focused on discussions around short presentations and theme-specific groups.
third international workshop on software engineering for high performance computing (hpc) applications. high performance computing systems are used to develop software in a wide variety of domains including nuclear physics, crash simulation, satellite data processing, fluid dynamics, climate modeling, bioinformatics, and financial modeling. the top500 website (http://www.top500.org) lists the top 500 high performance computing systems. the diversity of government, scientific, and commercial organizations present on this list illustrates the growing prevalence and impact of hpc applications on modern society.
languages for safety-critical software: issues and assessment. safety-critical systems (whose anomalous behavior could have catastrophic consequences such as loss of human life) are becoming increasingly prevalent; standards such as do-178b, originally developed for the certification of commercial avionics, are attracting attention in other communities. the requirement to comply with such standards imposes constraints (on quality assurance, traceability, etc.) much beyond what is typical for commercial-off-the-shelf software. one of the major decisions that affects the development of safety-critical software is the choice of programming language(s). specific language features, either by their presence of absence, may make certification easier or harder. indeed, full genera-lpurpose languages are almost always too complex, and restricted subsets are required. this tutorial compares several languages currently in use or under consideration for safety-critical systems --c (and also c++), ada, and java -- and assesses them with respect to their suitability to be constrained for use for such purposes. it specifically examines the misra c subset, spark, and the in-progress effort to develop a safety-critical profile of the real-time specification for java. the tutorial also identifies the challenges that object oriented programming imposes on safety certification and indicates possible future directions.