7,582 research outputs found
A Generic Module System forWeb Rule Languages: Divide and Rule
An essential feature in practically usable programming languages is
the ability to encapsulate functionality in reusable modules. Modules make large
scale projects tractable by humans. For Web and Semantic Web programming,
many rule-based languages, e.g. XSLT, CSS, Xcerpt, SWRL, SPARQL, and RIF
Core, have evolved or are currently evolving. Rules are easy to comprehend
and specify, even for non-technical users, e.g. business managers, hence easing
the contributions to the Web. Unfortunately, those contributions are arguably
doomed to exist in isolation as most rule languages are conceived without modularity,
hence without an easy mechanism for integration and reuse. In this paper
a generic module system applicable to many rule languages is presented. We
demonstrate and apply our generic module system to a Datalog-like rule language,
close in spirit to RIF Core. The language is gently introduced along the
EU-Rent use case. Using the Reuseware Composition Framework, the module
system for a concrete language can be achieved almost for free, if it adheres to
the formal notions introduced in this paper
Designing Software Architectures As a Composition of Specializations of Knowledge Domains
This paper summarizes our experimental research and software development activities in designing robust, adaptable and reusable software architectures. Several years ago, based on our previous experiences in object-oriented software development, we made the following assumption: âA software architecture should be a composition of specializations of knowledge domainsâ. To verify this assumption we carried out three pilot projects. In addition to the application of some popular domain analysis techniques such as use cases, we identified the invariant compositional structures of the software architectures and the related knowledge domains. Knowledge domains define the boundaries of the adaptability and reusability capabilities of software systems. Next, knowledge domains were mapped to object-oriented concepts. We experienced that some aspects of knowledge could not be directly modeled in terms of object-oriented concepts. In this paper we describe our approach, the pilot projects, the experienced problems and the adopted solutions for realizing the software architectures. We conclude the paper with the lessons that we learned from this experience
Model checking usage policies
We study usage automata, a formal model for specifying policies on the usage of resources. Usage automata extend finite state automata with some additional features, parameters and guards, that improve their expressivity. We show that usage automata are expressive enough to model policies of real-world applications. We discuss their expressive power, and we prove that the problem of telling whether a computation complies with a usage policy is decidable. The main contribution of this paper is a model checking technique for usage automata. The model is that of usages, i.e. basic processes that describe the possible patterns of resource access and creation. In spite of the model having infinite states, because of recursion and resource creation, we devise a polynomial-time model checking technique for deciding when a usage complies with a usage policy
- âŚ