bluuebunny/crossref_metadata_2025 huggingface dataset:
Red spruce seedling health: an assessment of acid fog deposition and heavy metal soil contamination as interactive stress factors
Authors: Geballe Gordon T. , Smith William H. , Wargo Philip M.
Published: November 2007

Two-year-old spruce (Picearubens Sarg.) seedlings were exposed to 12 treatment regimes of acid fog deposition and heavy metal soil amendment over a 2-year period. Seedling health was assessed by measuring five health indices, including general vigor estimate, height, diameter, bud number, and biomass (leaf, stem, and twig, and total). Soil was amended with cadmium, copper, lead, manganese, nickel, and zinc added in amounts comparable to high-elevation forest soils in the northeastern United States. Seedlings were also treated with simulated fog, with ionic chemistry similar to high-elevation northeastern fog events, adjusted to pH 3 or 5. The seedlings were planted in metal-amended soil and subjected to fog treatments in greenhouse chambers from August 6, 1986, to October 29, 1987, in weekly regimes of 30-h exposures. Of all the seedling stress factors imposed, only the lead amendment at 2000 ppm concentration, which is approximately 10 times the current ambient forest floor high-elevation level, had a consistently adverse impact on the seedling health parameters measured. Vigor rating of experimental seedlings was adversely impacted by precipitaton acidity in the absence of lead and other heavy metal soil amendments. Height, diameter, and live bud count of the seedlings were quite insensitive to treatment conditions. Treatment interactions were also generally unimportant.
THE N-TACHYON ASSISTED INFLATION
Authors: SINGH HARVENDRA
Published: November 2007

In continuation of the papers hep-th/0505012 and hep-th/0508101 we investigate the consequences when N open-string tachyons roll down simultaneously. We demonstrate that the N-tachyon system coupled to gravity does indeed give rise to the assisted slow-roll inflation.
Dynamic graph-based software fingerprinting
Authors: Collberg Christian S. , Thomborson Clark , Townsend Gregg M.
Published: November 2007

Fingerprinting embeds a secret message into a cover message. In media fingerprinting, the secret is usually a copyright notice and the cover a digital image. Fingerprinting an object discourages intellectual property theft, or when such theft has occurred, allows us to prove ownership.

The Software Fingerprinting problem can be described as follows. Embed a structure
W
into a program
P
such that:
W
can be reliably located and extracted from
P
even after
P
has been subjected to code transformations such as translation, optimization and obfuscation;
W
is stealthy;
W
has a high data rate; embedding
W
into
P
does not adversely affect the performance of
P
; and
W
has a mathematical property that allows us to argue that its presence in
P
is the result of deliberate actions.

In this article, we describe a software fingerprinting technique in which a dynamic graph fingerprint is stored in the execution state of a program. Because of the hardness of pointer alias analysis such fingerprints are difficult to attack automatically.
A proof theory for machine code
Authors: Ohori Atsushi
Published: November 2007

This article develops a proof theory for low-level code languages. We first define a proof system, which we refer to as the
sequential sequent calculus
, and show that it enjoys the cut elimination property and that its expressive power is the same as that of the natural deduction proof system. We then establish the Curry-Howard isomorphism between this proof system and a low-level code language by showing the following properties: (1) the set of proofs and the set of typed codes is in one-to-one correspondence, (2) the operational semantics of the code language is directly derived from the cut elimination procedure of the proof system, and (3) compilation and decompilation algorithms between the code language and the typed lambda calculus are extracted from the proof transformations between the sequential sequent calculus and the natural deduction proof system. This logical framework serves as a basis for the development of type systems of various low-level code languages, type-preserving compilation, and static code analysis.
An improved bound for call strings based interprocedural analysis of bit vector frameworks
Authors: Karkare Bageshri , Khedker Uday P.
Published: November 2007

Interprocedural data flow analysis extends the scope of analysis across procedure boundaries in search of increased optimization opportunities. Call strings based approach is a general approach for performing flow and context sensitive interprocedural analysis. It maintains a history of calls along with the data flow information in the form of call strings, which are sequences of unfinished calls. Recursive programs may need infinite call strings for interprocedural data flow analysis. For bit vector frameworks this method is believed to require all call strings of lengths up to 3
K
, where
K
is the maximum number of distinct call sites in any call chain.

We combine the nature of information flows in bit-vector data flow analysis with the structure of interprocedurally valid paths to bound the call strings. Instead of bounding the length of call strings, we bound the number of occurrences of any call site in a call string. We show that the call strings in which a call site appears at most three times, are sufficient for convergence on interprocedural maximum fixed point solution. Though this results in the same worst case length of call strings, it does not require constructing all call strings up to length 3
K
. Our empirical measurements on recursive programs show that our bound reduces the lengths and the number of call strings, and hence the analysis time, significantly.
Bicubic polar subdivision
Authors: Karčiauskas Kȩstutis , Peters Jörg
Published: November 2007

