waashk/dblp huggingface dataset:
cross software development for microprocessors using a translator writing system. this paper illustrates four experiences in cross software development for microprocessors. after a comparison among some programming techniques (high-level languages, macroprocessors, meta-assemblers and special purpose systems) a translator writing system has been used to implement a cross-assembler, a simulator, a microassembler and a cross compiler for a microprocessor, showing its great flexibility at a low cost. each of the four applications is briefly described and compared with similar programs written using other techniques.
application downloading. the purpose of our research is to investigate the feasibility of this methodology for distributed application development by examining possible approaches to carrying out such developments. in particular, our emphasis lies in transformation technology, wherein user-invoked source-to-source transformations are applied to the partitioned system for the purpose of optimizing the transactions required to effect the distributed behavior. in this way, the application downloading system need only produce a correct partitioning of the original program, not an efficient one. the user, with system guidance, optimizes the partitioned program by applying transformations chosen from the system library. thus, application downloading can be viewed as a narrow domain in which to apply the transformation technology we have developed elsewhere in a broader context(1).
supporting industrial hyperwebs: lessons in scalability. open hypermedia is one approach to managing the relationships that exist in software development projects. a key technical issue in this endeavor is support for scalability. our experience supporting scalability in open hypermedia has revealed several key insights including the notion of the transitivity of scalability, the need to consider issues of scale in moving from design to implementation, the need to apply multiple techniques in tandem, and the unexpected nontechnical issues that arise when scaling a system to meet the demands of industrial software engineering. these insights are grounded in observations of a development project that scaled an open hypermedia system, chimera, two orders of magnitude to meet the demands of an industrial user.
on the transformational implementation approach to programming. this paper discusses various approaches to programming, defining and highlighting transformational implementation; it then examines the basic causes of the software problem and their resolution with transformational implementation. finally, an example illustrating the approach is given.
dragonfly: linking conceptual and implementation architectures of multiuser interactive systems. software architecture styles for developing multiuser applications are usually defined at a conceptual level, abstracting such low-level issues of distributed implementation as code replication, caching strategies and concurrency control policies. ultimately, such conceptual architectures must be cast into code. the iterative design inherent in interactive systems implies that significant evolution will take place at the conceptual level. equally, however, evolution occurs at the implementation level in order to tune performance. this paper introduces dragonfly, a software architecture style that maintains a tight, bidirectional link between conceptual and implementation software architectures, allowing evolution to be performed at either level. dragonfly has been implemented in the java-based telecomputing developer (tcd) toolkit.
3rd international workshop on adoption-centric software engineering acse 2003. the key objective of this workshop is to explore innovative approaches to the adoption of software engineering tools and practices---in particular by embedding them in extensions of commercial off-the-shelf (cots) software products and/or middleware technologies. the workshop aims to advance the understanding and evaluation of adoption of software engineering tools and practices by bringing together researchers and practitioners who investigate novel solutions to software engineering adoption issues.
recovery blocks in action: a system supporting high reliability. the need for reliable complex systems motivates the development of techniques by which acceptable service can be maintained, even in the presence of residual errors. recovery blocks allow a software designer to include tests on the acceptability of the various phases of a system's operation, and to specify alternative actions should the acceptance tests fail. this approach relies on certain architectural features, ideally implemented in hardware, by which control and data structures can be retrieved after errors. a brief account is presented of the recovery block scheme, together with a description of a new implementation of the underlying cache mechanism. the salient features of a proposed computer architecture are described, which incorporates this implementation and also provides a high level of detection for errors such as the corruption of code and data. a prototype system has been constructed to test the viability of these techniques by executing programs containing recovery blocks on an emulator for the proposed architecture. experiences in running this system are recounted with respect to the execution of programs based on erroneous algorithms and also with respect to errors introduced by deliberate attempts to corrupt the system.
4th international workshop on adoption-centric software engineering. the acse series of events aims to advance the adoptionof software engineering tools and techniques by bringingtogether researchers and practitioners who investigatenovel approaches to fostering the transition betweenlimited-use research prototypes and broadly applicablepractical solutions. one proven technique to aidadoption is to leverage existing commercial platformsand infrastructure. the key objective of acse 2004 is toexplore innovative approaches to the adoption of proof-of-concept systems by embedding them in extensions of commercial off-the-shelf (cots) products and/or using middleware technologies to integrate the prototypes into existing toolsets.
towards large-scale information integration. software engineers confront many challenges during software development. one challenge is managing the relationships that exist between software artifacts. we refer to this task as information integration, since establishing a relationship between documents typically implies that an engineer must integrate information from each of the documents to perform a development task. in the past, we have applied open hypermedia techniques and technology to address this challenge. we now extend this work with the development of an information integration environment. we present the design of our environment along with details of its first prototype implementation. furthermore, we describe our efforts to evaluate the utility of our approach. our first experiment involves the discovery of keyword relationships between text-based software artifacts. our second experiment examines the code of an open source project and generates a report on how its module relationships have evolved over time. finally, our third experiment develops the capability to link code claiming to implement w3c standards with the xhtml representation of the standards themselves. these experiments combine to demonstrate the promise of our approach. we conclude by asserting that the process of software development can be significantly enhanced if more tools made their relationships available for integration.
hiding distribution in distributed systems. the author focuses on the evolution of transparency in distributed systems, that is, the provision of logically centralized system facilities on distributed system architectures. the author proposes a comparison between the virtues and faults of centralized and distributed architectures, and reviews the evolution of distributed systems. the notion of transparency is described in detail with some examples. the main features of new technologies used to build transparent subsystems on distributed architectures are discussed
an automated program testing methodology and its implementation. this paper describes an automated testing methodology and an experiment performed to determine its effectiveness. the method is to insert in the program to be tested a number of &ldquo;executable assertions,&rdquo; statements about the program that trigger error signals whenever they are evaluated to be false (violated). a test-case is then developed for the program using actual values of the input variables. when the program is run, a plot is generated of the number of assertions violated versus the input variable values used. the resulting function is called the &ldquo;error function&rdquo;. heuristic search algorithms can then be used to maximize this function and thereby automatically locate input values which cause the most errors to occur. the experiment included developing assertions for the program to be tested, choosing and inserting representative errors into the program, and implementing search and data collection algorithms for testing. the results indicate that combining executable assertions with heuristic search algorithms is an effective method for automating the testing of computer programs.
language features for description of cooperating processes. language features are introduced in order to describe communicating processes. these constructs allow a clear separation of the definition of processes from that of their cooperations rules. elements of a language for the description of communications are presented and discussed.
is mutation an appropriate tool for testing experiments? the empirical assessment of test techniques plays an important role in software testing research. one common practice is to instrument faults, either manually or by using mutation operators. the latter allows the systematic, repeatable seeding of large numbers of faults; however, we do not know whether empirical results obtained this way lead to valid, representative conclusions. this paper investigates this important question based on a number of programs with comprehensive pools of test cases and known faults. it is concluded that, based on the data available thus far, the use of mutation operators is yielding trustworthy results (generated mutants are similar to real faults). mutants appear however to be different from hand-seeded faults that seem to be harder to detect than real faults.
computational reflection in software process modeling: the slang approach. slang is a domain-specific language for software process modeling and enactment. the authors present the basic features provided by slang to support the enactment and, in particular, dynamic evolution of a process model. software production processes are subject to changes during their lifetime. therefore, software process formalism must include mechanisms to support the analysis and dynamic modification of process models, even while they are being enacted. it is thus necessary for a process model to have the ability to reason about its own structure. petri net based process languages have been criticized because of the lack of these reflective features and their inability to effectively support process evolution. the reflective features offered by slang are outlined, which is a process formalism based on a high-level petri net notation. in particular, the mechanisms are discussed to create and modify different net fragments while the modeled process is being enacted
theme: an approach for aspect-oriented analysis and design. aspects are behaviours that are tangled and scatteredacross a system. in requirements documentation, aspectsmanifest themselves as descriptions of behaviours that areintertwined, and woven throughout. some aspects may beobvious, as specifications of typical crosscutting behaviour.others may be more subtle, making them hard to identify. ineither case, it is difficult to analyse requirements to locateall points in the system where aspects should be applied.these issues lead to problems achieving traceability of aspectsthroughout the development lifecycle. to identify aspectsearly in the software lifecycle, and establish sufficienttraceability, developers need support for aspect identificationand analysis in requirements documentation. to addressthis, we have devised the theme approach for viewingthe relationships between behaviours in a requirements document,identifying and isolating aspects in the requirements,and modelling those aspects using a design language. thispaper describes the approach, and illustrates it with a casestudy and analysis.
third international workshop on dynamic analysis(woda 2005). dynamic analysis techniques reason over program executions and show promise in aiding the development of robust and reliable large-scale systems. it has become increasingly clear that limitations of static analysis can be overcome by integrating static and dynamic analyses, and that the performance and value of dynamic analysis can be improved by static analysis. hence, a key focus of the workshop will be on hybrid analyses that involve both static and dynamic components.
conceptual module querying for software reengineering. many tools have been built to analyze source. most of these tools do not adequately support reengineering activities because they do not allow a software engineer to simultaneously perform queries about both the existing and the desired source structure. this paper introduces the conceptual module approach that overcomes this limitation. a conceptual module is a set of lines of source that are treated as a logical unit. we show how the approach simplifies the gathering of source information for reengineering tasks, and describe how a tool to support the approach was built as a front-end to existing source analysis tools.
broad-spectrum studies of log file analysis. this paper reports on research into applying the technique of log file analysis for checking test results to a broad range of testing and other tasks. the studies undertaken included applying log file analysis to both unit- and system-level testing and to requirements of both safety-critical and non-critical systems, and the use of log file analysis in combination with other testing methods. the paper also reports on the technique of using log file analyzers to simulate the software under test, both in order to validate the analyzers and to clarify requirements. it also discusses practical issues to do with the completeness of the approach, and includes comparisons to other recently-published approaches to log file analysis.
design pattern rationale graphs: linking design to source. a developer attempting to evolve a system in which design patterns have been applied can benefit from knowing which code implements which design pattern. for instance, the developer may be able to understand the purpose, or to assess the flexibility of the code, more quickly. the degree to which the developer benefits depends upon their understanding of the pattern. achieving an in-depth understanding of even a simple pattern can be difficult as pattern descriptions span several pages of text, and discuss interrelated design concepts and choices. to enable a developer to effectively trace the design goals associated with a pattern to and from source, we have developed the design pattern rationale graph (dprg) approach and associated tool. a dprg makes explicit the relationships between design concepts in a design pattern, provides a graphical representation of the design pattern text, and supports the linking of those concepts to implementing code. in this paper, we introduce the dprg approach and tool, and present case studies to show that a dprg can, at low-cost, help a developer identify design goals in a pattern, and can improve a developer's confidence about how those goals are realized in a code base.
extracting concepts from file names: a new file clustering criterion. decomposing complex software systems into conceptually independent subsystems is a significant software engineering activity which received considerable research attention. most of the research in this domain considers the body of the source code; trying to cluster together files which are conceptually related. we discuss techniques for extracting concepts (abbreviations) from a more informal source of information: file names. the task is difficult because nothing indicates where to split the file names into substrings. in general, finding abbreviations would require domain knowledge to identify the concepts that are referred to in a name and intuition to recognize such concepts in abbreviated forms. we show by experiment that the techniques we propose allow about 90% of the abbreviations to be found automatically
programming at the processor-memory-switch level. users of networks of heterogeneous processors are concerned with allocating specialized resources to tasks of medium to large size. they need to create processes, which are instances of tasks, allocate these processes to processors, and specify the communication patterns between processes. these activities constitute processor-memory-switch (pms) level programming, in contrast with traditional programming activities, which take place at the instruction set processor (isp) level. in this paper we describe the use of pms-level programming in computation-intensive, real-time applications, e.g., vision, robotics, and vehicular control, that require efficient concurrent execution of multiple tasks, e.g., sensor data collection, obstacle recognition, and global path planning, devoted to specific pieces of the application. at cmu we are developing languages and tools for this new style of programming, and in this paper we describe their status.
functional paleontology: system evolution as the user sees it. it has long been accepted that requirements analysis should precede architectural design and implementation, but in software evolution and reverse engineering this concern with black-box analysis of function has necessarily been de-emphasized in favor of code-based analysis and designer-oriented interpretation. in this paper, we redress this balance by describing &ldquo;functional paleontology&rdquo;, an approach to analyzing the evolution of user-visible features or services independent of architecture and design intent. we classify the benefits and burdens of interpersonal communication services into core and peripheral categories and investigate the telephony services available to domestic subscribers over a fifty-year period. we report that services were introduced in discrete bursts, each of which emphasized different benefits and burdens. we discuss the general patterns of functional evolution that this &ldquo;fossil record&rdquo; illustrates and conclude by discussing their implications for forward engineering of software products.
the use of goals to surface requirements for evolving systems. this paper addresses the use of goals to surface requirements for the redesign of existing or legacy systems. goals are widely recognized as important precursors to system requirements, but the process of identifying and abstracting them has not been researched thoroughly. we present a summary of a goal-based method (gbram) for uncovering hidden issues, goals, and requirements and illustrate its application to a commercial system, an intranet-based electronic commerce application, evaluating the method in the process. the core techniques comprising gbram are the systematic application of heuristics and inquiry questions for the analysis of goals, scenarios and obstacles. we conclude by discussing the lessons learned through applying goal refinement in the field and the implications for future research
who should fix this bug? open source development projects typically support an open bug repository to which both developers and users can report bugs. the reports that appear in this repository must be triaged to determine if the report is one which requires attention and if it is, which developer will be assigned the responsibility of resolving the report. large open source developments are burdened by the rate at which new bug reports appear in the bug repository. in this paper, we present a semi-automated approach intended to ease one part of this process, the assignment of reports to a developer. our approach applies a machine learning algorithm to the open bug repository to learn the kinds of reports each developer resolves. when a new report arrives, the classifier produced by the machine learning technique suggests a small number of developers suitable to resolve the report. with this approach, we have reached precision levels of 57% and 64% on the eclipse and firefox development projects respectively. we have also applied our approach to the gcc open source development with less positive results. we describe the conditions under which the approach is applicable and also report on the lessons we learned about applying machine learning to repositories used in open source development.
a case study of the evolution of jun: an object-oriented open-source 3d multimedia library. jun is a large open-source graphics and multimedia library. it is object-oriented and supports 3d geometry, topography and multimedia. this paper reviews the development of the jun library from five perspectives: open-source, software evolution processes, development styles, technological support, and development data. we conclude the paper with lessons learned from the perspective of a for-profit company providing open-source object-oriented software to the community.
tutorial: towards dynamic web services. this tutorial introduces dynamic web services as a solution to cope with the dynamism and flexibility required by many modern software systems. current technologies (wsdl, ws-bpel, etc.) have proven insufficient in addressing these issues; however, they remain a good starting point for the analysis of the current situation and for building for the future.the core part of the tutorial analyzes ---by looking at available technologies and prominent research proposals---the deployment and execution of these applications within three separate phases: a composition phase, to discover available services and implement the desired behavior, a monitoring phase, to understand if a given service is behaving correctly (with respect to both functional and non-functional requirements), and a recovery phase, to react to anomalies by means of suitable replanning or recovery strategies.in conclusion, the tutorial summarizes the main topics, presents a list of still-to-be-solved problems, and highlights possible directions for future research.
agile software process and its experience. this article proposes a new software process model, asp (agile software process) and discusses its experience in large-scale software development. the japanese software factory was a successful model in the development of quality software for large-scale business applications in the 80s. however, the requirements for software development have dramatically changed. development cycle-time has been promoted to one of the top goals of software development in the 90s. unlike conventional software process models based on volume, the asp is a time-based process model which aims at quick delivery of software products by integrating the lightweight processes, modular process structures and incremental and iterative process enaction. the major contributions of aps include: a new process model and its enaction mechanism based on time; a software process model for evolutional delivery; a software process architecture integrating concurrent and asynchronous processes, incremental and iterative process enaction, distributed multi-site processes, and the people-centered processes; a process-centered software engineering environment for asp; and experience and lessons learned from the use of asp in the development of a family of large-scale communication software systems for more than five years