waashk/dblp huggingface dataset:
a recovery mechanism for modular software. when an exception occurs, the state of a system is damaged : further processing may cause additional exceptions. under some hypotheses concerning the system structure we give an a priori estimate of the damage caused by exceptions. based on this estimate we propose a recovery strategy and a recovery mechanism.
component-based software engineering for embedded systems. although attractive, cbd has not been widely adopted in domains of embedded systems. the main reason is inability of these technologies to cope with the important concerns of embedded systems, such as resource constraints, real-time or dependability requirements. however an increasing understanding of principles of cbd makes it possible to utilize these principles in implementation of different component-based models more appropriate for embedded systems. the aim of this tutorial is to point to the opportunity of applying this approach for development and maintenance of embedded systems. the tutorial gives insights into basic principles of cbd, the main concerns and characteristics of embedded systems and possible directions of adaptation of component-based approach for these systems. different types of embedded systems and approaches for applying cbd are presented and illustrated by examples from research and practices. also, challenges and research directions of cbd for embedded systems are discussed.
a case study: demands on component-based development. building software systems with reusable components brings many advantages. the development becomes more efficient, the realibility of the products is enhanced, and the maintenance requirement is significantly reduced. designing, developing and maintaining components for reuse is, however, a very complex process which places high requirements not only for the component functionality and flexibility, but also for the development organization. in this paper we discuss the different levels of component reuse, and certain aspects of component development, such as component generality and efficiency, compatibility problems, the demands on development environment, maintenance, etc. the evolution of requirements for products generates new requirements for components, if components are not enough general and mature. this dynamism determines the component life cycle where the component first reaches its stability and later degenerates in an asset that is difficult to use, difficult to adapt and maintain. when reaching this stage, the component becomes an obstacle for efficient reuse and should be replaced. questions related to use of standard and de-facto standard components are addressed specifically. as an illustration of reuse issues, we present a successful implementation of a component-based system which is widely used for industrial process control.
4th icse workshop on component-based software engineering: component certification and system prediction. this workshop brings together researchers from the areas of component trust and certification, component technology, and software architecture. the goal of this workshop is to ensure that work in the areas of certification of software components and architectural analysis for prediction of system quality attributes will be mutually aware, if not mutually reinforcing. the output of the workshop will be a defined set of community model problems that reflects this intersection of interests.
5 icse workshop on component-based software engineering: benchmarks for predictable assembly. this workshop brings together researchers and practitioners from the community interested in predictable assembly from certifiable components. the goal of this workshop is to ensure continued collaboration among the members of this community. one output of the workshop will be an understanding of composition theory and how it applies to community model problems that were suggested at the workshop on component-based software engineering held at icse in 2001. a second output will be the identification of research opportunities that lie on the perimeter of predictable assembly.
6th icse workshop on component-based software engineering: automated reasoning and prediction. this report gives an overview of the 6th icse workshop on component-based software engineering held at 25th international conference on software engineering. the workshop brought together researchers and practitioners from three communities: component technology, software architecture, and software certification. the primary goal of the workshop was to continue clarifying the concepts, identifying the main challenges and findings of predictable assembly of certifiable software components. this report gives a comprehensive summary of the position papers, of the workshop, its findings, and its results.
check 'n' crash: combining static checking and testing. we present an automatic error-detection approach that combines static checking and concrete test-case generation. our approach consists of taking the abstract error conditions inferred using theorem proving techniques by a static checker (esc/java), deriving specific error conditions using a constraint solver, and producing concrete test cases (with the jcrasher tool) that are executed to determine whether an error truly exists. the combined technique has advantages over both static checking and automatic testing individually. compared to esc/java, we eliminate spurious warnings and improve the ease-of-comprehension of error reports through the production of java counterexamples. compared to jcrasher, we eliminate the blind search of the input space, thus reducing the testing time and increasing the test quality.
dynamically discovering likely interface invariants. dynamic invariant detection is an approach that has received considerable attention in the recent research literature. a natural question arises in languages that separate the interface of a code module from its implementation: does an inferred invariant describe the interface or the implementation? furthermore, if an implementation is allowed to refine another, as, for instance, in object-oriented method overriding, what is the relation between the inferred invariants of the overriding and the overridden method? the problem is of great practical interest. invariants derived by real tools, like daikon, often suffer from internal inconsistencies when overriding is taken into account, becoming unsuitable for some automated uses. we discuss the interactions between overriding and inferred invariants, and describe the implementation of an invariant inference tool that produces consistent invariants for interfaces and overridden methods.
a comparison of communication technologies to support novice team programming. this paper describes an initial investigation of how different conditions for conducting a team programming exercise impact learning. we conducted a series of in-depth case studies on the use of various communication technologies and compared them with face-to-face case studies of team programming. we explored how these communication technologies can help improve students' learning. we summarize the findings from these studies and give guidance to instructors and to tool designers on how future tools can be improved to support collaborative learning in team programming.
exploiting an event-based infrastructure to develop complex distributed systems. the development of complex distributed systems demands for the creation of suitable architectural styles (or paradigms) and related run-time infrastructures. an emerging style that is receiving increasing attention is based on the notion of event. in an event-based architecture, distributed software components interact by generating and consuming events. the occurrence of an event in a component (called source) is asynchronously notified to any other component (called recipient) that has declared some interest in it. this paradigm holds the promise of supporting a flexible and effective interaction among highly reconfigurable distributed software components. we have developed an object-oriented infrastructure, called jedi (java event-based distributed infrastructure), to support the development and operation of event-based systems. during the past year, jedi has been used to implement a significant example of distributed system, namely, the opss workflow management system. the paper illustrates jedi main features and how we have used it to implement the opss workflow management system. moreover, it provides an initial evaluation of our experiences in using an event-based architectural style
from mcc and cmm: technology transfers bright and dim. this paper describes lessons learned during the author's five lives in technology transfer. the author's first life came in general electric's space division where he performed research on software metrics and structured programming, and transferred technology to the pages of technical journals. his second life came at itt's programming technology center where he was responsible for transferring software measurement practices into common use across itt's worldwide software operations. some measurement initiatives survived, but most were short-lived. his third life came in mcc's human interface laboratory and software technology program. mcc's member companies were only occasionally able to transfer the advanced technology they challenged mcc to produce. his fourth life came in directing the software process program at the software engineering institute where he led the team that produced the capability maturity model. although the cmm's transfer was occasionally too rapid to control, the cmm suggested that you should transfer no technology before its time. the author's fifth and current life involves co-founding teraquest and helping companies to improve their software development capability. the paper includes twenty-five lessons in technology transfer and one model.
fifteen years of psychology in software engineering: individual differences and cognitive science. since the 1950's, psychologists have studied the behavioral aspects of software engineering. however, the results of their research have never been organized into a subfield of either software engineering or psychology. this failure results from the difficulty of integrating theory and data from the mixture of paradigms borrowed from psychology. this paper will review some of the psychological research on software engineering performed since the garmisch conference in 1968. this review will be organized under two of the psychological paradigms used in exploring programming problems: individual differences and cognitive science. the major theoretical and practical contributions of each area to the theory and practice of software engineering will be discussed. the review will end with a call for more research guided by the paradigm of cognitive science, since such results are the easiest to integrate with new developments in artificial intelligence and computer science theory.
on building software process models under the lamppost. most software process models are based on the management tracking and control of a project. the popular alternatives to these models such as rapid prototyping and program transformation are built around specific technologies, many of which are still in their adolescence. neither of these approaches describe the actual processes that occur during the development of a software system. that is, these models focus on the series of artifacts that exist at the end of phases of the process, rather than on the actual processes that are conducted to create the artifacts. we conducted a field study of large system development projects to gather empirical information about the communication and technical decision-making processes that underlie the design of such systems. the findings of this study are reviewed for their implications on modeling the process of designing large software systems. the thesis of the paper is that while there are many foci for process models, the most valuable are those which capture the processes that control the most variance in software productivity and quality.
evaluating pattern catalogs: the computer games experience. patterns and pattern catalogs (pattern languages) have been proposed as a mechanism for re-use. traditionally, patterns have been used to foster design re-use, and generative design patterns have been used to achieve both design and code re-use. in theory, a pattern catalog could be created and used to provide re-usable patterns within a project and across a group of related projects. this idea raises a natural question. how can we measure the effectiveness of a pattern catalog or compare the effectiveness of different pattern catalogs? in this paper, we define four metrics that can be used to measure the effectiveness of pattern catalogs. we illustrate these metrics by applying them to a case study that uses a pattern catalog of generative design patterns to generate scripting code for computer games. the metrics are general enough to assess any pattern catalog, independent of application domain or whether the patterns are generative or descriptive.
non-functional requirements: from elicitation to modelling languages. although non-functional requirements (nfrs) have been present in many software development methods, they have been presented as a second or even third class type of requirement, frequently hidden inside notes and therefore, frequently neglected or forgotten. surprisingly, despite the fact that non-functional requirements are among the most expensive and difficult to deal with there are still few works that focus on nfrs as first class requirements. although these works have brought a contribution on how to represent and deal with nfrs, two aspects remain not sufficiently explored: how to elicit nfrs and how to merge these nfrs with conceptual models. our work aims at filling this gap, proposing a strategy to elicit nfrs and to integrate them into conceptual models we focus our attention on conceptual models expressed using uml, and therefore, we propose extensions to uml such that nfrs can be expressed. more precisely, we will show how to integrate nfrs to the class, sequence and collaboration diagrams. we will also show how use cases and scenarios can be adapted to deal with nfrs. this work was validated by three case studies and their results suggest that by using our proposal we can improve the quality of uml models.
reliable software and communication: software quality, reliability, and safety. examines the software development process and suggests opportunities for improving the process by using a combination of statistical and other process control techniques. each phase of the software process affects the ultimate quality, reliability, and safety of the software. control of the process, supported by appropriate tools to collect and analyze data, is essential to improvement of the software product. since the ability to observe, control, and improve software depends on the ability to measure and analyze data drawn from the software process, data collection is central to the approach. detailed data about each of the subprocesses are needed, along with tools to measure and analyze the data. statistical process control techniques, besides improving system reliability, can produce a substantial economic gain in the software development process. the views are based upon experiences with large telecommunications systems
workshop on advances in model-based software testing. the paper summarizes the themes and goals of the workshop on advances in model-based software testing.
workshop on global software development. the goal of this workshop is to bring together researchers and practitioners in trying to understand the emerging phenomenon of global software development. as we witness an increased globalization of software development, it is important that research addresses the challenges of distributed software engineering and informs the development of techniques and technologies to improve such practice.
instructional design and assessment strategies for teaching global software development: a framework. in the context of increasing pressure to adopt global approaches to software development, the importance of teaching skills for geographically distributed software development (gsd) becomes essential. this paper reports the experience of teaching a course to prepare graduates for software engineering (se) in global customer-developer teams, and which was taught in three-university collaboration (canada, australia and italy). the course emphasized the learning of requirements management activities in frequent synchronous computer-mediated client-developer relationships and created a gsd environment with significant time zone and language differences. we describe our instructional approach and assessment strategies within a gsd instructional design framework which integrates (a) required gsd skills and strategies for aligning classroom projects with contemporary and authentic gsd conditions, (b) strategies for assessment of learning of gsd skills and (c) examples from our gsd course.
the 3rd international workshop on global software development. the goal of this workshop is to provide anopportunity for researchers and industry practitioners toexplore both the state-of-the art and the state-of-the-practicein global software development (gsd).increased globalization of software developmentcreates software engineering challenges due to the impactof temporal, geographical and cultural differences, andrequires development of techniques and technologies toaddress these issues. the workshop will foster interactionbetween practitioners and researchers and help grow acommunity of interest in this area. practitionersexperiencing challenges in gsd will share their concernsand successful solutions and learn from research aboutcurrent investigations. researchers addressing gsd willgain a better understanding of the key issues facingpractitioners and share their work in progress with othersin the field.
the role of asynchronous discussions in increasing the effectiveness of remote synchronous requirements negotiations. important and yet very difficult process in software development, requirements engineering is plagued with additional challenges in the emergent dynamics of geographically distributed software teams. our hypothesis is that a mix of lean and rich communication media are needed towards increasing the effectiveness of meetings in reaching mutual agreement when stakeholders are geographically dispersed.we studied tool-supported remote inspections in six educational global project teams in a multicultural software development environment. in this paper we present the preliminary results from comparing the effectiveness of the requirements negotiations when preceded by the asynchronous discussions to those negotiations with no prior asynchronous discussions.
addressing the challenges of software industry globalization: the workshop on global software development. the goal of this workshop is to provide an opportunity for researchers and industry practitioners to explore both the state-of-the art and the state-of-the-practice in global software development (gsd).increased globalization of software development creates software engineering challenges due to the impact of temporal, geographical and cultural differences, and requires development of techniques and technologies to address these issues. the workshop will foster interaction between practitioners and researchers and help grow a community of interest in this area. practitioners experiencing challenges in gsd will share their concerns and successful solutions and learn from research about current investigations. researchers addressing gsd will gain a better understanding of the key issues facing practitioners and share their work in progress with others in the field.
three approximation techniques for astral symbolic model checking of infinite state real-time systems. astral is a high-level formal specification language for real-time systems. it has structuring mechanisms that allow one to build modularized specifications of complex real-time systems with layering. based upon the astral symbolic model checler reported in [13], three approximation techniques to speed-up the model checking process for use in debugging a specification are presented. the techniques are random walk, partial image and dynamic environment generation. ten mutation tests on a railroad crossing benchmark are used to compare the performance of the techniques applied separately and in combination. the test results are presented and analyzed.
using the astral model checker to analyze mobile ip. astral is a high level formal specification language for real time systems. it is provided with structuring mechanisms that allow one to build modularized specifications of complex real time systems with layering. the astral model checker checks the satisfiability of critical requirements of a specification by enumerating possible runs of transitions within a given time bound. the paper discusses the mechanism of the model checker and how it can be used to analyze encryption protocols. several classic benchmarks have been investigated, including the needham-schroeder public-key authentication protocol (r.m. needham and m.d. schroeder, 1978) and the tmn protocol, and a number of attacks were uncovered. the paper focuses on using astral to specify mobile ip (c. perkins, 1996) and testing the specification using the model checker.
an infrastructure for the rapid development of xml-based architecture description languages. research and experimentation in software architectures over the past decade have yielded a plethora of software architecture description languages (adls). continuing innovation indicates that it is reasonable to expect more new adls, or at least adl features. this research process is impeded by the difficulty and cost associated with developing new notations. an architect in need of a unique set of modeling features must either develop a new architecture description language from scratch or undertake the daunting task of modifying an existing language. in either case, it is unavoidable that a significant effort will be expended in building or adapting tools to support the language. to remedy this situation, we have developed an infrastructure for the rapid development of new architecture description languages. key aspects of the infrastructure are its xml-based modular extension mechanism, its base set of reusable and customizable architectural modeling constructs, and its equally important set of flexible support tools. this paper introduces the infrastructure and demonstrates its value in the context of several real-world applications.
using off-the-shelf middleware to implement connectors in distributed software architectures. software architectures promote development focused on modular building blocks and their interconnections. since architecture-level components often contain complex functionality, it is reasonable to expect that their interactions will also be complex. modeling and implementing software connectors thus becomes a key aspect of architecture-based development. software interconnection and middleware technologies such as rmi, corba, ilu, and activex provide a valuable service in building applications from components. the relation of such services to software connectors in the context of software architectures, however, is not well understood. to understand the tradeoffs among these technologies with respect to architectures, we have evaluated several off-the-shelf middleware technologies and identified key techniques for utilizing them in implementing software connectors. our platform for investigation was c2, a component- and message-based architectural style. by encapsulating middleware functionality within software connectors, we have coupled c2's existing benefits such as component interchangeability, substrate independence and structural guidance with new capabilities of multi-lingual, multi-process and distributed application development in a manner that is transparent to architects.