bluuebunny/crossref_metadata_2025 huggingface dataset:
Problems, communications, and common sense
Authors: Lercher Lorenz , Kaindl Hermann
Published: January 2007

Problem solving in the real world is a more general issue than what is currently understood under this notion in the majority of today's AI publications. Particularly, finding an appropriate formal representation of a given problem in the real world is very difficult even for humans. We think that this is reminiscent of the core difficulty of knowledge acquisition for knowledge acquisition for knowledge-based systems, i.e.modelingthe real world. If a machine is to understand problem statements in natural language, much commonsense knowledge must be available. However, even if it were available, it would be very difficult to retrieve those chunks of knowledge necessary for the problem at hand. We propose a view of presenting a problem to a problem solver as an act ofcommunication,which may provide hints for finding such knowledge.
An object language versus an expert system shell
Authors: Bonačic Davor , Stiglic Bruno , Kolmanič Tomaž
Published: January 2007

Often there comes up a problem that is laborious or awkward to solve by means of the third generation languages. Sometimes it is difficult for the programmers to see or know the better way, or even to decide which is the most suitable language or programming tool for solving their problem. Lately, many easily available and not expensive expert shells as well as various kinds of object-oriented languages also for smaller and personal computers have appeared on the market. Various problems can usually be more or less effectively solved by means of either: an object-oriented language or an expert system. In this paper, we describe the example of solving the school time-table problem by first applying one, and then the other way.
The Turing Test is not a trick
Authors: Harnad Stevan
Published: January 2007

It is important to understand that the Turing Test (TT) is not, nor was it intended to be, a trick; how well one can fool someone is not a measure of scientific progress. The TT is an empirical criterion: It sets AI's empirical goal to be to generate human scale performance capacity. This goal will be met when the candidate's performance is totally indistinguishable from a human's. Until then, the TT simply represents what it is that AI must endeavor eventually to accomplish scientifically.
The use of scenarios in design
Authors: Nardi Bonnie A.
Published: January 2007

A scenario is a description of a set of users, a work context, and a set of tasks that users perform or want to perform. A scenario sketches future technologies that will help users do the things they want to do. A scenario blends a carefully researched description of some set of real ongoing activities with an imaginative futuristic look at how technology could support those activities better.
Usability testing vs. heuristic evaluation
Authors: Jeffries Robin , Desurvire Heather
Published: January 2007

Recent research comparing usability assessment methods has been interpreted by some to imply that usability testing is no longer necessary, because other techniques, such as heuristic evaluation, can find some usability problems more cost-effectively. Such an interpretation grossly overstates the actual results of the studies. In this article, we, as authors of studies that compared inspection methods to usability testing, point out the rather severe limitations to using inspection methods as a substitute for usability testing and argue for a more balanced repertoire of usability assessment techniques.
Minimalism reconsidered
Authors: Williams Thomas R. , Farkas David K.
Published: January 2007

During the past decade, few efforts aimed at the articulation of new computer documentation models have inspired as much interest within the documentation community as has John Carroll's formulation of the tenets of "minimalism." In our experience, however, minimalism is often incorrectly understood by practitioners simply as a prescription for brevity. Minimalism is, in fact, more complex than this. In "The Minimal Manual" (1987--88) Carroll and his coauthors suggest that minimalism comprises four characteristics: (1) brevity (or perhaps conciseness), (2) focus on real tasks, (3) support of error recognition and recovery efforts, and (4) adoption of an instructional philosophy termed "guided exploration."
Nested arrays and operators
Authors: Benkard J. Philip
Published: January 2007

Following the new direction taken by the ISO Standards Committee meeting in Palo Alto, during August, 1991, an extended APL standard is considered using a nested array basis with particular features from IBM's APL2 program product. APL2 develops from ISO APL with the relaxation of two early scalar constraints. Enclose, disclose, and each are derived from properties of bracket indexing and scalar conformance. Identities connect these new operations with the structural operators. Decisions must be made on what features from other systems, presently implemented or not, should be added to the nested array foundation. Candidates for inclusion are rank and depth operators and various sorts of program definable data types. Comparisons are made between constructs, and tentative conclusions are advanced.
Walks into the APL design space
Authors: Gfeller Martin
Published: January 2007

Like any living language, APL is evolving. The design space for its future development is wide open. Some trails into that space are known, for other languages have followed them. We will walk on some trails, visit some sights and also some dead ends. We will see which development areas could solve some old problems of APL, without changing its fabric.

