bluuebunny/crossref_metadata_2025 huggingface dataset:
Parameter passing and control stack management in Prolog implementation revisited
Authors: Zhou Neng-Fa
Published: October 2002

Parameter passing and control stack management are two of the crucial issues in Prolog implementation. In the Warren Abstract Machine (WAM), the most widely used abstract machine for Prolog implementation, arguments are passed through argument registers, and the information associated with procedure calls is stored in possibly two frames. Although accessing registers is faster than accessing memory, this scheme requires the argument registers to be saved and restored for back tracking and makes it difficult to implement full tail recursion elimination. These disadvantages may far outweigh the advantage in emulator-based implementations because registers are actually simulated by using memory. In this article, we reconsider the two crucial issues and describe a new abstract machine called ATOAM (yet Another Tree-Oriented Abstract Machine). The ATOAM differs from the WAM mainly in that (1) arguments are passed directly into stack frames, (2) only one frame is used for each procedure call, and (3) procedures are translated into matching trees is possible, and clauses in each procedure are indexed on all input arguments. The above-mentioned inefficiencies of the WAM do not exist in to he ATOAM because backtracking requires less bookkeeping operations, and tail recursion can be handled in most cases like a loop statement in procedural languages. An ATOAM-emulator-based Prolog system called B-Prolog has been implemented, which is available through anonymous ftp from
ftp.kyutech.ac.jp (131.206.1.101)
in the directory
pub/Language/prolog
.B-Prolog is comparable in performance with and can sometimes be significatly faster than emulated SICStus-Prolog. By measuring the numbers of memory and register references made in both systems, we found that passing arguments in stack is no worse than passing arguments in registers even if accessing memory is four times as expensive as accessing registers.
The multiway rendezvous
Authors: Charlesworth Arthur
Published: October 2002

The
multiway rendezvous
is a natural generalization of the rendezvous in which more than two processes may participate. The utility of the multiway rendezvous is illustrated by solutions to a variety of problems. To make their simplicity apparent, these solutions are written using a construct tailor-made to support the multiway rendezvous. The degree of support for multiway rendezvous applications by several well-known languages that support the two-way rendezvous is examined. Since such support for the multiway rendezvous is found to be inadequate, well-integrated extensions to these languages are considered that would help provide such support.
Disjunctive program analysis for algebraic data types
Authors: Jensen Thomas
Published: October 2002

We describe how binding-time, data-flow, and strictness analyses for languages with higher-order functions and algebraic data types can be obtained by instantiating a generic program logic and axiomatization of the properties analyzed for. A distinctive feature of the analyses is that disjunctions of program properties are represented exactly. This yields analyses of high precision and provides a logical characterization of abstract interpretations involving tensor products and uniform properties of recursive data structures. An effective method for proving properties of a program based on fixed-point iteration is obtained by grouping logically equivalent formulae of the same type into equivalence classes, obtaining a lattice of properties of that type, and then defining an abstract interpretation over these lattices. We demonstrate this in the case of strictness analysis by proving that the strictness abstract interpretation of a program is the equivalence class containing the strongest property provable of the program in the strictness logic.
Synthesis of concurrent systems with many similar processes
Authors: Attie Paul C. , Emerson E. Allen
Published: October 2002

Methods for synthesizing concurrent programs from temporal logic
specifications based on the use of a decision procedure for testing
temporal satisfiability have been proposed by Emerson and Clarke
and by Manna and Wolper. An important advantage of these synthesis methods is that they obviate the need to manually compose a program and manually construct a proof of its correctness. One only has to formulate a precise problem specification; the synthesis method then mechanically constructs a
correct solution. A serious drawback of these methods in practice,
however, is that they suffer from the state explosion problem. To
synthesize a concurrent system consisting of
K
sequential processes, each having
N
states in its local transition diagram, requires
construction of the global product-machine having about

N
K

global states in general. This exponential growth in
K
makes it infeasible to synthesize systems composed of more than 2 or 3
processes. In this article, we show how to synthesize concurrent
systems consisting of many (i.e., a finite but arbitrarily large
number
K
of) similar sequential processes. Our approach avoids construction of the global product-machine for
K
processes; instead, it constructs a two-process product-machine for a single pair of generic sequential processes. The method is uniform in
K
, providing a simple template that can be instantiated for each process to yield a solution for any fixed
K
. The method is also illustrated on synchronization problems from the literature.
Optimizing compilation of CLP( ℛ )
Authors: Kelly Andrew D. , Marriott Kim , MacDonald Andrew , Stuckey Peter J. , Yap Roland
Published: October 2002

