bluuebunny/crossref_metadata_2025 huggingface dataset:
Staffing the user services function
Authors: Simonson Eve
Published: January 2007

Ten years ago, User Services Organizations did not exist at most university computer installations. In fact, the need for this type of service wasn't present ten years ago. At that time computers were rather small, and research processing was a hands-on operation. Most of the computer users were from the hard sciences --- math and physics. Very few social scientists had the background or desire to learn how to program the computer to perform the data analyses required in their research. BMD, one of the first statistical packages, was begun in 1964. This was followed by SPSS in 1965, and SAS in 1966. These packages were developed in response to a need --- the need to simplify the process of data handling and statistical analyses. At the same time, however, those packages opened the world of computers to many new users who had little or no technical background in computer science. User Services Departments have evolved in large part to meet the need for assistance by such unsophisticated users.
Educating computer people about people & computers
Authors: Scown Philip J. A. , McManus Barbara
Published: January 2007

This report describes a panel session on HCI Education held at the HCI'95 Conference. During the debate, expert views were expressed about many of the key issues affecting HCI teachers today, including: how can educators cope with the flood of new HCI ideas? should HCI be fully integrated into software engineering courses or taught in specialist modules? what are the core elements of HCI that all students should learn? there are perceived cultural differences in HCI teaching in the UK, USA and Scandinavia --- are these differences real and are they important? should we be sharing educational materials? can HCI design be taught or are creative designers born not bred?
How machine delays change user strategies
Authors: O'Donnell Paddy , Draper Stephen W.
Published: January 2007

As machine response delays vary, the most important effect on users may be not their annoyance but that they change the way they use an interface. Even the very simple task of copytyping three digit numbers gives rise to at least three different user strategies (i.e. procedures). However the effect seems not be a simple function of delay length, contrary to earlier reported work. Instead users are probably shifting between strategies more fluidly.
Objects in real-time systems
Authors: Achauer Bruno
Published: January 2007

Object-oriented languages are now recognized as powerful tools for building large and complex applications. In particular, two central aspects of the object paradigm are encapsulation and inheritance; these provide a sound basis for creating software that is easy to maintain and reuse.
Object technologies and real-time scheduling
Authors: Forbes Harold , Schwan Karsten
Published: January 2007

Any object-based real-time system gives rise to real-time scheduling issues not easily solved by use of standard scheduling methods, including: (1) the invocation of an object's method may imply the need for online schedulability analysis for the thread(s) able to execute method code, (2) parallelism internal to objects may result in the need to schedule multiple threads and target processors simultaneously, and (3) methods that invoke other methods as part of their execution give rise to hierarchically composed groups of to-be-scheduled real-time threads. The Rapid scheduler presented in this paper addresses such dynamic object-based real-time systems for target machines comprised of both multi- and uniprocessor machines. To address the variety of needs of object-based real-time systems, Rapid is 1) configurable to the target multiprocessor architecture, 2) dynamically re-configurable to changes in application requirements, 3) efficient in terms of processor utilization, and 4) effective in producing high quality schedules. Rapid's current implementation addresses hard deadline application, with future work concerning alternative formulations of timing constraints.
Book review: Machine Learning, Neural and Statistical Classification Edited by D. Michie, D.J. Spiegelhalter and C.C. Taylor (Ellis Horwood Limited, 1994)
Authors: Liu Huan
Published: January 2007

The book is based on the "StatLog" project which lasted from 1990 to 1993, and involved six academic and 6 industrial laboratories. Statisticians, AI researchers in machine learning, and neural net specialists conducted extensive, collaborative work on the task of
classification.
This well-edited book provides an up-to-date review of different approaches to classification, compares their performance on a wide range of challenging datasets, and draws conclusions on their applicability to realistic industrial problems.
ABA
Authors: Gomes Carla Pedro , Hsu Julie
Published: January 2007

In this paper we describe an approach to allocating a set of tasks to a set of resources or processors. The novelty of the approach has to do with the way decisions are performed. Rather than making one decision about one resource (or one task) at a time, several decisions concerning multiple resources and multiple tasks are made at a time. The algorithm incorporates the formulation of the assignment problem. Furthermore, knowledge about temporal constraints between activities is exploited to improve the computational efficiency of the algorithm. The algorithm is very flexible, allowing for the incorporation of different types of constraints as well as the consideration of non-equivalent resources.
A review of symbolic solvers
Authors: Bernardin Laurent
Published: January 2007

Solving equations and systems of equations symbolically is a key feature of every Computer Algebra System. This review examines the capabilities of the six best known general purpose systems to date in the area of general algebraic and transcendental equation solving. Areas explicitly not covered by this review are differential equations and numeric or polynomial system solving as special purpose systems exist for these kinds of problems.The aim is to provide a benchmark for comparing Computer Algebra Systems in a specific domain. We do not intend to give a rating of overall capabilities as for example [8].
Fast message assembly using compact address relations
Authors: Dinda Peter A. , O'Hallaron David R.
Published: January 2007

