Tinus Strauss

A service oriented architecture for wireless sensor and actor network applications

The emergence of Wireless Sensor and Actor Networks (WSAN) has contributed significantly to the progress of ubiquitous and pervasive computing, but has also introduced new challenges. The authors researched this technology and its applicability to real-world scenarios through the Cerberus project. This paper offers a discussion of the processes the authors went through from initial contact with the technology to implementing a system based on it, as well as the problems faced while working with WSAN. These experiences indicate the need for a dynamic, mote and application-independent management system. A service oriented architecture (SOA) for the management of WSAN, which makes use of OSGi, is proposed and evaluated. This SOA allows for the updating and changing of the application largely independent of the mote configuration as well as for easy management of different types of motes and actors.

Efficient automata constructions and approximate automata

In this paper, we present data structures and algorithms for efficiently constructing approximate automata. An approximate automaton for a regular language L is one which accepts at leastL. Such automata can be used in a variety of practical applications, including network security pattern matching, in which false-matches are only a performance nuisance. The construction algorithm is particularly efficient, and is tunable to yield more or less exact automata.

A Sequential Recursive Implementation of Dead-Zone Single Keyword Pattern Matching

Earlier publications provided an abstract specification of a family of single keyword pattern matching algorithms [18] which search unexamined portions of the text in a divide-and-conquer fashion, generating dead-zones in the text as they progress. These dead zones are area of text that require no further examination. Here the results are described of implementing in C++ a sequential recursive version of the algorithm family, where all instances of a single keyword p in a text S are sought—the online keyword matching problem where S may not be precomputed.

A CONCURRENT SPECIFICATION OF BRZOZOWSKI'S DFA CONSTRUCTION ALGORITHM

In this paper two concurrent versions of Brzozowskis deterministic finite automaton (DFA) construction algorithm are developed from first principles, the one being a slight refinement of the other. We rely on Hoares CSP as our notation. The specifications that are proposed of the Brzozowski algorithm are in terms of the concurrent composition of a number of top-level processes, each participating process itself composed of several other concurrent processes. After considering a number of alternatives, this particular overall architectural structure seemed like a natural and elegant mapping from the sequential algorithms structure. While we have carefully argued the reasons for constructing the concurrent versions as proposed in the paper, there are of course, a large range of alternative design choices that could be made. There might also be scope for a more fine-grained approach to updating sets or checking for similarity of regular expressions. At this stage, we have chosen to abstract away from these considerations, and leave their exploration for a subsequent step in our research.

Performance assessment of dead-zone single keyword pattern matching

A so-called dead-zone pattern matching family of algorithms has previously been proposed as a concept. Here the performance of several instances of the family are empirically investigated. An abstract description of the algorithm family is given, as well as of these instances. This leads to a total of five different implementations of the algorithm. The time-performance of each of these implemented variants was then compared against those of the well-known Horspool and Boyer-Moore pattern matching algorithms, the latter being representative of the best-known pattern matchers currently available. Various data sets, pattern selections and pattern lengths were used, but the same Horspool-like shift tables were used throughout by the dead-zone variants. It was found that in some contexts variants of the dead zone algorithm compare very favourably against the Horspool and Boyer-Moore algorithms.

A New CSP Operator for Optional Parallelism

We introduce a new CSP operator for modeling scenarios characterised by partial or optional parallelism. We provide examples of such scenarios and sketch the semantics of our operator. Relevant properties are proven.

Logical Traffic Isolation Using Differentiated Services

This paper proposes a scheme in which the differentiated services field of IP headers is used to logically isolate network traffic for forensic purposes. The scheme is described and two example scenarios are presented to illustrate its utility. The scheme, which is based on standard networking technology, helps achieve isolation without additional network infrastructure. Moreover, the scheme is relatively easy to implement in an existing differentiated services network. The paper also discusses key design and configuration challenges that must be addressed in a successful implementation.

Network forensics in a clean-slate Internet architecture

This paper reflects on the network forensic implication of a specific clean-slate future internetwork architecture. The paper first provides an overview of the architecture and how it compares to the well-established TCP/IP model. The architectures network forensic features are then considered. The architectures approach to naming and addressing fundamentally differs from the approach used in the current Internet. Great care is taken to distinguish between names and addresses. Names are used to identify entities and generally have a large scope. Addresses, however, are used to locate entities within a limited scope and are consequently not necessarily globally significant. These properties in particular create additional challenges when capturing and analysing network traffic as evidence. The paper shows that the architecture is well-suited for a distributed systems approach to forensics and that the network architecture increases the potential sources of reliable evidence.

Using CSP to Develop Quality Concurrent Software

A method for developing concurrent software is advocated that centres on using CSP to specify the behaviour of the system. A small example problem is used to illustrate the method. The problem is to develop a simulation system that keeps track of and reports on the least unique bid of multiple streams of randomly generated incoming bids. The problem’s required high-level behaviour is specified in CSP, refined down to the level of interacting processes and then verified for refinement and behavioural correctness using the FDR refinement checker. Heuristics are used to map the CSP processes to a GO implementation. Interpretive reflections are offered of the lessons learned as a result of the exercise.

CSP for parallelising Brzozowski's DFA construction algorithm

CSP, a simple and elegant process algebra, is used to specify five successive parallel versions of Brzozowski’s sequential algorithm for constructing deterministic finite automata from regular expressions. Early versions were not sufficiently mature to easily map to a programming language. However, each version exposed new possibilities for refinement so that later versions could subsequently be implemented (in Go). The exercise illustrates the value of the lightweight use of process algebras for supporting abstract thinking when attempting to solve computational problems in a parallel fashion. The emphasis here is on algorithm specification and not on the implementation.