Constraint Logic Programming (CLP) languages extend logic programming by allowing the use of constraints from different domains such as real numbers or Boolean functions. They have proved to be ideal for expressing problems that require interactive mathematical modeling and complex combinatorial optimization problems. However, CLP languages have mainly been considered as research systems, useful for rapid prototyping, by not really competitive with more conventional programming languages where efficiency is a more important consideration. One promising approach to improving the performance of CLP systems is the use of powerful program optimizations to reduce the cost of constraint solving. We extend work in this area by describing a new optimizing compiler for the CLP language CLP(ℛ). The compiler implements six powerful optimizations: reordering of constraints, removal of redundant variables, and specialization of constraints which cannot fail. Each program optimization is designed to remove the overhead of constraint solving when possible and keep the number of constraints in the store as small as possible. We systematically evaluate the effectiveness of each optimization in isolation and in combination. Our empirical evaluation of the compiler verifies that optimizing compilation can be made efficient enough to allow compilation of real-world programs and that it is worth performing such compilation because it gives significant time and space performance improvements.
Automatic translation of FORTRAN programs to vector form
Authors: Allen Randy , Kennedy Ken
Published: October 2002

The recent success of vector computers such as the Cray-1 and array processors such as those manufactured by Floating Point Systems has increased interest in making vector operations available to the FORTRAN programmer. The FORTRAN standards committee is currently considering a successor to FORTRAN 77, usually called FORTRAN 8x, that will permit the programmer to explicitly specify vector and array operations.

Although FORTRAN 8x will make it convenient to specify explicit vector operations in new programs, it does little for existing code. In order to benefit from the power of vector hardware, existing programs will need to be rewritten in some language (presumably FORTRAN 8x) that permits the explicit specification of vector operations. One way to avoid a massive manual recoding effort is to provide a translator that discovers the parallelism implicit in a FORTRAN program and automatically rewrites that program in FORTRAN 8x.

Such a translation from FORTRAN to FORTRAN 8x is not straightforward because FORTRAN DO loops are not always semantically equivalent to the corresponding FORTRAN 8x parallel operation. The semantic difference between these two constructs is precisely captured by the concept of
dependence
. A translation from FORTRAN to FORTRAN 8x preserves the semantics of the original program if it preserves the dependences in that program.

The theoretical background is developed here for employing data dependence to convert FORTRAN programs to parallel form. Dependence is defined and characterized in terms of the conditions that give rise to it; accurate tests to determine dependence are presented; and transformations that use dependence to uncover additional parallelism are discussed.
Efficient algorithms for automatic construction and compactification of parsing
Authors: Rosenkrantz D. J. , Hunt H. B.
Published: October 2002

Several computational problems about grammars are studied. Efficient algorithms are presented for the problems of (1) determining, for a given semantic grammar, if there exists a related parsing grammar in some specified grammar class, and (2) finding such a related parsing grammar when one exists. The two grammars are to be related by mergers of nonterminals and/or terminals. Efficient algorithms are presented for most of the grammar classes used in compilers. We also study the problem of (3) determining which terminals of a grammar are good candidates for merger into common lexical tokens of the corresponding parsing grammar.
Conversion from data-driven to synchronous execution in loop programs
Authors: Cuny Janice E. , Snyder Lawrence
Published: October 2002

Conversion algorithms are presented that would enable programmers to write programs in a high-level, data flow language and then run those programs on a synchronous machine. A model of interprocess communication systems is developed in which both data-driven and synchronous execution modes are represented. Balancing equations are used to characterize a subclass of parallel programs, called loop programs, for which conversions are possible. We show that all loop programs having the finite buffer property can be converted into synchronous mode. Finally two algorithms for the conversion of loop programs are presented and discussed.
Backtracking in a Generalized Control Setting
Authors: Lindstrom Gary
Published: October 2002

Backtracking is a powerful conceptual and practical programming language control structure. However, its application in general has been limited to global control over recursive programs. In this paper we explore the coherence and utility of applying backtracking in a more general control setting, namely, block-structured coroutines. The following criteria are proposed for such a control combination to be judged successful: (i) retention of each control form's individual semantics; (ii) coherent semantics for each legal application of the combination; (iii) nonpreeminence of either control form, and (iv) facilitation of genuinely novel programming effects. The attainability of these criteria is assessed, with the aid of an informal language design and three illustrative applications: (i) a dual tree walk program using coroutine-managed backtracking subsystems; (ii) a context-free language intersection tester using bilevel hierarchical backtracking, and (iii) an optimizing computer job scheduler using backtracking in a simulation language context. Full programs are given for each example, phrased in a Pascal extension offering both coroutines and backtracking (expressed through nondeterministic control).
Comments on “Communicating Sequential Processes”
Authors: Kieburtz Richard B. , Silberschatz Abraham
Published: October 2002

In his recent paper, “Communicating Sequential Processes” (
Comm. ACM
21, 8 (Aug. 1978), 666-677), C.A.R. Hoare outlines a programming language notation for interprocess communication in which processes are synchronized by the messages they exchange. The notation carries with it certain implications for the synchronization protocols required in a message transfer. These are not at all obvious and are made explicit here. An alternative convention is suggested in which communication and synchronization are partially uncoupled from one another.
External Representations of Objects of User-Defined Type
Authors: Wallis Peter L.
Published: October 2002

