waashk/dblp huggingface dataset:
the dimensions of maintenance. the area of software maintenance has been described by one author as an &ldquo;iceberg.&rdquo; (edp analyzer, 1972) much goes on here that does not currently meet the eye. in part, this is the consequence of measurement difficulties. practitioners and researchers can benefit from an understanding of the &ldquo;dimensionality&rdquo; of the maintenance problem. some measures are suggested for coming to grips with this dimensionality, and problems of utilization associated with these measures are explored.
component technology - what, where, and how?. software components, if used properly, offer many software engineering benefits. yet, they also pose many original challenges starting from quality assurance and ranging to architectural embedding and composability. in addition, the recent movement towards services, as well as the established world of objects, causes many to wonder what purpose components might have.this extended abstract summarizes the main points of my frontiers of software practice (fosp) talk at icse 2003. the topics covered aim to offer an end-to-end overview of what role components should play, where they should be used, and how this can be achieved some key open problems are also pointed out.
the making of a software engineer challenges for the educator. software engineering is foremost an engineering discipline. engineering in general and software engineering specifically has to balance many factors to achieve viable tradeoffs - an understanding of the factors as well as the viability criteria is at the heart of the educational challenge. all engineering has one ultimate goal: the delivery of artifacts (products, commercial or not) that meet the needs of those using such artifacts. all engineering lives in the intersection of people, technology, domain, and opportunity aspects. software engineering, however, is laden with its own specific difficulties. software as an engineering medium fills a space between the fluidity of digital content, with which software shares the representation, and the nature of machines, with which software shares the flexible and repeatable application.
agent system development method based on agent patterns. this paper proposes a method of agent system development based on agent patterns that represent typical and recurring structures and behaviors of agents. the agent patterns are classified according to their appropriate architectural levels and the degree of their dependence on specific agent platforms. our method enables developers to design agent systems efficiently since they can construct complicated system architectures and behaviors by dividing the design process into two architectural levels and applying the appropriate agent patterns. in addition, the higher level designs are independent of specific agent platforms and can be therefore easily reused.
a programmer performance measure based on programmer state transitions in testing and debugging process. to organize and manage software development teams, it as important to evaluate the capability of each programmer based on reliable and easily collected data. we present a system which automatically monitors programmer activities, and propose a programmer debugging performance measure based on data monitored by the system. the system automatically categorizes programmer activity in real time into three types (compilation, program execution, and program modification) by monitoring and analyzing key strokes of a programmer. the resulting outputs are the time sequences of monitored activities. the measure we propose is the average length of debugging time per fault, d, estimated from the data sequences monitored by the system. to estimate the debugging time per fault, we introduce a testing and debugging process model. the process model has parameters associated with the average length of a program modification, d, and the probability of a fault being fixed completely by a program modification, r. by taking account of r as well as d, the debugging time per fault can be estimated with high accuracy. the model parameters, such as d and r, are computed from the monitored data sequences by using a maximum likelihood estimation method
visual aid for fortran program debugging. this paper presents a new type of debugging tool for fortran programs. we call this the &ldquo;dock&rdquo; system, referring to the dock where ships stay during repairs. dock provides new debugging functions such as slow display of program execution. major functions and a brief indication of the methods of implementation are given in this paper. four &ldquo;execution modes&rdquo; control execution speed. execution is displayed on the screen in full screen mode. the source program listing is displayed with the executing statement shown in a different color or brightness. at certain places, the program stops temporarily in a status called &ldquo;stationary mode&rdquo;. in the stationary mode, several debugging functions are available.
an empirical study of a model for program error prediction. a model is presented for estimating the number of errors remaining in a program at the beginning of the testing phase of development. the relationships between the errors occurring in a program and the various factors that affect software development, such as programmer skill, are statistically analyzed. the model is then derived using the factors significantly identified in the analysis. on the basis of data collected during the development of large-scale software systems, it is shown that factors such as frequency of program specification change, programmer skill, and volume of program design documentation are significant and that the model based on these factors is more reliable than conventional error prediction methods based on program size alone.
how to teach software modeling. to enhance motivation of students to study software engineering, some way of finding balance between the scientific aspect and the practical aspect of software engineering is required. in this paper, we claim that teaching multiple software modeling techniques from a unified viewpoint is a good way of obtaining the balance and attracting the students' interest as well.
requirements and design change in large-scale software development: analysis from the viewpoint of process backtracking. change of requirements and design specifications is one of the fatal causes of large scale software development project problems. the authors study this problem from the viewpoint of software process backtracking. they conducted case studies of real business application system development projects. it was found that there were several cases of process backtracking in large scale projects and the process model should be flexible to allow reversibility. the users learning processes are considered. among many probable factors that cause the volatility of user requirements and thus result in process backtracking, specific attention is given to the fact that as users learn to use a system and accumulate experience of the system usage, they change their system requirements level. the importance of considering this evolution process and finding a way of predicting changes in user requirements are discussed
an adaptive object model with dynamic role binding. to achieve the goal of realizing object adaptation to environments, a new role-based model epsilon and a language epsilonj is proposed. in epsilon, an environment is defined as a field of collaboration between roles and an object adapts to the environment assuming one of the roles. objects can freely enter or leave environments and belong to multiple environments at a time so that dynamic adaptation or evolution of objects is realized. environments and roles are the first class constructs at runtime as well as at model description time so that separation of concerns is not only materialized as a static structure but also observed as behaviors. environments encapsulating collaboration are independent reuse components to be deployed separately from objects. in this paper, the epsilon model and the language are explained with some examples. the effectiveness of the model is illustrated by a case study on the problem of integrated systems. implementation of the language is also reported.
heuristic-based model refinement for flavers. flavers is a finite-state verification approach that allowsan analyst to incrementally add constraints to improvethe precision of the model of the system being analyzed. exceptfor trivial systems, however, it is impractical to computewhich constraints should be selected to produce preciseresults for the least cost. thus, constraint selection hasbeen a manual task, guided by the intuition of the analyst.in this paper, we investigate several heuristics for selectingtask automaton constraints, a kind of constraint that tendsto reduce infeasible task interactions. we describe an experimentshowing that one of these heuristics is extremelyeffective at improving the precision of the analysis resultswithout significantly degrading performance.
managing space for finite-state verification. finite-state verification (fsv) techniques attempt to prove properties about a model of a system by examining all possible behaviors of that model. this approach suffers from the state-explosion problem, where the size of the model or the analysis costs may be exponentially large with respect to the size of the system. using symbolic data structures to represent subsets of the state space has been shown to usually be an effective optimization approach for hardware verification. the value for software verification, however, is still unclear. in this paper, we investigate applying two symbolic data structures, binary decision diagrams (bdds) and zero-suppressed binary decision diagrams (zdds), in two fsv tools, ltsa and flavers. we describe an experiment showing that these two symbolic approaches can improve the performance of both fsv tools and are more efficient than two other algorithms that store the state space explicitly. moreover, the zdd-based approach often runs faster and can handle larger systems than the bdd-based approach.
estimating loc for information systems from their conceptual data models. effort and cost estimation is crucial in software management. estimation of software size plays a key role in the estimation. line of code (loc) is still a commonly used software size measure. despite the fact that software sizing is well recognized as an important problem for more than two decades, there is still much problem in existing methods. conceptual data model is widely used in the requirements analysis for information systems. it is also not difficult to construct conceptual data models in the early stage of developing information systems. much characteristic of an information system is actually reflected from its conceptual data model. we explore into the use of conceptual data model for estimating loc. this paper proposes a novel method for estimating loc for an information system from its conceptual data model through the use of multiple linear regression model. we have validated the method through collecting samples from both the industry and open-source systems.
consistency management for complex applications. consistency management is important in many complex applications, but current languages and database systems inadequately support it. to address this limitation, we defined a consistency management model and incorporated it into the pleiades object management system. this paper illustrates some typical consistency management requirements and discusses the requirements in terms of both functionality and cross-cutting concerns that affect how this functionality is provided. it then describes the model and some design and implementation issues that arose in instantiating it. finally, we discuss user feedback and future research plans
workshop on multi-dimensional separation of concerns in software engineering. separation of concerns has been central to software engineering for decades, yet its many advantages are still not fully realized. a key reason is that traditional modularization mechanisms do not allow simultaneous decomposition according to multiple kinds of (overlapping and interacting) concerns. this workshop was intended to bring together researchers working on more advanced modularization mechanisms, and practitioners who have experienced the need for them, as a step towards a common understanding of the issues, problems and research challenges.
hyper/j: multi-dimensional separation of concerns for java. hyper/j supports a new approach to constructing, integrating and evolving software, called multi-dimensional separation of concerns. it addresses a number of common problems in the development, evolution, and integration of large-scale, complex software systems, helping to achieve many goals of software engineering. these include: improved comprehension and reduced complexity of software; non-invasive adaptation and customization, promoting off-the-shelf reuse; the ability to synthesize, compose, and integrate separate pieces of software into new pieces of software; the ability to extract new concerns from existing software, non-invasively; non-invasive, low-impact evolution; and improved ability to allow multiple, decentralized teams to work on different, but overlapping, parts of software simultaneously, thus reducing development bottlenecks and promoting more rapid software development.
workshop on advanced separation of concerns in software engineering. separation of concerns can provide a host of well-known and crucial benefits, but only if the concerns that are separated and modularized match the concerns one needs to deal with&mdash;which can be of dramatically different kinds in different development contexts. traditional modularization approaches have proven inadequate. work in the growing area of advanced separation of concerns seeks to provide more powerful and flexible modularization, capable of encapsulating multiple kinds of overlapping, interacting and crosscutting concerns. this workshop is intended to bring together researchers and practitioners in this and related areas, to explore some of the many open issues..
a programming environment supporting reuse of object-oriented software. we have developed a programming environment for object-oriented programming. this environment supports reuse of classes, especially retrieval of them with an expert system. the user can find classes and methods by describing the features of objects and operations according to an object model proposed by us. the target programming language is momo, which is developed by us to implement the object model. this paper mainly focuses on the retrieval part of the environment.
a technique for prototyping directly from a specification. a technique is described for prototyping a system directly from a specification. the technique uses the logic programming language prolog and involves translating the specification into a prolog form. this is used in conjunction with a set of functions, also written in prolog, which provide an operational interpretation of the semantics of the specification language, and a user interface which allows the user to exercise the specification and examine its behaviour.
workshop on software engineering and computer-human interaction: joint research issues. software engineering and computer-human interaction have much to do with each other, but their respective research communities typically have little interaction. the purpose of the article is to explore the intersections of these areas, determining what each community has to offer the other as well as to identify and address open problems of mutual interest. topics of discussion were drawn from the following: cost drivers, current products, prototyping, requirements, formal methods and specifications, testing and evaluation, design and development, architectures, user interfaces and software environments, chi and cscw concerns and toolkits
steps to an advanced ada programming environment. conceptual simplicity, tight coupling of tools, and effective support of host-target software development will characterize advanced ada programming support environments. several important principles have been demonstrated in the arcturus system, including template-assisted ada editing, command completion using ada as a command language, and combining the advantages of interpretation and compilation. other principles, relating to analysis, testing, and debugging of concurrent ada programs, have appeared in other contexts. this paper discusses several of these topics, considers how they can be integrated, and argues for their inclusion in an environment appropriate for software development in the late 1980's.
a tour through cedar. this lively walk through a sophisticated programming environment is taken from a videotaped demonstration of the system. there is no need to adjust your set.
an early report on encompass. encompass is an environment to support the incremental construction of ada&reg; programs using executable specifications and formal techniques similar to the vienna development method. encompass supports the rigorous development of software: parts of a project may use completely formal methods, while other, less critical parts use less expensive techniques. encompass provides automated support for all aspects of the development process including specification, prototyping, testing, formal verification, documentation, configuration control and project management. in encompass, software can be specified using please, an ada-based executable specification language which can be automatically translated into prolog. a prototype implementation of encompass has been constructed. in this paper, we give an overview of encompass, describe the decisions made in the design of the prototype, and discuss the lessons learned in the process.
evolution in the design of abstract machines for software portability. the abstract machine model is the best one for solving the difficult problem of program transferring, but an evolution in the design of these machines is necessary. after a brief survey of the well-known abstract machines, this paper proposes the design of a more general one to implement portable operating systems. the complex problem of relating this abstract machine to existing computers is discussed and the paper explains how the top-down methodology is an inestimable means to reduce the machine dependence.
team-based fault content estimation in the software inspection process. the main objective of software inspection is to detectfaults within a software artifact. this helps to reduce thenumber of faults and to increase the quality of a softwareproduct. however, although inspections have been performedwith great success, and although the quality of theproduct is increased, it is difficult to estimate the quality.during the inspection process, attempts with objective estimationsas well as with subjective estimations have beenmade. these methods estimate the fault content after an inspectionand give a hint of the quality of the product. thispaper describes an experiment conducted throughout theinspection process, where the purpose is to compare the estimationmethods at different points. the experiment evaluatesteam estimates from subjective and objective faultcontent estimation methods integrated with the software inspectionprocess. the experiment was conducted at two differentuniversities with 82 reviewers. the result shows thatobjective estimates outperform subjective when point andconfidence intervals are used. this contradicts the previousstudies in the area.
third international summit on software engineering education (ssee iii): bridging the university/industry gap. innovative university/industry interactions are examined in this open event with the aim of providing inputs to an international project that is being funded through the united kingdom's teaching fellowship scheme. these inputs will support the first stage of the project which is concerned with gaining knowledge of industrial software engineering practices and the development of a framework that can be used in the classification and evaluation of such practices.
design, implementation, and evaluation of a revision control system. the revision control system (rcs) is a software tool that helps in managing multiple revisions of text. rcs automates the storing, retrieval, logging, identification, and merging of revisions, and provides access control. it is useful for text that is revised frequently, for example programs and documentation. this paper presents the design and implementation of rcs. both design and implementation are evaluated by contrasting rcs with sccs, a similar system. sccs is implemented with forward, merged deltas, while rcs uses reverse, separate deltas. (deltas are the differences between successive revisions.) it is shown that the latter technique improves run-time efficiency, while requiring almost no extra space.
binary refactoring: improving code behind the scenes. we present binary refactoring: a software engineering technique for improving the implementation of programs without modifying their source code. while related to regular refactoring in preserving a program's functionality, binary refactoring aims to capture modifications that are often applied to source code, although they only improve the performance of the software application and not the code structure. we motivate binary refactoring, present a binary refactoring catalogue, describe the design and implementation of barber---our binary refactoring browser for java, and demonstrate the usefulness of binary refactoring through a series of benchmarks.
evaluating the reverse engineering capabilities of web tools for understanding site content and structure: a case study. this paper describes an evaluation of the reverse engineering capabilities of three web tools for understanding site content and structure. the evaluation is based on partitioning web sites into three classes (static, interactive, and dynamic), and is structured using an existing reverse engineering environment framework (reef). this case study also represents an initial evaluation of the applicability of the reef in the related but qualitatively different domain of web sites. the case study highlights several shortcomings of current web tools in the context of aiding understanding to support evolution. for example, most web tools are geared towards new page design and development, not to understanding detailed page content or overall site structure. the evaluation also identified some aspects of the reef that might benefit from refinement to better reflect web tool capabilities that support common evolution tasks. for example, web server log file analysis as a specialized form of data gathering and subsequent information presentation.
improvement of a configuration management system. the company cad-ul ag develops software tools for embedded systems. single tools as compilers, linkers and debuggers are offered as well as complete development tool chains for the software development process. in contrast to application software for personal computers, embedded systems require very specialized software of highly optimized and exhaustively tested code.since the previously existing configuration management was not efficient in comparison to the state-of-the-art in software engineering, an improvement was implemented by the introduction of a modern configuration management (cm) system [1].in this presented paper, cad-ul intends to show the results and the experiences of the european systems & software initiative process improvement experiment (essi-pie) icms with the new configuration management system.