The goal of the paper is to enable the reader to explore the APL design space on his or her own. To that end I will point the reader to some good books and articles about problems and solutions only touched upon in the paper.
An APL2 tool box investigating Schwarz methods
Authors: Pospiech Christoph
Published: January 2007

A Schwarz method is an iterative algorithm for aggregating the solution of an elliptic PDE on some domain Ω from repeated solutions on overlapping sub-domains. This general definition incorporates many algorithms which differ in the sequence of sub-domain solutions and the way this information is aggregated. This calls for a tool for investigating and comparing these different algorithms at least for a model problem without the tedious work of programming. The idea is to have simple building blocks for formulating the algorithm in terms of sub-domain solutions. On the other hand this tool should give the user as much freedom as possible, still maintaining ease of use. APL2 was chosen as the base of the tool box because of the interactive environment, the graphics facilities, and the hot spot and run time analysis ready at hand. For maintaining performance, the CPU intensive parts are taken from the ESSL library or coded directly in Vector Assembler.
Matrix operations over integral domains using nested APL
Authors: Willhoft Robert G.
Published: January 2007

This paper deals with the use of APL to solve matrix theory problems with elements that are members of an integral domain. Two types of integral domains are used to illustrate the methods developed in this paper, integers (Z) and polynomials with real coefficients (Re[X]). However, the method of approach can be easily generalized to include other integral domains.

APL2, due to its generalized data representations and rich functional semantics, was chosen to implement the solution to this problem. For each integral domain presented, a method of data representation is developed, and implementations of the necessary “primitive” functions (Addition, Multiplication, Division, and Comparison) are given.

Finally, this newly developed system of functions and data representation is used to solve several of the most common Matrix Algebra problems. A simple recursive determinant and an implementation of Euclid's Greatest Common Divisor Algorithm are presented. Then, with these building blocks, a general algorithm for finding Smith's Canonical form and an algorithm to find the Invariant Factors are presented.
Towards the integration of a query mechanism and navigation for retrieval of data on multimedia documents
Authors: Duval E. , Olivié H.
Published: January 2007

Traditionally, two paradigms are discerned with respect to data retrieval [3, 17]:1. A
query mechanism
enables the user to express conditions that characterize the data he is looking for. The Data Base Management System (DBMS) is responsible for retrieval of the data that satisfy these conditions.2.
Navigation
or
browsing
can be used to investigate the content of the database by following links between related data.We will start with a discussion of these paradigms in the first two sections. We will then explore how both approaches can be combined. Finally, a practical implementation of the advocated approach will be presented. The implemented prototype supports access to a database on multimedia material. A more elaborated discussion of our ideas and results in this area can be found in [16].
Career orientations of I.S. personnel
Authors: Ginzberg Michael J. , Barondi Jack J.
Published: January 2007

Ginzberg and Baroudi [1988] proposed several propositions regarding the diversity of the career anchors of IS personnel. In addition, they suggested that geographic and organizational factors might influence the patterns of career anchors. This study examines several of these propositions through a survey administered to IS personnel in four large organizations in several geographic locations. In contrast to some other recent studies, the career anchors displayed by this sample of IS personnel were highly varied, with neither technical competence nor management competence dominating. Additionally, few meaningful differences were found in the patterns of career anchors across industry or geography.
The impact of alternative IS acquisition strategies upon IS success
Authors: Iivari Juhani , Ervasti Irja
Published: January 2007

Information systems (IS) managers and developers continually face the problem of deciding among alternative acquisition options: to develop the system in-house, to use a subcontractor, to develop the system jointly among several adopting units, to buy an application package, etc. The question of the relative success of these options is still a controversial issue. This paper puts forward a number of hypotheses concerning the relationship between alternative acquisition options, a set of intervening variables - user participation, originality and complexity of the systems and vendor competence - and IS success. Based on a field study analysing 21 information systems, their acquisition options and their success, it provides some evidence that the acquisition options at the end of in-house development are more successful. Among the intervening variables potentially explaining success, only complexity emerged as important.
An analysis of dynamic page placement on a NUMA multiprocessor
Authors: LaRowe Richard P. , Holliday Mark A. , Ellis Carla Schlatter
Published: January 2007

The class of NUMA (nonuniform memory access time) shared memory architectures is becoming increasingly important with the desire for larger scale multiprocessors. In such machines, the placement and movement of code and data are crucial to performance. The operating system can play a role in managing placement through the policies and mechanisms of the virtual memory subsystem. In this paper, we develop an analytic model of memory system performance of a Local/Remote NUMA architecture based on approximate mean-value analysis techniques. The model assumes that a simple workload model based on a few parameters can often provide insight into the general behavior of real applications. The model is validated against experimental data obtained with the DUnX operating system kernel for the BBN GP1000 while running a synthetic workload. The results of this validation show that in general, model predictions are quite good, though in some cases the model fails to include the effect of unexpected behaviors in the implementation. Experiments investigate the effectiveness of dynamic multiple-copy page placement. We investigate the cost of incorrect policy decisions by introducing different percentages of policy error and measuring their effect on performance.
A reservation based cyclic server queue with limited service
Authors: Lee Duan-Shin , Sengupta Bhaskar
Published: January 2007

