The role of the human posterior parietal cortex in memory-guided saccade execution: a double-pulse transcranial magnetic stimulation study

The present study investigated the role of the right posterior parietal cortex (PPC) in the triggering of memory-guided saccades by means of double-pulse transcranial magnetic stimulation (dTMS). Shortly before saccade onset, dTMS with different interstimulus intervals (ISI; 35, 50, 65 or 80 ms) was applied. For contralateral saccades, dTMS significantly decreased saccadic latency with an ISI of 80 ms and increased saccadic gain with an ISI of 65 and 80 ms. Together with the findings of a previous study during frontal eye field (FEF) stimulation the present results demonstrate similarities and differences between both regions in the execution of memory-guided saccades. Firstly, dTMS facilitates saccade triggering in both regions, but the timing is different. Secondly, dTMS over the PPC provokes a hypermetria of contralateral memory-guided saccades that was not observed during FEF stimulation. The results are discussed within the context of recent neurophysiological findings in monkeys.

Test Blueprints - Exposing Side Effects in Execution Traces to Support Writing Unit Tests

Writing unit tests for legacy systems is a key maintenance task. When writing tests for object-oriented programs, objects need to be set up and the expected effects of executing the unit under test need to be verified. If developers lack internal knowledge of a system, the task of writing tests is non-trivial. To address this problem, we propose an approach that exposes side effects detected in example runs of the system and uses these side effects to guide the developer when writing tests. We introduce a visualization called Test Blueprint, through which we identify what the required fixture is and what assertions are needed to verify the correct behavior of a unit under test. The dynamic analysis technique that underlies our approach is based on both tracing method executions and on tracking the flow of objects at runtime. To demonstrate the usefulness of our approach we present results from two case studies.

Gute Arbeit gibt herrlichen Lohn, in einer Predigt über das Evangelium am Sonntage Septuagesimae, Math. XX. 1. - 16. in der Kirche St. Leonhard in Stutgard, 1738 : mit einer eingeflossenen Anweisung, wie die vorsehende Execution des verurtheilten Juden, Joseph Süß Oppenheimers, christlich anzusehen und zu gebrauchen seye, ...

von Georg Cunrad Rieger

Execution der An̄a Maria Karpffin : ihres Alters 28 Jahr, v. Unterdencken gebürtig, welche Zu Dahlhoffen ein Kind jämerl. ermordet und noch ein anders WochenKind gestohlen ...

Thomas Bäck sc. exc.

Vorstellung der scharpffen Execution, wie selbige an 6 Malefitz Personen in der Fürstlichen Statt Wohlau, den 27. April, vnd II July deß 1661. Jahrs, vollzogen worden : Von ihrem abscheulichen Verbrechen, meldet der Text weitläufftig

Original: Text fehlt. Risse u. kleinere Fehlstellen im Kupferstich

Keyserliche Execution vber die Aechter vnd Malefitz Personen in Franckfuhrt am Mayn ergangenn : 1616

Simon Severin Aegemann fecit Anno 1616[?]

Vorstellung der Execution, welche an den beyden Wallachischen Rebellen, Horia und Klotska, zu Karlsburg vollzogen worden

I. D. D. [d.i. wahrscheinl. Johann David Donnhäuser]

Warhaffte Contrafactur und Abbildung, deren ehmals Vornehm-Berühmten drey Ungarischen Grafen : nachmals aber an Ihrer Römischen Kayserl. Mayst. höchst-vergriffenen Rebellen, Nadasti, Serini und Frangipani, mit beygefügter ausführlicher Beschreibung, was massen selbige, dem billich-ergangenem Urtheil gemäß zur Execution gezogen, und den 30. April dieses 1671. Jahrs vom Leben zum Tod gebracht worden

Portr.-Medaillons d. Rebellen u. d. Hinrichtungsszenen

Parallel execution of Prolog programs: a survey

Since the early days of logic programming, researchers in the field realized the potential for exploitation of parallelism present in the execution of logic programs. Their high-level nature, the presence of nondeterminism, and their referential transparency, among other characteristics, make logic programs interesting candidates for obtaining speedups through parallel execution. At the same time, the fact that the typical applications of logic programming frequently involve irregular computations, make heavy use of dynamic data structures with logical variables, and involve search and speculation, makes the techniques used in the corresponding parallelizing compilers and run-time systems potentially interesting even outside the field. The objective of this article is to provide a comprehensive survey of the issues arising in parallel execution of logic programming languages along with the most relevant approaches explored to date in the field. Focus is mostly given to the challenges emerging from the parallel execution of Prolog programs. The article describes the major techniques used for shared memory implementation of Or-parallelism, And-parallelism, and combinations of the two. We also explore some related issues, such as memory management, compile-time analysis, and execution visualization.

Cooperative Task Execution between Modular Robots Based on Tight-Loose Cooperation Strategies

The complexity in the execution of cooperative tasks is high due to the fact that a robot team requires movement coordination at the beginning of the mission and continuous coordination during the execution of the task. A variety of techniques have been proposed to give a solution to this problem assuming standard mobile robots. This work focuses on presenting the execution of a cooperative task by a modular robot team. The complexity of the task execution increases due to the fact that each robot is composed of modules which have to be coordinated in a proper way to successfully work. A combined tight and loose cooperation strategy is presented and a bar-pushing example is used as a cooperative task to show the performance of this type of system.

Towards execution time estimation in abstract machine-based languages

Abstract machines provide a certain separation between platformdependent and platform-independent concerns in compilation. Many of the differences between architectures are encapsulated in the speciflc abstract machine implementation and the bytecode is left largely architecture independent. Taking advantage of this fact, we present a framework for estimating upper and lower bounds on the execution times of logic programs running on a bytecode-based abstract machine. Our approach includes a one-time, programindependent proflling stage which calculates constants or functions bounding the execution time of each abstract machine instruction. Then, a compile-time cost estimation phase, using the instruction timing information, infers expressions giving platform-dependent upper and lower bounds on actual execution time as functions of input data sizes for each program. Working at the abstract machine level makes it possible to take into account low-level issues in new architectures and platforms by just reexecuting the calibration stage instead of having to tailor the analysis for each architecture and platform. Applications of such predicted execution times include debugging/veriflcation of time properties, certiflcation of time properties in mobile code, granularity control in parallel/distributed computing, and resource-oriented specialization.

Combining static analysis and profiling for estimating execution times

Effective static analyses have been proposed which infer bounds on the number of resolutions. These have the advantage of being independent from the platform on which the programs are executed and have been shown to be useful in a number of applications, such as granularity control in parallel execution. On the other hand, in distributed computation scenarios where platforms with different capabilities come into play, it is necessary to express costs in metrics that include the characteristics of the platform. In particular, it is specially interesting to be able to infer upper and lower bounds on actual execution times. With this objective in mind, we propose an approach which combines compile-time analysis for cost bounds with a one-time profiling of a given platform in order to determine the valúes of certain parameters for that platform. These parameters calibrate a cost model which, from then on, is able to compute statically time bound functions for procedures and to predict with a significant degree of accuracy the execution times of such procedures in that concrete platform. The approach has been implemented and integrated in the CiaoPP system.

Using combined static analysis and profiling for logic program execution time estimation

Predicting statically the running time of programs has many applications ranging from task scheduling in parallel execution to proving the ability of a program to meet strict time constraints. A starting point in order to attack this problem is to infer the computational complexity of such programs (or fragments thereof). This is one of the reasons why the development of static analysis techniques for inferring cost-related properties of programs (usually upper and/or lower bounds of actual costs) has received considerable attention.