Message assembly and disassembly represent a significant fraction of total communication time in many parallel systems. We introduce a run-time approach for fast message assembly and disassembly. The approach is based on generating addresses by decoding a precomputed and compactly stored address relation that describes the mapping of addresses on the source node to addresses on the destination node. The main result is that relations induced by redistributions of regular block-cyclic distributed arrays can be encoded in an extremely compact form that facilitates high throughput message assembly and disassembly. We measure the throughput of decoding-based message assembly and disassembly on several systems and find performance on par with copy throughput.
Coordinated allocation of memory and processors in multiprocessors
Authors: Parsons Eric W. , Sevcik Kenneth C.
Published: January 2007

An important issue in multiprogrammed multiprocessor systems is the scheduling of parallel jobs. Most research in the area has focussed solely on the allocation of processors to jobs. However, since memory is also a critical resource for many parallel jobs, the allocation of memory and processors must be coordinated to allow the system to operate most effectively.To understand how to design such coordinated scheduling disciplines, it is important to have a theoretical foundation. To this end, we develop bounds on the achievable system throughput when both memory and processing time are in demand. We then propose and simulate a simple discipline and relate its performance to the throughput bounds. An important result of our work is for the situation in which the workload speedup is convex (from above), but the speedup characteristics of individual jobs are unknown. It shows that an equi-allocation strategy for processors can achieve near-maximum throughput, yet offer good mean response times, when both memory and processors are considered.
Embra
Authors: Witchel Emmett , Rosenblum Mendel
Published: January 2007

This paper describes Embra, a simulator for the processors, caches, and memory systems of uniprocessors and cache-coherent multiprocessors. When running as part of the SimOS simulation environment, Embra models the processors of a MIPS R3000/R4000 machine faithfully enough to run a commercial operating system and arbitrary user applications. To achieve high simulation speed, Embra uses dynamic binary translation to generate code sequences which simulate the workload. It is the first machine simulator to use this technique. Embra can simulate real workloads such as multiprocess compiles and the SPEC92 benchmarks running on Silicon Graphic's IRIX 5.3 at speeds only 3 to 9 times slower than native execution of the workload, making Embra the fastest reported complete machine simulator. Dynamic binary translation also gives Embra the flexibility to dynamically control both the simulation statistics reported and the simulation model accuracy with low performance overheads. For example, Embra can customize its generated code to include a processor cache model which allows it to compute the cache misses and memory stall time of a workload. Customized code generation allows Embra to simulate a machine with caches at slowdowns of only a factor of 7 to 20. Most of the statistics generated at this speed match those produced by a slower reference simulator to within 1%. This paper describes the techniques used by Embra to achieve high performance, focusing on the requirements unique to machine simulation, including modeling the processor, memory management unit, and caches. In order to study Embra's memory system performance we use the SimOS simulation system to examine Embra itself. We present a detailed breakdown of Embra's memory system performance for two cache hierarchies to understand Embra's current performance and to show that Embra's implementation techniques benefit significantly from the larger cache hierarchies that are becoming available. Embra has been used for operating system development and testing as well as for studies of computer architecture. In this capacity it has simulated large, commercial workloads including IRIX running a relational database system and a CAD system for billions of simulated machine cycles.
Asynchronous updates in large parallel systems
Authors: Greenberg Albert G. , Shenker S. , Stolyar Alexander L.
Published: January 2007

Lubachevsky [5] introduced a new parallel simulation technique intended for systems with limited interactions between their many components or sites. Each site has a local simulation time, and the states of the sites are updated asynchronously. This asynchronous updating appears to allow the simulation to achieve a high degree of parallelism, with very low overhead in processor synchronization. The key issue for this asynchronous updating technique is: how fast do the local times make progress in the large system limit? We show that in a simple
K
-random interaction model the local times progress at a rate 1/(
K
+ 1). More importantly, we find that the asymptotic distribution of local times is described by a
traveling wave
solution with exponentially decaying tails. In terms of the parallel simulation, though the interactions are local, a very high degree of global synchronization results, and this synchronization is succinctly described by the traveling wave solution. Moreover, we report on experiments that suggest that the traveling wave solution is
universal;
i.e., it holds in realistic scenarios (out of reach of our analysis) where interactions among sites are not random.
Design and analysis of frame-based fair queueing
Authors: Stiliadis Dimitrios , Varma Anujan
Published: January 2007