In this paper, we examine a problem which is an extension of the limited service in a queueing system with a cyclic server. In this service mechanism, each queue, after receiving service in cycle
j
, makes a reservation for its service requirement in cycle
j
+ 1. In this paper, we consider symmetric case only, i.e., the arrival rates to all the queues are the same. The main contribution to queueing theory is that we propose an approximation for the queue length and sojourn-time distributions for this discipline. Most approximate studies on cyclic queues, which have been considered before, examine the means only. Our method is an iterative one, which we prove to be convergent by using stochastic dominance arguments. We examine the performance of our algorithm by comparing it to simulations and show that the results are very good.
State space exploration in Markov models
Authors: de Souza e Silva Edmundo , Ochoa Pedro Mejiá
Published: January 2007

Performance and dependability analysis is usually based on Markov models. One of the main problems faced by the analyst is the large state space cardinality of the Markov chain associated with the model, which precludes not only the model solution, but also the generation of the transition rate matrix. However, in many real system models, most of the probability mass is concentrated in a small number of states in comparison with the whole state space. Therefore, performability measures may be accurately evaluated from these “high probable” states. In this paper, we present an algorithm to generate the most probable states that is more efficient than previous algorithms in the literature. We also address the problem of calculating measures of interest and show how bounds on some measures can be efficiently calculated.
Temporal reasoning for planning and scheduling
Authors: Boddy Mark
Published: January 2007

We briefly describe the current implementation of the
Time Map Manager
(TMM), followed by a description of the system's suitability for and application to planning and scheduling tasks.
The management of information systems occupations: A research agenda
Authors: Turner Jon A , Baroudi Jack J
Published: January 2007

It is accepted, generally, that Information Systems (IS) personnel have specific needs and present a unique set of problems for management. This position is challenged. It is our contention that IS personnel exhibit relatively few differences when compared with other, similar, occupational groupings. This does not imply, however, that the unique aspects of IS work are unimportant, or that attention need not be focused on understanding the determinants of particular behavioral outcomes. Rather, it suggests, that the effective management of the IS human resource may well rest more on general management practices than is commonly believed.This paper identifies managerial complaints about IS personnel and provides a summary of research findings. A model, based on accepted principles of worker behavior, intended to integrate much of the previous work, is presented. The IS staff is classified into categories and propositions about each are developed. Specific research questions are formulated which, when answered, will provide more insight into the unique aspects of IS work and will identify managerial strategies for improving employee performance and well being.
Is speech recognition usable?
Authors: Franzke Marita , Marx Adam N. , Roberts Teresa L. , Engelbeck George E.
Published: January 2007

US WEST Advanced Technologies conducted an experiment using the "Wizard-of-Oz" paradigm. We compared a simulated speech recognition interface ("wizard") for a basic voice mail application to functionally similar touch-tone and operator assisted versions. This poster abstract highlights the results of this experiment, focussing on performance times and errors, the perceived ease of use, and a description of the linguistic characteristics of users' utterances. The results are interpreted to be in favor of applying speech recognition technology to user interfaces.
A tool for the rapid evaluation of input devices using Fitts' law models
Authors: MacKenzie I. Scott , Buxton William
Published: January 2007

A tool for building Fitts' law models is described. MODEL BUILDER runs on the Apple
Macintosh
using any device which connects to the Apple Desktop Bus. After 16 blocks of trials taking about 4--5 minutes, the program provides an immediate (albeit tentative) statistical analysis, showing the coefficients in the prediction equation, the coefficient of correlation, and a regression line with scatter points. MODEL BUILDER can be retrieved anonymously by researchers, educators, developers, or anyone with access to INTERNET through file-transfer-protocol (FTP).
IMPLICATIONS OF A COGNITIVE MODEL OF DATABASE QUERY
Authors: Ogden William C.
Published: January 2007