The portable programming language (PPL) is one of a number of recently designed programming languages that enable the user to define new types by giving their representations and operations in terms of those of previously available types. Such provisions for the construction of objects of user-defined type have been discussed elsewhere; this work concerns the related problem of the external representations of such objects, both on input-output media and as written constants within the program text. We introduce an enhancement to the PPL design allowing specification of the external representations of objects of user-defined type. This extension to the PPL design means that objects of user-defined type can be read, written, and used as constants exactly as if their representations had been selected by the writer of the PPL compiler. The implementation and use of the added facilities are also discussed.
Assignment and Procedure Call Proof Rules
Authors: Gries David , Levin Gary
Published: October 2002

The multiple assignment statement is defined in full generality—including assignment to subscripted variables and record fields—using the “axiomatic” approach of Hoare. Proof rules are developed for calls of procedures using global variables, var parameters, result parameters, and value parameters, using the idea of multiple assignment to provide understanding. An attempt is made to clarify some issues that have arisen concerning the use of rules of inference to aid in generating “verification conditions” in mechanical verifiers and the use of logical variables to denote initial values of program variables.
Control predicates are better than dummy variables for reasoning about program control
Authors: Lamport Leslie
Published: October 2002

When explicit control predicates rather than dummy variables are used, the Owicki-Gries method for proving safety properties of concurrent programs can be strengthened, making it easier to construct the required program annotations.
Type extensions
Authors: Wirth N.
Published: October 2002

Software systems represent a hierarchy of modules. Client modules contain sets of procedures that extend the capabilities of imported modules. This concept of extension is here applied to data types. Extended types are related to their ancestor in terms of a hierarchy. Variables of an extended type are compatible with variables of the ancestor type. This scheme is expressed by three language constructs only: the declaration of extended record types, the type test, and the type guard. The facility of extended types, which closely resembles the class concept, is defined in rigorous and concise terms, and an efficient implementation is presented.
Constrained expressions: toward broad applicability of analysis methods for distributed software systems
Authors: Dillon Laura K. , Avrunin George S. , Wileden Jack C.
Published: October 2002

It is extremely difficult to characterize the possible behaviors of a distributed software system through informal reasoning. Developers of distributed systems require tools that support formal reasoning about properties of the behaviors of their systems. These tools should be applicable to designs and other preimplementation descriptions of a system, as well as to completed programs. Furthermore, they should not limit a developer's choice of development languages.

In this paper we present a basis for broadly applicable analysis methods for distributed software systems. The
constrained expression
formalism can be used with a wide variety of distributed system development notations to give a uniform closed-form representation of a system's behavior. A collection of formal analysis techniques can then be applied with this representation to establish properties of the system. Examples of these formal analysis techniques appear elsewhere. Here we illustrate the broad applicability of the constrained expression formalism by showing how constrained expression representations are obtained from descriptions of systems in three different notations: SDYMOL, CSP, and Petri nets. Features of these three notations span most of the significant alternatives for describing distributed software systems. Our examples thus offer persuasive evidence for the broad applicability of the constrained expression approach.
Symmetric intertask communication
Authors: Francez Nissim , Yemini Shaula A.
Published: October 2002

We argue for the need of supporting a symmetric select construct, in which entry calls as well as accepts can be alternatives. We present several situations in which a symmetric select leads to a more natural programming style. We show that several semantic principles are violated by a nonsymmetric select, while being satisfied by a symmetric one. In particular, the suggested symmetric intertask communication mechanism is fully abstract and composable, and has a distributed termination rule which reduces the risk of deadlock. Our discussion is in terms of Ada™.
Affix grammar driven code generation
Authors: Ganapathi Mahadevan , Fischer Charles N.
Published: October 2002

Affix grammars are used to describe the instruction set of a target architecture for purposes of compiler code generation. A code generator is obtained automatically for a compiler using attributed parsing techniques. A compiler built on this model can automatically perform most popular machine-dependent optimizations, including peephole optimizations. Code generators based on this model demonstrate
retargetability
for the VAX
1
-11, iAPX
2
-86, Z-8000
3
, PDP
4
-11, MC-68000, NS32032, FOM, and IBM-370 architectures.
Analysis of functional programs to detect run-time garbage cells
Authors: Inoue Katsuro , Seki Hiroyuki , Yagi Hikaru
Published: October 2002

We propose a method for detecting the generation of garbage cells by analyzing a source text written in a functional programming language which uses ordinary linked lists to implement list-type values. For a subexpression such as
F
(
G
( . . . )) in a program where the function values of
F
and
G
are of list type, if a cell
c
is created during the computation of
G
and if
c
does not appear in a list-type value of
F
, then
c
becomes a garbage cell at the end of the computation of
F
. We discuss this problem on the basis of formal languages derived from the functional program text and show some sufficient conditions that predict the generation of garbage cells. Also, we give an efficient algorithm to detect at compile time the generation of garbage cells which are linearly linked. We have implemented these algorithms in an experimental LISP system. By executing several sample programs on the system, we conclude that our method is effective in detecting the generation of garbage cells.
Applicative caching
Authors: Keller Robert M. , Sleep M. R.
Published: October 2002

