31,761 research outputs found
A Survey of Languages for Specifying Dynamics: A Knowledge Engineering Perspective
A number of formal specification languages for knowledge-based systems has been developed. Characteristics for knowledge-based systems are a complex knowledge base and an inference engine which uses this knowledge to solve a given problem. Specification languages for knowledge-based systems have to cover both aspects. They have to provide the means to specify a complex and large amount of knowledge and they have to provide the means to specify the dynamic reasoning behavior of a knowledge-based system. We focus on the second aspect. For this purpose, we survey existing approaches for specifying dynamic behavior in related areas of research. In fact, we have taken approaches for the specification of information systems (Language for Conceptual Modeling and TROLL), approaches for the specification of database updates and logic programming (Transaction Logic and Dynamic Database Logic) and the generic specification framework of abstract state machine
An algebraic basis for specifying and enforcing access control in security systems
Security services in a multi-user environment are often based on access control mechanisms. Static aspects of an access control policy can be formalised using abstract algebraic models. We integrate these static aspects into a dynamic framework considering requesting access to resources as a process aiming at the prevention of access control violations when a program is executed. We use another algebraic technique, monads, as a meta-language to integrate access control operations into a functional
programming language. The integration of monads and concepts from a denotational model for process algebras provides a framework for programming of access control in security systems
Abstract State Machines 1988-1998: Commented ASM Bibliography
An annotated bibliography of papers which deal with or use Abstract State
Machines (ASMs), as of January 1998.Comment: Also maintained as a BibTeX file at http://www.eecs.umich.edu/gasm
Promoting Component Reuse by Separating Transmission Policy from Implementation
In this paper we present a methodology and set of tools which assist the
construction of applications from components, by separating the issues of
transmission policy from component definition and implementation. This promotes
a greater degree of software reuse than is possible using traditional
middleware environments. Whilst component technologies are usually presented as
a mechanism for promoting reuse, reuse is often limited due to design choices
that permeate component implementation. The programmer has no direct control
over inter-address-space parameter passing semantics: it is fixed by the
distributed application's structure, based on the remote accessibility of the
components. Using traditional middleware tools and environments, the
application designer may be forced to use an unnatural encoding of application
level semantics since application parameter passing semantics are tightly
coupled with the component deployment topology. This paper describes how
inter-address-space parameter passing semantics may be decided independently of
component implementation. Transmission policy may be dynamically defined on a
per-class, per-method or per-parameter basis.Comment: Submitted to ICDCS 200
Intelligent agent simulator in massive crowd
Crowd simulations have many benefits over real-life research such as in computer games, architecture and entertainment. One of the key elements in this study is to include elements of decision-making into the crowd. The aim of this simulator is to simulate the features of an intelligent agent to escape from crowded environments especially in one-way corridor, two-way corridor and four-way intersection. The addition of the graphical user interface enables intuitive and fast handling in all settings and features of the Intelligent Agent Simulator and allows convenient research in the field of intelligent behaviour in massive crowd. This paper describes the development of a simulator by using the Open Graphics Library (OpenGL), starting from the production of training data, the simulation process, until the simulation results. The Social Force Model (SFM) is used to generate the motion of agents and the Support Vector Machine (SVM) is used to predict the next step for intelligent agent
Towards a Rule Interchange Language for the Web
This articles discusses rule languages that are needed for a a
full deployment of the SemanticWeb. First, it motivates the need for such
languages. Then, it presents ten theses addressing (1) the rule and/or
logic languages needed on the Web, (2) data and data processing, (3)
semantics, and (4) engineering and rendering issues. Finally, it discusses
two options that might be chosen in designing a Rule Interchange Format
for the Web
Automated Verification of Design Patterns with LePUS3
Specification and [visual] modelling languages are expected to combine strong abstraction mechanisms with rigour, scalability, and parsimony. LePUS3 is a visual, object-oriented design description language axiomatized in a decidable subset of the first-order predicate logic. We demonstrate how LePUS3 is used to formally specify a structural design pattern and prove (âverifyâ) whether any JavaTM 1.4 program satisfies that specification. We also show how LePUS3 specifications (charts) are composed and how they are verified fully automatically in the Two-Tier Programming Toolkit
Encapsulation and Aggregation
A notion of object ownership is introduced as a solution to difficult problems of specifying and reasoning about complex linked structures and of modeling aggregates (composit objects). Syntax and semantics are provided for extending Eiffel with language support for object ownership annotation and checking. The ideas also apply to other OOPLs such as C++
Applying Formal Methods to Networking: Theory, Techniques and Applications
Despite its great importance, modern network infrastructure is remarkable for
the lack of rigor in its engineering. The Internet which began as a research
experiment was never designed to handle the users and applications it hosts
today. The lack of formalization of the Internet architecture meant limited
abstractions and modularity, especially for the control and management planes,
thus requiring for every new need a new protocol built from scratch. This led
to an unwieldy ossified Internet architecture resistant to any attempts at
formal verification, and an Internet culture where expediency and pragmatism
are favored over formal correctness. Fortunately, recent work in the space of
clean slate Internet design---especially, the software defined networking (SDN)
paradigm---offers the Internet community another chance to develop the right
kind of architecture and abstractions. This has also led to a great resurgence
in interest of applying formal methods to specification, verification, and
synthesis of networking protocols and applications. In this paper, we present a
self-contained tutorial of the formidable amount of work that has been done in
formal methods, and present a survey of its applications to networking.Comment: 30 pages, submitted to IEEE Communications Surveys and Tutorial
- âŠ