In this paper we introduce and analyze
frame-based fair queueing
, a novel traffic scheduling algorithm for packet-switched networks. The algorithm provides end-to-end delay bounds identical to those of PGPS (packet-level generalized processor sharing), without the complexity of simulating the fluid-model system in the background as required in PGPS. The algorithm is therefore ideally suited for implementation in packet switches supporting a large number of sessions. We present a simple implementation of the algorithm for a general packet switch. In addition, we prove that the algorithm is fair in the sense that sessions are not penalized for excess bandwidth they received while other sessions were idle. Frame-based fair queueing belongs to a general class of scheduling algorithms, which we call
Rate-Proportional Servers
. This class of algorithms provides the same end-to-end delay and burstiness bounds as PGPS, but allows more flexibility in the design and implementation of the algorithm. We provide a systematic analysis of this class of schedulers and obtain bounds on their fairness.
Networking support for large scale multiprocessor servers
Authors: Yates David J. , Nahum Erich M. , Kurose James F. , Towsley Don
Published: January 2007

Over the next several years the performance demands on globally available information servers are expected to increase dramatically. These servers must be capable of sending and receiving data over hundreds or even thousands of simultaneous connections. In this paper, we show that connection-level parallel protocols (where different connections are processed in parallel) running on a shared-memory multiprocessor can deliver high network bandwidth across a large number of connections.We experimentally evaluate connection-level parallel implementations of both TCP/IP and UDP/IP protocol stacks. We focus on three questions in our performance evaluation: how throughput scales with the number of processors, how throughput changes as the number of connections increases, and how fairly the aggregate bandwidth is distributed across connections. We show how several factors impact performance: the number of processors used, the number of threads in the system, the number of connections assigned to each thread, and the type of protocols in the stack (i.e., TCP versus UDP).Our results show that with careful implementation connection-level parallel protocol stacks scale well with the number of processors, and deliver high throughput which is, for the most part, sustained as the number of connections increases. Maximizing the number of threads in the system yields the best overall throughput. However, the best fairness behavior is achieved by matching the number of threads to the number of processors and scheduling connections assigned to threads in a round-robin manner.
Micro-architecture evaluation using performance vectors
Authors: Krishnaswamy Umesh , Scherson Isaac D.
Published: January 2007

Benchmarking is a widely used approach to measure computer performance. Current use of benchmarks only provides running times to describe the performance of a tested system. Glancing through these execution times provides little or no information about system strengths and weaknesses. A novel benchmarking methodology is proposed to identify key performance parameters; the methodology is based on measuring performance vectors. A performance vector is a vector of ratings that represents delivered performance of primitive operations of a system. Measuring the performance vector of a system in a typical user workload can be a tough problem. We show how the performance vector falls out of an equation consisting of dynamic instruction counts and execution times of benchmarks. We present a non-linear approach for computing the performance vector. The efficacy of the methodology is ascertained by evaluating the micro-architecture of the Sun SuperSPARC superscalar processor using SPEC benchmarks. Results show interesting tradeoffs in the SuperSPARC and speak favorably of our methodology.
Self-similarity in World Wide Web traffic
Authors: Crovella Mark E. , Bestavros Azer
Published: January 2007

Recently the notion of
self-similarity
has been shown to apply to wide-area and local-area network traffic. In this paper we examine the mechanisms that give rise to the self-similarity of network traffic. We present a hypothesized explanation for the possible self-similarity of traffic by using a particular subset of wide area traffic: traffic due to the World Wide Web (WWW). Using an extensive set of traces of actual user executions of NCSA Mosaic, reflecting over half a million requests for WWW documents, we examine the dependence structure of WWW traffic. While our measurements are not conclusive, we show evidence that WWW traffic exhibits behavior that is consistent with self-similar traffic models. Then we show that the self-similarity in such traffic can be explained based on the underlying distributions of WWW document sizes, the effects of caching and user preference in file transfer, the effect of user "think time", and the superimposition of many such transfers in a local area network. To do this we rely on empirically measured distributions both from our traces and from data independently collected at over thirty WWW sites.
On the modeling and performance characteristics of a serpentine tape drive
Authors: Hillyer Bruce K. , Silberschatz Avi
Published: January 2007

New applications require online access to many terabytes of data, but a magnetic disk storage system this large requires thousands of drives. Magnetic tape is be a good alternative, except that the application demand for transparent data retrieval is not met by current tape systems because of their high access latency. This latency can be significantly improved by good retrieval scheduling. A fundamental prerequisite to efficient scheduling is the ability to estimate the amount of time required for tape positioning operations (the
locate time
). For serpentine tape, which is the most common mass storage tape technology, this estimation is subtle and complex. The main contribution of this paper is a locate-time model for a DLT4000 tape drive. The accuracy of the model is evaluated by measurements, and the utility of the model is demonstrated through a model-driven simulation of retrieval scheduling, validated by measurements and sensitivity testing. In brief, the locate-time model is accurate to within a few percent, which enables the production of efficient schedules.
An analytic model of hierarchical mass storage systems with network-attached storage devices
Authors: Menascé Daniel A. , Pentakalos Odysseas I. , Yesha Yelena
Published: January 2007