The “referential transparency” principle of applicative language expressions stipulates that a single value exists for all occurrences of an expression in a given context (where a context is a set of bindings of variables to values). In principle, each such value therefore need to be computed only once. However, in applicative language systems supporting recursive programming or tasking notions, the bindings are not all precomputed and explicit. As a result, textual recognition of all multipleoccurrences is precluded, with the unfortunate consequence that such occurrences are recomputed. We elaborate upon the early notion of “memo function” for solving this problem. We suggest syntactic and semantic constructs providing programmer control for avoiding recomputation, which is incorporated into a “building-block” approach.
Data-driven evolution of data mining algorithms
Authors: Smyth Padhraic , Pregibon Daryl , Faloutsos Christos
Published: October 2002

Fundamentally, these algorithms are driven by the nature of the data being analyzed, in both scientific and commercial applications.
Motion capture assisted animation
Authors: Pullen Katherine , Bregler Christoph
Published: October 2002

We discuss a method for creating animations that allows the animator to sketch an animation by setting a small number of keyframes on a fraction of the possible degrees of freedom. Motion capture data is then used to enhance the animation. Detail is added to degrees of freedom that were keyframed, a process we call texturing. Degrees of freedom that were not keyframed are synthesized. The method takes advantage of the fact that joint motions of an articulated figure are often correlated, so that given an incomplete data set, the missing degrees of freedom can be predicted from those that are present.
Eyes alive
Authors: Lee Sooha Park , Badler Jeremy B. , Badler Norman I.
Published: October 2002

For an animated human face model to appear natural it should produce eye movements consistent with human ocular behavior. During face-to-face conversational interactions, eyes exhibit conversational turn-taking and agent thought processes through gaze direction, saccades, and scan patterns. We have implemented an eye movement model based on empirical models of saccades and statistical models of eye-tracking data. Face animations using stationary eyes, eyes with random saccades only, and eyes with statistically derived saccades are compared, to evaluate whether they appear natural and effective while communicating.
Object-based image editing
Authors: Barrett William A. , Cheney Alan S.
Published: October 2002

We introduce Object-Based Image Editing (OBIE) for real-time animation and manipulation of static digital photographs. Individual image objects (such as an arm or nose, Figure 1) are selected, scaled, stretched, bent, warped or even deleted (with automatic
hole filling
) -
at the object, rather than the pixel level
- using simple gesture motions with a mouse. OBIE gives the user direct, local control over object shape, size, and placement while dramatically reducing the time required to perform image editing tasks.Object selection is performed by manually collecting (subobject) regions detected by a watershed algorithm. Objects are tessellated into a triangular mesh, allowing shape modification to be performed in real time using OpenGL's texture mapping hardware.Through the use of
anchor points,
the user is able to interactively perform editing operations on a whole object, or just part(s) of an object - including moving, scaling, rotating, stretching, bending, and deleting.
Indirect
manipulation of object shape is also provided through the use of sliders and Bezier curves. Holes created by movement are filled in real-time based on surrounding texture.When objects stretch or scale, we provide a method for preserving
texture granularity
or scale. We also present a
texture brush,
which allows the user to "paint" texture into different parts of an image, using existing image texture(s).OBIE allows the user to perform interactive, high-level editing of image objects in a few seconds to a few ten's of seconds
On XML integrity constraints in the presence of DTDs
Authors: Fan Wenfei , Libkin Leonid
Published: October 2002

The article investigates XML document specifications with DTDs and integrity constraints, such as keys and foreign keys. We study the consistency problem of checking whether a given specification is meaningful: that is, whether there exists an XML document that both conforms to the DTD and satisfies the constraints. We show that DTDs interact with constraints in a highly intricate way and as a result, the consistency problem in general is undecidable. When it comes to unary keys and foreign keys, the consistency problem is shown to be NP-complete. This is done by coding DTDs and integrity constraints with linear constraints on the integers. We consider the variations of the problem (by both restricting and enlarging the class of constraints), and identify a number of tractable cases, as well as a number of additional NP-complete ones. By incorporating negations of constraints, we establish complexity bounds on the implication problem, which is shown to be coNP-complete for unary keys and foreign keys.
On computing givens rotations reliably and efficiently
Authors: Bindel David , Demmel James , Kahan William , Marques Osni
Published: October 2002