We have developed an cognitive model of query writing, shown in Figure 1, which consists of three distinct stages. In stage one, Query Formulation, users attempt to satisfy goals by drawing on what information they may have about the stored data to generate a natural language request. In stage two, Query Translation, users must use pragmatic information about the database, including information about the system's model of the database (i.e. objects and available actions on those objects), to translate their natural language request into a request that satisfy the pragmatics of the intended query. In the third stage, Query Writing, users need information about the syntactic and semantic rules of the particular query language interface to produce a query that will be acceptable to the system.
WINDOW MANAGEMENT IN INTERACTIVE COMPUTER SYSTEMS
Authors: Bury Kevin F. , Darnell Michael J.
Published: January 2007

Despite the popularity of window-management systems in the marketplace, research investigating the usage and possible benefits of such systems has only recently begun to emerge (Bly and Rosenberg, 1986; Bury, Davies and Darnell, 1985; Davies, Bury, and Darnell, 1985). Window-management systems vary enormously, both in terms of the amount of functionality they give to users, and in terms of the command mechanisms provided to users for interacting with the window manager. Our laboratory has been involved in a series of experimental investigations exploring issues related to window management.
AUTOSPEC: Automatic Motor Specification System
Authors: Suscheck Charles A. , Komar Gregory J.
Published: January 2007

The AUTOSPEC system is an automatic motor specification software system that primarily serves to non-interactively produce bill of materials from sales orders. At the core, the system applies Expert System and coordinated Relational Database technology to effect an object-oriented implementation. Computer Aided Software Engineering (CASE) tools supporting object-oriented analysis (OOA) and an object-oriented design (OOD) approach were used to provide a smooth transition of the software design effort into production at motor manufacturing plants. The powerful mechanisms of class inheritance, and forward chaining, as well as graphical program construction provided by the ProKappa Knowledge Base System are employed. Motif Graphical User Interface (GUI) development was carried out using UIM/X, a WYSIWYG screen development tool. The ORACLE Database Management System was used to provide data independence necessary for engineering system interfacing.
Interfacing different object-oriented programming languages
Authors: Danforth Scott
Published: January 2007

This poster presentation illustrates the use of SOM (the IBM System Object Model) for interfacing, different object-oriented programming (OOP) languages. Our approach allows classes defined in one OOP language to be used by different (possibly non-OOP) languages—both for subclassing, and for object creation. This extends the utility of OOP class libraries and makes it possible to define “multilanguage” objects, whose supporting methods and instance variables are provided by different languages.
Object design of modularity, reuse and quality (abstract)
Authors: Bennett Douglas
Published: January 2007

Turning buzzwords like modularity, reusable components, extensibility, testability, and robustness into reality requires more than just a compiler for an object-oriented language, or even an integrated development environment. These properties must be designed into the software product. This tutorial shows how to make design decisions so the product will do what its users want and so the buzzwords actually show up in the product. The tutorial will work through the steps of a design project, documenting user and producer needs, modeling the thing objects, describing behavior with event response models, and, finally, developing an architecture for the product. Part of each step is evaluating the design against the magic words. The result will be a product structure that is probably very different from conventional software architectures, but one that can be measured against the design criteria.

This tutorial teaches the explicit design of software. It uses notations from several existing methods. You may use your own notations, if you wish.
Types for the language designer (abstract)
Authors: Schwartzbach Michael , Palsberg Jens
Published: January 2007

The type systems of object-oriented languages have specific goals: they serve as partial documentation, they provide modularity, and they ensure safety and efficiency at run-time. There are many choices in the design of a type system, and it is hard to evaluate their tradeoffs. This tutorial teaches a coherent theory of type systems for object-oriented languages that can be used for both explicit systems (where the programmer supplies type annotations) and implicit systems (where the compiler must perform type inference), and forty systems based on interfaces, classes, and sets of classes.

The tutorial defines an idealized object-oriented language, inspired by Smalltalk, and develops several type systems for it. This uniform framework makes it easy to compare different approaches. The tutorial explores the limitations of static type checking and shows how dynamic type checking can be introduced. It demonstrates how subclassing is different from subtyping, how specification types differ from implementation types, and the influence of a type system on separate compilation.
Introduction to object-oriented design (abstract)
Authors: Stipp Lori , Booch Grady
Published: January 2007

This tutorial describes the Booth method for object-oriented design, including details of the notation and the design process. It describes the principles that are necessary for thinking and abstracting in terms of classes and objects. The tutorial includes a number of examples, including war stories from specific projects. It also covers extensions to the notation beyond that described in Object-Oriented Design with Applications.

This tutorial is a condensed version of Booths popular tutorial given at past OOPSLAs. If you have attended that in the past then you should attend tutorial 18 instead of this one.
The pragmatics of building object-oriented systems (abstract)
Authors: Booch Grady
Published: January 2007