Network attached storage devices improve I/O performance by separating control and data paths and eliminating host intervention during data transfer. Devices are attached to a high speed network for data transfer and to a slower network for control messages. Hierarchical mass storage systems use disks to cache the most recently used files and tapes (robotic and manually mounted) to store the bulk of the files in the file system. This paper shows how queuing network models can be used to assess the performance of hierarchical mass storage systems that use network attached storage devices. The analytic model validated through simulation was used to analyze many different scenarios.
On optimal piggyback merging policies for video-on-demand systems
Authors: Aggarwal Charu , Wolf Joel , Yu Philip S.
Published: January 2007

A critical issue in the performance of a video-on-demand system is the I/O bandwidth required in order to satisfy client requests. A number of techniques have been proposed in order to reduce these bandwidth requirements. In this paper we concentrate on one such technique, known as adaptive piggybacking. We develop and analyze piggyback merging policies which are optimal over large classes of reasonable methods.
Supporting stored video
Authors: Salehi James D. , Zhang Zhi-Li , Kurose James F. , Towsley Don
Published: January 2007

VBR compressed video is known to exhibit significant, multiple-time-scale bit rate variability. In this paper, we consider the transmission of stored video from a server to a client across a high speed network, and explore how the client buffer space can be used most effectively toward reducing the variability of the transmitted bit rate.We present two basic results. First, we present an optimal smoothing algorithm for achieving the
greatest possible reduction in rate variability
when transmitting stored video to a client with given buffer size. We provide a formal proof of optimality, and demonstrate the performance of the algorithm on a set of long MPEG-1 encoded video traces. Second, we evaluate the impact of optimal smoothing on the network resources needed for video transport, under two network service models: Deterministic Guaranteed service [1, 9] and Renegotiated CBR (RCBR) service [8, 7]. Under both models, we find the impact of optimal smoothing to be dramatic.
Analysis of balanced fork-join queueing networks
Authors: Varki Elizabeth , Dowdy Lawrence W.
Published: January 2007

This paper presents an analysis of closed, balanced, fork-join queueing networks with exponential service time distributions. The fork-join queue is mapped onto two non-parallel networks, namely, a serial-join model and a state-dependent model. Using these models, it is proven that the proportion of the number of jobs in the different subsystems of the fork-join queueing network remains constant, irrespective of the multiprogramming level. This property of balanced fork-join networks is used to compute quick, inexpensive bounds for arbitrary fork-join networks.
Why computer algebra systems sometimes can't solve simple equations
Authors: Fateman Richard J.
Published: January 2007

Among the basic equations one might wish a computer to solve symbolically is the inverse of the power function, solving
y
=

z
w

for
z.
(Note:

z
w

≡ exp(
w
ln
z
)). While many special cases, easily solved, abound, the general question is fraught with implications: if this is so hard, how can we expect success in other ventures? Having solved this, we can naturally use it in a "composition" of solution methods for expressions of the form
y
=
f
(
z
)

w

.Can't we already do this? Is it not the case that the solution of
y
=

z
a+bi

is trivially
z
=
y

1/(
a+bi
))

?Not so. if this were the case, then a plot of the function
t
(
y
) :=
y
- (
y

1/(1+
i
))

)

1+
i

would be indistinguishable from
t
(
y
) ≡ 0. For many values,
t
(
y
) is (allowing for round-off error), zero. But if your computer system correctly computes with values in the complex plane, then, (to pick two complex points from a region described later),
t
(-10000 + 4000
i
) is not zero, but about -9981 + 3993
i
and
t
(-0.01 + 0.002
i
) is about 5.34 - 1.06
i.
These strange numbers are not the consequence of round-off error or some other numerical phenomena. The alleged solution is just not mathematically correct.Computer algebra systems as usually programmed lack the expressive capability to return the exact and complete set of solutions, in general.
Experiments in automated load balancing
Authors: Wilson Linda F. , Nicol David M.
Published: January 2007

One of the promises of parallelized discrete-event simulation is that it might provide significant speedups over sequential simulation. In reality, high performance cannot be achieved unless the system is fine-tuned to balance computation, communication, and synchronization requirements. In this paper, we discuss our experiments in automated load balancing using the SPEEDES simulation framework. Specifically, we examine three mapping algorithms that use run-time measurements. Using simulation models of queuing networks and the National Airspace System, we investigate (i) the use of run-time data to guide mapping, (ii) the utility of considering communication costs in a mapping algorithm, (iii) the degree to which computational ``hot-spots'' ought to be broken up in the linearization, and (iv) the relative execution costs of the different algorithms. We compare the performance of the three algorithms using results from the Intel Paragon.
Reducing synchronization overhead in parallel simulation
Authors: Legedza Ulana , Weihl William E.
Published: January 2007

