The interactive effects of alcohol and temazepam on P300 and reaction time

The present research investigated the separate and interactive effects of the minor tranquilliser, temazepam, and a low dose of alcohol on the amplitude and latency of P300 and on reaction time. Twenty-four participants completed four drug treatments in a repeated measures design. The four drug treatments, organised as a fully repeated 2 x 2 design, included a placebo condition, an alcohol only condition, a temazepam only condition, and an alcohol and temazepam combined condition. Event-related potentials were recorded from midline sites Fz, Cz, and Pz within an oddball paradigm. The results indicated that temazepam, with or without the presence of alcohol, reduced P300 amplitude. Alcohol, on the other hand, with or without the presence of temazepam, affected processing speed and stimulus evaluation as indexed by reaction time and P300 latency. At the low dose levels used in this experiment alcohol and temazepam appear not to interact, which suggests that they affect different aspects of processing in the central nervous system. (C) 2003 Elsevier Inc. All rights reserved.

Interactive effects of MC1R and OCA2 on melanoma risk phenotypes

The relationships between MC1R gene variants and red hair, skin reflectance, degree of freckling and nevus count were investigated in 2331 adolescent twins, their sibs and parents in 645 twin families. Penetrance of each MC1R variant allele was consistent with an allelic model where effects were multiplicative for red hair but additive for skin reflectance. Of nine MC1R variant alleles assayed, four common alleles were strongly associated with red hair and fair skin (Asp84Glu, Arg151Cys, Arg160Trp and Asp294His), with a further three alleles having low penetrance (Val60Leu, Val92Met and Arg163Gln). These variants were separately combined for the purposes of this analysis and designated as strong 'R' (OR=63.3; 95% CI 31.9-139.6) and weak 'r ' (OR=5.1; 95% CI 2.5-11.3) red hair alleles. Red-haired individuals are predominantly seen in the R/R and R/r groups with 67.1 and 10.8%, respectively. To assess the interaction of the brown eye color gene OCA2 on the phenotypic effects of variant MC1R alleles we included eye color as a covariate, and also genotyped two OCA2 SNPs (Arg305Trp and Arg419Gln), which were confirmed as modifying eye color. MC1R genotype effects on constitutive skin color, freckling and mole count were modified by eye color, but not genotype for these two OCA2 SNPs. This is probably due to the association of these OCA2 SNPs with brown/green not blue eye color. Amongst individuals with a R/R genotype (but not R/r), those who also had brown eyes had a mole count twice that of those with blue eyes. This suggests that other OCA2 polymorphisms influence mole count and remain to be described.

Tool support for executable documentation of Java class hierarchies

While object-oriented programming offers great solutions for today's software developers, this success has created difficult problems in class documentation and testing. In Java, two tools provide assistance: Javadoc allows class interface documentation to be embedded as code comments and JUnit supports unit testing by providing assert constructs and a test framework. This paper describes JUnitDoc, an integration of Javadoc and JUnit, which provides better support for class documentation and testing. With JUnitDoc, test cases are embedded in Javadoc comments and used as both examples for documentation and test cases for quality assurance. JUnitDoc extracts the test cases for use in HTML files serving as class documentation and in JUnit drivers for class testing. To address the difficult problem of testing inheritance hierarchies, JUnitDoc provides a novel solution in the form of a parallel test hierarchy. A small controlled experiment compares the readability of JUnitDoc documentation to formal documentation written in Object-Z. Copyright (c) 2005 John Wiley & Sons, Ltd.

Incremental learning for interactive e-mail filtering

In this article, we propose a framework, namely, Prediction-Learning-Distillation (PLD) for interactive document classification and distilling misclassified documents. Whenever a user points out misclassified documents, the PLD learns from the mistakes and identifies the same mistakes from all other classified documents. The PLD then enforces this learning for future classifications. If the classifier fails to accept relevant documents or reject irrelevant documents on certain categories, then PLD will assign those documents as new positive/negative training instances. The classifier can then strengthen its weakness by learning from these new training instances. Our experiments’ results have demonstrated that the proposed algorithm can learn from user-identified misclassified documents, and then distil the rest successfully.

Interactive email filtering: Learning from misclassified examples

Learning from mistakes has proven to be an effective way of learning in the interactive document classifications. In this paper we propose an approach to effectively learning from mistakes in the email filtering process. Our system has employed both SVM and Winnow machine learning algorithms to learn from misclassified email documents and refine the email filtering process accordingly. Our experiments have shown that the training of an email filter becomes much effective and faster

Mutation-based exploration of a method for verifying concurrent Java components

Summary form only given. The Java programming language supports concurrency. Concurrent programs are harder to verify than their sequential counterparts due to their inherent nondeterminism and a number of specific concurrency problems such as interference and deadlock. In previous work, we proposed a method for verifying concurrent Java components based on a mix of code inspection, static analysis tools, and the ConAn testing tool. The method was derived from an analysis of concurrency failures in Java components, but was not applied in practice. In this paper, we explore the method by applying it to an implementation of the well-known readers-writers problem and a number of mutants of that implementation. We only apply it to a single, well-known example, and so we do not attempt to draw any general conclusions about the applicability or effectiveness of the method. However, the exploration does point out several strengths and weaknesses in the method, which enable us to fine-tune the method before we carry out a more formal evaluation on other, more realistic components.

Testing java interrupts and timed waits

Testing concurrent software is difficult due to problems with inherent nondeterminism. In previous work, we have presented a method and tool support for the testing of concurrent Java components. In this paper, we extend that work by presenting and discussing techniques for testing Java thread interrupts and timed waits. Testing thread interrupts is important because every Java component that calls wait must have code dealing with these interrupts. For a component that uses interrupts and timed waits to provide its basic functionality, the ability to test these features is clearly even more important. We discuss the application of the techniques and tool support to one such component, which is a nontrivial implementation of the readers-writers problem.

UML approach to the generation of test sequences for Java-based concurrent systems

Starting with a UML specification that captures the underlying functionality of some given Java-based concurrent system, we describe a systematic way to construct, from this specification, test sequences for validating an implementation of the system. The approach is to first extend the specification to create UML state machines that directly address those aspects of the system we wish to test. To be specific, the extended UML state machines can capture state information about the number of waiting threads or the number of threads blocked on a given object. Using the SAL model checker we can generate from the extended UML state machines sequences that cover all the various possibilities of events and states. These sequences can then be directly transformed into test sequences suitable for input into a testing tool such as ConAn. As an illustration, the methodology is applied to generate sequences for testing a Java implementation of the producer-consumer system. © 2005 IEEE

Dealing with non-determinism in testing concurrent java components

The testing of concurrent software components can be difficult due to the inherent non-determinism present in these components. For example, if the same test case is run multiple times, it may produce different results. This non-determinism may lead to problems with determining expected outputs. In this paper, we present and discuss several possible solutions to this problem in the context of testing concurrent Java components using the ConAn testing tool. We then present a recent extension to the tool that provides a general solution to this problem that is sufficient to deal with the level of non-determinism that we have encountered in testing over 20 components with ConAn. © 2005 IEEE