We describe and analyze a subdivision scheme that generalizes bicubic spline subdivision to control nets with polar structure. Such control nets appear naturally for surfaces with the combinatorial structure of objects of revolution and at points of high valence in subdivision meshes. The resulting surfaces are
C
2
except at a finite number of isolated points where the surface is
C
1
and the curvature is bounded.
Streamflex
Authors: Spring Jesper H. , Privat Jean , Guerraoui Rachid , Vitek Jan
Published: November 2007

The stream programming paradigm aims to expose coarse-grained parallelism inapplications that must process continuous sequences of events. The appeal ofstream programming comes from its conceptual simplicity. A program is acollection of independent filters which communicate by the means ofuni-directional data channels. This model lends itself naturally toconcurrent and efficient implementations on modern multiprocessors. As theoutput behavior of filters is determined by the state of their inputchannels, stream programs have fewer opportunities for the errors (such asdata races and deadlocks) that plague shared memory concurrent programming. This paper introduces StreamFlex, an extension to Java which marries streams with objects and thus enables to combine, in the same Java virtual machine, stream processing code with traditional object-oriented components. StreamFlex targets high-throughput low-latency applications with stringent quality-of-service requirements. To achieve these goals, it must, at the same time, extend and restrict Java. To allow for program optimization and provide latency guarantees, the StreamFlex compiler restricts Java by imposing a stricter typing discipline on filters. On the other hand, StreamFlex extends the Java virtual machine with real-time capabilities, transactional memory and type-safe region-based allocation. The result is a rich and expressive language that can be implemented efficiently.
Type qualifier inference for java
Authors: Greenfieldboyce David , Foster Jeffrey S.
Published: November 2007

Java's type system provides programmers with strong guarantees of type and memory safety, but there are many important properties not captured by standard Java types. We describe JQual, a tool that adds user-defined
type qualifiers
to Java, allowing programmers to quickly and easily incorporateextra lightweight, application-specific type checking into their programs. JQual provides type qualifier inference, so that programmers need only add a few key qualifier annotations to their program, and then JQual infers any remaining qualifiers and checks their consistency. We explore two applications of JQual. First, we introduce opaque and enumqualifiers to track C pointers and enumerations that flow through Java code via the JNI. In our benchmarks we found that these C values are treated correctly, but there are some places where a client could potentially violate safety. Second,we introduce a read only qualifier for annotating references that cannot be used to modify the objects they refer to. We found that JQual is able to automatically infer read only in many places on method signatures. These results suggest that type qualifiers and type qualifier inference are a useful addition to Java.
Ownership transfer in universe types
Authors: Müller Peter , Rudich Arsenii
Published: November 2007

Ownership simplifies reasoning about object-oriented programs by controlling aliasing and modifications of objects. Several type systems have been proposed to express and check ownership statically.

For ownership systems to be practical, they must allow objects to migrate from one owner to another. This
ownership transfer
is common and occurs, for instance, during the initialization of data structures and when data structures are merged. However, existing ownership type systems either do not support ownership transfer at all or they are too restrictive, give rather weak static guarantees, or require a high annotation overhead.

In this paper, we present UTT, an extension of Universe Types that supports ownership transfer. UTT combines ownership type checking with a modular static analysis to control references to transferable objects. UTT is very flexible because it permits temporary aliases, even across certain method calls. Nevertheless, it guarantees statically that a cluster of objects is externally-unique when it is transferred and, thus, that ownership transfer is type safe. UTT provides the same encapsulation as Universe Types and requires only negligible annotation overhead.
Scalable omniscient debugging
Authors: Pothier Guillaume , Tanter Éric , Piquer José
Published: November 2007

Omniscient debuggers make it possible to navigate backwards in time within a program execution trace, drastically improving the task of debugging complex applications. Still, they are mostly ignored in practice due to the challenges raised by the potentially huge size of the execution traces. This paper shows that omniscient debugging can be realistically realized through the use of different techniques addressing efficiency, scalability and usability. We present TOD, a portable Trace-Oriented Debugger for Java, which combines an efficient instrumentation for event generation, a specialized distributed database for scalable storage and efficient querying, support for partial traces in order to reduce the trace volume to relevant events, and innovative interface components for interactive trace navigation and analysis in the development environment. Provided a reasonable infrastructure, the performance of TOD allows a responsive debugging experience in the face of large programs.
Living it up with a live programming language
Authors: McDirmid Sean
Published: November 2007