Synchronization is often the dominant cost in conservative parallel simulation, particularly in simulations of parallel computers, in which low-latency simulated communication requires frequent synchronization. We present and evaluate LOCAL BARRIERS and PREDICTIVE BARRIER SCHEDULING, two techniques for reducing synchronization overhead in the simulation of message-passing multicomputers. Local barriers use nearest-neighbor synchronization to reduce waiting time at synchronization points. Predictive barrier scheduling, a novel technique that schedules synchronizations using both compile-time and runtime analysis, reduces the frequency of synchronization operations. In contrast to other work in this area, both techniques reduce synchronization overhead without decreasing the accuracy of network simulation. These techniques were evaluated by comparing their performance to that of periodic global synchronization. Experiments show that local barriers improve performance by up to 24% for communication-bound applications, while predictive barrier scheduling improves performance by up to 65% for applications with long local computation phases. Because the two techniques are complementary, we advocate a combined approach. This work was done in the context of PARALLEL PROTEUS, a new parallel simulator of message-passing multicomputers.
Conservative circuit simulation on shared-memory multiprocessors
Authors: Keller Jörg , Rauber Thomas , Rederlechner Bernd
Published: January 2007

We investigate conservative parallel discrete event simulations for logical circuits on shared-memory multiprocessors. For a first estimation of the possible speedup, we extend the critical path analysis technique by partitioning strategies. To incorporate overhead due to the management of data structures, we use a simulation on an ideal parallel machine (PRAM). This simulation can be directly executed on the SB-PRAM prototype, yielding both an implementation and a basis for data structure optimizations. One of the major tools to achieve these is the SB-PRAM's hardware support for parallel prefix operations. Our reimplementation of the PTHOR program on the SB-PRAM yields substantially higher speedups than before.
Optimistic simulation of parallel architectures using program executables
Authors: Chandrasekaran Sashikanth , Hill Mark D.
Published: January 2007

A key tool of computer architects is computer simulation at the level of detail that can execute program executables. The time and memory requirements of such simulations can be enormous, especially when the machine under design-the target-is a parallel machine. Thus, it is attractive to use parallel simulation, as successfully demonstrated by the Wisconsin Wind Tunnel (WWT). WWT uses a conservative simulation algorithm and eschews network simulation to make lookahead adequate. Nevertheless, we find most of WWT's slowdown to be due to the synchronization overhead in the conservative simulation algorithm. This paper examines the use of optimistic algorithms to perform parallel simulations of parallel machines. We first show that we can make optimistic algorithms work correctly even with WWT's direct execution of program executables. We checkpoint processor registers (integer, floating-point, and condition codes) and use executable editing to log the value of memory words just before they are overwritten by stores. Second, we consider the performance of two optimistic algorithms. The first executes programs optimistically, but performs protocol events (e.g., sending messages) conservatively. The second executes everything optimistically and is similar to Time Warp with lazy message cancellation. Unfortunately, both approaches make parallel simulation performance worse for the default WWT assumptions. We conclude by speculating on the performance of optimistic simulation when simulating (1) target network details, and (2) on hosts with high message latencies and no synchronization hardware.
Estimating the cost of throttled execution in time warp
Authors: Das Samir R.
Published: January 2007

Over-optimistic execution has long been identified as a major performance bottleneck in Time Warp based parallel simulation systems. An appropriate throttle or control of optimism can improve performance by reducing the number of rollbacks. However, the design of an appropriate throttle is a difficult task, as correct computations on the critical path may be blocked, thus increasing the overall execution time. In this paper we build a cost model for throttled execution that involves both rollback probability and probability for an event computation being on the critical path. The model can estimate an appropriate size of time window for a throttled execution using statistics collected from the purely optimistic execution. The model is validated by an experimental study with a set of synthetic workloads.
Improving conservative VHDL simulation performance by reduction of feedback
Authors: Hurford Joel F. , Hartrum Thomas C.
Published: January 2007

