waashk/dblp huggingface dataset:
dynamic layout of distributed applications in fargo. the design of efficient and reliable distributed applications that operate in large networks, over links with varying capacities and loads, demands new programming abstractions and mechanisms. the conventional static design-time determination of local-remote relationships between components implies that (dynamic) environmental changes are hard if not impossible to address without reengineering. the paper presents a novel programming model that is centered around the concept of "dynamic application layout", which permits the manipulation of component location at runtime. this leads to a clean separation between the programming of the application's logic and the programming of the layout, which can also be performed externally at runtime. the main abstraction vehicle for layout programming is a reflective inter-component reference, which embodies co- and re-location semantics. we describe an extensible set of reference types that drive and constrain the mapping of components to hosts, and show how this model elevates application performance and reliability yet requires minimal changes in programming the application's logic. the model was realized in the fargo system, whose design and implementation in java are presented, along with an event based scripting language and corresponding event monitoring service for managing the layout of fargo applications.
unanticipated reuse of large-scale software features. software reuse has been endorsed as a way to reduce development times and costs while increasing software quality and reliability. techniques designed to encourage software reuse have concentrated on creating reusable software in the form of frameworks, reuse repositories, and component libraries. these approaches do not help a developer who wants to leverage, from an existing system, a complex feature that was not designed to be reusable. we propose an approach that allows developers to investigate the reuse potential of a feature within an existing system, to create a plan for reusing the feature, and to support the transformation of the feature to the developer's project. we believe that by providing explicit support for the reuse of large-scale source code features, the reuse process---and its benefits---can be made accessible to developers.
using structural context to recommend source code examples. when coding to a framework, developers often become stuck, unsure of which class to subclass, which objects to instantiate and which methods to call. example code that demonstrates the use of the framework can help developers make progress on their task. in this paper, we describe an approach for locating relevant code in an example repository that is based on heuristically matching the structure of the code under development to the example code. our tool improves on existing approaches in two ways. first, the structural context needed to query the repository is extracted automatically from the code, freeing the developer from learning a query language or from writing their code in a particular style. second, the repository can be generated easily from existing applications. we demonstrate the utility of this approach by reporting on a case study involving two subjects completing four programming tasks within the eclipse integrated development environment framework.
a practical method for verifying event-driven software. formal verification methods are used only sparingly in software development. the most successful methods to date are based on the use of model checking tools. to use such tools, the user must first define a faithful abstraction of the application (the model), specify how the application interacts with its environment, and then formulate the properties that it should satisfy. each step in this process can become an obstacle. to complete the verification process successfully often requires specialized knowledge of verification techniques and a considerable investment of time. in this paper we describe a verification method that requires little or no specialized knowledge in model construction. it allows us to extract models mechanically from the source of software applications, securing accuracy. interface definitions and property specifications have meaningful defaults that can be adjusted when the checking process becomes more refined. all checks can be executed mechanically, even when the application itself continues to evolve. compared to conventional software testing, the thoroughness of a check of this type is unprecedented.
data flow testing as model checking. this paper presents a model checking-based approach to data flow testing. we characterize data flow oriented coverage criteria in temporal logic such that the problem of test generation is reduced to the problem of finding witnesses for a set of temporal logic formulas. the capability of model checkers to construct witnesses and counterexamples allows test generation to be fully automatic. we discuss complexity issues in minimal cost test generation and describe heurstic test generation algorithms. we illustrate our approach using ctl as temporal logic and smv as model checker.
distributed software prototyping with ads. the difficulties ordinarily experienced in designing and developing large software systems are greatly increased in the case of distributed data processing (ddp) systems. thus there is an urgent need to support the software life cycle activities with effective prototyping tools and techniques. the architecture development system (ads) is being developed for use in prototyping ddp systems within a distributed testbed. ads features an interactive graphical user interface, a distributed runtime environment, and a prototyping framework based on the concept of abstract ddp objects with attributes and relationships. this paper presents the ads prototyping features and the user interface to describe, synthesize, execute and analyze system representations. then a discussion is presented of the applicability of ads support to the distributed software life cycle. the current implementation status of ads is also summarized.
pitfalls and safeguards in real-time digital systems with emphasis on programming. real-time digital systems are largely a technical innovation of the past decade, but they appear destined to become more wide spread in the future. they monitor or control a real physical environment, such as an air-traffic situation, as distinguished from simulating that environment on an arbitrary time scale. the complexity and rapid variation of such an environment necessitates use of a fast and versatile central-control device, a role well suited to digital computers. the usual system will include some combination of sensors, communication, control, display, and effectors. although many parts of such a system pose no novel management problems, their distinguishing feature, the central digital device, frequently presents unusually strict requirements for speed, capacity, reliability and compatibility, together with the need for a carefully designed stored program. these features, particularly the last, have implications that are not always foreseen by management. an attempt is made to point out specific hazards common to most real-time digital systems and to show a few ways of minimizing the risks associated with them.
experimental context classification: incentives and experience of subjects. there is a need to identify factors that affect the result of empirical studies in software engineering research. it is still the case that seemingly identical replications of controlled experiments result in different conclusions due to the fact that all factors describing the experiment context are not clearly defined and hence controlled. in this article, a scheme for describing the participants of controlled experiments is proposed and evaluated. it consists of two main factors, the incentives for participants in the experiment and the experience of the participants. the scheme has been evaluated by classifying a set of previously conducted experiments from literature. it can be concluded that the scheme was easy to use and understand. it is also found that experiments that are classified in the same way to a large extent point at the same results, which indicates that the scheme addresses relevant factors.
establishing experience factories at daimler-benz an experience report. the experience factory concept enables systematic learning and continuous improvement in software development. as with most learning initiatives, it is hard to establish. in our experience, there is a great deal of uncertainty and skepticism about the mission and contents of an experience factory. the starting phase is especially endangered through pitfalls or unexpected delays. as expectations vary and there is pressure to demonstrate success within only a few months, tension arises which may jeopardize the entire enterprise. in the course of a large-scale software improvement program, we have established three experience factories in different environments of the daimler-benz ag within two years. at each site, several application projects are involved. we describe how we approached the task, what actions we took, and the lessons we learned
signaling in monitors. monitors are a convenient and powerful tool for writing schedulers in concurrent programs. there are at least four conventions for handling their wait and signal operations: the signaling process may yield to the waiting one, continue and thus leave the signal pending, or return immediately from the monitor; or signals may be performed automatically. formal proof schemas are presented for each of the signaling conventions. such schemas not only support proof of monitors, they also display the conventions' properties precisely and allow them to be compared. it is shown that all of the conventions are equivalent except for immediate return, which is strictly weaker than the others. a modification of immediate return which corrects its weakness and retains its desirable features is proposed.
theoretical and empirical studies of program testing. two approaches to the study of program testing are described. one approach is theoretical and the other empirical. in the theoretical approach situations are characterized in which it is possible to use testing to formally prove the correctness of programs or the correctness of properties of programs. in the empirical approach statistics are collected which record the frequency with which different testing strategies reveal the errors in a collection of programs. a summary of the results of two research projects which investigated these approaches are presented. the differences between the two approaches are discussed and their relative advantages and disadvantages are compared.
completeness criteria for testing elementary program functions. program testing metrics are based on criteria for measuring the completeness of a set of program tests. branch testing measures the percentage of program branches that are traversed during a set of tests. mutation testing measures the ability of a set of tests to distinguish a program from similar programs. a criterion for test completeness is introduced in this paper which measures the ability of a set of tests to distinguish between functions which are implemented by parts of programs. the criterion is applied to functions which are implemented by different kinds of programming language statements. it is more effective than branch testing and incorporates some of the advantages of mutation testing. its effectiveness can be discussed formally and it can be described as part of an integrated approach to testing. a tool can be used to implement the method.
a method of large-scale software development. large-scale software requires a consistent development philosophy in all phases, from design through coding to maintenance. this paper describes the closed control tree structure concept which we used to achieve this consistency while developing aim/rdb, a large relational data base system.
a software engineering experience in the management, design and implementation of a data secure system. hsdms (highly secure data management system) is a secure, on-line and multi-user experimental database management system developed on the digital equipment corporation's pdp-10 computer system. it is a vehicle for testing new facilities and applications of data management and access control. furthermore the development of hsdms itself has been aimed at the outset as an exercise in software engineering management and control. in the first part of the paper, the software engineering techniques that were used in the management and control of the programming team and efforts are discussed. the discussion centers on the application of some of the known concepts such as the chief programmer team, structured programming and composite design to programming of the database management system. in the second part of the paper, system goals and capabilities are presented. the goals for hsdms were to achieve data independence, efficient storage and access, effective user interface, and secure access control. the ability of hsdms to meet the goals result from the utilization and integration of a number of design concepts and implementation approaches. for each system goal the concepts and approaches that have provided hsdms with the capabilities to achieve the goal are shown. in the final part of the paper, we attempt to relate this single experience with hsdms to its possible impact on software engineering of database management systems in general and to data secure systems in particular.
applying the value/petri process to erp software development in china. commercial organizations increasingly need software processes sensitive to business value, quick to apply, and capable of early analysis for subprocess consistency and compatibility. this paper presents experience in applying a lightweight synthesis of a value-based software quality achievement (vbsqa) process and an object-petri-net-based process model (called vbsqa-opn) to achieve a manager-satisfactory process for software quality achievement in an on-going erp software project in china. the results confirmed that 1) the application of value-based approaches was inherently better than value-neutral approaches adopted by most erp software projects; 2) the vbsqa-opn model provided project managers with a synchronization and stabilization framework for process activities, success-critical stakeholders and their value propositions; 3) process visualization and simulation tools significantly increased management visibility and controllability for the success of software project.
easy language extension with meta-aspectj. domain-specific languages hold the potential of automating the software development process. nevertheless, the adoption of a domain-specific language is hindered by the difficulty of transitioning to different language syntax and employing a separate translator in the software build process. we present a methodology that simplifies the development and deployment of small language extensions, in the context of java. the main language design principle is that of language extension through unobtrusive annotations. the main language implementation idea is to express the language as a generator of customized aspectj aspects, using our meta-aspectj tool. the advantages of the approach are twofold. first, the tool integrates into an existing software application much as a regular api or library, instead of as a language extension. this means that the programmer can remove the language extension at any point and choose to implement the required functionality by hand without needing to rewrite the client code. second, a mature language implementation is easy to achieve with little effort since aspectj takes care of the low-level issues of interfacing with the base java language.
a database model for effective configuration management in the programming environment. the effective management of configurations by programmers requires automatic techniques which are operative in the program development environment. in this paper, an abstract model is developed to cover the significant aspects of a typical programming environment pertinent to configuration management, using a database to capture configuration knowledge. the two aspects of the model deal with configuration identification and configuration control. in considering configuration identification, it is shown that the tools in the programming environment determine which configuration items need to be identified and also determine what the interesting and useful relations are among those items. in considering configuration control, the notion of a workspace, consisting of certain modification rights and certain visibility into the database, is developed to prevent conflict and to promote cooperation among programmers. the entire model can be used to evaluate the effectiveness of configuration management within a particular programming environment or as the basis of a programming environment design.
a multiple case study on the impact of pair programming on product quality. pair programming is a programming technique in which two programmers use one computer to work together on the same task. there is an ongoing debate over the value of pair programming in software development. the current body of knowledge in this area is scattered and unorganized. review shows that most of the results have been obtained from experimental studies in university settings. few, if any, empirical studies exist, where pair programming has been systematically under scrutiny in real software development projects. thus, its proposed benefits remain currently without solid empirical evidence. this paper reports results from four software development projects where the impact of pair programming on software product quality was studied. our empirical findings appear to offer contrasting results regarding some of the claimed benefits of pair programming. they indicate that pair programming may not necessarily provide as extensive quality benefits as suggested in literature, and on the other hand, does not result in consistently superior productivity when compared to solo programming.
an index organization for applications with highly skewed access patterns. the conventional way of organizing indices in large data base systems is to use balanced tree structures such as b-trees or static tree structures, e.g. isam. it is well known in practice that most applications do not have a uniform record reference distribution but rather the 80/20-rule or zipf's law applies. the balanced index implementations mentioned do not exploit these skewed access patterns. this paper, which is an extract from the author's ph.d.-thesis, proposes a data structure - the c-tree - which is designed to exploit the skewness of such access distributions with the intent of obtaining short response times for transactions accessing the index. an analytical model of the proposed structure and a b-tree is used for making a comparative evaluation of the structures. conclusions are drawn and discussed with regard to the circumstances under which the proposed structure outperforms the b-tree.
using the web for document versioning: an implementation report for delta v. the current suite of systems that offer client/server capabilities for document versioning relies on proprietary protocols for communicating between a central versioning repository and a remote client. in order to support better document authoring via the web, the deltav working group of the web-dav (www distributed authoring and versioning) project of the internet engineering task force is working on a standard protocol for versioning over http. the authors present a prototype of deltav based on the 04.5 draft. this system demonstrates that, though important aspects of the protocol need to be revised, versioning via the web can be a practical means of supporting remote access to a central versioning repository.
applying winwin to quality requirements: a case study. this paper describes the application of the winwin paradigm to identify and resolve conflicts in a series of real-client, student-developer digital library projects. the paper is based on a case study of the statistical analysis of 15 projects and an in-depth analysis of one representative project. these analyses focus on the conflict resolution process, stakeholders' roles and their relationships to quality artifacts, and tool effectiveness. we show that stakeholders tend to accept satisfactory rather than optimal resolutions. users and customers are more proactive in stating win conditions, whereas developers are more active in working toward resolutions. further, we suggest that knowledge-based automated aids have potential to significantly enhance process effectiveness and efficiency. finally, we conclude that such processes and tools have theoretical and practical implications in the quest for better software requirements elicitation.
a dynamic pair-program sending architecture for industrial remote operations. remote operations such as maintenance, diagnoses, and command executions are more and more needed in industrial automation domains. remote operation software that flexibly responds to changes in requirements from factory, chemical plants, or remote-side operators is desired. we developed a dynamic program-sending and automatic starting architecture for this purpose. in the architecture, a pair of programs appears in one remote operation context at a time. one program called a "worker" is dynamically sent to a plant side and another called a "workergui" is dynamically sent to a remote operator side. both programs are simultaneously started and communicate each other using java/rmi. the remote-side operator's commands via the "workergui" are sent and executed in the plant side "worker" program and the execution results are sent back to the operator side "workergui". by using this architecture, a remote-side operator is able to select best match programs whenever he or she needs, and dynamically send and start them. thus, the architecture establishes flexible remote operation environments. in this paper, we explain our architecture first, and then, report the evaluation results through experiences of architecture development, three prototype application developments, and using the applications in a real remote plant operation environment.
component rank: relative significance rank for software component search. collections of already developed programs are important resources for efficient development of reliable software systems. in this paper, we propose a novel method of ranking software components, called component rank, based on analyzing actual use relations among the components and propagating the significance through the use relations. we have developed a component-rank computation system, and applied it to various java programs. the result is promising such that non-specific and generic components are ranked high. using the component rank system as a core part, we are currently developing software product archiving, analyzing, and retrieving system named spars.