A dynamic language promotes ease of use through flexible typing, a focus on high-level programming, and by streamlining the edit-compile-debug cycle. Live languages go beyond dynamic languages with more ease of use features. A
live language
supports
live programming
that provides programmers with responsive and continuous feedback about how their edits affect program execution. A live language is also based on high-level constructs such as declarative rules so that programmers can write less code. A live language could also provide programmers with responsive semantic feedback to enable time-saving services such as code completion. This paper describes the design of a textual live language that is based on reactive data-flow values known as
signals
and
dynamic inheritance
. Our language, SuperGlue, supports live programming with responsive semantic feedback, which we demonstrate with a working prototype.
The transactional memory / garbage collection analogy
Authors: Grossman Dan
Published: November 2007

This essay presents remarkable similarities between transactional memory and garbage collection. The connections are fascinating in their own right, and they let us better understand one technology by thinking about the corresponding issues for the other.
SP1
Authors: Barnes John G. P.
Published: November 2007

Ada 2005 is the latest chapter in the Ada story. Ada 95 was a huge leap forward from Ada 83. However, experience showed that Ada 95 has a number of gaps. Ada 2005 is not such a giant leap forward but aims rather to round off Ada 95 and so provide the community with a really smooth programming language suited for the demanding applications of the 21st century.

John will explain the specific goals of the development and introduce the key new features of Ada 2005. The most obvious new features are in the OO model with the introduction of interfaces and in the real-time area with more control over timing and scheduling plus much more in the predefined library. But there are other improvements as well in areas such as visibility control, exceptions and generics. And of course also downward closures so that Ada is at last as good as Algol 60 in that area.
Using ada in a service-Ooriented architecture
Authors: Sward Ricky E.
Published: November 2007

One of the latest trends in software architecture is known as a Service-Oriented Architecture (SOA). This paper describes SOA briefly and one of the enabling technologies of SOA, namely the Enterprise Service Bus (ESB). The paper goes on to describe two ways in which Ada applications can be built as services in a SOA. The first method is to build the Ada code as a Dynamically Linked Library (DLL) and wrap it in Java code. The second method is to use the Ada Web Server (AWS) and build a direct interface to the Ada code that is needed to plug into the ESB.
Architectural trends in large systems
Authors: Amdahl Gene M.
Published: November 2007

Large systems architectural ideas progressed very rapidly during the middle of the 60's but is currently in a sort of hiatus. This hiatus is largely due to the need to digest the significance of the preceding developments and is currently reinforced by the economic recession. These architectural developments have yielded announced or about to be announced products like the IBM 195, the CDC 7600 and STAR, and the ILLIAC IV. These machines represent not only different solutions to the problem of high performance, but also different views of what constitutes the problem. These concepts of problems, along with their solutions, goes from: consisting of identical processing performed at each of a great many points---so put in many execution units run by a single instruction control---and ranges to: problems require quite diverse functions rather locally---so make it possible to utilize these diverse facilities concurrently. These machines above are listed in the order of their degree of independence of problem regularity when it occurs. The common denominator of these machines is the intent to capitalize upon the existence of concurrently executable sequentially independent process strings.
Microprogramming for computer graphics
Authors: van Dam Andries
Published: November 2007

Interactive computer graphics (graphics) is the construction, storage, retrieval, manipulation, alteration and analysis of pictorial data, using an on-line display console with manual input (interaction) devices. Among such input devices are the alphanumeric and function keyboards for typing text and activating preprogrammed subroutines respectively, and the light pen and data tablet for identifying and entering graphic data by means of pointing and drawing.
The application of microprogramming technology
Authors: Clapp J. A.
Published: November 2007

This report surveys promising applications of microprogramming. Emphasis is on the value of microprogramming as a tool which permits computer users to modify the architecture of a general-purpose machine to better match a particular set of requirements. Factors are discussed which affect the choice of microprogramming over hardware and software in the design and implementation of computer-based systems. Actual and potential examples of its application are given to illustrate its relevance to the solution of implementation and performance problems. Finally, research and development tasks are proposed which lead to the realization of the benefits of this technology in operational systems.
MICSIM - a microprogrammed expression parsing simulator
Authors: Habib S.
Published: November 2007

This section describes the microprogrammed architecture of the translator. This architecture might very well represent a subset of the total computer required to implement the other chores of translation and execution.
The Rio symposium
Authors: McLean Robert S.
Published: November 2007

