waashk/dblp huggingface dataset:
configuration control for evolutional software products. this paper describes the concept of and a system for configuration control for evolutional software products, in which a wide spectrum of varied software products are being continuously evolved, along with rapid advancements in hardware technologies. the system contains a database for dealing with the overall configuration structure, including hierarchical product structure with change status, master file directories, difficulty occurrences and user information. the data representing the configuration can be in more abstract or macroscopic level than the traditional software configuration control, since the configuration manager should control the overall outlines for all software products. the concept and system described in the paper have been used for intelligent terminal software product management in nec's data terminals division.
a systematic approach to domain-oriented software development. we describe our experience with domain-oriented software development in the domain of automatic teller machine applications. we systematically proceeded with development in four phases: domain analysis, domain formalization, domain facility building, and product development. in this development, we built domain facilities consisting of a domain framework and domain case (computer aided software engineering) tools, then employed them for application development. the framework shared about 4% of the application, and the remaining 96% was generated by the case tools automatically. our approach was found to realize effective reuse of design and implementation and to enable domain-oriented development in large domains
automatic tuning of multi-task programs for real-time embedded systems. this paper describes a programming tool for real-time embedded systems. real-time embedded systems are usually implemented by multiple tasks. it is important to allocate tasks to the system appropriately. our tool, called true, performs the allocation of tasks by transformation of the program the user has written. true reads the program and the requirements about its response time. true transforms the program applying rules based on the requirements. then the program is translated into a code for operating system i-tron. i-tron is our original real-time operating system for 32-bit microprocessors. this paper also describes the implementation of true and an example of its use.
a new design language for communication protocols and a systematic design method of communication systems. a systematic design method of a communication system is given, by which the design, validation, implementation and maintenance of the system can be developed under the consistent philosophy. next, the dai-expression method for describing communication protocols is proposed to support the above design method. here, the dai-expression consists of three types of expressions, namely, the d-expression, a-expression and i-expression depending upon the purposes such as design, validation and implementation. and the new design language copdel is given as the d-expression which is a logical design-oriented expression. finally, the validation algorithm expa is given, which is a generalization of the perturbation analysis given by c.h.west. furthermore, the expa can validate communication protocols described by the copdel.
structural models for software reliability prediction. many previous software reliability prediction models by this author and others have concentrated on the bulk (macro) aspects of the program. this paper describes a newly developed micro model which is based on program structure. it is assumed that the program has been written in structured or modular form so that decomposition in to its constituent parts is simple. further, we assume that via analysis of the program the decomposition can be related to several paths or other functional structures within the program. the model is constructed based upon the frequencies with which each of the j paths are run, (fj), the running time of each path, (tj), and the probability of error along each path, (qj). several methods of calculating or measuring the fj, tj, and qj parameters are suggested. in fact it is possible to use one technique (historical data) to produce crude estimates at the start of the design, and refine the estimates with more accurate values as the design progresses. the paper concludes with the application of the model to a particular example: calculation of the roots of a quadratic equation, and a discussion of proposed experiments for validating the model.
improving software inspections by using reading techniques. reading techniques are step-by-step procedures that guide individual inspectors while they uncover defects in a software artifact. reading techniques provide a systematic and well-defined way of inspecting a document, allowing feedback and improvement. this tutorial introduces perspective-based reading (pbr), a specific reading technique used to review software requirements. pbr verifies the quality of requirements specifications by requiring each reviewer to take the perspective of a specific stakeholder of the document (such as designer, tester, and user). this tutorial aims at industry practitioners, managers and developers alike, who want to learn more about ways to improve their software inspections with systematic reading techniques. attending this tutorial will enable the participants to be more effective and more focused in looking for potential defects in software documents. since the focus of the tutorial is on systematic reading techniques for defect detection, it is beneficial for participants to have some basic understanding about software inspections.
requirements, domain and specifications: a viewpoint-based approach to requirements engineering. viewpoint-based requirements engineering (vbre) is based on the fact that there is a multiplicity of stakeholders that take part in any requirements process. this will inevitably lead to conflicts and inconsistencies that, if adequately managed, can be used to improve the process, as they are sources of requirements. there comes a time in every vbre process when different viewpoints need to be compared to fin discrepancies (conflicts, inconsistencies). but in requirements engineering (re) we also deal with other categories of statements, apart from "requirements", like domain descriptions and interface specifications. we could use this categorization to (i) internally classify the contents of each viewpoint by categories; (ii) compare the contents of one viewpoint against another, taking into account that this comparison should only be made between elements of the same category; (iii) classify the discrepancies by the affected categories and (iv) generate resolutions for the discrepancies according to this classification. in this paper, we present a vbre method based on this approach, which is not constrained to a particular representation formalism. the proposed framework includes discrepancy detection and classification and solution generation.
using benchmarking to advance research: a challenge to software engineering. benchmarks have been used in computer science to compare the performance of computer systems, information retrieval algorithms, databases, and many other technologies. the creation and widespread use of a benchmark within a research area is frequently accompanied by rapid technical progress and community building. these observations have led us to formulate a theory of benchmarking within scientific disciplines. based on this theory, we challenge software engineering research to become more scientific and cohesive by working as a community to define benchmarks. in support of this challenge, we present a case study of the reverse engineering community, where we have successfully used benchmarks to advance the state of research.
the ramp-up problem in software projects: a case study of how software immigrants naturalize. joining a software development team is like moving to a new country to start employment; the immigrant has a lot to learn about the job, the local customs, and sometimes a new language. in an exploratory case study, we interviewed four software immigrants, in order to characterize their naturalization process. seven patterns in four major categories were found. in this paper, these patterns are substantiated, and their implications discussed. the lessons learned from this study can be applied equally to improving the naturalization process, and to the formulation of further research questions
on the supervision and assessment of part-time postgraduate software engineering projects. this paper describes existing practices in the supervision and assessment of projects undertaken by part-time, post-graduate students in software engineering. it considers this aspect of the learning experience, and the educational issues raised, in the context of existing literature---much of which is focussed upon the experience of full-time, undergraduate students. the importance of these issues will increase with the popularity of part-time study at a postgraduate level; the paper presents a set of guidelines for project supervision and assessment.
using an information retrieval system to retrieve source code samples. software developers often face steep learning curves in using a new framework, library, or new versions of frameworks for developing their piece of software. in large organizations, developers learn and explore use of frameworks, rarely realizing, several peers may have already explored the same. a tool that helps locate samples of code, demonstrating use of frameworks or libraries would provide benefits of reuse, improved code quality and faster development. this paper describes an approach for locating common samples of source code from a repository by providing extensions to an information retrieval system. the approach improves the existing approaches in two ways. first, it provides the scalability of an information retrieval system, supporting search over thousands of source code files of an organization. second, it provides more specific search on source code by preprocessing source code files and understanding elements of the code as opposed to considering code as plain text.
positive experiences with an open project assignment in an introductory programming course. the course sif8005 object-oriented programming at the ntnu is in many respects taught in a quite traditional manner, with a well-known textbook, lectures in huge auditoria, and compulsory exercises that the students have to deliver to be allowed to sit a final written exam. the exercise part of the course is a mixture of individual exercises on a weekly basis, and a somewhat larger project to be done by groups of 4 students.this paper particularly discusses the project, which has become a huge success after some notable changes were made for the 2001 offering of the course. then the assignment profile was changed from one of fixed requirements set by staff to an open assignment, where each group made a computer game according to their own preferences. this change eliminated many of the problems present in earlier offerings and increased student inspiration.
beg, borrow, or steal (workshop session): using multidisciplinary approaches in empirical software engineering research. the goal of this workshop is to provide an interactive forum for software engineers and empirical researchers to investigate the feasibility of applying proven methods from other research disciplines to software engineering research. participants submitted position papers describing problems that might benefit from a multidisciplinary approach. expert guest speakers from software engineering and other disciplines will address the issues highlighted in the papers with the goal of encouraging more multidisciplinary research.
system-dependence-graph-based slicing of programs with arbitrary interprocedural control flow. many algorithms for automating software engineering tasks require program slices. to be applicable to large software systems, these slices must be computed interprocedurally. slicing techniques based on the system dependence graph (sdg) provide one approach for computing interprocedural slices, but these techniques are defined only for programs in which called procedures necessarily return to call sites. when applied to programs that contain arbitrary interprocedural control flow, existing sdg-based slicing techniques can compute incorrect slices; this limits their applicability. this paper presents an approach to constructing sdgs, and computing slices on sdgs, that accommodates programs with arbitrary interprocedural control flow. the main benefit of our approach is that it allows the use of the sdg-based slicing technique on a wide class of practical programs to which it did not previously apply.
automated support for development, maintenance, and testing in the presence of implicit control flow. although object-oriented languages can improve programmingpractices, their characteristics may introducenew problems for software engineers. one important problemis the presence of implicit control flow caused byexception handling and polymorphism. implicit controlflow causes complex interactions, and can thus complicatesoftware-engineering tasks. to address this problem, wepresent a systematic and structured approach, for supportingthese tasks, based on the static and dynamic analyses ofconstructs that cause implicit control flow. our approachprovides software engineers with information for supportingand guiding development and maintenance tasks. wealso present empirical results to illustrate the potential usefulnessof our approach. our studies show that, for thesubjects considered, complex implicit control flow is alwayspresent and is generally not adequately exercised.
software components in a data structure precompiler. predator is a data structure precompiler that generates efficient code for maintaining and querying complex data structures. it embodies a novel component reuse technology that transcends traditional generic data types. in this paper, we explain the concepts of our work and our prototype system. we show how complex data structures can be specified as compositions of software building blocks and present performance results that compare predator output to hand-optimized programs.
a formal approach to component-based software engineering: education and evaluation. this paper summarizes an approach for introducing component-based software engineering (cbse) early in the undergraduate cs curriculum, and an evaluation of the impact of the approach at two institutions. principles taught include a modular style of software development, an emphasis on human understanding of component behavior even while using formal specifications, and the importance of maintainability, as well as classical issues such as efficiency analysis and reasoning. qualitative and quantitative evaluations of student outcomes and end-to-end changes in student attitudes show mostly positive results that are statistically significant, confirming that (1) it is possible to teach cbse principles without displacing "classical principles usually taught in introductory courses, (2) students can understand and reuse formally-specified components without knowing their implementations, and (3) student attitudes towards software engineering can be altered in directions heretofore often assumed to be difficult to achieve.
precise service level agreements. slang is an xml language for defining service levelagreements, the part of a contract between the client andprovider of an internet service that describes the quality attributesthat the service is required to possess. we definethe semantics of slang precisely by modelling the syntax ofthe language in uml, then relating the language model toa model that describes the structure and behaviour of services.the presence of slang elements imposes behaviouralconstraints on service elements, and the precise definitionof these constraints using ocl constitutes the semantic descriptionof the language. we use the semantics to define anotion of sla compatibility, and an extension to uml thatenables the modelling of service situations as a precursorto analysis, implementation and provisioning activities.
fault-tolerance in a distributed management system: a case study. our case study provides the most important conceptual lessons learned from the implementation of a distributed telecommunication management system (dtms), which controls a networked voice communication system. major requirements for the dtms are fault-tolerance against site or network failures, transactional safety, and reliable persistence. in order to provide distribution and persistence both transparently and fault-tolerant we introduce a two-layer architecture facilitating an asynchronous replication algorithm. among the lessons learned are: component based software engineering poses a significant initial overhead but is worth it in the long term; a fault-tolerant naming service is a key requirement for fail-safe distribution; the reasonable granularity for persistence and concurrency control is one whole object; asynchronous replication on the database layer is superior to synchronous replication on the instance level in terms of robustness and consistency; semi-structured persistence with xml has drawbacks regarding consistency, performance and convenience; in contrast to an arbitrarily meshed object model, a accentuated hierarchical structure is more robust and feasible; a query engine has to provide a means for navigation through the object model; finally the propagation of deletion operation becomes more complex in an object-oriented model. by incorporating these lessons learned we are well underway to provide a highly available, distributed platform for persistent object systems.
on the effectiveness of set associative page mapping and its application to main memory management. set associative page mapping algorithms have become widespread for the operation of cache memories for reasons of cost and efficiency. in this paper we show how to calculate analytically the effectiveness of set associative paging relative to full associative (unconstrained mapping) paging. for two miss ratio models, saltzer's linear model and a mixed geometric model, we are able to obtain simple, closed form expressions for the relative lru fault rates. trace driven simulations are used to verify the accuracy of our results. we suggest that as electronically accessed third level memories, such as electron beam memories, magnetic bubbles or charge coupled devices become available, algorithms currently used only for cache paging will be applied to main memory, for the same reasons of efficiency, implementation ease and cost.
propel: an approach supporting property elucidation. property specifications concisely describe what a software system is supposed to do. it is surprisingly difficult to write these properties correctly. there are rigorous mathematical formalisms for representing properties, but these are often difficult to use. no matter what notation is used, however, there are often subtle, but important, details that need to be considered. propel aims to make the job of writing and understanding properties easier by providing templates that explicitly capture these details as options for commonly-occurring property patterns. these templates are represented using both "disciplined" natural language and finite-state automata, allowing the specifier to easily move between these two representations.
mining components for a software architecture and a product line: the options analysis for reengineering (oar) method. this tutorial discusses the problem of identifying candidate software components from legacy systems and determining their reuse potential for insertion in a new architecture, particularly in a software product line architecture. the tutorial outlines options analysis for reengineering (oar), which is a systematic method for evaluating the feasibility and benefits of mining existing components for a product line. oar operates like a funnel in which a set of potential assets is screened out so that the effort can focus on those components that will most effectively meet the technical and programmatic needs of the target architecture. the method incorporates a set of scalable techniques and exercises to collaboratively analyze existing components, determine viable mining options, and evaluate the most promising options. it provides a structured approach to determine the cost, effort, and risk of mining a set of software components from legacy systems.
design and evaluation of the mobile agent architecture for distributed consistency management. the proposed mobile agent architecture for carrying out incremental consistency checks between sets of distributed software engineering documents is described and evaluated. functionality of architectural components and collaboration between them throughout the consistency check are described. architecture simulation, based on concurrent &ldquo;execution&rdquo; of state chart models of components, is used for evaluation of scalability in a number of system configurations. this work represents the first part of a thesis, which aims to establish applicability of mobile agent technology to the domain of distributed consistency management.
experiences with place lab: an open source toolkit for location-aware computing. location-based computing (lbc) is becoming increasing important in both industry and academia. a key challenge is the pervasive deployment of lbc technologies; to be effective they must run on a wide variety of client platforms, including laptops, pdas, and mobile phones, so that location data can be acquired anywhere and accessed by any application. moreover, as a nascent area, lbc is experiencing rapid innovation in sensing technologies, the positioning algorithms themselves, and the applications they support. lastly, as a newcomer, lbc must integrate with existing communications and application technologies, including web browsers and location data interchange standard.this paper describes our experience in developing the place lab architecture, a widely used first-generation open source toolkit for client-side location sensing. using a layered, pattern-based architecture, it supports modular development in any dimension of lbc, enabling the field to move forward more rapidly as these innovations are shared with the community as pluggable components. our experience shows the benefits of domain-specific abstractions, and how we overcame high-level language constraints to support a wide array of platforms in this emerging space. we also describe our experience in re-engineering parts of the architecture based on the needs of the user community, including insights on software licensing issues.
understanding requirements for computer-aided healthcare workflows: experiences and challenges. medical informatics and software engineering researchers have studied how to use software technologies to define, analyze, automate, and provide decision support for healthcare workflows. we, as the requirement engineering and prototyping group of the siemens r&d center, have been involved in the research and development of healthcare workflows. during interactions with the workflow users and developers, we found significant confusion about the terminologies and the purposes of supporting different healthcare workflows. thus, we are motivated to classify computer-aided healthcare workflows, including their approaches, goals, and major characteristics. this paper also discusses workflow application issues and software challenges based upon our experiences and research.