We consider the efficient and accurate computation of Givens rotations. When
f
and
g
are positive real numbers, this simply amounts to computing the values of
c
=
f
/√
f
2
+
g
2
,
s
=
g
/√
f
2
+
g
2
, and
r
= √
f
2
+
g
2
. This apparently trivial computation merits closer consideration for the following three reasons. First, while the definitions of
c
,
s
and
r
seem obvious in the case of two nonnegative arguments
f
and
g
, there is enough freedom of choice when one or more of
f
and
g
are negative, zero or complex that LAPACK auxiliary routines SLARTG, CLARTG, SLARGV and CLARGV can compute rather different values of
c
,
s
and
r
for mathematically identical values of
f
and
g
. To eliminate this unnecessary ambiguity, the BLAS Technical Forum chose a single consistent definition of Givens rotations that we will justify here. Second, computing accurate values of
c
,
s
and
r
as efficiently as possible and reliably despite over/underflow is surprisingly complicated. For complex Givens rotations, the most efficient formulas require only one real square root and one real divide (as well as several much cheaper additions and multiplications), but a reliable implementation using only working precision has a number of cases. On a Sun Ultra-10, the new implementation is slightly faster than the previous LAPACK implementation in the most common case, and 2.7 to 4.6 times faster than the corresponding vendor, reference or ATLAS routines. It is also more reliable; all previous codes occasionally suffer from large inaccuracies due to over/underflow. For real Givens rotations, there are also improvements in speed and accuracy, though not as striking. Third, the design process that led to this reliable implementation is quite systematic, and could be applied to the design of similarly reliable subroutines.
Improving retrieval feedback with multiple term-ranking function combination
Authors: Carpineto Claudio , Romano Giovanni , Giannini Vittorio
Published: October 2002

In this article we consider methods for automatic query expansion from top retrieved documents (i.e., retrieval feedback) that make use of various functions for scoring expansion terms within Rocchio's classical reweighting scheme. An analytical comparison shows that the retrieval performance of methods based on distinct term-scoring functions is comparable on the whole query set but differs considerably on single queries, consistent with the fact that the ordered sets of expansion terms suggested for each query by the different functions are largely uncorrelated. Motivated by these findings, we argue that the results of multiple functions can be merged, by analogy with ensembling classifiers, and present a simple combination technique based on the rank values of the suggested terms. The combined retrieval feedback method is effective not only with respect to unexpanded queries but also to any individual method, with notable improvements on the system's precision. Furthermore, the combined method is robust with respect to variation of experimental parameters and it is beneficial even when the same information needs are expressed with shorter queries.
Algorithm 819: AIZ, BIZ
Authors: Gil Amparo , Segura Javier , Temme Nico M.
Published: October 2002

Two Fortran 77 routines for the evaluation of Airy functions of complex arguments
Ai
(
z
),
Bi
(
z
) and their first derivatives are presented. The routines are based on the use of Gaussian quadrature, Maclaurin series and asymptotic expansions. Comparison with a previous code by D. E. Amos [1986] is provided.
I-structures: data structures for parallel computing
Authors: Arvind  , Nikhil Rishiyur S. , Pingali Keshav K.
Published: October 2002

It is difficult to achieve elegance, efficiency, and parallelism simultaneously in functional programs that manipulate large data structures. We demonstrate this through careful analysis of program examples using three common functional data-structuring approaches-lists using Cons, arrays using Update (both fine-grained operators), and arrays using make-array (a “bulk” operator). We then present I-structure as an alternative and show elegant, efficient, and parallel solutions for the program examples in Id, a language with I-structures. The parallelism in Id is made precise by means of an operational semantics for Id as a parallel reduction system. I-structures make the language nonfunctional, but do not lose determinacy. Finally, we show that even in the context of purely functional languages, I-structures are invaluable for implementing functional data abstractions.
An exercise in the formal derivation of parallel programs: maximum flows in graphs
Authors: Knapp Edgar
Published: October 2002

We apply a new method for the development of parallel programs to the problem of finding maximum flows in graphs. The method facilitates concurrent program design by separating the concerns of correctness from those of hardware and implementation. It uses predicate transformer semantics to define a set of basic operators for the specification and verification of programs. From an initial specification program development proceeds by a series of refinement steps, each of which constitutes a strengthening of the specification of the previous refinement. The method is completely formal in the sense that all reasoning steps are performed within predicate calculus. A program is viewed as a mathematical object enjoying certain properties, rather than in terms of its possible executions. We demonstrate the usefulness of the approach by deriving an efficient algorithm for the Maximum Flow Problem in a top-down manner.
An approach to support automatic generation of user interfaces
Authors: Dewan Prasun , Solomon Marvin
Published: October 2002

In traditional interactive programming environments, each application individually manages its interaction with the human user. The result is duplication of effort in implementing user interface code and nonuniform—hence confusing—input conventions. This paper presents an approach to support automatic generation of user interfaces in environments based on algebraic languages.

The approach supports the editing model of interaction, which allows a user to view all applications as data that can be edited. An application interacts with a user by submitting variables (of arbitrary types) to a
dialogue manager
, which displays their
presentations
to the user and offers type-directed editing of these presentations. Applications and dialogue managers communicate through a protocol that allows a presentation to be kept consistent with the variable it displays.