The Rio Symposium on Computer Education for Developing Countries, held in Rio de Janeiro early in August, 1972, drew 280 computing specialists. They came from 40 countries at virtually all stages of economic development. The majority of the attendance was from the host country, Brazil, with 155 members. The second largest group, and the most vocal in terms of presentations and comments, was from the USA with 29 members. All of the other countries had fewer than ten persons present.
Reading, writing, arithmetic, and computing
Authors: Luehrmann Arthur
Published: November 2007

The promise of technology has always been an increase in productivity. Labor-intensive activities become machine-intensive. It seems likely that this traditional scenario applies to technology and education, probably the most labor-intensive of human activities. New communications technology, new information-processing technology and new systems for creating and validating machine-administered courses of instruction will surely lead to cost reductions and greater personal convenience and individualization.
Teaching recursive programming using BASIC
Authors: Daykin P. N.
Published: November 2007

The value of a recursive programming capability in a high level programming language is now generally recognized. The teaching of recursive programming, however, is often postponed to a second-semester college course in computing science, as if the topic belonged to an advanced level, though it has been shown (1, 2) that recursion can be grasped by students of mathematics at the secondary school level or earlier. One unfortunate result of this postponement of recursion in computing science teaching is that students who take one semester only carry away with them the false notion that computers are limited intrinsically to understanding iterative processes.
An algol-based language for defining collateral execution of procedures in general and hybrid programming in particular
Authors: Roberts John B.
Published: November 2007

Augmentations to Algol 60 are presented which in the first place provide statements for the operation devices by referring to them as reserved Algol identifiers, and for the collateral execution of procedures which use different devices. While explicit sharing of a common data area is not allowed, interaction is permitted if it can be expressed through statements (syntactically similar to the device statements) which address specially defined linking primitives. In this way, reproducible behaviour is guaranteed for programmes, operating ideally asynchronous devices. Further facilities need to be defined, however, for time critical operations associated in particular with hybrid computing. Most of the facilities have been implemented by using a macro-generator.
Opening the sensornet black box
Authors: Choi Jung Il , Lee Jung Woo , Wachs Megan , Levis Philip
Published: November 2007

We argue that the principal cause of sensornet deployment and development difficulty is an inability to observe a network's internal operation. We further argue that this lack of visibility is due to the activity and resource constraints enforced by limited energy. We present the Mote Network (MNet) architecture, which elevates visibility to be its dominant design principle. We propose a quantitative metric for network visibility and explain why network isolation and fairness are critical concerns. We describe the Fair Waiting Protocol (FWP), MNet's single-hop protocol and show how its fairness and isolation can improve throughput and efficiency. We present the Pull Collection Protocol as a case study in designing multihop protocols in the architecture.
Notes on improving Lisp
Authors: McCarthy John
Published: November 2007

I understand that there is considerable tension between the goal of standardizing Common Lisp and the idea, prominent in Europe, that major improvements should be made in the course of creating an international standard. I agree with the idea that Common Lisp should be standardized as a consolidation of existing practice, and that innovations should be avoided in this process. My experience with the Algol 60 meetings led me to the opinion that innovation and standardization do not mix well. The trading involved in compromising interests in existing ways of doing things is only too compatible with what might be called implicit academic log rolling. "I'll agree that your new idea is great if you'll agree with mine." The result is an unimplementable monstrosity.
Lisp environments
Authors: Foderaro John
Published: November 2007

In this issue we survey the Lisp programming environment provided on the family of Lisp machines built by Xerox. These machines, which once ran only Interlisp-D, are now said to run 'Xerox Lisp' which is a combination of Interlisp-D and Common Lisp.
Overview of garbage collection in symbolic computing
Authors: McEntee Timothy J.
Published: November 2007

Many readers of this article have heard the term "garbage collection" on occasion without being given much explanation as to what it is. One purpose of this paper, therefore, is to describe what garbage collection is and why it is a subject of concern for computing in general and symbolic computing in particular. The first section briefly describes garbage collection. The next section gives a general description of what has come to be known as the "classical" garbage collection algorithms. A few of the classical algorithms' shortcomings for use in today's systems are described in the next section. This is followed by a section on a few techniques in garbage collection which address the needs of today's and tomorrow's symbolic computing systems.
LYSP
Authors: Kosinski Paul R.
Published: November 2007

Some ten years ago, a small group of us at IBM Research undertook to write a new kind of text editor, to run in the VM/370 environment, based on our experience with the experimental Business Definition System (BDS) we had implemented previously. This new editor, called the Parametric Editor, or P-EDIT, was to be upwards compatible with an existing popular editor in use at that time, while providing the ability to edit multiple versions of a file simultaneously, and providing a general UNDO command which could be used to return to any previous state of the editing session, and which itself was UNDOable.
The scheme environment
Authors: Clinger William
Published: November 2007

