waashk/dblp huggingface dataset:
using operational distributions to judge testing progress. although most software test data adequacy criteria proposed as a way to assess the progress of testing rely on the coverage of the code, the coverage of the specification, or the percentage of the input domain that has been exercised, none of these are really good indicators of how thoroughly the software has been tested. instead we propose that the assessment be based on the percentage of the probability mass associated with the test suite. this requires that data be collected to determine how the software is used in practice over a period of time, so that this can be properly assessed. in that way a project is able to accurately determine how testing is progressing.
neutralizing windows-based malicious mobile code. mobile code---executable programs that get copied from computer-to-computer via e-mail, web browsers, etc.---is a popular way to stage malicious attacks against users. the windows operating system is often the target of such attacks, in part because of its ubiquity and in part because of the vast functionality it provides. some of this functionality, like executable e-mail attachments and scripting, provides opportunity for mobile code to cause significant damage to a host system. one obvious solution is to disable such features in windows. however, many users find such features a convenient and productive way to conduct their business. thus, techniques that can protect against mobile code without sacrificing functionality are needed.but even disabling functionality such as scripting will not provide complete security; it only catches the most sophomoric exploits. all operating systems, including windows, are vulnerable to malicious use at their lowest level of operation: executing compiled code. mobile programs, just like local programs, can access operating system components in ways that damage a users' data or render their computer useless. these programs can be written in system-level languages such as c and assembly, which are capable of compiling os components directly into their binaries and writing directly to interrupt vectors. disabling such functionality will mean an operating system that simply doesn't work.this paper investigates techniques to protect windows-based systems from malicious mobile code while minimizing functionality loss. our solution involves writing a layer of protective code that is able to detect mobile code running on a system and then monitors its behavior. behaviors deemed benign are allowed to execute; behaviors deemed malicious are either shutdown, quarantined or logged (so that restoration procedures can be constructed). we describe new techniques for identifying. monitoring and neutralizing malicious mobile code. we demonstrate the techniques by testing our "vaccine" against a number of the most notorious windows viruses and worms. further, we demonstrate how our solution maintains functionality while minimizing false positives during execution of benign programs.
value-oriented design of service coordination processes: correctness and trust. the rapid growth of service coordination languages creates a need for methodological support for coordination design. coordination design differs from workflow design because a coordination process connects different businesses that can each make design decisions independently from the others, and no business is interested in supporting the business processes of others. in multi-business cooperative design, design decisions are only supported by all businesses if they contribute to the profitability of each participating business. so in order to make coordination design decisions supported by all participating businesses, requirements for a coordination process should be derived from the business model that makes the coordination profitable for each participating business. we claim that this business model is essentially a model of intended value exchanges. we model the intended value exchanges of a business model as e3 -value value models and coordination processes as uml activity diagrams. the contribution of the paper is then to propose and discuss a criterion according to which a service coordination process must be correct with respect to a value exchange model. this correctness is necessary to gain business support for the process. finally, we discuss methodological consequences of this approach for service coordination process design.
the "look and feel" of an ebook: considerations in interface design. this paper asks, "how should an electronic textbook look and feel?" the results of the visual book and the web book experiments, both of which address this question, are discussed, and the eboni (electronic book on-screen interface) project's evaluations involving students and lecturers in uk higher education are outlined. it is proposed that, in terms of the on-screen appearance of information, certain aspects of the paper book metaphor should be retained and that text should be made more "scannable" to suit the electronic medium. in terms of the look and feel of the physical object, issues such as display technology, size, weight and ergonomics should be taken into account. these considerations will form the basis of eboni's best practice guidelines for designing electronic textbooks.
evaluating the usability of portable electronic books. this paper outlines the methodology and results of the eboni project's evaluation of portable electronic books, in which staff from uk academia were provided with a selection of book readers and asked to report back on their experiences. a set of issues of importance to users of electronic books is uncovered, and compared with concerns arising from other experiments in the same field. finally, recommendations for successful ebook design are made.
a study into the usability of e-encyclopaedias. this paper describes a usability study performed on three different e-encyclopaedias, all of which were available on the web, contained similar content and targeted similar audiences, but differed in their styles of presentation. the purpose of the study was to discover the effectiveness of each design in terms of overall usability and subjective satisfaction, to extract general guidelines for the successful design of e-encyclopaedias, and to examine the requirements of different user groups.
information requirements engineering for data warehouse systems. information requirements analysis for data warehouse systems differs significantly from requirements analysis for conventional information systems. based on interviews with project managers and information systems managers, requirements for a methodological support of information requirements analysis for data warehouse systems are derived. existing approaches are reviewed with regard to these requirements. using the method engineering approach, a comprehensive methodology that supports the entire process of determining information requirements of data warehouse users, matching information requirements with actual information supply, evaluating and homogenizing resulting information requirements, establishing priorities for unsatisfied information requirements, and formally specifying the results as a basis for subsequent phases of the data warehouse development (sub)project has been proposed. the most important sources for methodology components were four in-depth case studies of information requirements analysis practices observed in data warehousing development projects of large organizations. in this paper, these case studies are presented and the resulting consolidated methodology is summarized. while an application of the proposed methodology in its entirety is still outstanding, its components have been successfully applied in actual data warehouse development projects.
reference modeling and method construction: a design science perspective. due to its importance for the development and the implementation of standard software applications in organizations, reference modeling has gained intensive coverage by is researchers as well as by practitioners. method engineering is covered less, in particular by is practice. there is evidence that the basic construction and application principles for reference models and methods are similar. the goal of this paper is to analyze reuse potentials. as a conceptual basis, the state-of-the-art of reference modeling and reference model application as well as the state-of-the-art of method engineering and method application are presented. reuse potentials are systematically analyzed, and future research directions in this area are outlined.
a framework for geometric constraint satisfaction problem. this article presents a metalanguage called gcml which allows the description of geometric constraint problems. in the spirit of algebraic specifications, it constitutes a framework to accompany a geometric problem from its expression to its solution. its originality is to provide a problem with its framework called geometric universe, a tuple (syntax, semantic) which allows to get rid of ambiguities and limitations concerning description which is then freed from any software restriction. moreover, distinction between syntax and semantic allows pre and post treatments in order to generate tools while adopting different semantic points of view in the following fields: modeling, visualization, resolution and documentation. pragmatically, this metalanguage is based upon xml which is a language of terminology description, and allows to embed other terminologies to express different semantics.
jelly view: a technology for arbitrarily advanced queries within rdbms. data processing capabilities of relational database management systems are limited. in particular, the following two categories of problems are hard to solve: traversal of structurally complex data structures (such as graphs, trees, terms, lists etc.) and search for admissible solutions under specified constraints (finding specific subsets of a given set, generation of structural solutions satisfying specific constraints etc.) this paper covers a part of the jelly view technology, which provides a new, practical methodology for knowledge decomposition, storage, and retrieval within rdbms. it also briefly presents a prototype system implementing the jelly view technology called redares. the technology tackles the above problems by introducing rule-based processing (intensional knowledge processing) to the database systems. to express intensional knowledge the prolog language syntax is used in the form of clauses. the clauses of prolog code are decomposed and stored in the rdbms founding reusable components of logic program. the database becomes a complete source of knowledge, both extensional and intensional. furthermore, to process intensional knowledge, an inference engine is coupled with the rdbms. the results of the inference process are visible as regular views, accessible through sql. the state of the view is generated dynamically, on-demand by the inference engine. from the end-user point of view the processing capability becomes unlimited (arbitrarily complex queries can be constructed), while the most external queries are expressed with standard sql. the relational database is extended with intensional knowledge, and coupled with an inference engine, which provides functionality analogous to that of the deductive databases.
good/fast/cheap: contexts, relationships and professional responsibility during software development. engineering requires tradeoffs [23]. when engineering computer applications, software engineers should consider the costs and benefits to humans as an integral part of the software development process. in this paper we focus on reliability, a central aspect of software quality, and the influence of relationships and various software development contexts on the software developer.
classification of ad hoc multi-lateral collaborations based on local workflow models. establishing multi-lateral collaborations based on local workflows without having a global workflow is complicated, because the set of requirements used for the searching and matchmaking of trading partners is underspecified. the issue is to consider inter-dependencies of trading partners within a local workflow on the one hand side and between services on the other hand side. within this paper, we suggest to develop an abstract model for establishing multi-lateral collaborations and propose a classification schema based on this model. the classification later on can be used to focus on particular aspects of the problem space and to develop solutions for different clusters within the problem domain.
facial emotion recognition by adaptive processing of tree structures. we present an emotion recognition system based on a probabilistic approach to adaptive processing of facial emotion tree structures (fets). fets are made up of localized gabor features related to the facial components according to the facial action coding system. the proposed model is an extension of the probabilistic based recursive neural network model applying in face recognition by cho and wong [1]. the robustness of the model in an emotion recognition system is evaluated by testing with known and unknown subjects with different emotions. the experiment results shows that the proposed model significantly improved the recognition rate in terms of generalization.
efficient management of xml contents over wireless environment by xstream. in this paper we investigated the issues pertaining to streaming generalized xml documents over the wireless environment. we highlight the disadvantages of employing existing approach to fragment and manage the transfer of xml contents across a wireless environment. in particular, existing approach of fragmenting data takes no consideration of the structure and semantics of the xml data. also, using the connection-oriented transport protocol, such as tcp, will result in lower throughput due to the head-of-line blocking and inefficient error control mechanisms operating in an error-prone environment. we proposed xstream to focus on the flexible management of xml data operating over the wireless environment. xstream leverages the structural characteristics of xml documents to fragment xml contents into autonomous units called xstream data unit (xdu). also, it incrementally sends fragments over a wireless link and performs look-ahead processing of the document. this facilitates the efficient use of scarce bandwidth. in this paper we describe the xstream framework and the techniques involved. a complete deployment and setup of xstream is discussed and the empirical performances are evaluated to verify the benefits of streaming xml documents using xstream.
source code-based software risk assessing. the more complex a software system is, the more likely it is that programmers will make mistakes that introduce faults which can lead to execution failures. a risk in a software system can be viewed as a potential problem, and a problem is a risk that has manifested. in order to reduce the risk of software operations, code which has the potential to cause problems has to be identified so that necessary actions (e.g., performing a more thorough testing on such code) can be taken to prevent any such problems from occurring. consequently, this can help programmers detect faults in the software before it is deployed and reduce the overall maintenance code. in this paper, we propose a static and a dynamic risk model using metrics collected based on the source code; more specifically, metrics which are either related to the static structure of the source code or the dynamic test coverage of the code. the computation of the risk of code is automated at different granularity levels ranging from basic blocks to functions. an experiment to demonstrate the feasibility of using our method is reported. high risk code, so identified by our method, can be integrated with information collected from other software quality assurance practices to further ensure the safe operation of software applications.
applying statistical methodology to optimize and simplify software metric models with missing data. during the construction of a software metric model, the decision on whether a particular predictor metric should be included is most likely based on an intuitive or experience based assumption that the predictor metric has an impact on the target metric with a statistical significance. however, a model constructed based on such an assumption may contain redundant predictor metric(s) and/or unnecessary predictor metric complexity. this is because the assumption made before the model construction is not verified after the model is constructed. to resolve the first problem (i.e., possible redundant predictor metric(s)), we propose a statistical hypothesis testing methodology to verify "retrospectively" the statistical significance of the impact of each predictor metric on the target metric. if the variation of a predictor metric does not correlate enough with the variation of the target metric, the predictor metric should be deleted from the model. for the second problem (i.e., unnecessary predictor metric complexity), we use "goodness-of-fit" to determine whether certain categories of a categorical predictor metric should be combined together. in addition, missing data often appear in the data sample used for constructing the model. we use a modified k-nearest neighbors (k-nn) imputation method to deal with this problem. a study using data from the "repository data disk - release 6" is reported. the results indicate that our methodology can be useful in trimming redundant predictor metrics and identifying unnecessary categories initially assumed for a categorical predictor metric in the model.
separation of concerns in compiler development using aspect-orientation. a major difficulty in compiler development regards the proper modularization of concerns among the various compiler phases. the traditional object-oriented development paradigm has difficulty in providing an optimal solution towards modularizing the analysis phases of compiler development, because implementation of each phase often crosscuts the class hierarchy defined by language syntax constructs. object-oriented design patterns, such as the visitor pattern, also cannot solve the crosscutting problem adequately because an object is not a natural representation of a collection of operations. this paper demonstrates the benefits of applying aspect-oriented programming languages (e.g., aspectj) and principles to compiler design and implementation. the experience result shows that the various language constructs in aspectj (e.g., inter-type declaration, pointcut-advice model, static aspect members and aspect inheritance) fit well with the various computation needs of compiler development, which results in a compiler implementation with improved modularity and better separation of concerns. the ideas utilized in this paper can also be generalized to other software systems with a tree-like structure.
vcr indexing for fast event matching for highly-overlapping range predicates. fast matching of events against a large number of range predicates is important for many applications. we present a novel vcr indexing scheme for highly-overlapping 2d range predicates. vcr stands for virtual construct rectangle. each predicate is decomposed into one or more vcrs, which are then considered to be activated. the predicate id is then stored in the id lists associated with these activated vcrs. event matching is conceptually simple. for each event point, the search result is stored in the id lists associated with the activated vcrs that cover the event point. however, it is computationally nontrivial to identify the activated covering vcrs. we define a covering vcr set for each event point and present an algorithm for fast event matching. simulations are conducted to study the performance of vcr indexing.
towards value disclosure analysis in modeling general databases. the issue of confidentiality and privacy in general databases has become increasingly prominent in recent years. a key element in preserving privacy and confidentiality of sensitive data is the ability to evaluate the extent of all potential disclosure for such data. this is one major challenge for all existing perturbation or transformation based approaches as they conduct disclosure analysis on the perturbed or transformed data, which is too large, considering many organizational databases typically contain a huge amount of data with a large number of categorical and numerical attributes. instead of conducting disclosure analysis on perturbed or transformed data, our approach is to build an approximate statistical model first and analyze various potential disclosure in terms of parameters of the model built. as the model learned is the only means to generate data for release, all confidential information which snoopers can derive is contained in those parameters.
weaving a debugging aspect into domain-specific language grammars. a common trend in programming language specification is to generate various tools (e.g., compiler, editor, profiler, and debugger) from a grammar. in such a generative approach, it is desirable to have the definition of a programming language be modularized according to specific concerns specified in the grammar. however, it is often the case that the corresponding properties of the generated tools are scattered and tangled across the language specification. in this paper, separation of concerns within a programming language specification is demonstrated by considering debugging support within a domain-specific language (dsl). the paper first describes the use of aspectj to weave the debugging semantics into the code created by a parser generator. the paper outlines several situations when the use of aspectj is infeasible at separating language specification properties. to accommodate such situations, a second approach is presented that weaves the debugging support directly into a grammar specification using a program transformation engine. a case study for a simple dsl is presented to highlight the benefits of weaving across language specifications defined by grammars.
efficient initialization and crash recovery for log-based file systems over flash memory. while flash memory has been widely adopted for storage systems for various embedded systems, issues on performance and reliability have started receiving growing attention in recent years. how to provide efficient roll back and quick mounting for flash-memory file systems has become important research topics in recent years, in addition to the work on effective garbage collection and superb run-time performance. such an observation motivates our work on the investigation of efficient initialization and crash recovery of flash-memory file systems based on log structures. a methodology is proposed for the acceleration of mounting and crash recovery for log-based file systems. a system prototype based on a well-known flash-memory file system yaffs was implemented with performance evaluation. the experimental results show that the proposed methodology can reduce the mounting time significantly, regardless of whether the file system is properly unmounted.