A particular implementation of the approach, called Dost, has been constructed for the Xerox development environment and the Mesa programming language. Dost is used as a concrete example to describe the editing model, the primitives to support it, and our preliminary experience with these primitives. The approach is compared with related work, its shortcomings are discussed, and suggestions for future work are made.
On the algebraic definition of programming languages
Authors: Broy Manfred , Wirsing Martin , Pepper Peter
Published: October 2002

The algebraic specification of the semantics of programming languages is outlined. Particular emphasis is given to the problem of specifying least-fixed points by first-order conditional equations. To cover this issue, the theory of specifying partial heterogeneous algebras by abstract data types is slightly extended by a more general notion of homomorphism. In this framework the semantics of programming languages can be uniquely specified in a purely algebraic way, using particular models of a hierarchy of abstract types. This approach is demonstrated for a simple procedural programming language. Several increasingly complex versions of iterations are treated and analyzed with respect to their theoretical consequences. Finally, as a complementary algebraic technique, transformational semantics is explained and applied to our examples.
Dancing with Diana: A Study in Hauntology
Authors: Taylor Diana
Published: October 2002

“What's Diana to me, that I should weep for her?” How and why does Princess Di's ghost haunt our memories as well as the latest political crisis?
Time Out of Mind: Anthropological Reflections on Temporality
Authors: Fox Robin
Published: October 2002

Our conception of historical time is biased towards the present and the immediate. We relegate ninety-nine percent of human history to 'pre-history.'This temporal obsession with the present emerged, along with consciousness, in social systems inherently cyclical. Kinship systems evolved from those with alternating generation terms through those with linear terms. Conceptions of time likewise altered from the cyclical to the linear.Time eventually came to be seen as progressive and cumulative. Theories of historical time however remain stubbornly cyclical, biased towards the post-Neolithic, and determined to set limits to time. This hierarchy of preferences in temporal thinking seems a basic feature of human nature.
Solar Influences on Holocene Climatic Changes Illustrated by Correlations between Past Lake-Level Fluctuations and the Atmospheric14C Record
Authors: Magny Michel
Published: October 2002

Chronological correlations established at different time scales among the lake-level fluctuations in the Jura and French Subalpine ranges, glacier movements in the Swiss and Austrian Alps, and the atmospheric14C record during the last 7 millennia show coincidences between lake-level rises, glacier advances, and high14C production and vice versa. These correspondences suggest that the short-term14C variations may be an empirical indicator of Holocene palaeoclimates and argue for possible origins of Holocene climatic oscillations: (1) The varying solar activity refers to secular climatic oscillations and to major climatic deteriorations showing a ca. 2300-yr periodicity. (2) A question is raised about a relationship between the earth's magnetic field and climate. First, the weak-strength periods of the earth's dipole magnetic field (between 3800 and ca. 2500 B.C.) coincide with higher climate variability, and vice versa. Second, the ca. 2300-yr periods revealed by the14C record and also by the major climatic deteriorations re. corded in Jurassian lakes (ca. 1500 A.D., ca. 800 B.C., and ca. 3500 B.C.) coincide with the ca. 2300-yr periods revealed by the earth's nondipole geomagnetic field. The present warming induced by anthropogenic factors should be intensified during the next few centuries by natural factors of climate evolution.
Holocene Environmental Signals from Mollusk Assemblages in Burgundy (France)
Authors: Rousseau Denis-Didier , Limondin Nicole , Puissegur Jean-Jacques
Published: October 2002

The malacofaunas of Burgundy, France, reflect changes in climate and the activities of man during the Holocene. Statistical analyses based on the Shannon diversity index and correspondence analysis are used to describe the mollusk assemblages in a composite sequence based on three well-dated sites. The variation demonstrated by the mollusks suggests that a two-step warming took place between 10,000 and 9000 and 8000 and 6000 yr B.P. in relative agreement with the timing of the deglaciation in the tropical Atlantic Ocean proposed by Mix and Ruddiman (1985, Quaternary Science Reviews 4, 59-108). High humidity, partly associated with widespread inundations of the valleys between 10,000 and 8000 yr B.P., may be related to estimated variations in the rate of freshwater discharge to the Atlantic Ocean reported by Fairbanks (1989, Nature 342, 637-642). The increasing impact of human activities on the environment during the past 2000 yr is indicated by the low diversity of the mollusk assemblages, demonstrating the need for careful interpretation of the youngest Holocene sediments in this region.
Archaeological Evidence for a Former Bay at Seaside, Oregon
Authors: Connolly Thomas J.
Published: October 2002