Scheme variables have
static scope
and
indefinite extent
. That is, the visibility (or scope) of a Scheme variable can be determined statically by looking at the lexical structure of a program, and the lifetime (or extent) of the variable is unbounded. The reason variables have indefinite extent in Scheme is that they may be remembered by procedures created as the result of evaluating a lambda expression.
Query-io
Authors: Dussud Patrick
Published: November 2007

I was wondering how someone can build a list from left to right efficiently in Lisp without using a loop macro.
Compacting garbage collection with ambiguous roots
Authors: Bartlett Joel F.
Published: November 2007

Many modern garbage collectors [4] recover space by copying. Using an initial "root" set of pointers which are stored in known locations, all accessible objects are copied into a "new space". Two of the attractive properties of such a collector are that it results in memory compaction and it can have a running time proportional to the amount of accessible storage [2]. However, such schemes place a large burden on the underlying system as all pointers to the objects must be found and changed.
(algorithms)
Authors: Curtis Pavel
Published: November 2007

Welcome to the first appearance of this new Lisp Pointers department on Algorithms. It has been noted by some editors that most Lisp hackers would rather write code than articles and I suspect that their reading preferences might run the same way. This department is an attempt to cater to those preferences. The articles you'll see here will tend to fit into one or more of three broad categories:

• Annotated implementations of interesting and relevant algorithms that make particularly good or novel use of the unique features of the Lisp family of programming languages (e.g., closures, continuations, code as data, polymorphism).

• Annotated implementations of algorithms whose subject matter is the Lisp family of languages (e.g., code analysis tools, iteration facilities, generic arithmetic), and

• Discussion of performance issues, benchmarking, or implementation experiences for interesting algorithms written in or about the Lisp family of languages.
The scheme of things
Authors: Clinger William
Published: November 2007

A reader has asked for suggestions on how to write Common Lisp programs so that they can in the future be translated into Scheme without too much difficulty. Someone else wants to write programs in Scheme that might eventually be translated into Common Lisp. These are interesting questions, but a related question is more immediate: How do you write programs in Scheme that can easily be translated to run in other implementations of Scheme?
Dynamic extent objects
Authors: Queinnec Christian
Published: November 2007

Lisp objects are heap- rather than stack-allocated because their extent is generally indefinite. Since stack-deallocation is performed without running the garbage collector, speed improvements are expected. Dedicated hardware can stack-allocate objects associated with reference counters or microcode daemons such that one can exactly know the status of the object to be deallocated and perform whatever appropriate treatment (usually a copy in the heap) according to its reachability. However such a solution is not efficient on stock hardware.

This paper presents and analyses a new technique to efficiently solve this problem. It creates first class dynamic extent objects (DEO) that are stack-allocated, permits to access them only while they are in the stack and prevent to follow up dangling pointers. Every usual indefinite extent object has its counterpart as a DEO associated with the same set of operators. Finally DEO do not require dedicated hardware and may be properly compiled. The technique can be used within other programming languages. Some performance figures are discussed at the end of the paper.
Recursive hidden-line elimination on an infinite surface
Authors: Greenspun Philip , Little James J.
Published: November 2007

Algorithms that display a piece of an arbitrary, infinite surface with a vector display or pen plotter are well-known (Figure 1). Iterative algorithms can be time-consuming to implement in Fortran or PL/1. We designed, coded and debugged a substantially more perspicuous implementation in Common Lisp in about two hours on a Symbolics 3670.
(algorithms)
Authors: Curtis Pavel
Published: November 2007

This issue's installment of (algorithms) is an article by Olivier Danvy giving his elegant solution to the (by now infamous) xp1 puzzle posed by Christian Queinnec and Jérôme Chailloux back in issue I-6 of Lisp Pointers. The code in the article is written in Scheme, but should be reasonably easy for any Common Lisp programmer to read. Just in case, I've included a short guide to Scheme for Common Lisp programmers at the end of the article.
A syntactic closures macro facility
Authors: Hanson Chris
Published: November 2007

This document describes
syntactic closures
, a low-level macro facility for the Scheme programming language. The facility is an alternative to the low-level macro facility described in the
Revised 4 Report on Scheme.
This document is an addendum to that report.
Macros in Scheme
Authors: Clinger William
Published: November 2007

Although macros are even older than Lisp, Scheme has just become the first block-structured programming language to support a reliable macro system. This macro system is described in the appendix to the
Revised
4
Report on the Algorithmic Language Scheme
, which appeared in the previous issue of
Lisp Pointers.
This issue contains three more articles on the subject of macros in Scheme, counting the article you are reading. I wrote this as an introduction to the other two articles, because it is very hard to understand their purpose without some background on macros in Scheme.
Hygienic macros through explicit renaming
Authors: Clinger William
Published: November 2007