This tutorial expands upon the process described in Booths Object-Oriented Design with Applications to provide a prescriptive, iterative process for object-oriented development. It describes both the macro and micro process of development. It gives guidelines for managing iterative development, and addresses the pragmatic issues of milestones and planning, staffing, integration and release management, reuse, testing, quality assurance and metrics, documentation, tools, and technology transfer.

This tutorial assumes that you are familiar with Booths design method.
Hardware support for object-oriented systems (abstract)
Authors: Wolczko Mario
Published: January 2007

When the performance penalty of object-oriented systems is mentioned, a common response is to blame antiquated hardware designs for not supporting object-oriented languages as they deserve, To what extent can the performance gap between conventional languages and object-oriented languages be closed using hardware? What architectural changes benefit object-oriented systems, and by how much?

There have been many attempts to make hardware that better supports object-oriented programming. This tutorial describes these systems, and the extent that they have succeeded or failed in their aims. These systems include SOAR, Rekursiv and MUSHROOM, as well as some features from mainstream architectures such as SPARC. Issues covered include: choice of instruction set, design of the memory system including caches and virtual memory hardware, scaleability, use of parallelism, and hardware/software trade-offs.

A common misconception is that if something is implemented in hardware then it must be fast. One aspect of the tutorial is to show that there are limits to what hardware support can achieve. However, better hardware can reduce the cost of some language features, such as dynamic binding, and can make a system more scaleable.
Efficient implementation of object-oriented programming languages (abstract)
Authors: Chambers Craig , Ungar David
Published: January 2007

This tutorial is for those who like to know how object-oriented languages work under the hood, why some things are expensive while other things are cheap, and why language definitions include certain restrictions. This tutorial provides that, and more. It describes features of object-oriented languages that are difficult to implement efficiently, and how this has affected language designs. It describes state-of-the-practice and state-of-the-art techniques for implementing languages like C++ and Smalltalk.

Language features include dynamic binding and generic operations, inheritance, user-defined control structures, static type systems, multiple inheritance and virtual base classes, and mixing object-oriented and non-object-oriented programming.

The tutorial also addresses questions like: What are the trade-offs in using the various implementation techniques? What problems remain that block more efficient object-oriented language implementations? What might be promising areas for future research?
Writing efficient Smalltalk programs (abstract)
Authors: Auer Ken
Published: January 2007

Smalltalk has a reputation for being slow and a offers many ways to create inefficient code, and memory hog. In reality, the Smalltalk environment programmers often exploit those opportunities.

However, there are just as many ways to create efficient code, some of which may not be available in more traditional languages. Whether an application is efficient or not has more to do with the way the programmer has used the available tools than the tools themselves.

This tutorial teaches Smalltalk programmers how to write efficient programs. The emphasis is on how to exploit, rather than sacrifice, the benefits of good object-oriented design. You should have at least six months experience with Smalltalk writing non-toy programs to get the most benefit from the tutorial.
The design of an object-oriented operating system (abstract)
Authors: Campbell Roy H. , Islam Nayeem , Madany Peter W.
Published: January 2007

This tutorial describes the object-oriented design of a complete operating system, written to be object-oriented, with a user and application interface that is object-oriented. The main objective is to illustrate object-oriented design trade-offs by studying a large object-oriented system, the Choices operating system.

Choices is an object-oriented multiprocessor operating system that runs native on SPARC stations, Encore Multimaxes, and IBM PCs. The system is built from a number of frameworks that implement a general file system, persistent store for persistent objects, process switching, parallel processing, distributed processing, interrupt handling, virtual memory, networking, and interprocess communication.

If you bring an IBM/PC 386-based portable computer running MS-DOS to the course then you may experiment by writing application programs for PC-Choices. All participants will receive a copy of PC-Choices on a floppy.

Participants should have experience with building object-oriented systems and have a basic understanding of operating systems design. Reading knowledge of C++ is helpful, but not necessary.
Object-orientation and Ada
Authors: Grant Douglas D.
Published: January 2007

This presentation discusses the evolution of the curriculum in object-oriented methods in the main undergraduate degree in the Department of Computer Science at Swinburne University of Technology in Melbourne, Australia. The degree has a strong Software Engineering emphasis, and object-oriented analysis and design methods are complemented by a programming curriculum which uses Ada. The forthcoming Ada9X will have a substantial impact on the curriculum.
Approaching classical algorithms in APL2
Authors: Bieri Hanspeter , Grimm Felix
Published: January 2007

