waashk/dblp huggingface dataset:
measuring cognitive activities in software engineering. this paper presents an approach to the study of cognitive activities in collaborative software development. this approach has been developed by a multidisciplinary team made up of software engineers and cognitive psychologists. the basis of this approach is to improve our understanding of software development by observing professionals at work. the goal is to derive lines of conduct or good practices based on observations and analyses of the processes that are naturally used by software engineers. the strategy involved is derived from a standard approach in cognitive science. it is based on the videotaping of the activities of software engineers, transcription of the videos, coding of the transcription, defining categories from the coded episodes and defining cognitive behaviors or dialogs from the categories. this project presents two original contributions that make this approach generic in software engineering. the first contribution is the introduction of a formal hierarchical coding scheme, which will enable comparison of various types of observations. the second is the merging of psychological and statistical analysis approaches to build a cognitive model. the details of this new approach are illustrated with the initial data obtained from the analysis of technical review meetings
specification of abstract data types with partially defined operations. we investigate equational inference rules for partial algebras and propose conditionally complete equational inference rules for partial algebras. based on the results obtained from the investigation we propose a new algebraic specification technique for partial abstract data types. it requires no superfluous equations concerning undefinedness.
efficient path conditions in dependence graphs. program slicing combined with constraint solving is a powerful tool for software analysis. path conditions are generated for a slice or chop, which --- when solved for the input variables --- deliver compact "witnesses" for dependences or illegal influences between program points.in this contribution we show how to make path conditions work for large programs. aggressive engineering, based on interval analysis and bdds, is shown to overcome the potential combinatoric explosion. case studies and empirical data will demonstrate the usefulness of path conditions for practical program analysis.
toward computational support for software process improvement activities. software organizations and projects need guidance on how to improve software process, not just guidelines on what to improve. several surveys demonstrate that the capability maturity model (cmm) and iso-9000 only provide the latter. we report our in-depth analysis on a seventeen-month effort in software process improvement (spi) at omron corporation. the goal of the analysis was to identify issues and challenges of spi and to design a step-wise practical method to avoid such problems. major problems we have found include the lack of shared goal among stakeholders, insufficient understanding of the current progress of spi efforts, and underutilization of a large amount of complex information generated during spi. we present the method for software organizations and projects for dealing with the problems, and argue for a knowledge-based spi support system based on the method
the software engineer and the development, management and use of intellectual property. this full day tutorial will offer instruction on patent, copyright, trade secret and other intellectual property issues faced by developers and users of software in protecting their innovations, including information on avoiding infringing the intellectual property rights of others in the software development process. the course is directed to conference attendees who are involved in any aspect of the development, management or use of intellectual property, including those in the private sector, universities and government. the course will be presented at a basic and understandable, level tailored for the software engineer audience. the course will comprise an oral presentation of nine (9) 30-35 minute segments, with 10 minute breaks for refreshments and specific attendee questions. the instructors will remain available for questions from attendees during breaks. answers to questions will also be provided during each session. power point slides will be used, and actual anecdotal experiences will be presented to illustrate important points.
challenges in the age of ubiquitous computing: a case study of t-engine, an open development platform for embedded systems. ubiquitous computing poses new challenges for the software engineering community. the t-engine platform consisting of standard real-time kernel, t-kernel, running on the standard hardware with networking facility creates broad application opportunities based on the collaboration of cutting edge microelectronics, software and embedded system technologies. however, to realize the true potential of such a system in a ubiquitous computing environment, we need to overcome software engineering issues among many hurdles we encounter. we describe such issues and the future challenges inherent in the ubiquitous computing based on our experience of using ubiquitous communicator terminal that is based on t-engine.
a model driven approach for software systems reliability. the main contribution of this research is to provideplatform-independent means to support reliability designfollowing the principles of a model driven approach. thecontribution aims to systematically address dependabilityconcerns from the early to the late stages of software development.mda appears to be a suitable framework toassess these concerns and, therefore, semantically integrateanalysis and design models into one environment.
a methodology for decomposing system requirements into data processing requirements. top level system design is considered, with attention focused on the decomposition of system requirements into subsystem requirements. primary interest is in the data processing subsystem. implementation details involving operating systems, selection and configuration of computers, and choice of specific algorithms are excluded from this study. a methodology is presented for transforming system requirements into functional structure and system operating rules. this methodology is viewed as the first step of a comprehensive software development methodology comprising: top level design, algorithm development, computer selection, and the translation of the functional algorithmic design into operational software. the top level design is carried to such detail that algorithms, to be developed subsequently and to be realized ultimately with hardware or software, can be considered bounded by the interfaces of the data processing subsystem (dps). that is, the interfaces are defined sufficiently well that the algorithm designer needs to consider neither the destination of data leaving the dps nor the source of data entering the dps. a system can be decomposed into four structural elements: functions, control, functional flows, and data. each of these elements is a subject of the decomposition methodology. the inter-relationships of system functions are structured to define a partial ordering of system functions that is amendable to representation as a directed graph. the system control mechanism is defined to be a finite state machine, whose only cycles are loops, having start and end states. for real time operation end states fold onto start states. functional flows represent each output of the control machine as a serial/parallel execution of the functions, consistent with their partial ordering. data is used to relate the several functions within a functional flow, to drive the control mechanism, and to link control to the functional flows.
a new program structure to improve accuracy and readability of pascal software. based on an analysis of errors in a piece of pascal software a new language feature is introduced to increase the degree of compile time checking of program logic and thus improve the confidence of the programmer in the correctness of a program. specifically this involves a form of abstract data type, augmented by restrictions on the use of operations provided with the type, and a means of allowing the programmer to bring logically related segments of program together textually.
software test program: a software residency experience. the software test program (stp) is a cooperation between motorola and the center for informatics of the federal university of pernambuco. it has been conceived with inspiration on the medical residency, adjusted to the software development practice. a software residency includes the formal teaching of the relevant concepts and deep practice, with specialization on some specific subject; here the focus is on software testing. the stp has been of great benefit to all parties involved.
specifying software/hardware interactions in distributed systems. this paper describes a system level specification approach that enables the designer to formulate and answer questions regarding the system's logical correctness and performance characteristics when the interaction between the hardware and the software is important, i.e., when the impact of faults, failures, communication delay, hardware selection, scheduling policies, etc., must be considered. in the simplest terms, our concern extends beyond the traditional software correctness questions by addressing the issue of employing logical verification techniques to determine software correctness and performance characteristics when running on a particular distributed hardware architecture and using a particular operating system. a language called csps (an extension of hoare's csp) is used in the illustration of the approach. employing csp as a base allows modelled systems to be verified using techniques already developed for verifying csp programs.
software architecture based on communicating residential environments. this paper describes an alternative approach to software architecture, where the classical division of responsibilities between operating systems, programming languages and compilers, and so forth is revised. our alternative is organized as a set of self-contained environments which are able to communicate pieces of software between them, and whose internal structure is predominantly descriptive and declarative. the base structure within each environment (its diversified shell) is designed so that it can accomodate such arriving software modules. the presentation of that software architecture is done in the context of an operational implementation, the screen system (system of communicating residential environments).
language and visualization support for large-scale concurrency. sdl (shared dataspace language) is a language for writing and visualizing programs consisting of thousands of processes executing on a highly-parallel multiprocessor. sdl is based on a model in which processes use powerful transactions to manipulate abstract views of a virtual, content-addressable data structure called the dataspace. the process society is dynamic and supports varying degrees of process anonymity. the transactions are executed over abstract views of the dataspace. this facilitates elegant conceptualization of dataspace transformations and compact program representation. processes and transactions enable sdl to combine elements of both large and fine grained concurrency. the view is a novel abstraction mechanism whose significance is derived from the fact that it allows processes to interrogate the dataspace at a level of abstraction convenient for the task they are pursuing. the view also plays a role in the definition of continuously updated, programmer-defined visual abstractions which enable exploration of the program's functionality and performance.
on the influence of scale in a distributed system. scale should be recognized as a primary factor influencing the architecture and implementation of distributed systems. this paper uses andrew, a distributed environment at carnegie mellon university, to validate this proposition. the design of andrew is dominated by considerations of performance, operability and security. caching of information and placing trust in as few machines as possible emerge as two general principles that enhance scalability. the separation of concerns made possible by specialized mechanisms is also valuable. heterogeneity is a natural consequence of growth and anticipating it in the initial stages of system design is important. a location transparent shared file system considerably enhances the usability of a distributed environment.
multifaceted distributed systems specification using processes and event synchronization. a new approach to modelling distributed systems is presented. it uses sequential processes and event synchronization as the major building blocks and is able to capture the functionality, architecture, scheduling policies, and performance attributes of a distributed system. the approach is meant to provide the foundation for a uniform incremental strategy for verifying both logical and performance properties of distributed systems. in addition, this approach draws together work on performance evaluation, resource allocation, and verification of concurrent processes by reducing some problems from the first two areas to equivalent problems in the third. a language called csps (an extension of hoare's csp) is used in the illustration of the approach. employing csp as a base allows modelled systems to be verified using techniques already developed for verifying csp programs
verification of a monitor specification. a specification of the monitor primitives that have been proposed for mutual exclusion and interprocess communication in operating systems is verified to be correct. the specification is given in the pascal programming language and the proofs of correctness use the axiomatic definition of this language. two aspects of correctness are considered: the correctness of the program implementation of the primitives and the correctness as viewed by the processes that execute the monitor primitives.
consistent group membership in ad hoc networks. the design of ad hoc mobile applications often requires the availability of a consistent view of the application state among the participating hosts. such views are important because they simplify both the programming and verification tasks. essential to constructing a consistent view is the ability to know what hosts are within proximity of each other, i.e., form a group in support of the particular application. in this paper we propose an algorithm that allows hosts within communication range to maintain a consistent view of the group membership despite movement and frequent disconnections. the novel features of this algorithm are its reliance on location information and a conservative notion of logical connectivity that creates the illusion of announced disconnection. movement patterns and delays are factored in the policy that determines which physical connections are susceptible to disconnection.
network abstractions for context-aware mobile computing. context-aware computing is characterized by the ability of a software system to continuously adapt its behavior to a changing environment over which it has little or no control. previous work along these lines presumed a rather narrow definition of context, one that was centered on resources immediately available to the component in question, e.g., communication bandwidth, physical location, etc. this paper explores context-aware computing in the setting of ad hoc networks consisting of numerous mobile hosts that interact with each other opportunistically via transient wireless interconnections. we extend the context to encompass awareness of an entire neighborhood within the ad hoc network. a formal abstract characterization of this new perspective is proposed. the result is a specification method and associated context maintenance protocol. the former enables an application to define an individualized context, one that extends across multiple mobile hosts in the ad hoc network. the latter makes it possible to delegate the continuous reevaluation of the context and the performance of operations on it to some middleware operating below the application level. this relieves application development of the obligation of explicitly managing mobility and its implications on the component's behavior.
assertional reasoning about pairwise transient interactions in mobile computing. mobile computing represents a major point of departure from the traditional distributed computing paradigm. the potentially very large number of independent computing units, a decoupled computing style, frequent disconnections, continuous position changes, and the location-dependent nature of the behavior and communication patterns of the individual components present designers with unprecedented challenges in the areas of modularity and dependability. the paper describes two ideas regarding a modular approach to specifying and reasoning about mobile computing. the novelty of our approach rests with the notion of allowing transient interactions among programs which move in space. we restrict our concern to pairwise interactions involving variable sharing and action synchronization. the motivation behind the transient nature of the interactions comes from the fact that components can communicate with each other only when they are within a certain range. the notation we propose is meant to simplify the writing of mobile applications and is a direct extension of that used in unity. reasoning about mobile computations relies on the unity proof logic.
an architecture-centric approach to the development of a distributed model-checker for timed automata. research in model-checking is focused on increasing the size of the problems tools can deal with. the ultimate wave has been the use of distributed-computing, where a cluster of computers work together to solve the problem [8, 3, 9].in our work we present a distributed model-checker that evolves from the tool kronos [5] and can handle backwards computation of tctl-reachability formulae [1] over timed-automata [2]. our proposal, including the arguments of its correctness, is based on software architectures, using a notation adapted from [6]. we find such an approach a natural and general way to address the development of complex tools that need to incorporate new features and optimizations as they evolve.we introduce some interesting features such as a priori graph partitioning (using metis [7], a standard library for graph partitioning), a sophisticated machinery to reach optimum performance (communication piggybacking and delayed messaging) and dead-time utilization, where every processor uses time intervals of inactivity to perform auxiliary, time-consuming tasks that will later speed up the rest of the computation.the correctness proof strategy combines an architecture evolution with the theoretical results about fix point calculation developed by patrick cousot in 1978 [4].
workshop on software engineering and mobility. mobility is redefining the hardware and software fabric of distributed systems. wireless communication allows network hosts to participate in a distributed computation while on the move. novel middleware technologies allow software components to migrate across hosts for enhanced flexibility or performance. workshop participants were invited to analyze the software engineering implications of this wave of technological changes, by discussing fundamental models, emerging themes, research opportunities, technological trends, and market forces.
design using software engineering principles: overview of an educational program. in 1981 ibm initiated a corporate-wide training program to introduce a standard, software engineering-based, programming technology, based on a similar program established in the federal systems division during the late seventies. the software engineering workshop has a strong mathematical orientation. the central focus is on mathematical models for program functions and data abstractions. the models allow mathematical statements of specifications, stepwise refinement, and function-based mental verification of each refinement step. the technology and a textual design language encourage orderly problem decomposition, encapsulation, and separation of concerns. this paper introduces the material taught in the workshop and summarizes the workshop's history and results. use of the technology is producing higher quality programs and providing greater professional satisfaction among its users.
software process maturity: measuring its impact on productivity and quality. with the current worldwide focus on improvement in software process, there is clearly a need for an understanding of its impact on software engineering productivity and quality. the paper documents an attempt to provide an empirical metrics `view' of such initiatives based on data collected in a worldwide benchmarking effort conducted between march, 1991 and december, 1991. surprisingly, of the more than 300 organizations that participated, fewer than 1 in 5 had any quantifiable performance data available prior to the start of this study. however, those that had embarked on significant process improvement efforts and were actively using metrics were able to demonstrate substantial grains in productivity and quality. in addition, insights derived from this large scale data analysis provide a framework for determining which metrics should be included in a standard software engineering measurement `dashboard'
software engineering management. the author discusses the links between management and software engineering. the author tries to show why, in europe and the usa, management has failed so often in this field. this seems to be due to a combination of narrow-minded attitudes from all the players: academia, work-force and management. the two main issues are software engineering does not produce competent managers, and software development is still an individual affair
an architectural style for multiple real-time data feeds. we present an architectural style for the integration of multiple real-time data feeds on windows nt platforms. we motivate the development of this style by highlighting different application areas in which the style has been deployed. we present the requirements that will be met by the architectural style and discuss the design of customizable components that implement the style based on microsoft's component object model.
acmestudio: supporting style-centered architecture development. software architectural modeling is crucial to the developmentof high-quality software. tool support is requiredfor this activity, so that models can be developed,viewed, analyzed, and refined to implementations. thissupport needs to be provided in a flexible and extensiblemanner so that the tools can fit into a companyýs processand can use particular, perhaps company-defined, domain-specific architectural styles. in this research demonstration, we describe acmestudio, a style-neutral architecturedevelopment environment that can be easilyspecialized for architectural design in different domains.