This paper describes an alternative to the low-level macro facility described in the

Revised
4
Report on the Algorithmic Language Scheme

[1]. The facility described here is based on explicit renaming of identifiers, and was developed for the first implementation of the hygienic macro expansion algorithm described in [2]. It was the first low-level macro facility to be designed for compatibility with a high-level hygienic macro system, and it remains one of the easiest to understand.
Programming environments
Authors: Foderaro John
Published: November 2007

I'd like to remind everyone to send me articles or letters with your thoughts on the important issues and developments in programming language environments. My address is printed at the beginning of this newsletter.
The "art" of programming gossip-based systems
Authors: Eugster Patrick , Felber Pascal , Le Fessant Fabrice
Published: November 2007

How does one best go about building actual gossip-based protocols? Trying to answer this question has brought us to address two preliminary questions, namely (1) what the intrinsics of such systems or protocols are, and (2) what kind of applications would in the end be built on top of such protocols. We address the first question by arguing that gossip-based protocols are all built following one and the same pattern, and describing three building blocks which we claim are used to support this recurrent pattern---most notably a source of randomness. We validate these claims by devising simplified versions of well-known protocols, in a layered fashion, on top of a conceptual interface describing these basic services. The second question is addressed by arguing that gossip-based protocols exhibit some probabilistic or imperfect flavor (e.g., probabilistic or partial completion), and by proposing to take such probabilistic behavior into account when devising interfaces for applications building on top of gossip-based protocols. We argue for inherent support for these probabilities in the programming model.
Reliable on-demand management operations for large-scale distributed applications
Authors: Liang Jin , Gupta Indranil , Nahrstedt Klara
Published: November 2007

This paper argues for attention to, and proposes a novel direction to solving,
instant monitoring and management
tasks for large-scale distributed applications running across hundreds of hosts. We present the MON (Management Overlay Networks) approach
1
, which uses a novel concept called
on-demand overlays
, in order to support instant commands such as queries and software pushes. On-demand overlays are built on-the-fly and probabilistically, by leveraging weakly-consistent gossip-style membership information underneath. Thus, they are lightweight in terms of memory, computation, and bandwidth. We augment on-demand overlays with several notions of application-specified reliability, and show how MON detects and adheres to these. MON is available atop PlanetLab, and we present experimental results. We conclude with a series of promising open problems in this direction.
Ground Control to Architect Tom...
Authors: Bell Alex
Published: November 2007

Project managers love him, recent software engineering graduates bow to him, and he inspires code warriors deep in the development trenches to wonder if a technology time warp may have passed them by. How can it be that no one else has ever proposed software development with the simplicity, innovation, and automation being trumpeted by Architect Tom? His ideas sound so space-age, so futuristic, but why should that be so surprising? After all, Tom is an architecture astronaut! Architecture astronauts such as Tom naturally think at such high levels of innovation because they spend much of their time in high orbit where low oxygen levels counterbalance the technological shackles imposed by reality.
The Code Delusion
Authors: Kelly-Bootle Stan
Published: November 2007

No, I’m not cashing in on that titular domino effect that exploits best sellers. The temptations are great, given the rich rewards from a gullible readership, but offset, in the minds of decent writers, by the shame of literary hitchhiking. Thus, guides to the Louvre become The Da Vinci Code Walkthrough for Dummies, milching, as it were, several hot cows on one cover. Similarly, conventional books of recipes are boosted with titles such as The Da Vinci Cookbook—Opus Dei Eating for the Faithful. Dan Brown’s pseudofiction sales stats continue to amaze, cleverly stimulated by accusations of plagiarism and subsequent litigation.
Evaluation of distributed cover set algorithms in mobile ad hoc network for simplified multicast forwarding
Authors: Macker Joseph , Downard Ian , Dean Justin , Adamson Brian
Published: November 2007

