waashk/dblp huggingface dataset:
prototyping in industrial software projects - bridging the gap between theory and practice. prototyping, a method and technique frequently used in many engineering disciplines, has been adopted as a technique in software engineering to improve the calculation of new projects involving risks. however, there has so far been a lack of documented experience with the use of prototyping in industrial software production. the paper tries to close this gap. first, we introduce central prototyping concepts and terminology. we also present five industrial software projects in which explicit use was made of prototyping. based on our analysis of these projects we present the resulting conclusions: prototyping means more than rapidly developing user interfaces; prototyping is a central part of a development strategy; prototyping means end user involvement; finding the right mixture of prototypes improves the development process.
is 'sometime' sometimes better than 'always'? intermittent assertions in proving program correctness. this paper explores a technique for proving the correctness and termination of programs simultaneously. this approach, which we call the intermittent-assertion method, involves documenting the program with assertions that must be true at some time when control passes through the corresponding point, but that need not be true every time. the method, introduced by burstall, promises to provide a valuable complement to the more conventional methods. we first introduce the intermittent-assertion method with a number of examples of correctness and termination proofs. some of these proofs are markedly simpler than their conventional counterparts. on the other hand, we show that a proof of correctness or termination by any of the conventional techniques can be rephrased directly as a proof using intermittent assertions. finally, we show how the intermittent assertion method can be applied to prove the validity of program transformations and the correctness of continuously operating programs. this is a revised and simplified version of a previous paper with the same title (aim-281, june 1976).
controlling the complexity of software design. our research has focused on identifying techniquesto develop software that is amenable to refactoring andchange. the law of demeter (lod) was one contributionin this effort. but it led to other problems. with thecurrent state of the art focused on aspect-oriented softwaredevelopment (aosd), it is useful to revisit thegeneral objectives of the lod and adapt it to the newideas. hence we introduce the law of demeter for concernsand discuss the important intersection of these approacheswith traversals. we explore the ramifications ofthe laws of demeter (lod and lodc) to achieve betterseparation of concerns through improved software processes.they are supported by language mechanisms thatare implemented using novel applications of automata theory.a revised version of this paper and the slides are availablefrom the demeter website:http://www.ccs.neu.edu/research/demeterin the directory papers/icse-04-keynote/
the prism model of changes. the author addresses the problem of managing changes to items of various types in a multitype software environment. prism, a model of changes, has been designed with the following features: (1) a separation of concern between changes to the described items and changes to the environmental facilities housing these items; (2) a facility, called the dependency structure, for describing various items and their interdependencies, and for identifying the items affected by a given change; (3) a facility, called the change structure, for classifying, recording and analyzing change related data, and for making qualitative judgments of the consequences of a change; (4) identification of the many distinct properties of a change; and (5) a built-in mechanism for providing feedback. the rationale for the design of the model of changes as well as that of the dependency structure and the change structure is given
building modular object-oriented systems with reusable collaborations (tutorial session). new approaches propose to deal with the tangling of logical units by extending the object-oriented language to support module (de)composition along more than one dimension of concern. the tutorial will briefly survey aspect-oriented programming (@@@@ectj tool), adaptive programming (the demeter tool), and hyper-dimensional separation of concerns (the hyper/j tool). the primary focus of the tutorial, however, will be on a daptive plug-and-play components (ap&pc) [2, 1].the ap&pc model enables the programmer to define reusable collaborations, in the sense of the unified modeling language (uml), in separate modules. in the ap&pc approach, an application is built out of a set of base classes that lay down the static structure of the application and several modules of reusable collaborations that are non-intrusively adapted to the needs of the base classes by means of explicit connectors, or adapter constructs. each module itself may be a composition of simpler collabortion modules. the adaptation includes the embedding of uml class diagrams into more elaborate uml class diagrams. we will show how such embeddings may be conveniently expressed using the traversal language of adaptive programming (which is also used in the xml traversal language called xpath.) we will discuss how the model supports the building of better modular object-oriented systems. in addition, the advantages and disadvantages of static versus dynamic adaptation of the reusable collaborations will be considered.in summary, the tutorial presents ap&pc and adapters as useful constructs to encapsulate logical units of design that cut across several classes. we compare ap&pc with other approaches to the tangling problem in software design and implementation.
the synthesis of structure changing programs. deductive techniques are presented for deriving programs systematically from given specifications. the specifications express the purpose of the desired program without giving any hint of the algorithm to be employed. the desired program is intended to achieve this purpose by means of such low-level primitives as assignment statements, the conditional statements, and recursion. the basic approach is to transform the specifications repeatedly according to certain rules, until a satisfactory program is produced. the rules are guided by a number of strategic controls. many of the transformation rules represent knowledge about the program's subject domain (e.g., numbers, lists, sets); some represent the meaning of the constructs of the specification language and the target programming language; and a few rules represent basic programming principles. the weakest-precondition operator and the concept of protection are employed to construct programs that must achieve more than one condition simultaneously. our previous work has centered on the synthesis of structure-maintaining programs, which produce an output without altering the value of any variable or changing the configuration of any data structure. here, we extend our previous techniques to permit the construction of structure-changing programs, which can reset the values of variables, change the contents of an array, and alter the structure of a list or other data object.
demeter: a case study of software growth through parameterized classes. demeter&trade; is a system designed for the development of large software projects using a new software design methodology which focuses on growing rather than building software. we describe the software development process as one of growth and evolution as opposed to building and rebuilding because most complex objects in the real world are grown and not built. since software design is obviously a complex process this new paradigm may be helpful in unraveling some of the problems associated with current software design practices. demeter begins by providing an ideal environment for the sprouting and nurturing of a seed (data dictionary) into a plant (large scale software project). in addition, through the combined use of object-oriented programming technology, and parameterized classes, demeter provides a facility for the reuse of software which was developed in previous software projects.
modeling of data-processing software for generating and reusing their programs. we propose a new modeling scheme named s-model (which is the abbreviation of &ldquo;semantic model&rdquo;) based on a uniform object-relationship formalism. s-model is the mixture of notations in logic, set theory, and abstract syntax and covers wide range of information of file-processing and data-structure manipulating software. by procedural algorithms and problem-solving capability of s-model system, we can generate and reuse programs in various fields.
configuration management with logical structures. when designing software, programmers usually think in terms of modules that are represented as functions and classes, but using existing configuration management systems, programmers have to deal with versions and configurations that are organized by files and directories. this is inconvenient and error-prone, since there is a gap between handling source code and managing configurations. we present a framework for programming environments that handles versions and configurations directly in terms of the functions and classes in source code. we show that with this framework, configuration management issues in software reuse and cooperative programming become easier. we also present a prototype environment that has been developed to verify our ideas.
early experiences with a multi-display programming environment. we summarize the features of mdps, an advanced programming environment with multiple crt displays, and describe our early experiences with mdps.
integrating static analysis and general-purpose theorem proving for termination analysis. we present emerging results from our work on termination analysis of software systems. we have designed a static analysis algorithm which attains increased precision and flexibility by issuing queries to a theorem prover. we have implemented our algorithm and initial results show that we obtain a significant improvement over the current state-of-the-art in termination analyses. we also outline how our approach, by integrating theorem proving queries into static analyses, can significantly impact the design of general-purpose static analyses.
control structure aptness: a cast study using top-down parsing. the range of control structures available in a higher-level programming language directly governs the set of algorithms conveniently programmable therein. this fact has been well-demonstrated by the salutary effect the ideas of structured programming have had on traditional control structures (sequential, iterative, and procedural). this paper seeks to demonstrate this same fact for more advanced control structures through the use of top-down parsing as a case study. a series of increasingly more satisfactory top-down parsers are presented, using (i) iterative, (ii) recursive, (iii) coroutine, and (iv) nondeterministic control forms. a fifth solution, using a new control form termed &ldquo;non-forgetful backtracking&rdquo;, is sketched. this study indicates that the development of new control forms, as well as more thorough understanding and application of existing ones, are worthy pursuits for software engineering. a few directions for continuing work in this spirit are offered in the concluding section.
developing new approaches for software design quality improvement based on subjective evaluations. this research abstract presents two approaches forutilizing the developersý subjective design qualityevaluations during the software lifecycle. in process-basedapproach developers study and improve theirsystemýs structure at fixed intervals. tool-based approachuses subjective evaluations as input to tool analysis.these approaches or their combination are expected toimprove software design and promote organizationallearning about software design.
designing data entry programs using state diagram as a common model. a minicomputer based data entry system recently developed at bell laboratories supports 73 transaction types and approximately 1000 fields. the user communicates with the system from a crt terminal in field-by-field mode via a uniform interface. this paper presents a common design for the family of data entry programs that process the various types of transactions. the design is represented by a compact, orderly, and verifiable model to demonstrate the consistent program behavior. the model is formalized and proved correct to validate the design. the common model reduces design effort, provides design generality, enables code generation, and enhances ease of maintenance. the correctness proof eliminates high level design errors and their consequences. in the general area of business application, a common design lends itself to quickly mass produce components of a software product, and makes it easy to maintain them later.
tools for understanding the behavior of telecommunication systems. many methods and tools for the reengineering of software systems have been developed so far. however, the domain-specific requirements of telecommunication systems have not been addressed sufficiently. these system are designed in a process- rather than in a data-centered way. furthermore, analyzing and visualizing dynamic behavior is a key to system understanding. in this paper, we report on tools for the reengineering of telecommunication systems which we have developed in close cooperation with an industrial partner. these tools are based on a variety of techniques for understanding behavior such as visualization of link chains, recovery of state diagrams from the source code, and visualization of traces by different kinds of diagrams. tool support has been developed step by step in response to the requirements and questions stated by telecommunication experts at ericsson eurolab germany.
a software methodology for buidling interactive tools. the methodology proposed is intended to aid in the development of cooperative interactive tools (i.e., those which are natural, helpful, and consistent). cooperative tools must incorporate knowledge of their own capabilities, limitations, and requirements. this required knowledge of tool functionality is provided by programming the tool in the process script formalism. the process script formalism is a specialized procedural/declarative language for writing tools. the key aspect of the process script specification of a tool is that, besides being executable, process scripts can be analyzed and understood for the purpose of cooperative interaction with the end user. this paper describes the process script formalism and explains its role in the development of a cooperative interactive system.
augmenting sadt to develop computer support for cooperative work. using the language-action perspective proposed by t. winograd and f. flores (1986), the author creates a general framework for both systems analysis and its practice. structured analysis and design technique (sadt), a systems analysis methodology, is augmented using this framework. this work took place on the contract (commitment negotiation and tracking tool) project. the author includes the experiences of both users and systems analysts during the project, and emphasizes how to develop sadt descriptions with users to represent the richness and complexity of social interactions at work. the resulting software specification is also presented, including how it aided the work of the people who actually helped develop it
an experimental, pluggable infrastructure for modular configuration management policy composition. building a configuration management (cm) system isa difficult endeavor that regularly requires tens of thousandsof lines of code to be written. to reduce this effort,several experimental infrastructures have been developedthat provide reusable repositories upon which to build acm system. in this paper, we push the idea of reusabilityeven further. whereas existing infrastructures only reusea generic cm model (i.e., the data structures used to capturethe evolution of artifacts), we have developed a novelexperimental infrastructure, called mccm, that additionallyallows reuse of cm policies (i.e., the rules bywhich a user evolves artifacts stored in a cm system).the key contribution underlying mccm is that a cmpolicy is not a monolithic entity; instead, it can be composedfrom small modules that each address a uniquedimension of concern. using the pluggable architectureand base set of modules of mccm, then, the core of adesired new cm system can be rapidly composed bychoosing appropriate existing modules and implementingany remaining modules only as needed. we demonstrateour approach by showing how the use of mccm significantlyreduces the effort involved in creating several representativecm systems.
static and dynamic data modeling for information system design. this paper illustrates an approach to designing software information systems. we have found this strategy to be sufficiently systematic and practically useful enough to merit exposition for a wider audience. the most novel aspect of our approach is how we analyze the problem in successive steps to produce a logical design. briefly, the steps are: (1) identify the (classes of) things in the problem's context and the invariant relationships between them. (2) for each (class of) thing that is of central importance to the problem describe the main stages and transitions in the thing's &ldquo;life&rdquo; with respect to the problem, (3) synthesize the logical data base structure with attributes determined for all record types using results from the previous two steps. these three steps are the way we model static and dynamic aspects of data as a prerequisite to designing information systems.
a software engineering approach and tool set for developing internet applications. if a business built a plant to produce products without first designing a process to manufacture them, the risk would be lack of capacity without significant plant redesign. similarly, lacking a software engineering approach and tools for designing e-business connections before creating them, can risk: 1) designing the business partnership incorrectly, 2) not implementing the connection quickly enough, or 3) having operations that cannot adapt to changes in business direction. this paper presents a software engineering tool for developing process-oriented internet applications that implement e-business connections. it gives an approach for using this tool in conjunction with standard commercial idefo tools to create adaptable connections. it is organized to match a formal demonstration that shows the step-by-step usage of these tools, and cites software engineering principles that, when applied, ensure adaptability.
cleanroom software engineering for zero-defect software. cleanroom software engineering is a theory-based, team-oriented process for developing very high quality software under statistical control. cleanroom combines formal methods of object-based box structure specification and design, function-theoretic correctness verification, and statistical usage testing for quality certification to produce software that has zero defects with high probability. the process of cleanroom development and certification is carried out incrementally. interface and design errors are rare because at each stage the harmonious operation of future increments at the next level of refinement is predefined by increments already in execution. the cleanroom process is being successfully applied in ibm and other applications. quality results from several cleanroom projects are summarized
recovering documentation-to-source-code traceability links using latent semantic indexing. an information retrieval technique, latent semantic indexing, is used to automatically identify traceability links from system documentation to program source code. the results of two experiments to identify links in existing software systems (i.e., the leda library, and albergate) are presented. these results are compared with other similar type experimental results of traceability link identification using different types of information retrieval techniques. the method presented proves to give good results by comparison and additionally it is a low cost, highly flexible method to apply with regards to preprocessing and/or parsing of the source code and documentation.
a study on exception detecton and handling using aspect-oriented programming. aspect-oriented programming (aop) is intended to ease situations that involve many kinds of code tangling. this paper reports on a study to investigate aop's ability to ease tangling related to exception detection and handling. we took an existing framework written in java&trade;, the jwam framework, and partially reengineered its exception detection and handling aspects using aspectj&trade;, an aspect-oriented programming extension to java.we found that aspectj supported implementations that drastically reduced the portion of the code related to exception detection and handling. in one scenario, we were able to reduce that code by a factor of 4. we also found that, with respect to the original implementation in plain java, aspectj provided better support for different configurations of exceptional behaviors, more tolerance for changes in the specifications of exceptional behaviors, better support for incremental development, better reuse, automatic enforcement of contracts in applications that use the framework, and cleaner program texts. we also found some weaknesses of aspectj that should be addressed in the future.
toward new techniques to assess the software implementation process. the author presents the concept of software boundaries and their automated detection. he describes an objective, high-level assessment technology to support process control of software development. the technique is largely independent of underlying design and development methods. an example illustrates an automated system partitioning application. the technique analyzes the end product and the delivered software code. by suitable adjustment of the analysis goals, measures, and criteria, the technique can help evaluate the effectiveness of many software implementation methods. the author discusses the technique's potential for increasing confidence in the fault-tolerating properties of a system
reducing and estimating the cost of test coverage criteria. test coverage criteria define a set of entities of a program flowgraph and require that every entity is covered by some test. we first identify e/sub c/, the set of entities to be covered according to a criterion c, for a family of widely used test coverage criteria. we then present a method to derive a minimum set of entities, called a spanning set, such that a set of test paths covering the entities in this set covers every entity in e/sub c/. we provide a generalised algorithm, which is parametrized by the coverage criterion. we suggest several useful applications of spanning sets of entities to testing. in particular they help to reduce and to estimate the number of tests needed to satisfy test coverage criteria.
dependability assessment of software-based systems: state of the art. my talk will present a personal and rather selective view of the state of the art of some aspects of dependability assessment for software-based systems. this short note gives a brief outline of the issues i shall address.