waashk/dblp huggingface dataset:
an architecture for heterogeneous groupware applications. the proliferation of wireless networks and small portable computing devices raises the need for applications that are adaptable to heterogeneous computing and communication environments and the contexts in which they are used. however, most current groupware systems as well as other software applications are not well prepared to handle the heterogeneity. the manifold framework presented here provides a software architecture for synchronous groupware applications to deal with heterogeneity. the framework's main characteristic is data centricity. the users collaborate on and exchange data, and the data is dynamically transformed to adapt to the particular computing/network platform. the design is based on multi-tier architecture and uses extensible markup language (xml) as a generic means for information exchange. the resulting design is simple yet very powerful and scalable. manifold is implemented and tested by developing several complex groupware applications.
how to measure software reliability, and how not to. this paper examines critically, with a view to stimulating a discussion, some concepts which have been used in early work on software reliability measurement, and suggests improvements and areas of potentially fruitful future research. it is proposed that hardware-motivated measures such as mttf, mtbf should not be used for software without justification, and it is shown that such justification may be lacking under quite unexceptionable circumstances. alternative methods of measuring software reliability are proposed. emphasis is placed upon differentiating between two concepts of software reliability which are often blurred in the work of previous authors. these are, on the one hand, the reliability of the program-as-it-is (the number of bugs it contains), on the other, the reliability of the program-as-it-performs (failure rate, distribution of time to next failure, etc.). it is argued that the latter, here called operational reliability, is the one we should use. measures of operational reliability which avoid use of mttf, etc., are proposed. a case is made for software engineers adopting a bayesian stand-point:both in the interpretation of probability statements and in inference procedures. it is suggested that reliability modelling solely in terms of failures (or number of bugs) is unnecessarily naive. interest really centres upon the consequences of failures as much as on their frequency. it is proposed that more effort be devoted to the development of models which incorporate a cost (or utility) structure. finally, brief consideration is given to the question of program structure. the enormous success of hardware reliability theory, in combining component reliabilities with knowledge of system sturcture, must be emulated for software. unfortunately, software structure does not easily lend itself to such an exercise. some existing models are considered.
interactive system for structured program production. the automation of program development procedures is one of the important subjects to be solved for improving productivity. the documentation of program specification and coding process involve many mechanical operations. presently, however, they are done mostly by human efforts. this greatly hinders the improvement of both productivity and program quality. for the purpose of solving all the problems, we developed an experimental system sdl/pad. upon receipt of the specifications described in a structured form which has been defined in accordance with structured design, the sdl/pad. system automatically generates programs written with a computer language such as pl/m or the like and specification documents. this system eliminates the troublesome inconsistency between documents and source programs.
a program complexity metric based on data flow information in control graphs. this paper presents a new approach to measuring program complexity with the use of data flow information in programs. a complexity metric, called du, is defined for the control graph of a structured program. this new metric is different from other control-graph based metrics in that it is based on &ldquo;representative&rdquo; data flow information in a control graph. an algorithm for computing the value of du(g) for a control graph g is given. the lower and upper bounds of du(g) are provided. the du metric is shown to have several advantages over other control-graph based complexity metrics.
fault tolerance via diversity against design faults (tutorial session): design principles and reliability assessment. research results indicate that (as usual in software engineering) these question can only be answered with reference to each specific application context and that diversity is no &ldquo;silver bullet&rdquo;. but diversity is an attractive option, made more interesting by current trends like the preference for cots items, and it is important for practitioners to go beyond the summary opinions and misunderstanding that surround it.this tutorial is designed for people involved in system design, acceptance or certification, especially in companies with high dependability requirements or plans to improve on current levels to move into more demanding markets. it is also appropriate for researchers in software engineering wishing to obtain an up-to-date view of knowledge in this area.this tutorial describes:the motivations behind the use of software fault tolerance, and thus the circumstances in which it should be considered as a possible choice;what design schemes one may adopt, and which issues a designer needs to be aware of, for effective application. we present both examples of industrial use and explanations of the important design choices and trade-offs. in this part, we cover the widely published solutions of n-version programming and recovery blocks, but also describe the various options available to a designer, and interesting specific solutions adopted in the railway and aviation industry, and scheme for applications to safety systems. we discuss the factors that may decide the scheme to be adopted and the design of adjudication between conflicting results; &ldquo;what one should really believe&rdquo; about the effectiveness of software fault tolerance in improving reliability, beyond the controversy and the misunderstandings surrounding it. we give a picture, assembled from more than 10 years of research, of what evidence has really been produced for and against software diversity. we explain the weaknesses of the extreme opinions voiced for and against software fault tolerance, and discuss the criteria that should affect practical decisions about using it, about how to improve its effectiveness by appropriate decisions in developing alternate versions of software components, and about its value for system acceptance.
experience from applying rim to educational erp development. developing a complex system requires partitioning the target system into several subsystems. it is generally difficult to define each subsystem's scope and functional requirements as well as data dependencies among subsystems. requirements integration model (rim), which consists of a workflow model and a work procedure, can provide specific guidelines and techniques to increase quality of requirements obtained under a time constraint. we have applied the technique to the implementation of the educational system for the department of computer engineering at chulalongkorn university, thailand. experiences from this case study have shown that the model can assist developers to clearly specify functional requirements for each subsystem and to identify data dependencies among subsystems.
understanding software application interfaces via string analysis. in software systems, different software applications often interact with each other through specific interfaces by exchanging data in string format. for example, web services interact with each other through xml strings. database applications interact with a database through strings of sql statements. sometimes these interfaces between different software applications are complex and distributed. for example, a table in a database can be accessed by multiple methods in a database application and a single method can access multiple tables. in this paper, we propose an approach to understanding software application interfaces through string analysis. the approach first performs a static analysis of source code to identify interaction points (in the form of interface-method-call sites). we then leverage existing string analysis tools to collect all possible string data that can be sent through these different interaction points. then we manipulate collected string data by grouping similar data together. for example, we group together all collected sql statements that access the same table. then we associate various parts of aggregated data with interaction points in order to show the connections between entities from interacting applications. our preliminary results show that the approach can help us understand the characteristics of interactions between database applications and databases. we also identify some challenges in this approach for our future work.
visual languages for event integration specification. we are exploring existing approaches and developing new techniques for visual event-based system integration. we are using domain-specific visual languages with different high-level visual metaphors (including tool abstraction, event-query-filter-action and spreadsheet) to specify event-handling support and provide backend processing tool support for event integration specification and visualisation of event propagation. we aim to generalise from three exemplar visual event-driven system metaphors and develop a new, generic visual event handling metaphor. from this we will build a visual environment for specifying event-based system integration. the visual metaphor we are developing should adapt the event-based communication model to a wide range of application domains, and also should support complex and intelligent system design and implementation.
feature oriented refactoring of legacy applications. feature oriented refactoring (for) is the process of decomposinga program into features, where a feature is an increment in programfunctionality. we develop a theory of for that relates code refac-toring to algebraic factoring. our theory explains relationshipsbetween features and their implementing modules, and why fea-tures in different programs of a product-line can have differentimplementations. we describe a tool and refactoring methodologybased on our theory, and present a validating case study.
automatic method refactoring using weighted dependence graphs. while refactoring makes frameworks more reusable, it is complex to do by hand. this paper presents a mechanism that automatically refactors methods in object-oriented frameworks by using weighted dependence graphs, whose edges are weighted based on the modification histories of the methods. to find the appropriate boundary between frozen spots and hot spots in the methods, the value of the weight varies based on whether the dependence in the original methods has been repeatedly preserved or destroyed in the methods of applications created by programmers. the mechanism constructs both template methods that contain the invariant dependence and hook methods that are separated by eliminating the variant dependence. the new template methods and hook methods tailored to each programmer save him/her from writing superfluous code when reusing a framework. experimental results show a reduction rate of up to 22% in the number of statements a programmer has to write when creating several applications; this percentage is double that achievable by a conventional refactoring technique.
xml conceptual modeling with xuml. as xml has become the standard format for representing structured and semi-structured data on the web, the methods for designing xml schemas is becoming more and more important. xml schemas represent the logical models of the documents. in order to design or integrate xml schemas, it is necessary to first design the conceptual structures with a proper conceptual model. we thus specify a xml conceptual model, xuml, which has following characteristics comparing with the existing xml conceptual models: 1) expressing the containment semantics more explicitly; 2) supporting the concept of business components; 3) specifying the data dependencies in multiple contexts. xuml is defined based on the uml2 standard, so it will be more friendly and practical for those who have had knowledge and experience on uml. based on xuml, we further present a framework of the methodology which is dedicated to the design of xml documents and xml databases. in this paper, the focus is put on xuml.
modeling and analysis of a virtual reality system with time petri nets. the design, implementation, and testing of virtual environments is complicated by the concurrency and real-time features of these systems. therefore, the development of formal methods for modeling and analysis of virtual environments is highly desirable. in the past, petri net models have led to good empirical results in the automatic verification of concurrent and real-time systems. we applied a timed extension of petri nets to modeling and analysis of the cavetm virtual environment at the university of illinois at chicago. we report on our time petri net model and on empirical studies that we conducted with the cabernet toolset from politecnico di milano. our experiments uncovered a flaw in the way a shared buffer is used by cave processes. due to an erroneous synchronization on the buffer, different cave walls can simultaneously display images based on different input information. we conclude from our empirical studies that petri net-based tools can effectively support the development of reliable virtual environments
specification, analysis, and prototyping of mobile systems. mobile code offers new strategies for the development of systems. i adopt a formal approach to study advantages, limitations, classification, and future trends of mobile code technologies.
an analytic framework for specifying and analyzing imprecise requirements. there are at least three challenges with requirements analysis. first, it needs to bridge informal requirements, which are often vague and imprecise, to formal specification methods. second, requirements often conflict with each other. third, existing formal requirement specification methodologies are limited in supporting trade-off analysis between conflicting requirements and identifying the impact of a requirement change to the rest of the system. in this paper, an analytic framework is developed for the specification and analysis of imprecise requirements. in this framework, the elasticity of imprecise requirements is captured using fuzzy logic and the relationships between requirements are formally classified into four categories: conflicting, cooperative, mutually exclusive and irrelevant. this formal foundation facilitates the inference of relationships between requirements for detecting implicit conflicts, to assess the relative priorities of requirements for resolving conflicts, and to assess the effect of a requirement change.
ltrules: an automated software library usage rule extraction tool. the need to manually specify temporal properties of software systems is a major barrier to wider adoption of software model checking, because the specification of software temporal properties is a difficult, time-consuming, and error-prone process. to address this problem, we propose to automatically extract software library usage rules, which are one type of temporal specifications. our approach uses a model checker to check a set of software library usage rule candidates against known good programs using that library, and identifies valid rules based on model checking results. these valid rules can help programmers learn about common software library usage. they can also be used to check new programs using the same library. we have implemented our approach in an eclipse plug-in named ltrules, which can extract software library usage rules from c programs using blast as the underlying model checker.
using a command language as a high-level programming language. the command language for the programmer's workbench (pwb) utilizes an extended version of the standard unix shell program, plus commands designed mainly for use within shell procedures (command files). modifications have been aimed at improving the use of the shell by large programming groups, and making it even more convenient to use as a high-level programming language. in line with the philosophy of much existing unix software, an attempt has been made to add new features only when they are shown necessary by actual user experience in order to avoid contaminating a compact, elegant system through &ldquo;creeping featurism.&rdquo; by utilizing the shell as a programming language, pwb users have been able to eliminate a great deal of the programming drudgery that often accompanies a large project. many manual procedures have been quickly, cheaply, and conveniently automated. because it is so easy to create and use shell procedures, each separate project has tended to customize the general pwb environment into one tailored to its own requirements, organizational structure, and terminology. a summary is given of the usage patterns revealed by a survey of 1,725 existing shell procedures.
xas: a system for accessing componentized, virtual xml documents. xml is emerging as an important format for describing the schema of documents and data to facilitate integration of applications in a variety of industry domains. an important issue that naturally arises is the requirement to generate, store and access xml documents. it is important to reuse existing data management systems and repositories for this purpose. in this paper, we describe the xml access server (xas), a general purpose xml based storage and retrieval system which provides the appearance of a large set of xml documents while retaining the data in underlying federated data sources that could be relational, object-oriented, or semi-structured. xas automatically maps the underlying data into virtual xml components when mappings between dtds and underlying schemas are established. the components can be presented as xml documents or assembled into larger components. xas manages the relationship between xml components and the mapping in the form of document composition logic. the versatility in its ways to generate xml documents enables xas to serve a large number of xml components and documents efficiently and expediently.
documentation tools and techniques. in a software development project of any appreciable size, the production of usable, accurate documentation may well consume more effort than the production of the software itself. several years of experience on many programmer's workbench projects have shown that document preparation should not be separated from software development and that the combination of a flexible operating system, a powerful command language, and good text processing facilities permits quick and convenient production of many kinds of documentation which might be otherwise unobtainable, impractical, or very expensive. our basic approach has been to develop techniques for effective combination of existing unix facilities. a number of case histories are given to illustrate the flexibility, convenience, and general usefulness of these techniques.
empirical studies on requirement management measures. the goal of this research is to demonstrate that a subsetof a set of 38 requirements management measures are goodpredictors of stability and volatility of requirements andchange requests. at the time of writing we have theoreticallyvalidated ten of these 38 measures. we are currentlyplanning and performing an industrial case study where wewant to reach the goal described above.
modeling mutation on a vector processor. mutation analysis is a software testing methodology designed to substantiate the correctness of a program &phgr;. the mutation approach is to induce syntactically correct changes in &phgr;, thereby creating a set of mutant programs. the goal of a tester is to construct a set of test data t that distinguishes the output of &phgr;(t) from that of all mutant programs. test data sensitive enough to distinguish al1 mutant programs is deemed adequate to infer the probable correctness of &phgr;. we propose an algorithm designed to exploit the architecture of a vector processor like the cyber 205 or cray x/mp. the algorithm manages the simultaneous execution of multiple mutant fortran 77 programs. this is accomplished by viewing the execution of these mutants as a sequence of vector instructions. the algorithm promises potential to greatly increase the performance of a mutation based testing system, as well as points towards a general method of simultaneous program execution against multiple data sets.
comparison of software product line architecture design methods: copa, fast, form, kobra and qada. product line architectures (plas) have been undercontinuous attention in the software research communityduring the past few years. although several methods havebeen established to create plas there are not availablestudies comparing pla methods. five methods are knownto answer the needs of software product lines: copa,fast, form, kobra and qada. in this paper, anevaluation framework is introduced for comparing pladesign methods. the framework considers the methodsfrom the points of view of method context, user, structureand validation. comparison revealed distinguishableideologies between the methods. therefore, methods donot overlap even though they all are pla design methods.all the methods have been validated on various domains.the most common domains are telecommunicationinfrastructure and information domains. some of themethods apply software standards; at least omgýs mdafor method structures, uml for language and ieee std-1471-2000 for viewpoint definitions.
task interaction graphs for concurrency analysis. a representation for concurrent programs, called `task interaction graphs'', is presented. task interaction graphs divide a program into maximal sequential regions connected by edges representing task inter- actions. this representation is illustrated and it is shown how it can be used to create concurrency graph representations that are much smaller than those created from control flow graph representations. both task interaction graphs and their corresponding concurrency graphs facilitate analysis of concurrent programs. some analyses and optimizations on these representations are also described.
improving design and source code modularity using aspectj (tutorial session). using only traditional techniques the implementation of concerns like exception handling, multi-object protocols, synchronization constraints, and security policies tends to be spread out in the code. the lack of modularity for these concerns makes them more difficult to develop and maintain. this tutorial shows how to use aspect-oriented programming (aop) [2, 3] to implement concerns like these in a concise modular way. we discuss the effect aspects have on software design and on code modularity. the concrete examples in the tutorial use aspectj [1], a freely available aspect-oriented extension to the java&trade; programming language.