This paper presents design issues and performance analysis of optimized cover set algorithms supporting Simplified Multicast Forwarding (SMF) of data plane traffic within mobile ad hoc network (MANET) environments. SMF is presently being developed within the Internet Engineering Task Force (IETF) as an experimental specification to provide simplified multicast data dissemination among multi-hop, wireless nodes within peer MANET routing neighborhoods. The SMF protocol allows for a variety of cover set reduction techniques to optimize the simplified data flooding and relaying process amongst routing peers. A variety of distributed algorithms for forming connected dominating sets (CDS) are being considered as mechanisms to reduce the cover set. This paper presents modeling and analysis work of various CDS relay set algorithms and demonstrates working code within an SMF implementation. We provide a brief problem background, discuss models and scenarios, compare various algorithms, and then summarize observations as well as discuss future work. A main purpose of the paper is to begin examining the robustness of the algorithms to mobility and increasing multicast traffic load. We examine the results against a classical flooding baseline for comparison. We observe similar efficiency and robustness performance for several forwarding algorithms of interest.
An efficient cross layer scheduler for multimedia traffic in wireless local area networks with IEEE 802.11e HCCA
Authors: Cicconetti Claudio , Lenzini Luciano , Mingozzi Enzo , Stea Giovanni
Published: November 2007

This paper proposes a scheduling algorithm, namely Wireless Timed Token Protocol (WTTP), for the Hybrid Coordination Function (HCF) Controlled Channel Access (HCCA) in IEEE 802.11e. WTTP provides traffic streams with a minimum reserved rate, as required by the standard, and it accounts for two types of traffic streams simultaneously, depending on the corresponding application: constant bit rate, which are served according to their rate, and variable bit rate traffic streams. The latter are guaranteed a minimum rate, but they are also allowed to exploit unused bandwidth, which preserves small access delays in case of bursty arrivals. Additionally, WTTP shares the capacity which is not reserved for QoS traffic streams transmissions among traffic flows with no specific QoS requirements. We also propose a strategy for the QoS Access Point to infer the idle/busy status of the uplink transmission buffers, based on cross layer information made available at the MAC by the application layer, which allows channel capacity to be saved. WTTP exhibits O(1) per packet computational complexity. We evaluate the performance of WTTP via simulation under different traffic conditions, and we investigate its resilience to variations of different system parameters.
An algorithm for fast, model-free tracking indoors
Authors: Chen Aiyou , Harko Cristina , Lambert Diane , Whiting Phil
Published: November 2007

Tracking people and objects indoors from signal strength measurements has applications as diverse as security monitoring, self-guided museum tours, and personalization of communications services. Accurate dynamic tracking in real-time has been elusive, though, because signal propagation in buildings and the paths that people follow are complex. This paper proposes a simple algorithm for indoor tracking that requires neither a propagation model nor a motion model. It is also simple to compute, requiring only standard tools: Delaunay triangulation, linear interpolation, moving averaging, and local regression. Experiments with real data and simulations based on real data show that the algorithm is not only simple, it is effective.
Designing mobility models based on social network theory
Authors: Musolesi Mirco , Mascolo Cecilia
Published: November 2007

Validation of mobile ad hoc network protocols relies almost exclusively on simulation. The value of the validation is, therefore, highly dependent on how realistic the movement models used in the simulations are. Since there is a very limited number of available real traces in the public domain, synthetic models for movement pattern generation must be used. However, most widely used models are currently very simplistic, their focus being ease of implementation rather than soundness of foundation. Simulation results of protocols are often based on randomly generated movement patterns and, therefore, may differ considerably from those that can be obtained by deploying the system in real scenarios. Movement is strongly affected by the needs of humans to socialise or cooperate, in one form or another. Fortunately, humans are known to associate in particular ways that can be mathematically modelled and that have been studied in social sciences for years.

In this paper we propose a new mobility model founded on social network theory. The model allows collections of hosts to be grouped together in a way that is based on social relationships among the individuals. This clustering is then mapped to a topographical space, with movements influenced by the strength of social ties that may also change in time. We have validated our model with real traces by showing that the synthetic mobility traces are a very good approximation of human movement patterns. The impact of the adoption of the proposed algorithm on the performance of AODV and DSR is also presented and discussed.
Risk of malignant brain tumors and cell phone use
Authors: Lin James C.
Published: November 2007

It has been estimated that there are about 2 billion users of cellular mobile telephones worldwide. The popularity of cellular telephones is beyond any debate. It's a good guess that most, if not all users, would prefer no links between cellular telephone and health effect, let alone cell-phone use and cancer.
On the correctness issues in two-process mutual exclusion algorithms
Authors: Banerjee Jayasri , Bandyopadhyay Anup Kumar , Mandal Ajit Kumar
Published: November 2007

Correctness issues in two process mutual exclusion algorithms are investigated. A new theorem is proposed and proved that describes the key concept involved in such algorithms. For the purpose of proving the techniques developed in [3] are used. Result of this theorem is applied to two different algorithms of which one could be proved incorrect. Technique developed in [3] is also used to prove the correct algorithm.
High-level open evolvable systems design by process-oriented modeling
Authors: Bastani Behzad , Bastani Hoda
Published: November 2007

