waashk/dblp huggingface dataset:
using a behavioral theory of program comprehension in software engineering. a theory is presented of how a programmer goes about understanding a program. the theory is based on a representation of knowledge about programs as a succession of knowledge domains which bridge between the problem domain and the executing program. a hypothesis and verify process is used by programmers to reconstruct these domains when they seek to understand a program. the theory is useful in several ways in software engineering: it makes accurate predictions about the effectiveness of documentation; it can be used to systematically evaluate and critique other claims about documentation, and it may even be a useful guideline to a programmer in actually constructing documentation.
an examination of the current state of ipse technology. the concept of an integrated project support environment (ipse) was developed in response to a recognition that communication and coordination between all tools used in software development and maintenance are essential to the efficient production of quality software systems. the author begins by examining some of the reasons for the relative implementation of ipse in the commercial world, and then turns his attention to alternative solutions which have seen greater success. the main areas of ipse research currently being pursued are highlighted. an analysis is given of key issues for the future
a graph theoretic approach to the verification of program structures. for large computer programs, verification of compliance with structured programming rules can present difficult problems for programmers and managers. in order to certify that code is structured, an algorithm and test tool were recently developed to audit source code and verify the use of structured constructs. the paper describes the segmentation of programs as a way of representing their logical control structure; presents the basic algorithm, illustrates algorithm extensions; and briefly reports on experience in using the tool on a large software project.
a critical overview of computer performance evaluation. effective computer performance evaluation requires: theories and models which effectively represent computer systems and computer processes, evaluation techniques which generate accurate assessments of system or program behavior from models and theories, technology for data gathering on executing systems or processes and technology for data analysis. this paper assesses the extent to which these requirements are currently met. a greater emphasis on combining empirical and theoretical work is needed. the significance and value of current applications of performance measurement and analysis are assessed. network and data base systems offer high leverage for application of performance modeling and evaluation.
fast: a second generation program analysis system. fast (fortran analysis system) implements a powerful set of analysis capabilities on fortran source language programs. its implementation was accomplished through the integration of existing software systems and by the use of modern language system development tools. the result is an order of magnitude reduction in effort of implementation coupled with a sizable increase in system capabilities. the use of a general purpose, commercially available data management system as a data handler and data correlator was a dominant factor in both reduction in effort of implementation and generation of additional power and flexibility in the analysis capabilities offered by fast. fast implements a capability for systematically qualified program analyses which is unique among existing program analyzers. this capability should be particularly useful in the program maintenance environment.
reuse library interoperability and the world wide web. the reuse library interoperability group (rig) was formed in 1991 for the purpose of drafting standards enabling the interoperation of software reuse libraries. at that time, prevailing wisdom among many reuse library operators was that each should be a stand-alone operation. many operators saw a need for only a single library, their own, and most strived to provide the most general possible services to appeal to a broad community of users. the asset program, initiated by the advanced research project agency stars program, was the first to make the claim that it should properly be one part of a network of interoperating libraries. shortly thereafter, the rig was formed, initially as a collaboration between the stars program and the air force raasp program, but growing within six months to a self-sustaining cooperation among twelve chartering organizations. the rig has grown to include over twenty members from government, industry, and academic reuse libraries. it has produced a number of technical reports and proposed interoperability standards, some of which are described in this report.
specification and modeling: an academic perspective. the specification and modeling of software systems, of their aspects, and their development processes is at the heart of software engineering. over the years, we have achieved a much deeper and more comprehensive understanding of software and its models as a basis for its specification. however, there is still a way to go to make sure that all we know right now is transferred into practice, and that all we do not understand so far is investigated in depth. the goal is a tractable scientific basis for modeling and specification in programming, software and system engineering and its employment in engineering methods.
automotive software engineering. information technology has become the driving force of innovation in many areas of technology and also in cars. embedded software controls the functions of cars, supports and assists the driver and realizes systems for information and entertainment. software in automobiles is today one of the great challenges for software engineering. on modern cars we find all issues of software systems in a nutshell. it is a challenge for software and systems engineering.
challenges in automotive software engineering. the amount of software in cars grows exponentially. driving forces of this development are cheaper and more powerful hardware and the demand for innovations by new functions. the rapid increase of software and software based functionality brings various challenges (see [21], [23], [25], [26]) for the automotive industries, for their organization, key competencies, processes, methods, tools, models, product structures, division of work, logistics, maintenance, and long term strategies. from a software engineering perspective, the automotive industry is an ideal and fascinating application domain for advanced techniques. although the automotive industry may adopt general results and solutions from the software engineering body of knowledge gained in other domains, the specific constraints and domain specific requirements in the automotive industry ask for individual solutions and bring various challenges for automotive software engineering. in cars we find literally all interesting problems and challenging issues of software and systems engineering.
software engineering: management, personnel and methodology. three key factors often determine the success or failure of a software project: the management of the project, the selection of personnel, and the development methodology that is used. this paper discusses the important considerations that should be addressed in each of these areas and examines the results of a typical project that paid attention to these factors. in particular, it was concluded that a good development methodology can help ensure the reliability, maintainability and timeliness of any software project.
finding latent code errors via machine learning over program executions. this paper proposes a technique for identifying programproperties that indicate errors. the technique generates machinelearning models of program properties known to resultfrom errors, and applies these models to program propertiesof user-written code to classify and rank propertiesthat may lead the user to errors. given a set of propertiesproduced by the program analysis, the technique selectssubset of properties that are most likely to reveal an error.an implementation, the fault invariant classifier,demonstrates the efficacy of the technique. the implementationuses dynamic invariant detection to generate programproperties. it uses support vector machine and decision treelearning tools to classify those properties. in our experimentalevaluation, the technique increases the relevance(the concentration of fault-revealing properties) by a factorof 50 on average for the c programs, and 4.8 for the javaprograms. preliminary experience suggests that most of thefault-revealing properties do lead a programmer to an error.
rapid prototyping of control systems using high level petri nets. this paper presents a rapid prototyping methodology for the carrying out of control systems in which high level petri nets provide the common framework to integrate the main phases of software development: specification, validation, performance evaluation, implementation. petri nets are shown to be translatable into ada program structures concerning processes and their synchronizations.
discovering faults in idiom-based exception handling. in this paper, we analyse the exception handling mechanism of a state-of-the-art industrial embedded software system. like many systems implemented in classic programming languages, our subject system uses the popular return-code idiom for dealing with exceptions. our goal is to evaluate the fault-proneness of this idiom, and we therefore present a characterisation of the idiom, a fault model accompanied by an analysis tool, and empirical data. our findings show that the idiom is indeed fault prone, but that a simple solution can lead to significant improvements.
a framework of greedy methods for constructing interaction test suites. greedy algorithms for the construction of software interaction test suites are studied. a framework is developed to evaluate a large class of greedy methods that build suites one test at a time. within this framework are many instantiations of greedy methods generalizing those in the literature. greedy algorithms are popular when the time for test suite construction is of paramount concern. we focus on the size of the test suite produced by each instantiation. experiments are analyzed using statistical techniques to determine the importance of the implementation decisions within the framework. this framework provides a platform for optimizing the accuracy and speed of "one-test-at-a-time" greedy methods.
static checking of interrupt-driven software. resource-constrained devices are becoming ubiquitous. examples include cell phones, palm pilots, and digital thermostats. it can be difficult to fit required functionality into such a device without sacrificing the simplicity and clarity of the software. increasingly complex embedded systems require extensive brute-force testing, making development and maintenance costly. this is particularly true for system components that are written in assembly language. static checking has the potential of alleviating these problems, but until now there has been little tool support for programming at the assembly level. in this paper we present the design and implementation of a static checker for interrupt-driven z86-based software with hard real-time requirements. for six commercial microcontrollers, our checker has produced upper bounds on interrupt latencies and stack sizes, as well as verified fundamental safety and liveness properties. our approach is based on a known algorithm for model checking of pushdown systems, and produces a control-flow graph annotated with information about time, space, safety, and liveness. each benchmark is approximately 1000 lines of code, and the checking is done in a few seconds on a standard pc. our tool is one of the first to give an efficient and useful static analysis of assembly code. it enables increased confidence in correctness, significantly reduced testing requirements, and support for maintenance throughout the system life-cycle.
performing systematic literature reviews in software engineering. context: making best use of the growing number of empirical studies in software engineering, for making decisions and formulating research questions, requires the ability to construct an objective summary of available research evidence. adopting a systematic approach to assessing and aggregating the outcomes from a set of empirical studies is also particularly important in software engineering, given that such studies may employ very different experimental forms and be undertaken in very different experimental contexts.objectives: to provide an introduction to the role, form and processes involved in performing systematic literature reviews. after the tutorial, participants should be able to read and use such reviews, and have gained the knowledge needed to conduct systematic reviews of their own.method: we will use a blend of information presentation (including some experiences of the problems that can arise in the software engineering domain), and also of interactive working, using review material prepared in advance.
international workshop on realising evidence-based software engineering. this workshop is concerned with defining the procedures that are needed to establish a sound empirical foundation for the practices of software engineering. our goal is to begin building a community that will review, analyse, codify and promulgate software engineering experiences as well as to identify the processes and infrastructure that are needed to support these activities.
experiments with prolog design descriptions and tools in caede: an iconic design environment for multitasking, embdedded systems. we report on experiments with prolog design descriptions and tools in caede (carleton embedded system design environment), an experimental, iconic design environment for multitasking, embedded systems. the philosophy of caede is to enter structural and temporal design information iconically, via a graphics interface, to serve as the basis for design analysis and skeleton code generation, and then to enter, under control of the iconic interface, program &ldquo;strips&rdquo; to fill in the functional gaps in the skeleton code. the iconic information is converted automatically into a prolog design data base of facts and rules. caede aims to support incremental design and to be incrementally extensible. in the current implementation of caede, which runs on a sun workstation supporting design for ada, the iconic interface is limited to structural design. here we describe the prolog side of our research, covering the nature of the facts produced from the iconic input by the current implementation and their use by experimental prolog tools for structural analysis, temporal analysis and ada code generation. the aim is to show how prolog is contributing to the framework of a powerful, extensible design environment.
action language: a specification language for model checking reactive systems. we present a specification language called action language for model checking software specifications. action language forms an interface between transition system models that a model checker generates and high level specification languages such as statecharts, rsml and scr&mdash;similar to an assembly language between a microprocessor and a programming language. we show that action language translations of statecharts and scr specifications are compact and they preserve the structure of the original specification. action language allows specification of both synchronous and asynchronous systems. it also supports modular specifications to enable compositional model checking.
the fujaba real-time tool suite: model-driven development of safety-critical, real-time systems. no abstract available
end-user software engineering with assertions in the spreadsheet paradigm. there has been little research on end-user program development beyond the activity of programming. devising ways to address additional activities related to end-user program development may be critical, however, because research shows that a large proportion of the programs written by end users contain faults. toward this end, we have been working on ways to provide formal "software engineering" methodologies to end-user programmers. this paper describes an approach we have developed for supporting assertions in end-user software, focusing on the spreadsheet paradigm. we also report the results of a controlled experiment, with 59 end-user subjects, to investigate the usefulness of this approach. our results show that the end users were able to use the assertions to reason about their spreadsheets, and that doing so was tied to both greater correctness and greater efficiency.
process assessments in nasa. a software process assessment procedure, recently refined by the software engineering institute (sei), gives managers a useful tool to identify the strengths and weaknesses of software organizations. the author discusses how process assessment techniques were introduced to nasa and how the procedure was enlarged to evaluate not just software development but also software quality assurance operations. initially, the techniques were extended to cover contract management and especially software quality assurance organizations. a preliminary assessment tool (questionnaire) consisting of 98 items was introduced. after some revision, it demonstrated its usefulness at a series of on-site surveys. the combined surveys demonstrated that a nasa questionnaire can point a team in the right direction
security attribute evaluation method: a cost-benefit approach. conducting cost-benefit analyses of architectural attributes such as security has always been difficult, because the benefits are difficult to assess. specialists usually make security decisions, but program managers are left wondering whether their investment in security is well spent. this paper summarizes the results of using a cost-benefit analysis method called saem to compare alternative security designs in a financial and accounting information system. the case study presented in this paper starts with a multi-attribute risk assessment that results in a prioritized list of risks. security specialists estimate countermeasure benefits and how the organization's risks are reduced. using saem, security design alternatives are compared with the organization's current selection of security technologies to see if a more cost-effective solution is possible. the goal of using saem is to help information-system stakeholders decide whether their security investment is consistent with the expected risks.
no 1a ess laboratory support system - erasable flag facility. a laboratory support system (lss) is provided in all no. 1a electronic switching system (ess) test laboratories to support the ess software development process. the lss tools are utilized by the developers to accomplish ess program database management, lab load administration, lab load generation, and program testing and debugging in the laboratory environment. this document describes one of the lss testing and debugging tools: the no. 1a ess laboratory erasable flag system. this facility is a test coverage analyzer which monitors how well an executed test procedure has exercised, or covered, specified instruction and data words resident in no. 1a ess memory. erasable flag output data makes it possible to enhance test procedures to achieve a more comprehensive level of software checkout during feature development and system integration of ess code.
engineering mobile-agent applications via context-dependent coordination. mobility introduces peculiar coordination problems in agent-based internet applications. first, it suggests the exploitation of an infrastructure based on a multiplicity of local interaction spaces. second, it may require coordination activities to be adapted both to the characteristics of the execution environment where they occur and to the needs of the application to which the coordinating agents belong. this paper introduces the concept of context-dependent coordination based on programmable interaction spaces. on the one hand, interaction spaces associated to different execution environments may be independently programmed so as to lead to differentiated, environment-dependent, behaviors. on the other hand, agents can program the interaction spaces of the visited execution environments to obtain an application-dependent behavior of the interaction spaces themselves. several examples show how an infrastructure for context-dependent coordination can be exploited to simplify the design of internet applications based on mobile agents. in addition, the mars coordination infrastructure is presented as an example of a system in which the concept of context-dependent coordination has found a clean and efficient implementation.
a periodic object model for real-time systems. time-sensitive objects (tso), a data-oriented model for real-time systems, impose timing constraints on object values using validity intervals and object histories. periodic objects, a class of objects within the tso model, are described in detail and compared with more traditional periodic processes. advantages of periodic objects are identified, including greater scheduling independence of processing related through data dependencies, more opportunity for concurrency, and improved structure for timing fault tolerance
path expressions in pascal. this paper describes the enhancement of pascal to specify synchronization between concurrent processes by path expressions. the extended language is being used to gain experience in the design and construction of practical real time systems and operating systems. an encapsulation mechanism is included to synchronize all accesses to encapsulated data. a network message transfer system is presented as an extended example of the use of path expressions.
concurrent software system design, supported by sara at the age of one. this paper presents a multilevel modeling method suitable for the design of concurrent hardware or software systems. the methodology is requirement driven and uses tools incorporated in a programming system called sara (systems architect's apprentice). both top down refinement and bottom up abstraction are supported. the design of an asynchronous sender receiver illustrates the key steps in going smoothly from programming in the large to programming in the small or actual code. the same methodology can be used to design hardware systems by applying different pragmatics than those proposed for software systems. sara consists of a set of interactive tools implemented both at ucla and also on the mit-multics system. although sara continues in long-term development, completed design tools accessible for experimentation by authorized users at either location via the arpanet.
developing and executing java awt applications on limited devices with tcpte. the paper describes tcpte, a framework that supports the development of thin-client applications for mobile devices. by using this framework, java awt applications can be executed on a server and their graphical interfaces can be displayed on a remote client. tcpte combines in a single framework the advantages of thin-client computing with the richness of client-server graphical interfaces and the simplicity of development that characterizes desktop applications.
modeling and controlling the software test process. a novel approach for modeling and control of the software test process is presented. the approach is based on the concept of state variables and uses techniques from the well-established field of automatic control theory. an initial model of the software test phase is described and the results of a case study analysis are presented.