waashk/dblp huggingface dataset:
fixing inconsistencies in uml design models. changes are inevitable during software development and so are their unintentional side effects. the focus of this paper is on uml design models, where unintentional side effects lead to inconsistencies. we demonstrate that a tool can assist the designer in discovering unintentional side effects, locating choices for fixing inconsistencies, and then in changing the design model. our techniques are "on-line," applied as the designer works, and non-intrusive, without overwhelming the designer. this is a significant improvement over the state-of-the-art. our tool is fully integrated with the design tool ibm rational rose^tm. it was empirically evaluated on 48 case studies.
suade: topology-based searches for software investigation. the investigation of a software system prior to a modification task often constitutes an important fraction of the overall effort associated with the task. we present suade, an eclipse plug-in to automatically generate suggestions for software investigation. the goal of suade is to increase the efficiency with which developers explore the source code by recommending locations that are likely to be relevant to the task. based on a context of software elements (fields and methods) explicitly specified by a developer, suade automatically generates other elements that are likely to be relevant given the context, by analyzing the topology of structural dependencies in a software system.
a leveled examination of test-driven development acceptance. test-driven development (tdd) has garnered considerable attention in professional settings and has made some inroads into software engineering and computer science education. a series of leveled experiments were conducted with students in beginning undergraduate programming courses through upper-level undergraduate, graduate, and professional training courses. this paper reports that mature programmers who try tdd are more likely to choose tdd over a similar test-last approach. additionally this research reveals differences in programmer acceptance of tdd between beginning programmers who were reluctant to adopt tdd and more mature programmers who were more willing to adopt tdd. attention is given to confounding factors, and future studies aimed at resolving these factors are identified. finally proposals are made to improve early programmer acceptance of tdd.
can requirements be creative? experiences with an enhanced air space management system. requirements engineering is a creative process in which stakeholders work together to create ideas for new software systems that are eventually expressed as requirements. this paper reports a workshop that integrated creativity techniques with different types of use case and system context modeling to discover stakeholder requirements for easm, a future air space management software system to enable the more effective, longer-term planning of uk and european airspace use. the workshop was successful in that it provided a range of outputs that were later assessed for their novelty and usefulness in the final specification of the easm software. the paper describes the workshop structure, gives examples of outputs from it, and uses these results to answer 2 research questions about the utility of creativity techniques and workshops that had not been answered in previous research.
reconceptualizing a family of heterogeneous embedded systems via explicit architectural support. it has been widely advocated that software architecture provides an effective set of abstractions for engineering (families of) complex software systems. however, architectural concepts are seldom supported directly at the level of system implementation. in embedded environments in particular, developers are often forced to rely on low-level programming languages. while this is conducive to fine-grain control over the system, it does not lend itself to addressing larger issues such as ensuring architectural integrity or managing an application family. in this paper we describe our experience with fundamentally altering the manner in which a family of embedded applications is designed, analyzed, implemented, deployed, and evolved using explicit architectural constructs. we discuss our strategy, the challenges we faced in the course of our project, the lessons learned in the process, and several open issues that remain unresolved.
the social dynamics of pair programming. this paper presents data from a four month ethnographic study of professional pair programmers from two software development teams. contrary to the current conception of pair programmers, the pairs in this study did not hew to the separate roles of "driver" and "navigator". instead, the observed programmers moved together through different phases of the task, considering and discussing issues at the same strategic "range" or level of abstraction and in largely the same role. this form of interaction was reinforced by frequent switches in keyboard control during pairing and the use of dual keyboards. the distribution of expertise among the members of a pair had a strong influence on the tenor of pair programming interaction. keyboard control had a consistent secondary effect on decision-making within the pair. these findings have implications for software development managers and practitioners as well as for the design of software development tools.
a formal framework for automated round-trip software engineering in static aspect weaving and transformations. we present a formal framework for a recently introduced approach to automated round-trip software engineering (are) in source-level aspect weaving systems. along with the formalization we improve the original method and suggest a new concept of weaving transactions in aspect-oriented programming (aop). as the major contribution we formally show how, given a tree-shaped intermediate representation of a program and an ancillary transposition tree, manual edits in statically woven code can consistently be mapped back to their proper source of origin, which is either in the application core or in an element in the aspect space. the presented formalism is constructive. it frames aop by generalizing static aspect weaving to classical tree transformations.
a technique for enabling and supporting debugging of field failures. it is difficult to fully assess the quality of software inhouse, outside the actual time and context in which it will execute after deployment. as a result, it is common for software to manifest field failures, failures that occur on user machines due to untested behavior. field failures are typically difficult to recreate and investigate on developer platforms, and existing techniques based on crash reporting provide only limited support for this task. in this paper, we present a technique for recording, reproducing, and minimizing failing executions that enables and supports inhouse debugging of field failures. we also present a tool that implements our technique and an empirical study that evaluates the technique on a widely used e-mail client.
kato: a program slicing tool for declarative specifications. this paper presents kato, a tool that implements a novel class of optimizations that are inspired by program slicing for imperative languages but are applicable to analyzable declarative languages, such as alloy. kato implements a novel algorithm for slicing declarative models written in alloy and leverages its relational engine kodkod for analysis. given an alloy model, kato identifies a slice representing the model's core: a satisfying instance for the core can systematically be extended into a satisfying instance for the entire model, while unsatisfiability of the core implies unsatisfiability of the entire model. the experimental results show that for a variety of subject models kato's slicing algorithm enables an order of magnitude speed-up over alloy's default translation to sat.
mining object usage models. programs usually follow many implicit programming rules or patterns, violations of which frequently lead to failures. this thesis proposes a novel approach to statically mine object usage models representing such patterns for objects used in a program. additionally, we will describe how object usage models can be used to automatically detect defects, increase program understanding and support programmers by providing code templates. in preliminary experiments the proposed method detected two previously unknown bugs in open source software.
applying iso 9001: 2000, mps.br and cmmi to achieve software process maturity: bl informatica's pathway. customer satisfaction, quality improvement and rework reduction are known to be the most important benefits obtained through deployment of software process maturity models and standards within an organization. since 2003 bl informática has been motivated and has established and maintained its software processes based on international standards (like iso 9001:2000) and maturity models (like mps.br and cmmi). in spite of the lack of financial and human resources, the organization achieved satisfactory results. this paper describes bl infomática's software processes improvement plan, lessons learned, difficulties and benefits that where collected during the execution of the improvement plan. it also presents quantitative results that demonstrate the return on investment during these years.
agility and experimentation: practical techniques for resolving architectural tradeoffs. this paper outlines our experiences with making architectural tradeoffs between performance, availability, security, and usability, in light of stringent cost and time-to-market constraints, in an industrial web-conferencing system. we highlight the difficulties in anticipating future architectural requirements and tradeoffs and the value of using agility and experiments as a tool for mitigating architectural risks in situations when up front pen-and- paper analysis is simply impossible.
role migration and advancement processes in ossd projects: a comparative case study. socio-technical processes have come to the forefront of recent analysis of the open source software development (ossd) world. interest in making these processes explicit is mounting, from industry and the software process community, as well as among those who may become contributors to ossd organization. this paper serves to close this gap by providing an empirical analysis of the role migration and project career advancement process, and role-sets within, that we have observed through comparative case studies within three large ossd project organizations: mozilla.org, apache.org, and netbeans.org.
on the impact of a collaborative pedagogy on african american millennial students in software engineering. millennial students (those born after 1982), particularly african americans and women, have demonstrated a propensity toward collaborative activities. we conducted a collective case study at north carolina state university and north carolina a&t to ascertain the role of collaboration and social interaction in attracting and retaining students in information technology. responses from semi-structured interviews with 11 representative african american students in these classes were coded and analyzed. the responses from these minority students were used to evolve a social interaction model. the conjectures generated from the model suggest that pair programming and agile software methodologies effectively create a collaborative environment that is desirable to millennial students, male and female, and, with the new evidence, minority and majority. additionally, the african american millennial students enjoy learning from their peers and believe that a collaborative environment better prepares them for the "real world."
feature oriented model driven development: a case study for portlets. model driven development (mdd) is an emerging paradigm for software construction that uses models to specify programs, and model transformations to synthesize executables. feature oriented programming (fop) is a paradigm for software product lines where programs are synthesized by composing features. feature oriented model driven development (fomdd) is a blend of fop and mdd that shows how products in a software product line can be synthesized in an mdd way by composing features to create models, and then transforming these models into executables. we present a case study of fomdd on a product line of portlets, which are components of web portals. we reveal mathematical properties of portlet synthesis that helped us to validate the correctness of our abstractions, tools, and specifications, as well as optimize portlet synthesis.
supporting generic sketching-based input of diagrams in a domain-specific visual language meta-tool. software engineers often use hand-drawn diagrams as preliminary design artefacts and as annotations during reviews. we describe the addition of sketching support to a domain-specific visual language meta-tool enabling a wide range of diagram-based design tools to leverage this human-centric interaction support. our approach allows visual design tools generated from high-level specifications to incorporate a range of sketching-based functionality including both eager and lazy recognition, moving from sketch to formalized content and back, and using sketches for secondary annotation and collaborative design review. we illustrate the use of our sketching extension for an example domain-specific visual design tool and describe the architecture and implementation of the extension as a plug-in for our eclipse-based meta-tool.
company-wide implementation of metrics for early software fault detection. to shorten time-to-market and improve customer satisfaction, software development companies commonly want to use metrics for assessing and improving the performance of their development projects. this paper describes a measurement concept for assessing how good an organization is at finding faults when most cost-effective, i.e. in most cases early. the paper provides results and lessons learned from applying the measurement concept widely at a large software development company. a major finding was that on average, 64 percent of all faults found would have been more cost effective to find during unit tests. an in-depth study of a few projects at a development unit also demonstrated how to use the measurement concept for identifying which parts in the fault detection process that needs to be improved to become more efficient (e.g. reduce the amount of time spent on rework).
modeling product line architectures through change sets and relationships. the essence of any modeling approach for product line architectures lies in its ability to express variability. existing approaches do so by explicitly specifying variation points inside the architectural specification of the entire product line, usually with optional and alternative elements of some form. this, however, leads to a sizable mismatch between conceptual variability (i.e., the features through which architects logically view and interpret differences in product architectures) and actual variability (i.e., the modeling constructs through which the logical differences must be expressed). we contribute a new product line architecture modeling approach that unites the two. our approach uses change sets to group related architectural differences and relationships to govern which change set combinations are valid when composed into a particular product architecture. the result lifts modeling of variability out of modeling architectural structure, consolidates related variation points, and explicitly and separately manages their compatibilities.
bringing the systems analysis and design course into 21^st century: a case study in implementing modern software engineering principles. while today's it students may have a theoretical knowledge of all the phases in the systems development lifecycle, they often have little exposure to software development core practices. few are able to build a new system from scratch. this paper examines a pedagogical approach to modern software engineering based on "doing" systems development from day one. course materials were produced by agile methodology expert, alistair cockburn. early results from an implementation of the experimental approach to the systems analysis and design course are examined.
using soloman-felder learning style index to evaluate pedagogical resources for introductory programming classes. soloman-felder learning style index has been applied extensively in engineering education to ascertain the learning styles of students. this paper presents an approach showing how learning styles of students can be used to evaluate pedagogical resources. in specific, learning style can be used to help determine an appropriate textbook and an appropriate mixture of additional pedagogical devices such as virtual labs or "clickers'. an example from a first undergraduate programming course is used to illustrate the approach.
overview of the impact project. this session is intended to introduce the icse audience to the impact project, whose goals are to 1) study the impact that software engineering research has had upon software engineering practice, and 2) promulgate project findings to the community, and then broadly to industry, academe, and government. the project is being sponsored by acm sigsoft, and funded by a variety of international funding sources. the project has been in operation for over six years, and preliminary reports on the project were presented at icse 2001 and icse 2002. formal reports have begun to appear as articles in acm tosem. here at icse 2007 we will report on the project again in the form of a 3-session mini-track. this first session will (re)introduce the project, and outline the studies that have been completed, are underway, and are anticipated. it will also summarize some of the larger findings and understandings about research impact that have been gleaned so far from observation of the various studies. this session and the mini-track are aimed at informing the community, and also at engaging it in both the studies themselves, and the discussions of the findings. thus, this session will conclude with ample time for discussion.
sequential circuits for relational analysis. the alloy tool-set has been gaining popularity as an alternative to traditional manual testing and checking for design correctness. alloy uses a first-order relational logic for modeling designs. the alloy analyzer translates alloy formulas for a given scope, i.e., a bound on the universe of discourse, to boolean formulas in conjunctive normal form (cnf), which are subsequently checked using propositional satisfiability solvers. we present sera, a novel algorithm that compiles a relational logic formula for a given scope to a sequential circuit. there are two key advantages of sequential circuits: they form a more succinct representation than cnf formulas, sometimes by several orders ofmagnitude. also sequential circuits are amenable to a range of powerful automatic analysis techniques that have no counterparts for cnf formulas. our experiments show that sera, used in conjunction with a sequential circuit analyzer, can check formulas for scopes that are an order of magnitude higher than those feasible with the alloy analyzer.
using server pages to unify clones in web applications: a trade-off analysis. server page technique is commonly used for implementing web application user interfaces. server pages can represent many similar web pages in a generic form. yet our previous study revealed high rates of repetitions in web applications, particularly in the user interfaces. code duplication, commonly known as "cloning', signals untapped opportunities to achieve simpler, smaller, more generic, and more maintainable web applications. using php server page technique, we conducted a case study to explore how far server page technique can be pushed to achieve clone-free web applications. our study suggests that clone unification using server pages affects system qualities (e.g., runtime performance) to an extent that may not be acceptable in many project situations. our paper discusses the trade-offs we observed when applying server pages to unify clones in web applications. we expect our findings to help in developing and validating complementary techniques that can unify clones without incurring such trade-offs.
'good' organisational reasons for 'bad' software testing: an ethnographic study of testing in a small software company. in this paper we report on an ethnographic study of a small software house to discuss the practical work of software testing. through use of two rich descriptions, we discuss that "rigour' in systems integration testing necessarily has to be organisationally defined. getting requirements "right', defining "good' test scenarios and ensuring "proper' test coverage are activities that need to be pragmatically achieved taking account of organisational realities and constraints such as: the dynamics of customer relationships; using limited effort in an effective way; timing software releases; and creating a market. we discuss how these organisational realities shape (1) requirements testing; (2) test coverage; (3) test automation; and (4) test scenario design.
supporting heterogeneous architecture descriptions in an extensible toolset. many architecture description languages (adls) have been proposed to model, analyze, configure, and deploy complex software systems. to face this diversity, extensible adls (or adl interchange formats) have been proposed. these adls provide linguistic support for integrating various architectural aspects within the same description. nevertheless, they do not support extensibility at the tool level, i.e. they do not provide an extensible toolset for processing adl descriptions. in this paper, we present an extensible toolset for easing the development of architecture-based software systems. this toolset is not bound to a specific adl, but rather uses a grammar description mechanism to accept various input languages, e.g. adls, interface definition languages (idls), domain specific languages (dsls). moreover, it can easily be extended to implement many different features, such as behavioral analysis, code generation, deployment, etc. its extensibility is obtained by designing its core functionalities using fine-grained components that implement flexible design patterns. experiments are presented to illustrate both the functionalities implemented by the toolset and the way it can be extended.
matching and merging of statecharts specifications. model management addresses the problem of managing an evolving collection of models, by capturing the relationships between models and providing well-defined operators to manipulate them. in this paper, we describe two such operators for manipulating hierarchical statecharts: match, for finding correspondences between models, and merge, for combining models with respect to known correspondences between them. our match operator is heuristic, making use of both static and behavioural properties of the models to improve the accuracy of matching. our merge operator preserves the hierarchical structure of the input models, and handles differences in behaviour through parameterization. in this way, we automatically construct merges that preserve the semantics of statecharts models. we illustrate and evaluate our work by applying our operators to at&t telecommunication features.