waashk/dblp huggingface dataset:
twenty dirty tricks to train software engineers. many employers find that graduates and sandwich students come to them poorly prepared for the every day problems encountered at the workplace. although many university students undertake team projects at their institutions, an education environment has limitations that prevent the participants experiencing the full range of problems encountered in the real world. to overcome this, action was taken on courses at the plessey telecommunications company and loughborough university to disrupt the students' software development progress. these actions appear mean and vindictive, and are labeled 'dirty tricks' in this paper, but their value has been appreciated by both the students and their employers. the experiences and learning provided by twenty 'dirty tricks' are described and their contribution towards teaching essential workplace skills is identified. the feedback from both students and employers has been mostly informal but the universally favourable comments received give strong indications that the courses achieved their aim of preparing the students for the workplace. the paper identifies some limitations on the number and types of 'dirty tricks' that can be employed at a university and concludes that companies would benefit if such dirty tricks were employed in company graduate induction programmes as well as in university courses.
a systematic approach to derive the scope of software product lines. product line scoping is a critical activity because it elicits the common realms upon which the different products of a product line can be optimally engineered with respect to economies of scope. this, in turn, upper bounds the overall economic benefits that can be accrued from product line based development. inherently, product line scoping is difficult because of the complexity of the factors that must be taken into account. many are not known a priori. traditional scoping approaches (from domain engineering) have focused on the notion of application domains. however, domains proved difficult to optimally scope and engineer from an enterprise standpoint because a domain captures extraneous elements that are of no interest to an enterprise which must focus on particular products, whether existing, under development, or anticipated. hence, the domain view provides a flawed economic basis for making a scoping decision. we introduce pulse-eco, a technique especially developed to address the aforementioned issues. its main characteristics are: a complete product-centric orientation done via product maps, the separation of concerns achieved through the definition and operationalization of strategic business objectives, and last, diverse types of analyses performed upon product maps allowing scoping decisions based on these objectives. we illustrate the technique with a running example.
avoiding packaging mismatch with flexible packaging. to integrate a software component into a system, it must interact properly with the system's other components. unfortunately, the decisions about how a component is to interact with other components are typically committed long before the moment of integration and are difficult to change. this paper introduces the flexible packaging method, which allows a component developer to defer some decisions about component interaction until system integration time. the method divides the component's source into two pieces: the ware, which encapsulates the component's functionality; and the packager, which encapsulates the details of interaction. both the ware and the packager are independently reusable. a ware, as a reusable part, allows a given piece of functionality to be employed in systems in different architectural styles. a packager, as a reusable part, encapsulates conformance to a component standard, like an activex control or an odbc database accessor. because the packager's source code is often formulaic, a tool is provided to generate the packager's source from a high-level description of the intended interaction, a description written in the architectural description language unicon. the method and tools are evaluated with a series of experiments in which three wares and nine types of packaging are combined to form thirteen components.
programmer performance and the effects of the workplace. wide variation in programmer performance has been frequently reported in the literature [1, 2, 3]. in the absence of other explanation, most managers have come to accept that the variation is due to individual characteristics. the presumption that there are order-of-magnitude differences in individual performance makes accurate cost projection seem nearly impossible. in an extensive study, 166 programmers from 35 different organizations, participated in a one-day implementation benchmarking exercise. while there were wide variations across the sample, we found evidence that characteristics of the workplace and of the organization seemed to explain a significant part of the difference.
syncro: a dataflow command shell for the lilith/modula computer. syncro is a two-dimensional command interpreter that allows human interface through a graphic command language. this paper describes the concept of two-dimensional commands for direct implementation of leveled data flow structures, and comments on the syncro scheme for effecting them. syncro is implemented in modula-2 on niklaus wirth's lilith/modula computer.
progress toward automated software testing. mothra is an integrated environment for automated software validation. using mothra, a tester can create and execute test cases, measure test case adequacy, determine input-output correctness, locate and remove faults or bugs, and control and document the test. there are no size constraints built into the design of the environment. a goal of the research has been to exploit computational opportunities in each of the major subtasks of software validation. the author has attempted to reduce test case generation, measurement of the effectiveness of test cases, input-output correctness checking, and debugging to one or more computational metaphors and to design the appropriate algorithms. the result is a system where there is a high degree of control over the apparent cost of testing
role-based exploration of object-oriented programs. we present a new technique for helping developers understand heap properties of object-oriented programs and how the actions of the program affect these properties. our dynamic analysis uses the aliasing properties of objects to synthesize a set of roles; each role represents an abstract object state intended to be of interest to the developer. we allow the developer to customize the analysis to explore the object states and behavior of the program at multiple different and potentially complementary levels of abstraction.the analysis uses roles as the basis for three abstractions: role transition diagrams, which present the observed transitions between roles and the methods responsible for the transitions; role relationship diagrams, which present the observed referencing relationships between objects playing different roles; and enhanced method interfaces, which present the observed roles of method parameters.together, these abstractions provide useful information about important object and data structure properties and how the actions of the program affect these properties. we have used our implemented role analysis to explore the behavior of several java programs. our experience indicates that, when combined with a powerful graphical user interface, roles are a useful abstraction for helping developers explore and understand the behavior of object-oriented programs.
data structure repair using goal-directed reasoning. data structure repair is a promising technique for enabling programs to execute successfully in the presence of otherwise fatal data structure corruption errors. previous research in this field relied on the developer to write a specification to explicitly translate model repairs into concrete data structure repairs, raising the possibility of 1) incorrect translations causing the supposedly repaired concrete data structures to be inconsistent, and 2) repaired models with no corresponding concrete data structure representation.we present a new repair algorithm that uses goal-directed reasoning to automatically translate model repairs into concrete data structure repairs. this new repair algorithm eliminates the possibility of incorrect translations and repaired models with no corresponding representation as concrete data structures.
an empirical evaluation of fault-proneness models. planning and allocating resources for testing is difficult and it is usually done on empirical basis, often leading to unsatisfactory results. the possibility of early estimating the potential faultiness of software could be of great help for planning and executing testing activities. most research concentrates on the study of different techniques for computing multivariate models and evaluating their statistical validity, but we still lack experimental data about the validity of such models across different software applications.this paper reports an empirical study of the validity of multivariate models for predicting software fault-proneness across different applications. it shows that suitably selected multivariate models can predict fault-proneness of modules of different software packages.
the project library : a tool for software development. the project library presented in this article insures the harmonious development of the documentation for a software system in tandem with the development of the system itself. it offers the programmer a well-defined framework for his work, and gives management an articulate means for planning and control. the structure of the project library is defined by three dimensions: (1) systems structure (modularization), (2) standard organization and (3) development status. the project library has been realized as a system of files on the programm-entwicklungs-terminalsystem pet/x1150 (known in the usa as maestro) and supported by an appropriate variety of pet-procedures. our experience with the project library, specifically in the start project, has been very positive and instructive.
resolving component deployment & configuration challenges for enterprise dre systems via frameworks & generative techniques. component-based software engineering (cbse) is increasingly being adopted for large-scale software systems, particularly for enterprise distributed real-time and embedded (dre) systems. one of the most challenging-and often most neglected-problems in cbse for enterprise dre systems is the system (re)deployment and (re)configuration (d&c) process, where the increasing heterogeneity and versatility of application domains requires supports for an unprecedented level of configurability and adaptability. existing d&c technologies suffer from two major problems: (1) insufficient module-level reusability and ability to evolve in the face of functionality evolution and diversification due to the interaction of too many orthogonal concerns imposed by a wide range of application requirements and (2) significant inherent and accidental complexities stemming from inadequate design tools. to address these problems, my research focuses on improving both computing performance and human productivity associated with the d&c of component-based enterprise dre systems. to improve computing performance, my research has systematically identified bottlenecks with conventional d&c approaches and provides an aspect-oriented approach to decouple "extrinsic" orthogonal d&c concerns from "intrinsic" core d&c infrastructure, thereby enabling different crosscutting d&c concerns to be weaved independently to create a light-weight, highly optimized and extensible d&c infrastructure. to improve human performance, my research provides model-driven tools and analysis techniques to alleviate key inherent and accidental complexities in the d&c process.
invariant-based specification, synthesis, and verification of synchronization in concurrent programs. concurrency is used in modern software systems as a means of addressing performance, availability, and reliability requirements. the collaboration of multiple independently executing components is fundamental to meeting such requirements and such collaboration is realized by synchronizing component execution.using current technologies developers are faced with a tension between correct synchronization and performance. developers can be confident when simple forms of synchronization are used, for example, locking all accesses to shared data. unfortunately, such simple approaches can result in significant run-time overhead, and, in fact, there are many cases in which such simple approaches cannot implement required synchronization policies. implementing more sophisticated (and less constraining) synchronization policies may improve run-time performance and satisfy synchronization requirements, but fundamental difficulties in reasoning about concurrency make it difficult to assess their correctness.this paper describes an approach to automatically synthesizing complex synchronization implementations from formal high-level specifications. moreover, the generated coded is designed to be processed easily by software model-checking tools such as bandera. this enables the generated synchronization solutions to be verified for important system correctness properties. we believe this is an effective approach because the tool-support provided makes it simple to use, it has a solid semantic foundation, it is language independent, and we have demonstrated that it is powerful enough to solve numerous challenging synchronization problems.
testing database transactions with agenda. agenda is a tool set for testing relational database applications. an earlier prototype was targeted to applications consisting of a single query and included components for populating a database with data suitable for testing the application, generating inputs to the query, and checking relatively simple aspects of the results of executing the query. this paper describes substantial extensions to agenda, allowing it to test transactions with multiple queries and with complex intended behavior. the paper introduces a technique for checking complex properties of the database state transition performed by the transaction under test, as well as an improved input generation heuristic. results of using agenda to test three applications with seeded faults are presented.
addressing crosscutting deployment and configuration concerns of distributed real-time and embedded systems via aspect-oriented & model-driven software development. model-driven development (mdd) is gaining importance as an approach to resolving lifecycle challenges of large-scale distributed real-time and embedded (dre) systems (e.g., avionics mission computing). dre systems are characterized by their stringent requirements for quality of service (qos), such as predictable end-to-end latencies, timeliness and scalability. delivering the qos needs of dre systems entails the need to configure correctly, fine tune and provision the infrastructure used to host the dre systems, which crosscuts different layers of middleware, operating systems and networks. addressing these tangled deployment and configuration concerns of dre systems requires integrating the principles of aspect-oriented software development (aosd) with mdd. this demo showcases a set of software tools that resolve both the inherently and accidental complexities arising due to the configuration and deployment crosscutting concerns of component middleware-based dre systems.
sacificing the calf of flexibility on the altar of reliability. a pattern of conflict between flexibility and reliability in system designs is examined.
the evolution of programs: program abstraction and instantiation. our goal is to develop techniques for abstracting a given set of concrete programs into a program schema and for instantiating a schema to satisfy concrete specifications. for example, from two programs using the binary-search method, one to compute quotients and another to compute cube-roots, an abstract schema is derived that embodies the method and that can be instantiated to solve similar new problems. we suggest the formulation of analogies as a basic tool in program abstraction. an analogy is first sought between the specifications of the given programs; this yields an abstract specification that may be instantiated to any of the given concrete specifications. the analogy is then used as a basis for transforming the existing programs into an abstract schema that represents the embedded technique. the invariant assertions and correctness proofs of the given programs are used to complete the analogy.
inference rules for program annotation. methods are presented whereby an algol-like program given together with its specifications can be documented automatically. the program is incrementaly annotated with invariant relations that hold between program variables at intermediate points in the program text and explain the actual workings of the program regardless of whether it is correct. thus, this documentation can be used for proving correctness of programs or may serve as an aid in debugging incorrect programs.
identifying objects using cluster and concept analysis. many approaches to support (semi-automatic) identification of objects in legacy code take the data structures as starting point for candidate classes. unfortunately, legacy data structures tend to grow over time, and may contain many unrelated fields at the time of migration. we propose a method for identifying objects by semi-automatically restructuring the legacy data structures. issues involved include the selection of record fields of interest, the identification of procedures actually dealing with such fields, and the construction of coherent groups of fields and procedures into candidate classes. we explore the use of cluster and concept analysis for the purpose of object identification, and we illustrate their effect on a 100,000 loc cobol system. furthermore, we use these results to contrast clustering with concept analysis techniques.
software architecture reconstruction. architecture reconstruction is the reverse engineeringprocess that aims at recovering the past design decisionsthat have been made about the software architecture ofa system. to be a successful activity, we need to identifythe proper architecturally significant information andto extract it from the artefacts. how to identify extract/present/analyse it ? what are the critical issues that have to be considered ? how to manage the reconstructionprocess in a product family ? what tools are available? this tutorial will address these and other questions that are relevant for the development of large and complex softwaresystems. we introduce the key concepts of a softwarearchitecture description and the context of the architecturereconstruction activity. we present our architecture reconstructionmethod with a strong emphasis on its practicalaspects and the tools supporting it. the extraction of architecturallysignificant information and its analysis are thekey goals of our approach that will be demonstrated with aset of examples taken from real cases. we derive our experiencemainly from the telecommunication domain. however,we believe the same general principles can be applied toother domains. the tutorial addresses software engineersand project managers that are involved in the developmentof complex software systems.
chime: customizable hyperlink insertion and maintenance engine for software engineering environments. source code browsing is an important part of program comprehension. browsers expose semantic and syntactic relationships (such as between object references and definitions) in gui-accessible forms. these relationships are derived using tools which perform static analysis on the original software documents. implementing such browsers is tricky. program comprehension strategies vary, and it is necessary to provide the right browsing support. analysis tools to derive the relevant cross-reference relationships are often difficult to build. tools to browse distributed documents require extensive coding for the gui, as well as for data communications. therefore, there are powerful motivations for using existing static analysis tools in conjunction with www technology to implement browsers for distributed software projects. the chime framework provides a flexible, customizable platform for inserting html links into software documents using information generated by existing software analysis tools. using the chime specification language, and a simple, retargetable database interface, it is possible to quickly incorporate a range of different link insertion tools for software documents, into an existing, legacy software development environment. this enables tool builders to offer customized browsing support with a well-known gui. this paper describes the chime architecture, and describes our experience with several re-targeting efforts of this system.
techniques for trusted software engineering. how do we decide if it is safe to run a given piece of software on our machine? software used to arrive in shrink-wrapped packages from known vendors. but increasingly, software of unknown provenance arrives over the internet as applets or agents. running such software risks serious harm to the hosting machine. risks include serious damage to the system and loss of private information. decisions about hosting such software are preferably made with good knowledge of the software product itself, and of the software process used to build it. we use the term trusted software engineering to describe tools and techniques for constructing safe software artifacts in a manner designed to inspire trust in potential hosts. existing approaches have considered issues such as schedule, cost and efficiency; we argue that the traditionally software engineering issues of configuration management and intellectual property protection are also of vital concern. existing approaches (e.g., java) to this problem have used static type checking, run-time environments, formal proofs and/or cryptographic signatures; we propose the use of trusted hardware in combination with a key management infrastructure as an additional, complementary technique for trusted software engineering, which offers some attractive features
analytical and empirical evaluation of software reuse metrics. how much can be saved by using existing software components when developing new software systems? with the increasing adoption of reuse methods and technologies, this question becomes critical. however, directly tracking the actual cost savings due to reuse is difficult. a worthy goal would be to develop a method of measuring the savings indirectly by analyzing the code for reuse of components. the focus of the paper is to evaluate how well several published software reuse metrics measure the "time, money and quality" benefits of software reuse. we conduct this evaluation both analytically and empirically. on the analytic front, we introduce some properties that should arguably hold of any measure of "time, money and quality" benefit due to reuse. we assess several existing software reuse metrics using these properties. empirically, we constructed a toolset (using gen+s) to gather data on all published reuse metrics from cs+ code; then, using some productivity and quality data from "nearly replicated" student projects at the university of maryland, we evaluate the relationship between the known metrics and the process data. our empirical study sheds some light on the applicability of our different analytic properties, and has raised some practical issues to be addressed as we undertake broader study of reuse metrics in industrial projects.