Quantifying the complexity of relative clause and cleft sentences

Explanations of the difficulty of relative-clause sentences implicate complexity but the measurement of complexity remains controversial. Four experiments investigated how far relational complexity (RC) theory, that has been found valid for cognitive development and human reasoning, accounts for the difficulty of 16 types of English, object- and subject-extracted relative-clause constructions. RC corresponds to the number of nouns assigned to thematic roles in the same decision. Complexity estimates based on RC and those based on maximal integration cost (MIC) were strongly correlated and accounted for similar variance in sentence difficulty (subjective ratings, comprehension accuracy, reading times). Consistent with RC theory, sentences that required more than 4 role assignments in the same decision were extremely difficult for many participants. Performance on nonlinguistic relational tasks predicted comprehension of object-extracted sentences, before and after controlling for subject-extractions. Working memory tasks predicted comprehension of object-extractions before controlling for subjectextractions. The studies extend the RC approach to a linguistic domain.

Reasoning algebraically about probabilistic loops

Back and von Wright have developed algebraic laws for reasoning about loops in the refinement calculus. We extend their work to reasoning about probabilistic loops in the probabilistic refinement calculus. We apply our algebraic reasoning to derive transformation rules for probabilistic action systems. In particular we focus on developing data refinement rules for probabilistic action systems. Our extension is interesting since some well known transformation rules that are applicable to standard programs are not applicable to probabilistic ones: we identify some of these important differences and we develop alternative rules where possible. In particular, our probabilistic action system data refinement rules are new.

Reasoning about timeouts

In real-time programming a timeout mechanism allows exceptional behaviour, such as a lack of response, to be handled effectively, while not overly affecting the programming for the normal case. For. example, in a pump controller if the water level has gone below the minimum level and the pump is on and hence pumping in more water, then the water level should rise above the minimum level within a specified time. If not, there is a fault in the system and it should be shut down and an alarm raised. Such a situation can be handled by normal case code that determines when the level has risen above the minimum, plus a timeout case handling the situation when the specified time to reach the minimum has passed. In this paper we introduce a timeout mechanism, give it a formal definition in terms of more basic real-time commands, develop a refinement law for introducing a timeout clause to implement a specification, and give an example of using the law to introduce a timeout. The framework used is a machine-independent real-time programming language, which makes use of a deadline command to represent timing constraints in a machine-independent fashion. This allows a more abstract approach to handling timeouts.

Reasoning about deadlines in concurrent real-time programs

We propose a method for the timing analysis of concurrent real-time programs with hard deadlines. We divide the analysis into a machine-independent and a machine-dependent task. The latter takes into account the execution times of the program on a particular machine. Therefore, our goal is to make the machine-dependent phase of the analysis as simple as possible. We succeed in the sense that the machine-dependent phase remains the same as in the analysis of sequential programs. We shift the complexity introduced by concurrency completely to the machine-independent phase.

Developing relational navigation to effectively understand software

Effective comprehension of complex software systems requires understanding of both the individual documents that represent software and the complex relationships that exist within and between documents. Relationships of all kinds play a vital role in a software engineer's comprehension of, and navigation within and between, software documents. User-determined relationships have the additional role of enabling the engineer to create and maintain relational documentation that cannot be generated by tools or derived from other relationships. We argue that for a software development environment to effectively support the understanding of complex software systems, relational navigation must be supported at both the document-focused (intra-document) and relation-focused (inter-document) levels. The need for a relation-focused approach is highlighted by an evaluation of an existing document-focused relational interface. We conclude with the requirements for a relation-focused approach to relational navigation. These requirements focus on the user's perspective when interacting with a collection of related documents. We define the requirements for a software development environment that effectively supports the understanding of the software documents and relationships that define a complex software system.

Mummy! Ball! Fish!: Why English-learning children produce nouns earlier than verbs

When English-learning children begin using words the majority of their early utterances (around 80%) are nouns. Compared to nouns, there is a paucity of verbs or non-verb relational words, such as 'up' meaning 'pick me up'. The primary explanations to account for these differences in use either argue in support of a 'cognitive account', which claims that verbs entail more cognitive complexity than nouns, or they provide evidence challenging this account. In this paper I propose an additional explanation for children's noun/verb asymmetry. Presenting a 'multi-modal account' of word-learning based on children's gesture and word combinations, I show that at the one-word stage English-learning children use gestures to express verb-like elements which leaves their words free to express noun-like elements.