Structured programming in MPI: a streaming framework experiment

The thesis describes the implementation of a structured programming environment providing stream parallel skeletons (pipelines and farms) implemented on top of MPI and targeting shared memory multicores. The MPI framework performance is evaluated and the results compared with the ones achieved when executing the same applications using FastFlow

StochKit-FF: Efficient Systems Biology on Multicore Architectures

The stochastic modelling of biological systems is an informative, and in some cases, very adequate technique, which may however result in being more expensive than other modelling approaches, such as differential equations. We present StochKit-FF, a parallel version of StochKit, a reference toolkit for stochastic simulations. StochKit-FF is based on the FastFlow programming toolkit for multicores and exploits the novel concept of selective memory. We experiment StochKit-FF on a model of HIV infection dynamics, with the aim of extracting information from efficiently run experiments, here in terms of average and variance and, on a longer term, of more structured data.Comment: 14 pages + cover pag

Structured Tools and Condiitonal Logic: an Empirical Investigation

An important outcome of recent work on the psychology of programming has been the recognition that we have a poor understanding of how various programming practices-indenting, commenting, naming, etc.-facilitate or inhibit the programming process. After a fairly extensive series of studies, many results obtained are contradictory and counterintuitive. The major probem seems to be that we have poor theoretical bases to drive the empirical research. In particular, we have little knowledge of the psychological constructs that programmers bring to bear when they perform various programming tasks, and we have little knowledge of what is natural for programmers. This research tested the propositon that the effectiveness of a programming practice is a function of the extent to which it provides a close cognitive fit with a programmers\u27 problem solving strategy when he or she performs a programming task. The proposition was tested in the context of two psychological processes that appear to be used by programmers when they design and code conditional logic: (a) taxonomizing-identifying the conditions that evoke particular actions; and (b) sequencing-converting the taxa to a linear sequence of program code. Three structured tools-structured English, decision tables, and decision trees-were investigated in a laboratory setting to determine how they facilitated these two processes. It was hypothesized that decision tables and decision trees would facilitate the taxonomising process because they allow conditions and actions to be easily identified, and that structurd English would facilitate the sequencing process because it provides a linear representation of logic that can be mapped easily into programming code. To test the hypotheses, 124 volunteer information systems and computer science students undertook three experiments. In the first experiment they were given a narrative description of some conditional logic and asked to represent the logic using one of the three types of structured tools. In the second experiment they were given conditional logic already represented via one of the tools and asked to convert it into COBOL code. In the third experiment they were given a narrative description of some conditional logic and asked to convert it into COBOL code after having first represented the logic using one of the three types of structured tools. Their perfomance was assessed in terms of the number of syntactic errors they made, the number of semantic errors they made, and the time taken to perform the experimental tasks. In general, the results confirmed the propostions investigated. When the taxonomizing task had to be undertaken, decision trees outperformed strutured English, although surprisingly structured English outperformed decision tables. When the sequencing task had to be undertaken, structured English outperformed decision tables, but decision trees evoked the same level of performance as structured English. Across all tasks, decision tables evoked relatively poor levels of perfomance. On the other hand, decision trees evoked high levels of performance across all tasks. It appears that the graphical tree structure allows taxon information to be represented poignantly. At the same time it appears relatively easy to trace a branch to its leaf node to perform the sequencing task. The superiority of decision trees seems to confirm the desirablity of graphically revealing the structure inherent in processes rather than using symbolic languages. Moreover, the results suggest that the syntax of current programming languages may be unnecessarily restrictive. Perhaps programming languages should provide decision trees as part of their syntax instead of providing only unidimensional, linear syntax to represent conditional logic

Programmers' performance on structured versus nonstructured function definitions

A control-flow model for functional programs is used in an experimental comparison of the performance of programmers on structured versus nonstructured Miranda function definitions. The performance is taken as a measure of the comprehensibility of functional programs. The experimental set-up is similar to the Scanlan study (1989). However, in the present study, a two-factor repeated measures design is used in the statistical analysis. The control-flow model appears to be useful in the shaping of the experiment. A significantly better performance has been found for structured function definitions on both dependent variables: the time needed to answer questions about the function definitions and the proportion correct answers. Moreover, for structured function definitions, a counter-intuitive result has been obtained: there are significantly fewer errors in larger definitions than in smaller ones

Category-based Extracting Keyword Method Selection with Genetic Programming

CD-RO

Evaluating the performance of model transformation styles in Maude

Rule-based programming has been shown to be very successful in many application areas. Two prominent examples are the specification of model transformations in model driven development approaches and the definition of structured operational semantics of formal languages. General rewriting frameworks such as Maude are flexible enough to allow the programmer to adopt and mix various rule styles. The choice between styles can be biased by the programmer’s background. For instance, experts in visual formalisms might prefer graph-rewriting styles, while experts in semantics might prefer structurally inductive rules. This paper evaluates the performance of different rule styles on a significant benchmark taken from the literature on model transformation. Depending on the actual transformation being carried out, our results show that different rule styles can offer drastically different performances. We point out the situations from which each rule style benefits to offer a valuable set of hints for choosing one style over the other