Classical algorithms and data structures as made popular by D.E. Knuth's "The Art of Computer Programming" have been largely ignored so far by APL2-programmers. This scepsis was understandable to a certain degree in the era of APL, but has lost its justification with the rise of APL2 and similar APL-successors. First the essence of classical algorithms as well as the principal ways of data structuring and accessing are reexamined. Then it is shown how pseudocodes or implementations of classical algorithms can be transfered one-to-one into APL2 almost automatically and often with an acceptable resulting performance. But, in general, the better way consists in maintaining only the general design principle behind a classical algorithm and combining it with the elegant and efficient specific possibilities of APL2. Both approaches are explained and illustrated by means of a typical classical algorithm from picture processing.
Structuring functions with operators
Authors: Eastwood David S.
Published: January 2007

Flow control for APL functions is limited to the simple GOTO facility supplied by the → arrow. Numerous papers have suggested enhancements to APL which provide flow control structures. This paper investigates to the extent to which control structures can be implemented in APL solely by means of features that already exist in the language, specifically by the use of primitive or defined operators. The exercise offers both a means to improve the quality of APL code and also affords an insight into the use of operators and their limitations. The paper assumes the use of APL2 or other compatible dialects such as APL.68000.
APROL
Authors: Holmes Dennis , Howland John E.
Published: January 2007

This paper describes the design of a hybrid language which combines the features of an array processing language and lisp dialect in a consistent and useful manner. This language, APROL (Array PROcessing Lisp) is derived from the J dialect of APL and the Scheme dialect of Lisp. The base syntactic structure is taken from Scheme, while the array processing features are based on the J programming language. A prototype implementation has been made and some experiences with this implementation are described. This implementation uses J as an imbedded array processing engine in a Scheme intrepreter/compiler.The language as specified provides a set of data types and manipulation tools which is more diverse than found in either Scheme or J. APROL allows the programmer to apply array processing functions to lists of arrays in the Scheme style and list processing functions to arrays of lists in typical J style. The result is a language which not only brings array processing capabilities to Scheme, but also significantly extends the functionality of the Scheme language.
Modern algebra self-taught through APL
Authors: Luksha Pavel
Published: January 2007

The study of modern algebra, especially that of finite algebra and its applications to error codes, was aided by the computer. The paper shows how a college student used APL for self-teaching this university-level subject. The approach of self-teaching is presented. It is shown how the learning process can be augmented through the use of APL. Various finite algebra problems and their APL solutions are presented, including error detecting codes and the search for irreducible and primitive polynomials.
Distributed computing in the workstation environment
Authors: Mitlöhner Johann
Published: January 2007

Exploiting unused processor time in workstation environments can result in large performance gains in user applications. A parallel each operator is shown which implements client-server based distributed processing. A time-consuming algorithm is sped up by using idle workstations in a local area network as APL servers.
Solving two or three polynomials in two or three variables
Authors: Selfridge R. G.
Published: January 2007

An algorithm is described that allows two polynomials in two variables to be reduced to a single polynomial in one variable, and then back solved to get all sets of solutions. The algorithm works faster than most other algorithms within its range of utility (providing sets of solutions as large as 70), and can be extended to cover some sets of 3 polynomials in 3 variables (those where one of the polynomials has only two of the variables). While subject to the known stability problems of polynomial root-finding this algorithm can also be extended to provide for reducing to the single variable polynomial with symbols, thus permitting proof of results, and potential removal of extraneous roots. Such manipulation can then materially shorten the numerical process if the problem is to be applied to a number of different cases.
Adaptive learning networks in APL2
Authors: Skomorokhov Alexander O.
Published: January 2007

The paper considers Adaptive Learning Networks (ALN) as a tool to solve the problems of modeling, prediction, diagnostics and pattern recognition in complex systems. This method is similar to the neural network technique. The main difference is the self-organization of network structure on the basis of generation and estimation of various nodes, connections and weights. A set of functions presented in the paper shows that ALNs are easily realized in APL2. User-defined operators are used as a very convenient tool for ALN programming. The paper discusses the application of implemented software to the problem of Burnout Heat Flux Prediction in nuclear reactors. It is shown that ALN technique allows the prediction of burnout heat flux with approximately three times better accuracy than other commonly used methods.
The Wisconsin Wind Tunnel
Authors: Reinhardt Steven K. , Hill Mark D. , Larus James R. , Lebeck Alvin R. , Lewis James C. , Wood David A.
Published: January 2007