This paper describes two forms of feedback in the simulation runtime of VHDL circuits that greatly influences performance. While circuit feedback and strongly connected components have been observed and documented as detrimental influences to conservative parallel discrete event simulation (PDES) efficiency, that influence has never been quantified. Moreover, in this study, the phenomenon of induced feedback was observed to diminish speedup to the same degree as explicit feedback. In this paper the influence of feedback on simulation runtime is analyzed and an algorithm for its elimination is presented. In addition, a metric for the quantification of feedback is introduced. By measuring feedback, it is possible to balance its influence on simulation runtime with that of other factors (e.g. load balance, number of processors, machine granularity, etc. ) through the use of a cost-based partitioning approach. This paper reports significant improvements in runtime for three circuits due to the prevention of feedback using the partitioning algorithm presented. In addition, strong correlation between the feedback metric and conservative parallel simulation overhead is demonstrated.
A visual environment for distributed simulation systems
Authors: Graham James H. , Elmaghraby Adel S. , Karachiwala Irfan , Soliman Hussam
Published: January 2007

Parallel and Distributed Simulation (PADS) algorithms are typically categorized to belong to one of two categories. They are either conservative or optimistic with respect to the method of handling causality. Conservative systems strictly preserve causality, while optimistic systems detect and correct causality errors when they occur.
Time Warp
is the basis of optimistic algorithms where rolling back the simulation clock allows the simulation to correct for errors. The Global Virtual Time (GVT) is the variable that maintains information about simulation progress, termination decision, and for committing input/output data. In this paper the basis for an environment for visualization distributed simulations with time warp on a network of UNIX workstations is presented. The visualization environment provides a graphical overview of simulation processes, and provides insight for algorithm performance. Extensions to the visualizations are also possible for animation of simulation results.
The Denver model for groupware design
Authors: Salvador Tony , Scholtz Jean , Larson James
Published: January 2007

The Denver Model is offered as a framework with which to plan or evaluate the capabilities associated with a particular groupware application. This model was the output of 14 participants at the two day workshop on Designing and Evaluating Groupware, held at CHI'95, Denver Colorado. The Denver Model consists of three submodels: goals and requirements, design and technology. A description of the framework is provided and evaluation strategies are described in this paper.
Analysing the return of investment of reuse
Authors: Succi Giancarlo , Baruchelli Francesco
Published: January 2007

Software reuse can be very useful in increasing the productivity and the quality level of a company, but the costs of this kind of investment are not always covered by the advantages it brings. It is particularly important to be able to correctly analyze the cost implied by software reuse in order to decide whether to adopt it or not. Even when a reuse policy has been adopted, reuse is not always the right solution and there are situations in which it is more convenient to develop a component from scratch. It is difficult to obtain a mathematical model for the evaluation of the effort required by the adaptation of a component in a new context. A different approach is proposed where the estimation is made using the knowledge and the experience gained from previous cases and stored in an ad-hoc base.
Graphic invention for user interfaces: an experimental course in user-interface design
Authors: Verplank Bill , Kim Scott
Published: January 2007

This Spring quarter at Stanford, we put together an experimental course on user-interface design. We were quite pleased with the results and would like to share some of our ideas and experiences.
Representation of fractal curves by means of L systems
Authors: Alfonseca Manuel , Ortega Alfonso
Published: January 2007

Fractals can be represented by means of L-systems (Development Grammars), together with a graphic interpretation. Two families of graphic interpretations have been used: turtle graphics and vector graphics. This paper describes an APL2/PC system able to draw fractals represented by L-systems, with both graphic interpretations. A theorem has been proved on the equivalence conditions for both interpretations. Another point shown is the fact that supposed deficiencies in L-systems that have prompted proposals of extensions are really deficiencies in the graphic translation scheme.
Real-time APL prototype of a GPS system
Authors: Beisner Henry M. , Rudd Jack G. , Benner Robert H.
Published: January 2007

The Global Positioning System (GPS) consists of a constellation of 24 high-altitude satellites with very accurate atomic clocks, along with a global network of satellite tracking stations and sophisticated ground processing stations, that together provide precise navigation coordinates to any user who possesses a small, readily available GPS receiver.The precision that is achieved depends on[1] the number of GPS satellites in view of the user and the geometries involved;[2] the design of the user's receiver (e.g., military or civilian);[3] the presence of nearby objects that may interfere with or degrade the reception of signals from one or more satellites;[4] and other factors.In most cases civilian users (whose receivers can read only unencrypted, intentionally corrupted GPS signals) can expect navigation accuracy on the order of 50-100 meters. The advertised accuracy for users with military receivers, which read the encrypted GPS signals, is 16 meters. Coalition forces in Desert Shield / Desert Storm relied heavily on GPS, and U.S. military authorities praised GPS effusively for its effectiveness as a force multiplier in that conflict.Loral Federal Systems (formerly IBM Federal Systems Division) in Gaithersburg, Maryland has been intimately involved with GPS from its concept validation phase through operations and maintenance. People in this group analyzed the physical dynamics, designed the mathematical algorithms and associated software, and performed the system integration work that culminated in the GPS ground control segment.APL was used over the years in most major aspects of GPS design and analysis. Early in the full-scale development phase, APL was used to model the initial GPS system design, to perform design tradeoffs, to model and test candidate algorithms, and to perform error analyses to estimate future system performance. In later phases APL was used to monitor and analyze actual GPS system performance, to compare it with theoretically achievable performance, and to analyze and isolate anomalies [Allan].
Using J as expository language in the teaching of computer science to liberal arts students
Authors: Howland John E.
Published: January 2007