Open Evolvable Systems' design requires a methodological [1] and conceptual paradigm different from the conventional software design. Evolvable Systems' research [2, 6, 16, and 17] has established itself as a new research field, but the content is more domain-oriented than universal. Consequently, major contributions toward substantiation of that universal methodological and conceptual paradigm are yet to come. In this paper we present a new perspective and method for the general-purpose design of Evolvable Systems. The paper presents the attributes of the Evolvable Systems and discusses the distinction between Evolvable Systems' and conventional software design as well as the methodological ramifications. We pose and address the question of what is an efficient methodology for designing a system for which we do not know the boundaries? We present our version of Process-oriented Modeling as the key method in the high-level design of Evolvable Systems and show its utilization in implementation of one modeling case of a complex Evolvable System, the DNA replication process. We also present the dynamic aspects of the design process management and pre-code verifications in the framework of Quantified Controls and Simulations.
TXM
Authors: Cordeiro Lucas , Barreto Raimundo , Barcelos Rafael , Oliveira Meuse , Lucena Vicente , Maciel Paulo
Published: November 2007

Arterial oxygen saturation and heart rate measured by pulse oximetry is widely used to monitor critical care patients. This kind of system is classified as embedded hard real-time system and requires rigorous development methodologies to guarantee the correctness and timeliness of the application. Therefore, the proposed development methodology combines agile principles with organizational patterns and adapts them to build medical devices focusing on the issues related to the system's constraints and safety. Strong unit testing is the foundation of the proposed methodology for ensuring timeliness and correctness. Moreover, platform-based design approach is used to balance costs and time-to-market in view of performance and functionality constraints. We conclude that the proposed methodology reduces significantly the design time and cost as well as leads to better software modularity and safety.
Surfing the net for software engineering notes
Authors: Doernhoefer Mark
Published: November 2007

The web has a lot of sites devoted to testing and test tools. If you are in charge of designing a test program for your development, a few hours surfing the sites listed here could get you off to a pretty good start. We'll visit some of the sites that offer test tools, but for the most part, I'm going to focus on sites that talk about testing, test methods, and test plans. There will be plenty of sites that have links to the tools, so you can take off from there. But remember, a test tool is
not
a test plan.
Modelaide
Authors: Shrager Richard I.
Published: November 2007

Mathematical modeling is a subtle mental exercise in which the computer, as we know it, can only serve as a mechanical aid. While the computer can improve the sum of squares given data, model, and first estimate of parameters, and while it can perform routine transformations on data, or error analyses, finally a man must judge if the fit is good, if the model makes sense, if parameters can be discarded, if an observation is faulty, and countless other judgements which are impractical to program. To quote Richard Hamming, "The purpose of computing is insight, not numbers." Our purpose is to lower the computation barrier between an investigator and a useful model.
Transactional evaluation
Authors: Seidel Robert J.
Published: November 2007

Evaluation in educational R&D programs seems to wear many hats. There is the goal-free approach of Scriven (1974), responsive evaluation of Stake (1967) and Evers (1975), standard goal-based evaluation techniques (summarized by Stufflebeam,
et al.
, 1971), etc. All of these evaluation techniques or models have one attribute in common. They all focus on the object of the innovation, whether it be change in process of learning by the student, or attaining of mastery of new objectives, or affective movement, etc. What seems to be missing from these approaches to evaluation of programs, and what transactional evaluation seems to provide an answer to--is a focus on the inter-personal effects of the perceptions of project team members and the people in the surrounding environment where the implementation or experimentation is taking place (see for example, Seidel,
et al.
, 1974; Hunter,
et al.
, 1975).
Evaluation of computer-based instructional material
Authors: Brown Bobby R. , Ellinger Robert S.
Published: November 2007

In this paper the authors address some of the benefits to be derived through evaluation in the development and the dissemination of computer based instructional materials. Formative evaluation is discussed as a practical and worthwhile means of improving quality and effectiveness of instructional material. The importance of summative evaluation and documentation for intelligent selection and use of disseminated instructional material is discussed. Procedural suggestions are offered for employing both formative and summative evaluation within the context of systematic instructional design. An example is presented in which these suggested procedures were employed.
The computer users group
Authors: Ludgin Quentin
Published: November 2007

The Computer Users Group has been officially sanctioned by the Bureau of the Census as a forum for the interchange of information among the working-level programmers at the Bureau. At the biweekly meetings, programmers from over thirty different divisions meet in a relaxed atmosphere with responsible officials from the "provider" divisions in the EDP area. Since 1977, I have served as Chairman of this group. In this paper, I propose to examine the path by which it has reached its current status as an effective tool for both the programmers and the "providers."