waashk/dblp huggingface dataset:
operations for programming in the all. a primary goal of software engineering is to improve the process of software development. it is being recognised that recent integrated programming environments have made significant progress towards this aim. this paper describes new operations, suitable for such environments, which are applicable in a much wider scope of programming, termed here as programming in the all. development of software in this new scope is carried out incrementally in program fragments of various types, called fragtypes. fragtypes range from a simple expression type to a complete subsystem type, and therefore are suited to the development of non-trivial software. the proposed operations on fragtypes have been incorporated in the design of the programming environment mupe-2 for modula-2, which is currently under development at mcgill university.
model based process assessments. the authors present an approach that combines process modeling with process assessments. they use the structured analysis and design technique (sadt) modeling notation (d.a. marca and c.l. mcgowan, 1988). the dod cim initiative has standardized on a subset of sadt, called idef0, to model business processes. a sadt (idef0) model was created of a large software maintenance process and the model led to process improvements that might have been missed otherwise. this model based process assessment approach is described as a process in its own right
impact of commercial off-the-shelf (cots) software on the interface between systems and software engineering. this presentation examines the changes in the interface between systems engineering and software engineering which are required to make effective use of commercial off-the-shelf software products, especially in large or complex systems.
the translation and compatibility of sequel and query by example. the problem of the translation and compatibility of high level data base query languages is addressed via a case study of the languages sequel and query by example. in particular, an algorithm for translating queries on a relational data base stated in query by example into queries expressed in sequel is introduced. this algorithm is used as a vehicle to describe a consistent interpretation of the semantics of sequel and query by example. the compatibility of query by example and sequel is briefly discussed. examples of the operation of the algorithm are presented.
a general framework for formalizing uml with formal languages. informal and graphical modeling techniques enable developers to construct abstract representations of systems. object-oriented modeling techniques further facilitate the development process. the unified modeling language (uml), an object-oriented modeling approach, could be broad enough in scope to represent a variety of domains and gain widespread use. currently, uml comprises several different notations with no formal semantics attached to the individual diagrams. therefore, it is not possible to apply rigorous automated analysis or to execute a uml model in order to test its behavior, short of writing code and performing exhaustive testing. we introduce a general framework for formalizing a subset of uml diagrams in terms of different formal languages based on a homomorphic mapping between metamodels describing uml and the formal language. this framework enables the construction of a consistent set of rules for transforming uml models into specifications in the formal language. the resulting specifications derived from uml diagrams enable either execution through simulation or analysis through model checking, using existing tools. this paper describes the use of this framework for formalizing uml to model and analyze embedded systems. a prototype system for generating the formal specifications and results from an industrial case study are also described.
a language and environment for architecture-based software development and evolution. software architectures have the potential to substantially improve the development and evolution of large, complex, multi-lingual, multi-platform, long-running systems. however, in order to achieve this potential, specific techniques for architecture-based modeling, analysis, and evolution must be provided. furthermore, one cannot fully benefit from such techniques unless support for mapping an architecture to an implementation also exists. this paper motivates and presents one such approach, which is an outgrowth of our experience with systems developed and evolved according to the c2 architectural style. we describe an architecture description language (adl) specifically designed to support architecture-based evolution and discuss the kinds of evolution the language supports. we then describe a component-based environment that enables modeling, analysis, and evolution of architectures expressed in the adl, as well as mapping of architectural models to an implementation infrastructure. the architecture of the environment itself can be evolved easily to support multiple adls, kinds of analyses, architectural styles, and implementation platforms. our approach is fully reflexive: the environment can be used to describe, analyze, evolve, and (partially) implement itself, using the very adl it supports. an existing architecture is used throughout the paper to provide illustrations and examples.
second international workshop on interdisciplinary software engineering research (wiser). wiser is a series of international workshops that focus on identifying and transferring techniques from other disciplines that might usefully be applied to software engineering research and practice.the workshops address this topic through presentations and discussions of both actual case studies and of ways in which potentially useful approaches can be identified, adapted and adopted within software engineering.
evolving legacy systems using feature engineering and cbse. this dissertation explores the relationships between feature engineering, cbse, and software evolution. software endusers and developers have different perspectives of a software system, resulting in a complexity gap between user expectations and the software functionality [2]. this gap together with aging code has resulted in lost assets for many organizations. by combining feature engineering and cbse, legacy code can be modernized so that many organizations can benefit from this technique. in our approach, we identify the legacy system's features through test cases and test suites. we then apply our code carving techniques to identify the code associated with those features and extract the code to create components. we validate our results in two ways. first, by inserting the component(s) back into the legacy system to continue functioning. second, by measuring the cost of adding a new feature after applying the methodology.
evolving legacy system features into fine-grained components. there is a constant need for practical, efficient, and cost-effective software evolution techniques. we propose a novel evolution methodology that integrates the concepts of features, regression tests, and component-based software engineering (cbse). regression test cases are untapped resources, full of information about system features. by exercising each feature with its associated test cases using code profilers and similar tools, code can be located and refactored to create components. these components are then inserted back into the legacy system, ensuring a working system structure. this methodology is divided into three parts. part one identifies the source code associated with features that need evolution. part two deals with creating components and part three measures results. by applying this methodology, afs has successfully restructured its enterprise legacy system and reduced the costs of future maintenance. additionally, the components that were refactored from the legacy system are currently being used within a web-enabled application.
towards a taxonomy of software connectors. software systems of today are frequently composed from prefabricated, heterogeneous components that provide complex functionality and engage in complex interactions. existing research on component-based development has mostly focused on component structure, interfaces, and functionality. recently, software architecture has emerged as an area that also places significant importance on component interactions, embodied in the notion of software connectors. however, the current level of understanding and support for connectors has been insufficient. this has resulted in their inconsistent treatment and a notable lack of understanding of what the fundamental building blocks of software interaction are and how they can be composed into more complex interactions. this paper attempts to address this problem. it presents a comprehensive classification framework and taxonomy of software connectors. the taxonomy is obtained through an extensive analysis of existing component interactions. the taxonomy is used both to understand existing software connectors and to suggest new, unprecedented connectors. we demonstrate the use of the taxonomy on the architecture of a large, existing system.
a cross-program investigation of students' perceptions of agile methods. research was conducted on using agile methods in software engineering education. this paper explores the perceptions of students from five different academic levels of agile practices. information has been gathered through the collection of quantitative and qualitative data over three academic years, and analysis reveals student experiences, mainly positive but also some negative. student opinions indicate the preference to continue to use agile practices at the workplace if allowed. a way these findings may potentially be extrapolated to the industrial settings is discussed. finally, this report should encourage other academics considering adoption of agile methods in their computer science or software engineering curricula.
using a goal-driven approach to generate test cases for guis. the widespread use of guis for interacting with software is leading to the construction of more and more complex guis. with the growing complexity comes challenges in testing the correctness of a gui and the underlying software. we present a new technique to automatically generate test cases for guis that exploits planning, a well developed and used technique in artificial intelligence. given a set of operators, an initial state and a goal state, a planner produces a sequence of the operators that will change the initial state to the goal state. our test case generation technique first analyzes a gui and derives hierarchical planning operators from the actions in the gui. the test designer determines the preconditions and effects of the hierarchical operators, which are then input into a planning system. with the knowledge of the gui and the way in which the user will interact with the gui, the test designer creates sets of initial and goal states. given these initial and final states of the gui, a hierarchical planner produces plans, or a set of test cases, that enable the goal state to be reached. our technique has the additional benefit of putting verification commands into the test cases automatically. we implemented our technique by developing the gui analyzer and extending a planner. we generated test cases for microsoft's word-pad to demonstrate the viability and practicality of the approach.
skoll: distributed continuous quality assurance. quality assurance (qa) tasks, such as testing, profiling,and performance evaluation, have historically been donein-house on developer-generated workloads and regressionsuites. since this approach is inadequate for many systems,tools and processes are being developed to improve softwarequality by increasing user participation in the qa process.a limitation of these approaches is that they focus onisolated mechanisms, not on the coordination and controlpolicies and tools needed to make the global qa process efficient, effective, and scalable. to address these issues, we have initiated the skoll project, which is developing and validatingnovel software qa processes and tools that leveragethe extensive computing resources of worldwide user communitiesin a distributed, continuous manner to significantlyand rapidly improve software quality. this paper providesseveral contributions to the study of distributed continuousqa. first, it illustrates the structure and functionality ofa generic around-the-world, around-the-clock qa processand describes several sophisticated tools that support thisprocess. second, it describes several qa scenarios builtusing these tools and process. finally, it presents a feasibilitystudy applying these scenarios to a 1mloc+ softwarepackage called ace+tao. while much work remains to bedone, the study suggests that the skoll process and toolseffectively manage and control distributed, continuous qaprocesses. using skoll we rapidly identified problems thathad taken the ace+tao developers substantially longer tofind and several of which had previously not been found.moreover, automatic analysis of qa task results often provideddevelopers information that quickly led them to theroot cause of the problems.
validation methods for calibrating software effort models. coconut calibrates effort estimation models using an ex-haustive search over the space of calibration parameters in a cocomo i model. this technique is much simpler than other effort estimation method yet yields pred levels com-parable to those other methods. also, it does so with less project data and fewer attributes (no scale factors). how-ever, a comparison between coconut and other methods is complicated by differences in the experimental methods used for effort estimation. a review of those experimental methods concludes that software effort estimation models should be calibrated to local data using incremental hold-out (not jack knife) studies, combined with randomization and hypothesis testing, repeated a statistically significant number of times.
the grand challenge of trusted components. reusable components equipped with strict guarantees of quality can help reestablish software development on a stronger footing, by taking advantage of the scaling effect of reuse to justify the extra effort of ensuring impeccable quality. this discussion examines work intended to help the concept of trusted component brings its full potential to the software industry, along two complementary directions: a "low road" leading to qualification of existing components, and a "high road" aimed at the production of components with fully proved correctness properties.
the software knowledge base. we describe a system for maintaining useful information about a software project. the &ldquo;software knowledge base&rdquo; keeps track of software components and their properties; these properties are described through binary relations and the constraints that these relations must satisfy. the relations and constraints are entirely user-definable, although a set of predefined libraries of relations with associated constraints is provided for some of the most important aspects of software development (specification, design, implementation, testing, project management). the use of the binary relational model for describing the properties of software is backed by a theoretical study of the relations and constraints which play an important role in software development.
data mining library reuse patterns using generalized association rules. in this paper, we show how data mining can be used to discover library reuse patterns in existing applications. specifically, we consider the problem of discovering library classes and member functions that are typically reused in combination by application classes. this paper improves upon our earlier research using &ldquo;association rules&rdquo; [8] by taking into account the inheritance hierarchy using &ldquo;generalized association rules&rdquo;. this turns out to be a non-trivial but worthwhile endeavor.by browsing generalized association rules, a developer can discover patterns in library usage in a way that takes into account inheritance relationships. for example, such a rule might tell us that application classes that inherit from a particular library class often instantiate another class or one of its descendents. we illustrate the approach using our tool, codeweb, by demonstrating characteristic ways in which applications reuse classes in the kde application framework.
assessing software libraries by browsing similar classes, functions and relationships. comparing and contrasting a set of software libraries is useful for reuse related activities such as selecting a library from among several candidates or porting an application from one library to another. the current state of the art in assessing libraries relies on qualitative methods. to reduce costs and/or assess a large collection of libraries, automation is necessary. although there are tools that help a developer examine an individual library in terms of architecture, style, etc., we know of no tools that help the developer directly compare several libraries. with existing tools, the user must manually integrate the knowledge learned about each library. automation to help developers directly compare and contrast libraries requires matching of similar components (such as classes and functions) across libraries. this is different than the traditional component retrieval problem in which components are returned that best match a user's query. rather, we need to find those components that are similar across the libraries under consideration. in this paper, we show how this kind of matching can be done.
helping users avoid bugs in gui applications. in this paper, we propose a method to help users avoid bugs in gui applications. in particular, users would use the application normally and report bugs that they encounter to prevent anyone -- including themselves -- from encountering those bugs again. when a user attempts an action that has led to problems in the past, he/she will receive a warning and will be given the opportunity to abort the action -- thus avoiding the bug altogether and keeping the application stable. of course, bugs should be fixed eventually by the application developers, but our approach allows application users to collaboratively help each other avoid bugs -- thus making the application more usable in the meantime. we demonstrate this approach using our "stabilizer" prototype. we also include a preliminary evaluation of the stabilizer's bug prediction.
formalizing design patterns. design patterns facilitate reuse of good design practices. they are typically given by using conventional notations that lack well-defined semantics and, therefore reasoning about their behaviors requires formalization. even when formalized, conventional communication abstractions may lead to too laborious formalizations when addressing the temporal behavior of a pattern as a whole instead of behaviors local to its components. we show that rigorous reasoning can be eased by formalizing temporal behaviors of patterns in terms of high-level abstractions of communication, and that by using property-preserving refinements, specifications can be naturally composed by using patterns as building blocks
"how do i know what i have to do?": the role of the inquiry culture in requirements communication for distributed software development projects. as software specifications for complex systems are practically never 100% complete and consistent, the recipient of the specification needs domain knowledge in order to decide which parts of the system are specified clearly and which parts are specified ambiguously and thus need inquiry to achieve a more detailed specification. in this paper we classify 16 different situations (states) of requirements communication and analyze, based on a state diagram, how a mature inquiry culture can help to initiate transitions from undesirable states into more desirable states. in a case study the inquiry practices of a very large software development organization are shown. knowledge networks within the organization play an important role in building up a mature inquiry culture.
a closer look at iteration: the self stabilizing capability of loops. let p be an iterative program on domain d, with state s. a close look at the structure of the loop invariant of p reveals that p has a desirable self stabilizing property: if during the computation, an error causes the state to take a contaminated value s', then, under some conditions, it is possible to recover from this contamination without knowing any previous correct state. this feature contrasts with the classical error recovery mechanisms which equate error recovery with the retrieval of a previously saved correct state, and the backtracking of the computation.
an integrated cost model for software reuse. several cost models have been proposed in the past for estimating, predicting, and analyzing the costs of software reuse. in this paper we analyze existing models, explain their variance, and propose a tool-supported comprehensive model that encompasses most of the existing models.
a system for classifying program verification methods: assigning meanings to program verification methods. many program verification methods are known nowadays: inductive assertion method, invariant assertion method, intermittent assertion method, symbolic execution method, subgoal induction method, computational induction method, structural induction method, fixpoint theory of programs. this paper presents a simple classification of them.
completely monotone regression estimates of software failure rates. a new method for estimating the present failure rate of a program is presented. a crude nonparametric estimate of the failure rate function is obtained from past failure times. this estimate is then smoothed by fitting a completely monotonic function, which is the solution of a quadratic programming problem. the value of the smoothed function at present time is used as the estimate of present failure rate. a monte carlo study gives an indication of how well this method works.
independent on-line monitoring of evolving systems. we argue that the trustworthiness of evolving software systems can be significantly enhanced by a rigorous process of independent on-line monitoring. such monitoring can prevent fraud, encourage careful maintenance, and serve as an early detector of irregularities in the state and behavior of a system. unfortunately, there is a conflict between the concepts of on-line and independent monitoring. this conflict is due to the fact that on-line monitoring requires the embedding of some kinds of sensors in the base-system. but the introduction of such sensors requires a degree of cooperation with the developers of the base system, and may interfere with the operations of that system, contrary to the requirements of independent monitoring. we describe a way to resolve this conflict by applying the concept of law-governed architecture.
ensuring integrity by adding obligations to privileges. conventional authorization mechanisms provide actors with permissions to act, without the actor ever incurring any obligations as a result of executing the permitted action. there exist, however, many situations where system integrity requires that certain actions always be followed by others, within some reasonable time frame. we propose an extension to conventional authorization which allows the explicit association of obligations with permissions, and enforces them. we demonstrate that the extended mechanism can be used to support and enforce several general types of control policies and integrity constraints which are otherwise difficult or impossible to support.
an evaluation of the paired comparisons method for software sizing. this paper evaluates the accuracy, precision and robustness of the paired comparisons method for software sizing and concludes that the results produced by it are superior to the so called &ldquo;expert&rdquo; approaches.