We have developed a new technique for evaluating cache coherent, shared-memory computers. The Wisconsin Wind Tunnel (WWT) runs a parallel shared-memory program on a parallel computer (CM-5) and uses execution-driven, distributed, discrete-event simulation to accurately calculate program execution time. WWT is a virtual prototype that exploits similarities between the system under design (the target) and an existing evaluation platform (the host). The host directly executes all target program instructions and memory references that hit in the target cache. WWT's shared memory uses the CM-5 memory's error-correcting code (ECC) as valid bits for a fine-grained extension of shared virtual memory. Only memory references that miss in the target cache trap to WWT, which simulates a cache-coherence protocol. WWT correctly interleaves target machine events and calculates target program execution time. WWT runs on parallel computers with greater speed and memory capacity than uniprocessors. WWT's simulation time decreases as target system size increases for fixed-size problems and holds roughly constant as the target system and problem scale.
Efficient on-line processor scheduling for a class of IRIS (
increasing reward with increasing service
) real-time tasks
Authors: Dey Jayanta K. , Kurose James F. , Towsley Don , Krishna C. M. , Girkar Mahesh
Published: January 2007

In this paper we consider the problem of on-line scheduling of real-time tasks which receive a "reward" that depends on the amount of service received. In our model, tasks have associated deadlines at which they must depart the system. The task computations are such that the longer they are able to execute before their deadline, the greater the value of their computations, i.e., the tasks have the property that they receive
increasing reward with increasing service (IRIS)
. We focus on the problem of scheduling IRIS tasks in a system in which tasks arrive randomly over time, with the goal of maximizing the average reward accrued per task and per unit time. We describe and evaluate a two-level policy for this system. A top-level algorithm executes each time a task arrives and determines the amount of service to allocate to each task in the absence of future arrivals. A lower-level algorithm, an earliest deadline first (EDF) policy in our case, is responsible for the actual selection of tasks to execute. This two-level policy is evaluated through a combination of analysis and simulation, We observe that it provides nearly optimal performance when the variance in the interarrival times and/or laxities is low and that the performance is more sensitive to changes in the arrival process than the deadline distribution.
Analyzing multiprocessor cache behavior through data reference modeling
Authors: Tsai Jory , Agarwal Anant
Published: January 2007

This paper develops a
data reference modeling
technique to estimate with high accuracy the cache miss ratio in cache-coherent multiproeessors. The technique involves analyzing the dynamic data referencing behavior of parallel algorithms. Data referenee modeling first identifies different types of shared data blocks accessed during the execution of a parallel algorithm, then captures in a few parameters the cache behavior of each shared block as a function of the problem size, number of processors, and cache line size, and finally constructs an analytical expression for each algorithm to estimate the cache miss ratio. Because the number of processors, problem size, and cache line size are included as parameters, the expression for the each miss ratio can be used to predict the performance of systems with different configurations. Six parallel algorithms are studied, and the analytical results compared against previously published simulation results, to establish the confidence level of the data reference modeling technique. It is found that the average prediction error for four out of six algorithms is within five percent and within ten percent for the other two. The paper also derives from the model several results on how cache miss rates scale with system size.
An analysis of the information content of address and data reference streams
Authors: Becker Jeffrey C. , Park Arvin
Published: January 2007

Recent increases in VLSI processor speed and transistor density have not been matched by a proportionate increase in the number of I/O pins used to communicate information on and off chip. Since the number of I/O pins is limited by packaging technology and switching constraints, this trend is likely to continue, and I/O bandwidth will become the primary VLSI system performance bottleneck. This paper analyzes the potential of address and data stream coding in order to reduce bandwidth requirements
A summary of TCP/IP networking software performance for the DECstation 5000
Authors: Kay Jonathan , Pasquale Joseph
Published: January 2007

Network software speed is not increasing as rapidly as that of work-station CPUs. The goal of this study is to determine how various components of network software contribute to this bottleneck. In this extended abstract, we summarize the performance of TCPIP and UDPIP networking software for the DECstation 5000/200 workstations connected by an FDDI LAN.
Evaluation of load sharing in HARTS while considering message routing and broadcasting
Authors: Shin Kang G. , Hou Chao-Ju
Published: January 2007

In this paper, we apply the load sharing (LS) mechanism proposed in [1, 2] to HARTS, an experimental distributed realtime system [3] currently being built at the Real-Time Computing Laboratory of the University of Michigan.
Benefits of cache-affinity scheduling in shared-memory multiprocessors
Authors: Torrellas Josep , Tucker Andrew , Gupta Anoop
Published: January 2007