APL and J are seldom, if ever, used in the teaching of college or university courses. Recently, the author has developed a new laboratory based computer science course for liberal arts students in which students are introduced to 13 core computer science topics. Programming language is used in an expository fashion to describe each topic by building simple working models of each topic. These models are then used as the basis of laboratory experiments in a co-requisite laboratory course. Students are not taught programming in this course, but rather, are taught just enough of the syntax and semantics of the language to be able to read and understand the exposition and models. Initially, Scheme was used in the lecture notes and laboratory materials developed for this course. Recently, however, an experiment is under way to replace the use of Scheme in this course by J. The development of this course and laboratory was funded by the Meadows Foundation and NSF grant DUE 9452050.
Economic forecasting by the deterministic-adaptive method
Authors: Obraztsov Sergei M. , Chelegatski Dmitri V. , Louneva Inna N. , Shimkevich Alexander L.
Published: January 2007

Economic forecasting is of great importance when some economic mechanism is changed rapidly as in Russia nowadays. Any economic system is a deterministic-stochastic entity of great complexity. Because of this, informative models which offer the interplay of the most significant factors are inadequate for satisfactory long-term forecasting.The paper describes a forecasting procedure based on the joint use of formalized method (numerical simulation) and adaptive method (simulation with a neural network) when the model structure is formed by incoming information.A combination of forecasts selected by experts allows one to make the most likely forecast from the "fan" of probable tracks.An APL implementation of this procedure has been used for the forecasting of municipal expenditures and has brought significant economic benefits.
Genetic algorithms
Authors: Skomorokhov Alexander O.
Published: January 2007

This paper describes an application oriented approach to the genetic-algorithm technique. The software is implemented in APL2 and exploits availability of user defined operators and separation of general purpose and problem specific code. The paper presents results of applying genetic algorithms to solve real life problems of simulation and predicting input order streams for a large consulting and service company. In an extended version of the paper, implementation of a GUI interface to genetic algorithm software in APL2 for OS/2 is described.
An SQL interface for VS APL
Authors: Bley Casey
Published: January 2007

The success of APL at Firemans Fund American Life Insurance Company (FFAL) has led to a problem which seems common to growing APL shops: data management. As the volume and complexity of data grows, a component file system soon becomes cumbersome, inefficient and application dependent. The result is a myriad of satellite systems which are unable to communicate and difficult to maintain because of unique file designs. To solve this problem, a database management system (DBMS) should be used to provide a more uniform approach to data management. SQL is a likely choice since it is a relational system which lends itself nicely to APL's array processing. FFAL is currently running SQL and APL under VM. Both VS APL and STSC's APL*PLUS are available. Unfortunately, neither environment has an interface to SQL. In order to solve this problem, an interface was developed in house. It provides APL with the advantages of a DBMS and gives programmers and applications easy access to SQL from APL. Also, the APL portion of the interface followed VS APL standards providing compatibility across APL environments.
The APL 90 project
Authors: Girardot Jean-Jacques
Published: January 2007

This paper presents some aspects of a new implementation of APL, the APL 90 system.

This implementation includes concepts inherited from LISP, such as the notion of property lists, or the ability to manipulate simply the internal representation of user defined functions or operators. These two features allow a great flexibility both in describing the system and using it.

The work presented here is being implemented under UNIX on a SM 90 computer.
Compiling APL for parallel execution on an FFP machine
Authors: Koster Alexis
Published: January 2007

This paper investigates the features of an APL compiler designed for a cellular computer (the FFP machine). This machine directly executes Formal Functional Programming (FFP) code. The APL compiler generates parallel FFP code. Techniques for parallel implementation of many APL array processing operators and functions are described. The implicit parallelism between different operations in a given APL program is also exploited. The FFP machine can accommodate the almost unbounded parallelism of FFP programs. Execution time analysis shows potential for highly efficient execution of APL programs on this machine.
APL and robotics
Authors: Euredjian A. Martin
Published: January 2007

Program execution speeds on today's general purpose APL running computers do not allow APL to be used as a Robot control language, this execution speed problem will go away with faster and better processors.

This paper presents an attempt to make APL work for Robotics with today's technology. The basic concept is quite simple: Leave to APL what it can do in real time and have another computer running a faster language do the rest. This allows for APL program development until the other computer with the faster language can be replaced with a very fast APL running system.

