waashk/dblp huggingface dataset:
the preliminary design as a key to successful software development. a successful software development effort is predicated upon the establishment of a complete preliminary design. a well disciplined methodology is required to ensure the satisfaction of the following key principles: 1) clear definition of data processing requirements 2) top-down design definition 3) design traceability 4) design verification a well integrated approach which considers these key elements ensures continuity between data processing subsystems engineering and detail design. it also provides clear visibility to management and reduces the risk in software development. trw has developed a preliminary design methodology which has successfully been applied to large scale software development. the methodology is a disciplined integration of design activities from initial system definition to successful completion of software preliminary design review. this paper will discuss the benefits from complete preliminary design and some of the specific design techniques employed.
gridunit: software testing on the grid. software testing is a fundamental part of system development. as software grows, its test suite becomes larger and its execution time may become a problem to software developers. this is especially the case for agile methodologies, which preach a short develop/test cycle. moreover, due to the increasing complexity of systems, there is the need to test software in a variety of environments. in this paper, we introduce gridunit, an extension of the widely adopted junit testing framework, able to automatically distribute the execution of software tests on a computational grid with minimum user intervention. experiments conducted with this solution have showed a speed-up of almost 70x, reducing the duration of the test phase of a synthetic application from 24 hours to less than 30 minutes. the solution does not require any source-code modification, hides the grid complexity from the user and provides a cost-effectiveness improvement to the software testing experience.
the role of a project-based capstone course. a project-based capstone course aims at using software development skills while performing a project in the course domain. one of our main challenges is to simulate a real world environment so to provide our students with the experience they need. planning this experience we should consider academic constraints as well as the students' schedule and skills. in this paper we describe how we implement an agile software development method in a project-based capstone course in the domain of operating systems. we elaborate on how we simulate a real world environment and present a role scheme that is used by the students to manage the process. we suggest a discussion on how to use the role scheme as an assessment tool to measure the development process in general and students' contribution in particular. we expect to extend and refine the comprehension regarding process measurement in students' teams at the academia.
a framework for modelling and analysis of software systems scalability. scalability is a widely-used term in scientific papers, technical magazines and software descriptions. its use in the most varied contexts contribute to a general confusion about what the term really means. this lack of consensus is a potential source of problems, as assumptions are made in the face of a scalability claim. a clearer and widely-accepted understanding of scalability is required to restore the usefulness of the term. this research investigates commonly found definitions of scalability and attempts to capture its essence in a systematic framework. its expected contribution is in assisting software developers to reason, characterize, communicate and adjust the scalability of software systems.
models and processes for the evaluation of cots components. this workshop summary presents an overview of theone-day international workshop on models and processesfor the evaluation of cots components (mpecý04), heldin conjunction with the 26th international conference onsoftware engineering (icseý04). details about mpecý04may be found at http://www.lsi.upc.es/events/mpec/.
coca: an automated debugger for c. presents coca, an automated debugger for c, where the breakpoint mechanism is based on events related to language constructs. events have semantics, whereas the source lines used by most debuggers do not have any. a trace is a sequence of events. it can be seen as an ordered relation in a database. users can specify precisely which events they want to see by specifying values for event attributes. at each event, visible variables can be queried. the trace query language is prolog with a handful of primitives. the trace query mechanism searches through the execution traces using both control flow and data, whereas debuggers usually search according to either control flow or data. as opposed to fully "relational" debuggers which use plain database querying mechanisms, the coca trace querying mechanism does not require any storage. the analysis is done on-the-fly, synchronously with the traced execution. coca is therefore more powerful than "source-line" debuggers and more efficient than relational debuggers.
a review of automated debugging systems: knowledge, strategies, and techniques. our review is based on descriptions of 18 existing automated systems on program debugging and of a dozen cognitive studies on debugging. we propose a classification of debugging knowledge, and a description of the corresponding knowledge representation in the systems. then we propose a classification of global debugging strategies used in the systems, and a description of the corresponding techniques. we assess the identified strategies from a real world program development point of view. the knowledge types we have identified are 1) knowledge of the intended program, 2) knowledge of the actual program, 3) understanding of the programming language, 4) general programming expertise, 5) knowledge of the application domain, 6) knowledge of bugs, 7) knowledge on debugging methods. the strategies we have identified are 1) filtering, 2) checking computational equivalence of intended program and actual one, 3) checking the well-formedness of actual program and 4) recognizing stereotyped errors.
a demand-driven analyzer for data flow testing at the integration level. data-flow testing relies on static analysis for computing the definition-use pairs that serve as the test case requirements for a program. when testing large programs, the individual procedures are first tested in isolation during unit testing. integration testing is performed to specifically test the procedure interfaces. the procedures in a program are integrated and tested in several steps. since each integration step requires data-flow analysis to determine the new test requirements, the accumulated cost of repeatedly analyzing a program can contribute considerably to the overhead of testing. data-flow analysis is typically computed using an exhaustive approach or by using incremental data-flow updates. this paper presents a new and more efficient approach to data-flow integration testing that is based on demand-driven analysis. we developed and implemented a demand-driven analyzer and experimentally compared its performance during integration testing with the performance of (i) a traditional exhaustive analyzer, and (ii) an incremental analyzer. our experiments show that demand-driven analysis is faster than exhaustive analysis by up to a factor of 25. the demand-driven analyzer also outperforms the incremental analyzer in 80% of the test programs by up to a factor of 5.
software development productivity tools and metrics. the continuing emphasis on improving productivity in the building of software has resulted in clearer definitions of software quality and software engineer productivity, and a greater interest by management and software engineer alike in the tools and measurements that aid in knowing a project is &ldquo;in control&rdquo;. this paper describes the software development process used within one software engineering group at digital equipment corporation, and the methods and tools used within the group to support the development of software products. experience in the application of software metrics to parts of the process as a means of quantifying productivity and quality is described.
using attributed grammars to test designs and implementations. we present a method for generating test cases that can be used throughout the entire life cycle of a program. this method uses attributed translation grammars to generate both inputs and outputs, which can then be used either as is, in order to test the specifications, or in conjunction with automatic test drivers to test an implementation against the specifications. the grammar can generate test cases either randomly or systematically. the attributes are used to guide the generation process, thereby avoiding the generation of many superfluous test cases. the grammar itself not only drives the generation of test cases but also serves as a concise documentation of the test plan. in the paper, we describe the test case generator, show how it works in typical examples, compare it with related techniques, and discuss how it can be used in conjunction with various testing heuristics.
communication system design using ada. this paper describes an experiment in ada design and some of the lessons learned from it. the experiment itself involved redesigning and reimplementing portions of an existing communication system. the paper compares the project team's design, based on traditional top-down structured design methods, with an alternative design based on information hiding. the project was intended to monitor how a typical industrial software team might adapt to using ada on realistic embedded application projects. just as important, however, were the insights gained on how to use ada in system design. although the team used virtually every novel feature of ada, they produced a design remarkably similar to that produced by the original implementors of the system, who used fortran and assembler. thus, the major problem in using ada appears to be one of education. it is not enough merely to teach the ada language itself. instead, one must stress the methodology&mdash;information hiding&mdash;that ada supports.
software reuse in an industrial setting: a case study. a summary of an ongoing case study of software reuse being carried out by the authors in cooperation with sperry marine incorporated is presented. the goals of the study are to analyze the problems that limit reuse and to seek solutions suitable for industrial application. to help determine its suitability for use within sperry marine, an experimental evaluation of object-oriented development was performed that focused on a specific subsystem domain found in several of sperry marine's commercial software products. a reuse library populated with classes written in c++ was prepared, and from this library simple versions of two representative subsystems were built. measurement of the resulting software showed a very high level of reuse
automating the detection of reusable parts in existing software. presents a model based on an expert-system approach for the scavenging of reusable components from existing software systems. the authors also describe a toolset called code miner that implements part of the model. the toolset uses prolog as its inference engine. code miner is designed to assist the programmer in finding reusable components in existing software written in c. to investigate the feasibility of the approach, an empirical study was conducted of the effectiveness of the toolset. in the study, public-domain software was scanned by the toolset for reusable parts and its output was examined by a team of human experts. the results of this experiment are outlined
object-oriented inspection in the face of delocalisation. software inspection is now widely accepted as an effective technique for defect detection. this acceptance is largely based on studies using procedural program code. this paper presents empirical evidence that raises significant questions about the application of inspection to object-oriented code.a detailed analysis of the 'hard to find' defects during an inspection experiment shows that many of them can be characterised as 'delocalised' &mdash; the information needed to recognise the defect is distributed throughout the software. the paper shows that key features of object-oriented technology are likely to exaggerate delocalisation.as a result, it is argued that new methods of inspection for object-oriented code are required. these must address: partitioning code for inspection (&ldquo;what to read&rdquo;), reading strategies (&ldquo;how to read&rdquo;), and support for understanding what isn't read &mdash; &ldquo;localising the delocalisation&rdquo;.
further investigations into the development and evaluation of reading techniques for object-oriented code inspection. this paper describes the development and experimental evaluation of a rigorous approach for effective object-oriented (oo) code inspection. since their development, inspections have been shown to be powerful defect detection strategies but little research has been done to investigate their application to oo systems, which have very different structural and execution models compared to procedural systems. previous investigations have demonstrated that the delocalised nature of oo software - the resolution of frequent non-local references, and the incongruous relationship between its static and dynamic representations, are primary inhibitors to its effective inspection. the experiment investigates a set of three complementary code reading techniques devised specifically to address these problems: one based on a checklist adapted to address the identified problems of oo inspections, one focused on the systematic construction of abstract specifications, and the last centered on the dynamic slice that a use-case takes through a system. the analysis shows that there is a significant difference in the number of defects found between the three reading techniques. the checklist-based technique emerges as the most effective approach but the other techniques also have noticeable strengths and so for the best results in a practical situation a combination of techniques is recommended.
a report on random testing. random testing of programs is usually (but not always) viewed as a worst case of program testing. test case generation that takes into account the program structure is usually preferred. path testing is an often proposed ideal for structural testing. path testing is treated here as an instance of partition testing. (partition testing is any testing scheme which forces execution of at least one test case from each subset of a partition of the input domain.) simulation results are presented which treat path and partition testing in a reasonably favorable way, and yet still suggest that random testing may often be more cost effective. results of actual random testing experiments are presented which tend to confirm the viability of random testing as a useful validation tool.
specification and verification of an object request broker. this paper reports the results of specifying, modeling and verifying a safe object request broker. this method has been applied on several case studies by using the spin verification tool. an object request broker has been implemented using sc++, a concurrent extension of c++ designed by our team. liveness and safety properties have been checked on the model to ensure the system behaviour is correct. this application shows the efficiency of using formal methods in building safe applications. it also shows that sc++ is appropriate for developing protocols and communicating systems and is easily translatable from models such as promela
patterns in property specifications for finite-state verification. model checkers and other finite-state verification tools allow developers to detect certain kinds of errors automatically. nevertheless, the transition of this technology from research to practice has been slow. while there are a number of potential causes for reluctance in adopting such formal methods, we believe that a primary cause is that practitioners are unfamiliar with specification processes, notations, and strategies. in a recent paper, we proposed a pattern-based approach to the presentation, codification and reuse of property specifications for finite-state verification. since then, we have carried out a survey of available specifications, collecting over 500 examples of property specifications. we found that most are instances of our proposed patterns. furthermore, we have updated our pattern system to accommodate new patterns and variations of existing patterns encountered in this survey. this paper reports the results of the survey and the current status of our pattern system.
a flexible architecture for building data flow analyzers. data flow analysis is a versatile technique that can be used to address a variety of analysis problems. typically, data flow analyzers are hand-crafted to solve a particular analysis problem. the cost of constructing analyzers can be high and is a barrier to evaluating alternative analyzer designs. we describe an architecture that facilitates the rapid prototyping of data flow analyzers. with this architecture, a developer chooses from a collection of pre-existing components or, using high-level component generators, constructs new components and combines them to produce a data flow analyzer. in addition to support for traditional data flow analysis problems, this architecture supports the development of analyzers for a class of combined data flow problems that offer increased precision. this architecture allows developers to investigate quickly and easily a wide variety of analyzer design alternatives and to understand the practical design tradeoffs better. we describe our experience using this architecture to construct a variety of different data flow analyzers.
a compact petri net representation for concurrent programs. array(0x8441c50) summary information that is necessary for performing program analysis. we present a flexible framework for checking a variety of properties of concurrent programs using the reachability graph generated from a tpn. we present experimental results that demonstrate the benefit of tpns over alternate petri net representations and discuss the applicability of petri net reduction techniques to tpns.
user perceived quality of interactive systems. user-perceived quality of interactive systems is defined in terms of statistically nonoverlapping categories, so-called dimensions or factors categories are identified by factor analysis and represent a dimensional concept of the quality of interactive systems as perceived by its users. each category describes essential user requirements.
a framework for multi-valued reasoning over inconsistent viewpoints. in requirements elicitation, different stakeholders often hold different views of how a proposed system should behave, resulting in inconsistencies between their descriptions. consensus may not be needed for every detail, but it can be hard to determine whether a particular disagreement affects the critical properties of the system. in this paper, we describe the xbel framework for merging and reasoning about multiple, inconsistent state machine models. xbel permits the analyst to choose how to combine information from the multiple viewpoints, where each viewpoint is described using an underlying multi-valued logic. the different values of our logics typically represent different levels of agreement. our multi-valued model checker, xchek, allows us to check the merged model against properties expressed in a temporal logic. the resulting framework can be used as an exploration tool to support requirements negotiation, by determining what properties are preserved for various combinations of inconsistent viewpoints.
2nd international workshop on living with inconsistency. in software engineering, there has long been a recognition that inconsistency is a fact of life. evolving descriptions of software artefacts are frequently inconsistent, and tolerating this inconsistency is important if flexible collaborative working is to be supported. this workshop will focus on reasoning in the presence of inconsistency, for a wide range of software engineering activities, such as building and exploring requirements models, validating specifications, verifying correctness of implementations, monitoring runtime behaviour, and analyzing development processes. a particular interest is on how existing automated approaches such as model checking, theorem proving, logic programming, and model-based reasoning can still be applied in the presence of inconsistency.
requirements uncertainty: influencing factors and concrete improvements. practically all industry studies on software project results conclude that good requirements engineering plays a pivotal role for successful projects. a key reason for project failures is insufficient management of changing requirements during all stages of the project life cycle. this article investigates one of the root causes for changing requirements, namely requirements uncertainty. in an experimental field study we looked into four underlying drivers for requirements uncertainty. we found several techniques must be used simultaneously to see tangible success. using only one such technique in isolation doesn't make a difference. the field study is supported by extensive data from well over 200 projects stemming from very different business areas of alcatel over a period of two years. results are presented with practical experiences to allow effective transfer.
improving validation activities in a global software development. global software development challenges traditional techniques of software engineering, such as peer reviews or teamwork. effective teamwork and coaching of engineers highly contribute towards successful projects. we will evaluate within this case study experiences with validation activities in a global setting within alcatel's switching and routing business. we will investigate three hypotheses related to effects of collocated inspections, intensive coaching, and feature-oriented development teams on globally distributed projects. as all these activities mean initial investment compared to a standard process with scattered activities, the major validation criteria for the 3 hypotheses is cost reduction due to earlier defect detection and less defects introduced. the data is taken from a sample of over 60 international projects of various sizes from which we collected all type of product and process metrics in the past 4 years.
tricks and traps of initiating a product line concept in existing product. many industries are hampered with introducing the product line concept into already existing products. though appealing, the concept is very difficult to introduce specifically into a legacy environment. all too often the impacts and risks are not considered adequately. this article describes the introduction of a product line approach in alcatel's s12 voice switching system business unit. practical impacts during the introduction are described as well as tricks and traps. the article not only summarizes the key software engineering principles, but also provides empirical evidence and practical techniques on which to build.
architecture, design, implementation. the terms architecture, design, and implementation are typically used informally in partitioning software specifications into three coarse strata of abstraction. yet these strata are not well-defined in either research or practice, causing miscommunication and needless debate.to remedy this problem we formalize the intension and the locality criteria, which imply that the distinction between architecture, design, and implementation is qualitative and not merely quantitative. we demonstrate that architectural styles are intensional and non-local; that design patterns are intensional and local; and that implementations are extensional and local.