Cultural shell middens, a common feature of coastal landscapes, preserve a record of past human use of coastal resources and often provide important paleoenvironmental information. Molluscan remains from two shell midden sites, located 0.7 km from the modern Pacific coast at Seaside, Oregon, suggest the former presence of a small sheltered bay at this locality. The modern sand beaches in the Seaside area, stretching for 30 km southward from the mouth of the Columbia River, are exposed to high-energy surf where razor clams (Siliqua patula) are today the only common bivalve. By contrast, over 90% of molluscan remains (by weight) recovered from the archaeological sites represent species that favor sheltered water. Geologic studies in the Seaside area have shown that the beach prograded some 2 km over the last 4 millennia. The midden evidence suggests that the progradation was accompanied by the infilling of a former bay.
Vertebrate Tracks in Pleistocene Eolian Sand-Sheet Deposits of Alaska
Authors: Lea Peter D.
Published: October 2002

Deformation structures interpreted as vertebrate hoof- and foot-tracks occur within upper-Pleistocene eolian sand-sheet deposits in the stabilized Kantishna sand sea of central Alaska and in the Nushagak lowland of southwestern Alaska. Exposures of tracks are generally limited to cross sections, which reveal concave-up deformation structures in which displacement of preexisting strata diminishes downward. Deposits in both areas contain tracks that are 6 to 16 cm in diameter and are divided by a central ridge, reflecting formation by artiodactyl (even-toed) ungulates. Larger (21–34 cm) tracks without a central ridge, observed in the Nushagak lowland, were formed by proboscideans, probably woolly mammoth. Large vertebrate tracks occur within irregularly stratified sand and silty sand that accumulated upon partially vegetated sand sheets, and within thin, even wind-ripple laminae of unvegetated sand sheets. The presence of tracks at multiple stratigraphic levels and preservation of roots and rhizocretions within the eolian deposits suggest that vegetated sand sheets may have formed a locally important grazing habitat for large herbivores during at least part of the last glaciation. Recognition that vertebrate tracks are preserved in eolian sand-sheet deposits, and in deposits of other environments as well, opens a new source of stratigraphic and paleoecological data to aid reconstruction of the vanished ecosystems of Beringia.
Determining the Exposure Age of a Karst Landscape
Authors: Frumkin Amos
Published: October 2002

An extensive salt karst system has developed in Mount Sedom salt diapir, Israel, during the Holocene. Multilevel vadose caves were 14C dated using wood fragments embedded in alluvial deposits. The oldest date of each cave is used to constrain the age of the salt exposure. The upper portion of the southeastern escarpment was the first to rise above base level ∼7100 yr B.P. Caves in the surrounding area indicate gradual landscape exposure around this initial karstified area between 7000 and 4000 yr B.P. The northern part of the mountain experienced a similar exposure history, lagging some 3000 yr after the southern part. This lag may be attributed to the narrow width of the diapir in the north, which increases viscous drag at the borders of the rising diapir.
Eemian Climatic and Hydrographical Instability on a Marine Shelf in Northern Denmark
Authors: Seidenkrantz Marit-Solveig , Knudsen Karen Luise
Published: October 2002

Benthic foraminifera and stable isotope data from the last interglaciation (Eemian, substage 5e) from a borehole at Skagen, Denmark, provide evidence for major environmental and hydrographic changes during this period. During the first millennium of the Eemian, water masses covering northern Denmark became gradually warmer. Temperate conditions prevailed during most of the interglaciation, but these were interrupted by two periods with decreased water temperatures. The first cooling (Event S-1) was not very distinct at Skagen, but the second (Event S-2), seen in both the foraminiferal and oxygen isotope record, represents a large shift to subarctic conditions. Carbon isotopes indicate a change in ocean circulation during both events. No comparable climate variations are seen within the Holocene record at the site. The final cooling of the water masses associated with the substage 5e/5d boundary occurred within a few hundred years. These last interglacial climatic changes were probably caused by variations in strength and/or position of the North Atlantic Drift, possibly as a result of varying vigor of the Atlantic conveyor. In addition, minor variations in the fossil assemblages also indicate fluctuations in the inflow of Atlantic water to the Skagerrak–Kattegat area during the warm intervals of substage 5e.
Late Pleistocene Eolian Sediments Related to Pyroclastic Eruptions of Mauna Kea Volcano, Hawaii
Authors: Porter Stephen C.
Published: October 2002

Loess and dune sands that mantle volcanic rocks on the northwest flank of Mauna Kea volcano consist predominantly of fine-grained pyroclasts of the alkalic Laupahoehoe Volcanics produced by explosive eruptions. The loess is divided into lower and upper units, separated by a well-developed paleosol, while older and younger dune sands are separated by loess. Four interstratified tephra marker horizons aid in regional stratigraphic correlation. Radiocarbon ages of charcoal fragments within the loess, U-series ages of rhizoliths in the dune sand, and K/Ar ages and relative stratigraphic positions of lava flows provide a stratigraphic and temporal framework. The lower loess overlies lava flows less than 103,000 ± 10,000 K/Ar yr old, and14C dates from the paleosol developed at its top average ca. 48,000 yr. Loess separating the dune sand units ranges from ca. 38,000 to 25,00014C yr old; the youngest ages from the upper loess are 17,000–18,00014C yr B.P. Dips of sand-dune foreset strata, isopachs on the upper loess, and reconstructed isopachs representing cumulative thickness of tephra associated with late-Pleistocene pyroclastic eruptions suggest that vents upslope (upwind) from the sand dunes were the primary source of the eolian sediments. Average paleowind directions during the eruptive interval (ca. 50,000–15,000 yr B.P.), inferred from cinder-cone asymmetry, distribution of tephra units, orientation of dune foreset strata, and the regional pattern of loess isopachs, suggest that Mauna Kea has remained within the trade-wind belt since before the last glaciation.
Drug specific resistance to oxaliplatin is associated with apoptosis defect in a cellular model of colon carcinoma
Authors: Gourdier Isabelle , Del Rio Maguy , Crabbé Laure , Candeil Laurent , Copois Virginie , Ychou Marc , Auffray Charles , Martineau Pierre , Mechti Nadir , Pommier Yves , Pau Bernard
Published: October 2002