The auxiliary computer is an eighth processor parallel computer running FORTH.

Except for the IBM-PC used to run STSC corporation's APL
*
PLUS/PC SYSTEM all of the hardware for this project has been designed and built by the author from the ground up.
AMS
Authors: Burgeson John W. , Germain Robert G.
Published: January 2007

This paper describes
AMS
, an integrated, user expandable collection of tools for use in the construction, debugging, modification and maintenance of
APL
application workspaces.

AMS
offers six significant advantages over conventional
APL
workspace management systems:

All of the function described in this paper is operational. The system, which is terminal-independent, will function in any APL environment. Implementations exist in APL.SV, VSAPL and IBM PC-APL systems.
Using dimensions to represent attributes
Authors: King Dan M.
Published: January 2007

In the design of a data base (DB) the grouping of attributes that define or describe a data entity can be represented as an object with many dimensions. This concept can serve as a framework for APL functions which provide efficient data extraction, manipulation and updating. The use of generalized data access functions to respond to specialized data requests can greatly simplify data gathering and reporting system code.
Design
Authors: Appleyard Fred , Hui Roger
Published: January 2007

A non-procedural financial modelling system is presented. The financial models can be deterministic or probabilistic. Some issues in the design and implementation of this system are discussed.
Operators for program control
Authors: Eusebi Edward V.
Published: January 2007

Structured programming constructs such as if-then-else and do-while have traditionally been used to give a natural flow to programs written in one of the ALGOL-like languages. Languages with a functional basis, such as APL and LISP, provide (and are characterized by) alternative means of controlling the flow of expression. These include function modularity, the application of functions across data structures, the use of data structures to control program flow, and the mapping of operations across data and across other operations.

In APL2, the use of these methods has been enhanced by the generalization of APL data structures, the addition of the primitive operator Each(″), and the ability to define operators. This paper will examine ways in which these features may be used to give a non-procedural look to APL2 functions.
Operators for recursion
Authors: Eusebi Edward V.
Published: January 2007

Recursion is frequently used in functional programming languages. In LISP, it is the primary means of traversing data structures, and, along with COND, is instrumental in controlling program flow. In APL2, the generalization of arrays to include arrays of arrays encourages the use of recursion. This usage is enhanced by the generalization of, and extensions to, operators. In particular, the ability to define operators allows us to create operators which simplify the coding of recursive logic.

This paper studies the use of operators to provide program control for solutions to problems which involve recursion. For the most part, iteration on the elements of a list is used to replace recursive function calls.

The program control methods used in this paper are introduced in a companion paper, Operators for Program Control (Eusebi[3]). The reader is encouraged to read that paper first.
An APL database system for R&D laboratories
Authors: Hartung H. A.
Published: January 2007

Descriptions are given for the main features of a data base system implemented with APL at the Philip Morris R&D laboratories. It has been used widely to solve various scientific and engineering problems. It is based on a flexible system for organizing APL direct access files such that they store groups of objects very conveniently. Conventions which have been durable over many years because they are very useful in R&D projects are explained.
Mathematics education through the perspective of rationalized APL
Authors: Alvord Linda
Published: January 2007

Mathematics expresses concepts by the use of a symbol system. The symbols include the familiar plus + , minus - , times x and divide ÷ . APL extends the conventional mathematical symbol system to include major ideas such as power, maximum and deal. These powerful ideas are expressed in simple APL symbols like *, ⌈, and ?. These functions require two arguments represented by the two Greek letters
alpha
and
omega
. They are generalized with the expressions α*ο α⌈ο and α?ο. The symbols have functions which are monadic counterparts called exponential, ceiling and roll when they have only one argument as in *ο, ⌈ο and ?ο.

The mind comprehends and manipulates increasingly complex concepts expressed in these abstract symbols. New thoughts and ideas are generated in response. On occasion, new concepts warrant symbols of their own. This paper demonstrates a strategy for teaching students the process of developing an extended symbol system of their own.

In education, teachers help learners to read and interpret what already exists. In addition, just as writers learn by expressing concepts in their own sentences, mathematicians need to experiment with the process of “symbol building” to learn the essential nature of mathematics. The example which follows shows the development of a “meaning” for the symbol. In the monadic case, ο, the function produces a frequency distribution of the elements in the numeric array argument. In the dyadic case, α ο, the result is a frequency distribution of the elements in the literal array argument entered in ο which are contained in the array provided in α.

Implementing the method requires both direct definition and
Rationalized APL
by Kenneth Iverson which proposes the use of the
del
operator to allow the APL user to make a function represented by a single symbol. The del operator creates a function which has both a monadic and a dyadic definition and consequently is called ambivalent. Learning to use these tools allows the student to experiment as a creator of mathematical language.