waashk/dblp huggingface dataset:
a software architecture-based framework for highly distributed and data intensive scientific applications. modern scientific research is increasingly conducted by virtual communities of scientists distributed around the world. the data volumes created by these communities are extremely large, and growing rapidly. the management of the resulting highly distributed, virtual data systems is a complex task, characterized by a number of formidable technical challenges, many of which are of a software engineering nature. in this paper we describe our experience over the past seven years in constructing and deploying oodt, a software framework that supports large, distributed, virtual scientific communities. we outline the key software engineering challenges that we faced, and addressed, along the way. we argue that a major contributor to the success of oodt was its explicit focus on software architecture. we describe several large-scale, real-world deployments of oodt, and the manner in which oodt helped us to address the domain-specific challenges induced by each deployment.
designing components versus objects: a transformational approach. a good object-oriented design does not necessarily make a good component-based design, and vice versa. what design principles do components introduce? this paper examines component-based programming and how it expands the design space in the context of an event-based component architecture. we present a conceptual model for addressing new design issues these components afford, and we identify fundamental design decisions in this model that are not a concern in conventional object-oriented design. we use javabeans-based examples to illustrate concretely how expertise in component-based design, as embodied in a component taxonomy and implementation space, impacts both design and the process of design. the results are not exclusive to javabeans&mdash;they can apply to any comparable component architecture.
pluggable reflection: decoupling meta-interface and implementation. reflection remains a second-class citizen in current programming models, where it's assumed to be imperative and tightly bound to its implementation. in contrast, most object-oriented apis allow interfaces to vary independently of their implementations. components take this separation a step further by describing unforeseeable attributes---the key to pluggable third-party components. this paper describes how reflection can benefit from a similar evolutionary path.
knowledge-based software design using design schemas. design schemas provide a means for abstracting software designs into broadly reusable components that can be assembled and refined into new software designs. this paper describes a knowledge-based software development paradigm that is based on the design schema representation. it combines design schemas, domain knowledge, and various types of rules to assist in the quick generation of software designs from user specifications. a prototypical environment, idea (intelligent design aid), is described that supports the knowledge-based paradigm. the schema-based techniques used in idea are presented along with some examples of their use.
what you always wanted to know about agile methods but did not dare to ask. a fleet of emerging agile methods is both gaining popularity and generating lots of controversy. real-world examples argue for (e.g. [4]) and against (e.g. [6]) agile methods. several leading software engineering experts suggest that synthesizing the two (agile with traditional) may provide developers with a comprehensive spectrum of methods (e.g. [1], [2], [5]). this high-level overview tutorial provides background to understand how agile teams are trying to solve modern software development issues.
agile methods: moving towards the mainstream of the software industry. a fleet of emerging agile methods of software development (with extreme programming and scrum being the most broadly used) is both gaining popularity and generating lots of controversy. this high-level tutorial gives an overview of agile methods and provides background to understand how agile teams are trying to address modern software development challenges. analysis of initial empirical evidence is used to discuss strengths and limitations of agile methods in various contexts. the participants are introduced to the innovation diffusion models and environments, and discuss what is needed for agile methods to cross the chasm and move into the mainstream of software development.
developing initial ooa models. the authors developed an initial object-oriented requirements model for an existing missile planning system. they adopted two approaches: a bottom-up approach in which object-oriented model fragments were constructed that corresponded to segments of the requirements documents, and a top-down approach that was driven by the construction and analysis of scenarios. the strengths and limitations of each approach were discussed in the context of the example. a bottom-up, fragment-driven approach is appropriate in cases where there is a large, rich body of documentation. a top-down, scenario-driven approach should dominate where there is no requirements specification, but some high-level, unintegrated information about how the system should operate
representation of factual information by equations and their evaluation. this paper describes a methodology for application software development, the objective being the reduction of volume of code and ease of maintenance. it is shown that constants as well as rules and regulations typically found in business applications should be factored out and stored separately from the application programs in a data base. definitional equations are proposed as a method for specifying such rules and regulations. the equations can be used as parameters to various types of interpreters to be used by application programs. as an illustration of the methodology, one such interpreter has been implemented. this paper shows its application to a screen handling program; other uses are discussed. the interpreter and its implementation are outlined.
assessing test-driven development at ibm. in a software development group of ibm retail store solutions, we built a non-trivial software system based on a stable standard specification using a disciplined, rigorous unit testing and build approach based on the test- driven development (tdd) practice. using this practice, we reduced our defect rate by about 50 percent compared to a similar system that was built using an ad-hoc unit testing approach. the project completed on time with minimal development productivity impact. additionally, the suite of automated unit test cases created via tdd is a reusable and extendable asset that will continue to improve quality over the lifetime of the software system. the test suite will be the basis for quality checks and will serve as a quality contract between all members of the team.
software engineering for large-scale multi-agent systems: selmas'2002. objects and agents are abstractions that exhibit points of similarity, but the development of agent-based software poses other challenges to software engineering since software agents are inherently more complex entities. in addition, a large-scale multi-agent system needs to satisfy multiple stringent requirements such as reliability, security, interoperability, scalability, reusability, and maintainability. this workshop brought together researchers and practitioners to discuss the current state and future direction of research in software engineering for large-scale multi-agent systems. a particular interest was to understand those issues in the agent technology that difficult and/or improve the production of large-scale distributed systems.
multilanguage interoperability in distributed systems. the q system provides interoperability support for multilingual, heterogeneous component-based software systems. initial development of q began in 1988, and was driven by the very pragmatic need for a communication mechanism between a client program written in ada and a server written in c. the initial design was driven by language features present in c, but not in ada, or vice-versa. in time our needs and aspirations grew and q evolved to support other languages, such as c++, lisp, prolog, java, and tcl. as a result of pervasive usage by the arcadia sde research project, usage levels and modes of the q system grew and so more emphasis was placed upon portability, reliability, and performance. in that context we identified specific ways in which programming language support systems can directly impede effective interoperability. this necessitated extensive changes to both our conceptual model and our implementation of the q system. we also discovered the need to support modes of interoperability far more complex than the usual client-server. the continued evolution of q has allowed the architecture of arcadia software to become highly distributed and component-based, exploiting components written in a variety of languages. in addition to becoming an arcadia project mainstay, and has also been made available to over 100 other sites, and it is currently in use in a variety of other projects. this paper summarizes key points that have been learned from this considerable base of experience.
the data transform programming metho: an example for file processing problems. this paper presents a new programming method, called the data transform programming method. in particular, we present a specialization of data transform programming to deal with file processing applications. direct comparison is made with jackson's approach1 by the presentation of uniform solutions to problems that cannot be solved through his basic method. the new method consists of the application of data transformations to the abstract problem statement, following the formal notions of problem reduction and problem decomposition. data transformations are expressed in programming terms through a basic set of data type constructors.
predicate-based test generation for computer programs. the author first describes a number of existing testing strategies for simple predicates and then explains why intuitive extensions of such strategies are ineffective or impractical for testing compound predicates, which are predicates with one or more and/or operators. two fault-based testing strategies for compound predicates are defined, bor (boolean operator) testing and bro (boolean and relational operator) testing. it is shown that for a predicate with n, n>0, and/or operators, at most n+2 (2*n+3) tests are needed to satisfy bor (bro) testing. preliminary experimental results indicate that bor and bro testing are effective for the detection of various types of faults in a predicate and provide more specific guidance than branch testing for test generation
behavioral analysis of software architectures using ltsa. the ltsa (labeled transition system analyzer) is a tool for modeling and analyzing the behavior of concurrent systems. the demonstration will focus on the use of architectural descriptions in developing behavioral models and on the analysis that can be performed on these models. three concurrent architecture examples; filter pipeline, supervisor-worker and announcer-listener which each use a different type of connector are used to illustrate the capabilities of the tool.
developing cost-effective model-based techniques for gui testing. most of today's software users interact with the software through a graphical user interface (gui). while guis have become ubiquitous, testing of guis has remained until recently, a neglected research area. existing gui testing techniques are extremely resource intensive primarily because guis have very large input spaces. this research proposes to advance the state-of-the-art in gui testing by empirically studying gui faults, interactions between gui events, why certain event interactions lead to faults, and use the results of these studies to develop cost-effective model-based gui testing techniques. the novel feature of this research will be a reduced model of the gui's event-interaction space. the model will be derived automatically from the gui; it will be used to automatically generate specialized gui test cases that are effective at detecting gui faults. the model will be extended to develop new test oracles, new coverage criteria for guis, and new regression testing techniques. moreover, this research will empirically evaluate the developed techniques.
system acquisition based on software product assessment. the procurement of complex software product involves many risks. to properly assess and manage those risks, bell canada has developed methods and tools that combine process capability assessment with a static analysis based software product assessment. this paper describes the software product assessment process that is part of our risk management approach. the process and the tools used to conduct a product assessment are described. the assessment is in part based on static source code metrics and inspections. a summary of the lessons learned since the initial implementation in 1993 is provided. over 20 products totalling more than 100 million lines of code have gone through this process.
comprehension processes during large scale maintenance. we present results of observing professional maintenance engineers working with industrial code at actual maintenance tasks. protocol analysis is used to explore how code understanding might differ for small versus large scale code. the experiment confirms that cognition processes work at all levels of abstraction simultaneously as programmers build a mental model of the code. cognition processes emerged at three levels of aggregation representing lower and higher level strategies of understanding. they show differences in what triggers them and how they achieve their goals. results are useful for defining core competencies which maintenance engineers need for their work and for documentation and development standards
requirements discovery during the testing of safety-critical software. this paper describes the role of requirements discovery during the testing of a safety-critical software system. analysis of problem reports generated by the integration and system testing of an embedded, safety-critical software system identified four common mechanisms for requirements discovery and resolution during testing: (1) incomplete requirements, resolved by changes to the software, (2) unexpected requirements interactions, resolved by changes to the operational procedures, (3) requirements confusion by the testers, resolved by changes to the documentation, and (4) requirements confusion by the testers, resolved by a determination that no change was needed. the experience reported here confirms that requirements discovery during testing is frequently due to communication difficulties and subtle interface issues. the results also suggest that "false positive" problem reports from testing (in which the software behaves correctly but unexpectedly) provide a rich source of requirements information that can be used to reduce operational anomalies in critical systems.
evaluation of mutation testing for object-oriented programs. the effectiveness of mutation testing depends heavily on the types of faults that the mutation operators are designed to represent. thus, the quality of the mutation operators is key to mutation testing. although, mutation operators for object-oriented languages have previously been presented, little research has been done to show the usefulness of the class mutation operators. to assess the usefulness of class mutation operators, we conducted two empirical studies. in the first study, we examine the number and kinds of mutants that are generated for object-oriented programs. in the second study, we investigate the way in which class mutation operators model faults that are not detected by traditional mutation testing. we conducted our studies using a well-known object-oriented system, bcel.
an adaptable generation approach to agenda management. as software engineering efforts move to more complex, distributed environments, coordinating the activities of people and tools becomes very important. while groupware systems address user level communication needs and distributed computing technologies address tool level communication needs, few attempts have been made to synthesize the common needs of both. this paper describes our attempt to do exactly that. we describe a framework for generating an agenda management system (ams) from a specification of the system's requirements. the framework can meet a variety of requirements and produces a customized ams appropriate for use by both humans and software tools. the framework and generated system support evolution in several ways, allowing existing systems to be extended as requirements change. we also describe our experiences using this approach to create an ams to support a process programming environment
mujava: a mutation system for java. mutation testing is a valuable experimental research technique that has been used in many studies. it has been experimentally compared with other test criteria, and also used to support experimental comparisons of other test criteria, by using mutants as a method to create faults. in effect, mutation is often used as a ``gold standard'' for experimental evaluations of test methods. although mutation testing is powerful, it is a complicated and computationally expensive testing method. therefore, automated tool support is indispensable for conducting mutation testing. this demo presents a publicly available mutation system for java that supports both method-level mutants and class-level mutants. mujava can be freely downloaded and installed with relative ease under both unix and windows. mujava is offered as a free service to the community and we hope that it will promote the use of mutation analysis for experimental research in software testing.
a model for program complexity analysis. a frequently stated objective of structured programming is to control program complexity. however, since the notion of complexity is not well under-stood and the existing techniques for measuring complexity are crude, it is difficult to determine if indeed structured programming can achieve this objective. the purpose of this paper is two-fold: to discuss the probable sources of complexity in a well-structured program to present a methodology for measuring and controlling complexity in a well-structured program.
experiences in assessing product family software architecture for evolution. software architecture assessments are a means to detect architectural problems before the bulk of development work is done. they facilitate planning of improvement activities early in the lifecycle and allow limiting the changes on any existing software. this is particularly beneficial when the architecture has been planned to (or already does) support a whole product family, or a set of products that share common requirements, architecture, components or code. as the family requirements evolve and new products are added, the need to assess the evolvability of the existing architecture is vital. i illustrate two assessment case studies i have recently worked on in the mobile telephone software domain: the symbian operating system platform and the network resource access control software system. the former assessment has been carried out as a task within the european project esaps, while the latter has been performed solely by nokia. by means of simple experimental data, i show evidence of the usefulness of architectural assessment as rated by the participating stakeholders. both assessments have led to the identification of previously unknown architectural defects, and to the consequent planning of improvement initiatives. in both cases, stakeholders noted that a number of side benefits, including improvement of communication and architectural documentation, were also of considerable importance. i illustrate the lessons we have learned, and outline suggestions for future research and experimentation.
sql dom: compile time checking of dynamic sql statements. most object oriented applications that involve persistent data interact with a relational database. the most common interaction mechanism is a call level interface (cli) such as odbc or jdbc. while there are many advantages to using a cli -- expressive power and performance being two of the most key -- there are also drawbacks. applications communicate through a cli by constructing strings that contain sql statements. these sql statements are only checked for correctness at runtime, tend to be fragile and are vulnerable to sql injection attacks. to solve these and other problems, we present the sql dom: a set of classes that are strongly-typed to a database schema. instead of string manipulation, these classes are used to generate sql statements. we show how to extract the sql dom automatically from an existing database schema, demonstrate its applicability to solve the mentioned problems, and evaluate its performance.
system dynamics modeling of an inspection-based process. a dynamic simulation model of an inspection-based software lifecycle process has been developed to support quantitative process evaluation. the model serves to examine the effects of inspection practices on cost, scheduling and quality throughout the lifecycle. it uses system dynamics to model the interrelated flows of tasks, errors and personnel throughout different development phases and is calibrated to industrial data. if extends previous software project dynamics research by examining an inspection-based process with an original model, integrating it with a knowledge-based method for risk assessment and cost estimation, and using an alternative modeling platform. while specific enough to investigate inspection practices, it is sufficiently general to incorporate changes for other phenomena. it demonstrates the effects of performing inspections or not, the effectiveness of varied inspection policies, and the effects of other managerial policies such as manpower allocation. the results of testing indicate a valid model that can be used for process evaluation and project planning, and can serve as a framework for incorporating other dynamic process factors.
the impact of pair programming on student performance, perception and persistence. this study examined the effectiveness of pair programming in four lecture sections of a large introductory programming course. we were particularly interested in assessing how the use of pair programming affects student performance and decisions to pursue computer science related majors. we found that students who used pair programming produced better programs, were more confident in their solutions, and enjoyed completing the assignments more than students who programmed alone. moreover, pairing students were significantly more likely than non-pairing students to complete the course, and consequently to pass it. among those who completed the course, pairers performed as well on the final exam as non-pairers, were significantly more likely to be registered as computer science related majors one year later, and to have taken subsequent programming courses. our findings suggest that not only does pairing not compromise students' learning, but that it may enhance the quality of their programs and encourage them to pursue computer science degrees.