To investigate acquired resistance to oxaliplatin, we selected two resistant clones from the HCT116 cell line. We found that the resistant phenotype was associated with resistance to oxaliplatin‐induced apoptosis as demonstrated by FACS analysis and by Western blotting of caspase 3 activation. In addition, the resistant phenotype showed a concomitant resistance to lonidamine and arsenic trioxide which are inducers of mitochondrial apoptosis. Furthermore, a complete loss of Bax expression due to a frameshift mutation was observed in the most resistant clone. Taken together, these findings suggest that altered mitochondrial‐mediated apoptosis could play a role in oxaliplatin resistance.
HU: promoting or counteracting DNA compaction?
Authors: Dame Remus Thei , Goosen Nora
Published: October 2002

The role of HU in Escherichia coli as both a protein involved in DNA compaction and as a protein with regulatory function seems to be firmly established. However, a critical look at the available data reveals that this is not true for each of the proposed roles of this protein. The role of HU as a regulatory or accessory protein in a number of systems has been thoroughly investigated and in many cases has been largely elucidated. However, almost 30 years after its discovery, convincing evidence for the proposed role of HU in DNA compaction is still lacking. Here we present an extensive literature survey of the available data which, in combination with novel microscopic insights, suggests that the role of HU could be the opposite as well. The protein is likely to play an architectural role, but instead of being responsible for DNA compaction it could be involved in antagonising compaction by other proteins such as H‐NS.
Catastrophic events, contagion, and stock market efficiency: the case of the space shuttle challenger
Authors: Blose Laurence E. , Bornkamp Robin , Brier Marci , Brown Kendis , Frederick Jerry
Published: October 2002

This study examines the stock returns experienced by NASA contractors associated with the Space Shuttle Challenger explosion. Because of the extensive public interest in the explosion and the intensive and stirring news coverage, this event is a candidate for an irrational market response such as a selloff, a panic, or a contagion effect. The market evidence shows that on the day of the explosion, there was a significantly negative average abnormal return on the stock of NASA contractors. Any contagion effect was limited to a very narrow set of NASA contractors who received more than 5% of their 1995 revenues from NASA. Furthermore, the market was able to identify within days after the event that the single firm most likely to be affected by the event was Morton Thiokol Corporation.
Screening and selection of Lactobacillus strains for use as adjunct cultures in production of semi-hard cheese
Authors: ANTONSSON MARTIN , ARDÖ YLVA , FRANS NILSSON BENGT , MOLIN GÖRAN
Published: October 2002

Thirty-three Lactobacillus strains were tested as adjuncts in a cheese model system. Eighteen strains originated from cheese (nine Lactobacillus spp. and nine Lb. paracasei/casei) and 15 from human intestinal mucosa (11 Lb. rhamnosus; three Lb. paracasei; one Lb. plantarum). Model cheeses weighing 120 g were made of cheese grains from full-scale production of washed curd semi-hard cheese (Herrgård). The model system was reproducible and similar to full-scale production with respect to moisture, salt content, pH and microbial flora. The model cheeses were sampled for aerobic and anaerobic plate count and viable counts of Lactobacillus and Lactococcus. The presence of adjuncts in the model cheeses was confirmed by typing isolates with Randomly Amplified Polymorphic DNA (RAPD). The sensory properties of model cheeses were described. In a first trial 23 of the 33 adjuncts were re-isolated from the corresponding model cheeses after 9 or 13 weeks. Adjuncts of Lb. paracasei were re-isolated more frequently than adjuncts of Lb. rhamnosus. Nine strains were selected, on the basis of their ability to grow and be a dominating part of the microflora of model cheese with interesting sensory properties. These strains were further studied together with two commercial cultures. The sensory influences on model cheeses of six of the adjuncts were confirmed, and flavour scores were in the range of 2.9–7.1 for model cheeses with different adjuncts while the control had a flavour score of 5.6 (0–10 scale). Survival and growth of seven out of the nine strains correlated with the results of the first trial. Growth and influence on flavour of four adjunct cultures were confirmed in experimental cheese manufactured in a 400-l open vat.