An interesting and common class of workloads for shared-memory multiprocessors is multiprogrammed workloads. Because these workloads generally contain more processes than there are processors in the machine, there are two factors that increase the number of cache misses. First, several processes are forced to time-share the same cache, resulting in one process displacing the cache state previously built up by a second one. Consequently, when the second process runs again, it generates a stream of misses as it rebuilds ita cache state. Second since an idle processor simply selects the highest priority runnable process, a given process often moves from one CPU to another. This frequent migration results in the process having to continuously reload its state into new caches, producing streams of cache misses. To reduce the number of misses in these workloads, processes should reuse their cached state more. One way to encourage this is to schedule each process based on its affinity to individual caches, that is, based on the amount of state that the process has accumulated in an individual cache. This technique is called
cache affinity scheduling
.
Approximate mean value analysis of interconnection networks with deflection routing
Authors: Wagner David B.
Published: January 2007

This paper presents an Approximate Mean Value Analysis model of deflection routing in Shuffle-Loop interconnection networks. (The methodology is readily extended to other network topologies.) In contrast to most previous work on deflection routing, the model makes no assumptions about traffic patterns, nor does it assume that messages that cannot be admitted to the network are lost. The technique allows the network to be modeled in its entirety: all processors, switches, and memory modules, and their steady-state interactions, are modeled explicitly. The results of the model are found to be in close agreement with the results of simulation experiments.
Time Warp simulation in time constrained systems
Authors: Ghosh Kaushik , Fujimoto Richard M. , Schwan Karsten
Published: January 2007

The suitability of the Time Warp mechanism to perform simulations with real-time constraints is examined. A model for Time Warp is developed that accounts for overheads such as state saving, state restoration, and sending and transmitting positive and negative messages. A criterion called R-schedulability is defined to indicate whether or not computations can meet real-time deadlines. It is shown that if false events (events that will be rolled back or cancelled later) are generated, and there are no committed events with timestamps equal to those of the false events, Time Warp cannot meet the R-schedulability criterion. Further, if aggressive cancellation is used, scheduling guarantees still cannot be made even in the absence of such false events. However, Time Warp using lazy cancellation is shown to be R-schedulable provided such false events do not exist. Finally, based on these results, bounds on the execution time of a Time Warp simulation are derived.
Efficient top-down induction of logic programs
Authors: Cameron-Jones R. Mike , Quinlan J. Ross
Published: January 2007

FOIL is a system for inducing function-free Horn clause definitions of relations from example and extensionally defined background relations. It demonstrates the successful application of a general to specific approach to clause induction using heuristically guided search. This paper describes the current version of FOIL, assesses its performance and notes areas for improvement. The successful application of similar methods in other systems is reviewed to demonstrate their general utility.
A model of the IS/organizational interface and users' perceptions of IS effectiveness
Authors: Beise Catherine M.
Published: January 2007

As the line between the IS function and user functional areas becomes increasingly blurred due to end-user computing and the deeper integration of IS with organizational planning and operations, the quality of the IS/organizational interface consists of communication linkages between the IS function and other functional organizational subunits. Components of this interface include general IS/user communication and coordination mechanisms, user training and documentation, end-user support and services, chargeback policies, and alignment of IS/organizational planning processes. In an effort to better define and understand this interface, data were gathered via interviews and questionnaires from IS and user department managers and staff in nine private sector firms. The results of the research indicate that perceived IS effectiveness is related to the quality of this interface. This paper develops a model of the IS/organizational interface and provides specific focal points for improving IS personnel effectiveness with respect to the model.
Comparing object-oriented analysis with knowledge acquisition
Authors: Kaindl Hermann
Published: January 2007

Based on our experience and a theoretical comparison, we see an interesting relationship betweenobject-oriented analysisin software engineering and certain aspects ofknowledge acquisitionin the course of buildingknowledge-based (expert) systems.In particular, we discuss here issues of modeling and the process dimension, i.e., how to do this modeling. According to this relationship, these fields should be able to stimulate each other.
Arrival theorems for product-form stochastic Petri nets
Authors: Balbo G. , Bruell S. C. , Sereno M.
Published: January 2007

We consider a particular class of Stochastic Petri Nets whose stationary probabilities at arbitrary instants exhibit a product form. We study these nets at specific instants in the steady state that occur directly after the firing of a transition. We focus our attention on the instant
after
tokens are removed from the places specified by a transition's input bag and just
before
tokens are entered into the places specified by the same transition's output bag. We show that the stationary probabilities at “arrival instants” are related to corresponding stationary probabilities at arbitrary instants in net(s) with lower load. We then show how one of the “arrival” theorems can be applied to the derivation of a formula for the mean sojourn time of a token in a place at steady state. This is the basis for the development of a Mean Value Analysis algorithm for the computation of performance indices for Product-Form Stochastic Petri Nets.