waashk/dblp huggingface dataset:
a method to construct knowledge table-base in k-in-a-row games. in any k-in-a-row game, the player should always analyze each consecutive sequence in 4 directions, which consists of either the void intersections or the intersections occupied by the same color stones. although the difficult problem in k-in-a-row game is that any void intersection on board can be placed a stone on, just like go, however, the hints in k-in-a-row are far more than those in go. we find it is a good method to decrease the complexity of the k-in-a-row games by using connection to represent the states of the game position. then, a precise classification criterion for connection, as well as a precise classification for the intersections is given. as the high-level knowledge of games seems hard to be acquired, the program designers always resort to human masters. however, we can construct a good knowledge table-base based on above idea without masters.
lts semantics for use case models. formalization is a necessary precondition for the specification of precise and unambiguous use case models, which serve as reference points for the design and implementation of software systems. in this paper, we define a formal semantics for use case models. we build on an abstract syntax definition formalizing the sequencing of use case steps. as a semantic domain we have chosen labeled transition systems (ltss), which, we believe, intuitively capture the behavioral aspects of the use case model. the mapping into ltss is defined over the various structural elements of the use case model. the proposed formal semantics allows for various semantic checks such as detection of livelocks and validation of model refinement, an important property in an iterative software development lifecycle. we also introduce our tool "use case model analyzer".
optimal service level allocation in environmentally powered embedded systems. energy management is a critical concern in the design of embedded systems to prolong the lifetime or to maximize the performance under energy constraints. in particular, the emerging embedded systems with renewable energy sources rise new problems and trigger the revision of conventional energy management. if, e.g., the size of a solar cell limits the available power/energy of an electronic device, decisions like when to provide which service have to be made in order to satisfy the needs of the user as well as possible. in this paper, we explore how to maximize the system reward of diverse applications for an energy harvesting system. by utilizing the notion of rewards to express the different priorities of services, we answer the fundamental question of how to optimize the use of energy provided by a scarce and time-varying environmental source. for this purpose, we provide algorithms to optimally adjust service parameters dynamically. our work is supported by simulation results which are based on long-term measurements of the power generated by real solar cells. furthermore, we demonstrate how to dimension the embedded system, e.g., the battery capacity and elaborate on implementation details which are of practical importance.
privacy protection for rfid data. radio frequency identification (rfid) is a technology of automatic object identification. retailers and manufacturers have created compelling business cases for deploying rfid in their supply chains. yet, the uniquely identifiable objects pose a privacy threat to individuals. in this paper, we study the privacy threats caused by publishing rfid data. even if the explicit identifying information, such as name and social security number, has been removed from the published rfid data, an adversary may identify a target victim's record or infer her sensitive value by matching a priori known visited locations and timestamps. rfid data by default is high-dimensional and sparse, so applying traditional k-anonymity to rfid data suffers from the curse of high dimensionality, and would result in poor data usefulness. we define a new privacy model, develop an anonymization algorithm to accommodate special challenges on rfid data, and evaluate its performance in terms of data quality, efficiency, and scalability. to the best of our knowledge, this is the first work on anonymizing high-dimensional rfid data.
adaptive resource management architecture for distributed real-time embedded systems. avionic distributed real-time embedded (dre) systems execute in open environments where operational conditions, input workload, and resource availability cannot be characterized accurately a prior. we present adaptive resource management architecture for these systems to achieve end-to-end qos. the architecture contains two loops and adopts bottom-up philosophy to deal with workload/resource variations. the inner loop is established based on feedback control theory, and handles mild variations; while the outer one includes subtask allocation and migration algorithms, to cope with drastic variations.
music retrieval based on a multi-samples selection strategy for support vector machine active learning. in active learning based music retrieval systems, providing multiple samples to the user for feedback is very necessary. in this paper, we present a new multi-samples selection strategy designed for support vector machine active learning. aiming to reduce the redundancy between the selected samples, the strategy enforces the selected samples to be diverse by explicitly maximizing the distance between each other in the feature space. experimental results on a music genre database demonstrated the effectiveness of the proposed strategy in selecting relevant multiple samples for human feedback on them.
heuristic approach for automated shelf space allocation. shelf space allocation is the problem of efficiently arranging retail products on shelves in order to maximise profit, improve stock control, improve customer satisfaction, etc. most work reported in the literature on this problem has focused on the case of large retailers such as big supermarkets. the interest here is to tackle this problem in the context of small retail shops where different issues arise when compared to large retailers. this paper proposes a heuristic approach to automate shelf space allocation in small retail shops. several initialisation heuristics and local search moves are incorporated into the proposed method which generates high quality practical arrangements represented graphically as simple planograms.
approximate indexing in road network databases. in this paper, we address approximate indexing for efficient processing of k-nearest neighbor(k-nn) queries in road network databases. previous methods suffer from either serious performance degradation in query processing or large storage overhead because they did not employ indexing mechanisms based on their network distances. to overcome these drawbacks, we propose a novel method that builds an index on those objects in a road network by approximating their network distances and processes k-nn queries efficiently by using that index. also, we verify the superiority of the proposed method via extensive experiments using the real-life road network databases.
component-based metrics applying the strength of dependency between classes. component-based development (cbd) is an emerging discipline for promoting practical reuse of software. in cbd, by building new software with independently developed components, we can gain the benefits promised by the software reuse such as quality improvement and rapid development. accordingly, to improve quality of components, we propose the component-based metrics applying the strength of dependency between classes to measure precisely. in addition, we prove the theoretical soundness of the proposed metrics by the axioms of briand et al. and suggest the accuracy and practicality of the proposed metrics through a comparison with the conventional metrics in component development phase.
specifying and checking protocols of multithreaded classes. in the design by contract (dbc) approach, programmers specify methods with pre and postconditions (also called contracts). earlier work added protocols to the dbc approach to describe allowed method call sequences for classes. we extend this work to deal with a variant of generic classes and multithreaded classes. we present the semantical foundations of our extension. we describe a new technique to check that method contracts are correct w.r.t. to protocols. we show how to generate programs that must be proven to show that method contracts are correct w.r.t. to protocols. because little support currently exists to help writing method contracts, our technique helps programmers to check their contracts early in the development process.
using minimum description length for process mining. in the field of process mining, the goal is to automatically extract process models from event logs. recently, many algorithms have been proposed for this task. for comparing these models, different quality measures have been proposed. most of these measures, however, have several disadvantages; they are model-dependent, assume that the model that generated the log is known, or need negative examples of event sequences. in this paper we propose a new measure, based on the minimal description length principle, to evaluate the quality of process models that does not have these disadvantages. to illustrate the properties of the new measure we conduct experiments and discuss the trade-off between model complexity and compression.
projecting code changes onto execution traces to support localization of recently introduced bugs. working collaboratively on complex software systems often leads to situations where a developer enhances or extends system functionality, thereby however, introducing bugs. at best the unintentional changes are caught immediately by regression tests. often however, the bugs are detected days or weeks later by other developers noticing strange system behavior while working on different parts of the system. then it is a highly time-consuming task to trace back this behavior change to code changes in the past. in this paper we propose a technique for identifying the recently introduced change that is responsible for the unexpected behavior. the key idea is to combine dynamic, static, and code change information on the system to reduce the possibly great amount of code modifications to those that may affect the system while running its faulty behavior. after having applied this massive automated filtering step, developers receive support in semi-automatically identifying the root cause change by means of a trace exploration frontend. within multiple synchronized views, developers explore when, how and why modified code locations are executed. the technique is implemented within a prototypical analysis tool that copes with large (> mloc) c/c++ software systems. we demonstrate the approach by means of industrial case studies.
operational control of service processes: modularization as precondition. managing business processes includes among others the normative, strategic, and operational control of processes. in case of a process performance deviation beyond a defined bandwidth, the process manager searches for short-term improvements within the operational control. however, the decision about improvements is limited because of the customer integration in the type of service processes. in this paper the modularization technique will be analyzed as a tool for eliminating the intense customer influence and for structuring the service process. for illustration purposes the loan approval process of a bank will be modularized and the modularization technique as precondition for the operational control will be discussed.
local reasoning for abstraction and sharing. the local reasoning provided by separation logic has been proven to be a good tool for the verification of programs with complex pointer manipulation. however, some problems arise when many structures share part of the heap since it becomes difficult to specify separately and it is even harder to preserve the abstractions that these structures provide. in this article, we present a generalization of separation logic which allows us to precisely specify complex abstract structures in the heap and the sharing relations among them. moreover, we provide also a compositional proof theory which can be used to verify programs in a modular way, even when a complete separation of the structures cannot be ensured.
cpref-sql: a query language supporting conditional preferences. nowadays, the need for incorporating preference querying in database technology is a very important issue in a variety of applications ranging from e-commerce to personalized search engines. a lot of recent research work has been dedicated to this topic in the artificial intelligence and database communities. several formalisms allowing preference reasoning and specification have been proposed in the ai field. on the other hand, in the database field the interest has been focused mainly in extending standard sql with preference facilities in order to provide personalized query answering. in this paper, we propose to build a bridge between these two approaches, by using a logic formalism originally designed to specify and reason with preference in order to extend sql with conditional preference constructors. such constructors allow to express a large class of preference statements with a ceteris-paribus semantics.
*-prefer: optimizing requirements elicitation process based on actor preferences. many software projects fail due to ill-defined requirements, or mismatch between system design and the preferences of involved actors in the environment. the quality and efficiency of requirements elicitation determines the ultimate quality of the system. in this paper, we propose to take the preferences of actors into consideration when making design decisions. furthermore, we use such preference information to help optimize the elicitation process. the requirements model is represented as an extension to the i* framework, called i*-prefer. major extension points are: (1) for each softgoal of an actor, a utility value is computed to depict actor's preferences; (2) a quantitative measurement is introduced to quantify the contribution of different design alternatives to each softgoal; (3) an evaluation process is used to compare the overall impact of different design strategies. a simplified seminar planning example is used to illustrate the proposed approach.
variable handling in time-based xml declarative languages. this paper focuses on time-based declarative languages. the use of declarative languages has the advantage of their simplicity and their high-level abstraction, usually requiring few or no programming skills. moreover, in general, declarative languages benefit portability and allow automatic control of application execution temporal flows, without author awareness. however, most time-based declarative languages have limited support for variable definition and manipulation, which causes developers to resort to imperative languages. this paper discusses and proposes an approach for variable handling in xml-based declarative languages used for temporal synchronization among media objects that balances flexibility and simplicity. an important goal is to resort to imperative languages only for those applications that require intensive algorithmic computation. the proposed solution was adopted by the ncl declarative language of the brazilian dtv system.
evaluating the affective tactics of an emotional pedagogical agent. this paper presents a quantitative (with students of a local middle school) and a qualitative evaluation (with teachers) of a lifelike and emotional pedagogical agent, called pat. pat has the goal of inferring students' emotions and applying affective tactics in order to adapt the learning environment. these tactics aim at motivating students and making them increase their efforts and their intrinsic motivation. pat attempts to achieve these goals by presenting emotional animated attitudes and encouragement messages that are chosen dynamically to compose its affective tactics.
refining spectrum-based fault localization rankings. spectrum-based fault localization is a statistical technique that aims at helping software developers to find faults quickly by analyzing abstractions of program traces to create a ranking of most probable faulty components (e.g., program statements). although spectrum-based fault localization has been shown to be effective, its diagnostic accuracy is inherently limited, since the semantics of components are not considered. in particular, components that exhibit identical execution patterns cannot be distinguished. to enhance its diagnostic quality, in this paper, we combine spectrum-based fault localization with a model-based debugging approach based on abstract interpretation within a framework coined deputo. the model-based approach is used to refine the ranking obtained from the spectrum-based method by filtering out those components that do not explain the observed failures when the program's semantics is considered. we show that this combined approach outperforms the individual approaches and other state-of-the-art automated debugging techniques.
a framework for dynamic adaptation of power-aware server clusters. this paper presents a framework to support dynamic adaptation of applications, which consists of a reusable infrastructure with standard elements to monitor and adapt running applications, and a contract-based adaptation language to enable one to express high-level adaptation policies. the proposed framework is used to introduce dynamic adaptation capabilities into a server cluster infrastructure, intended to address power and performance management concerns. by experimental evaluation, we demonstrate that our approach is useful and effective in providing the required support for describing and deploying typical power management contracts.
labeled images verification using gaussian mixture models. we are proposing in this paper an automated system to verify that images are correctly associated to labels. the novelty of the system is in the use of gaussian mixture models (gmms) as statistical modeling scheme as well as in several improvements introduced specifically for the verification task. our approach is evaluated using the caltech 101 database. starting from an initial baseline system providing an equal error rate of 27.4%, we show that the rate of errors can be reduced down to 13% by introducing several optimizations of the system. the advantage of the approach lies in the fact that basically any object can be generically and blindly modeled with limited supervision. a potential target application could be a post-filtering of images returned by search engines to prune out or reorder less relevant images.
collaborative modeling of business processes: a comparative case study. we study collaborative modeling of business processes with respect to the impact of tool support on the modeling process. for this purpose we compared model quality and modeling costs in two cases. the first was carried out with the help of a collaborative modeling tool; in the second case we kept all other parameters as closely as possible to the first one but conducted the modeling session in the usual way without tool support. we observed a marked increase in modeling time in the second case and a reduction in model quality.
quality of service management in gmpls-based grid obs networks. this paper proposes an architecture for the establishment of routes with absolute qos constraints for optical burst switched grid networks. this model uses traffic engineering provided by gmpls to build lsps that matches the required performance in response to a request made by the user/application of the grid. results show that the proposal is capable of enforcing qos by reducing the loss experienced by burst classes and allowing a better utilization of the computing resources.
an approach for semantic web services automatic discovery and composition with similarity metrics. with the emerging growth of web services tecnology, the web is now evolving to become a service provider. in this context, the semantic web services discovery and composition are hard tasks because injecting context into adaptive service integration raises a number of significant challenges, i.e. defining effective metrics to manage adaptation. this paper proposes an algorithm for semantic web services discovery and compositon which makes use of similarity metrics.
composing a high fidelity hla federation for littoral operations. modeling and simulation and synthetic environments have been widely popularized in the context of military applications. nonetheless, the design and development of some simulation systems still pose true conceptual and technical challenges. this is particularly compelling when the simulation requires the replication of complex systems (as airborne sensors) behavioral models with a high level of credibility. we faced this problem when developing a simulation for tactics development of air platforms. we focused on the integration of high fidelity assets, in terms of: the sensors suite modeling, operator reading and control of the sensors, the physical representation of the entities, and the surrounding terrain and natural environment (ocean, atmosphere). the resulting system combines both constructive and virtual entities, running in a hla setting with jsaf as the scenario generator, and highly sophisticated sensor models. this paper justifies the overall architecture of the simulation system, describes some of the technical integration details, and provides an insight into the resulting synthetic natural environment.
building a customizable embedded operating system with fine-grained joinpoints using the aox programming environment. aspect-oriented programming (aop) has been successful in modularizing crosscutting concerns in complex software systems. in this paper, we present our aspect-oriented approach to building a highly customizable embedded operating system. this is a challenging task since embedded operating systems consist of intertwined concerns often implemented using a mixture of multiple programming languages including an assembly language. furthermore, they often contain hand-optimized code that makes clear modularization extremely difficult. we provide a two-step approach that addresses these difficulties. first, we devised an aspect-oriented programming environment aox (aspect-oriented extension). it supports both modularization and customization of complex software via a set of aspect-oriented mechanisms. aox extends existing approaches in the sense that it is entirely programming language independent and provides finegrained joinpoints. second, using aox, we built a customizable embedded operating system we call the heart os. it is highly configurable and very user-friendly. aox has been implemented and integrated into the eclipse ide as a plug-in module. the heart os has also been implemented and ported to the xscale and x86 platforms. our experience with aox in building the heart os was very positive.
a new cross-training approach by using labeled data. we propose a new cross-training based learning algorithm in this paper. this algorithm generates three classifiers based on the three subsets of original labeled and unlabeled training set. the proposed algorithm is evaluated using data from the uci repository by the experiment. experimental results show that our algorithm can improve classification accuracy compared to those of other algorithms.