bluuebunny/crossref_metadata_2025_split huggingface dataset:
Simulation of a distributed system for performance modelling
Authors: Bennett David A. , Landauer Christopher A. 
Published: January 2007

A distributed system of cooperating minicomputers is simulated by AIMER (Automatic Integration of Multiple Element Radars) to model and analyze the behavior of a radar tracking system. Simulation is applied in the AIMER project in an attempt to model a network of minicomputers to discover a maximally flexible network architecture. Because building the tracking system out of real hardware would not result in a flexible enough testbed system, the proposed configuration is represented by a software emulation. The instruction sets of the individual processors are emulated in order to allow separation of the measurement facilities from the execution of the system. The emulation is supported by a Nano-data QM-1 micro and nano-programmable host. Extensive performance monitoring hooks have been built into the emulation system which allow small performance perturbations to become visible.
The tracking network is controlled by a combination firmware operating system and a special emulated virtual control machine. The tracking algorithms run on virtual machines whose instruction sets and computational throughput can be parameterized when the model is generated, or dynamically by an operator during a run.
The radar and ground truth environments for the tracking system are simulated with logic resident in one of the emulated machines, allowing these functions to be monitored as accurately as the tracking algorithms.
The use of this simulation technique has resulted in an extremely flexible testbed for the development of distributed radar tracking system models. The testbed itself can be quickly tailored to other application problems.
Evaluation methods in SARA—the graph model simulator
Authors: Razouk Rami R. , Vernon Mary , Estrin Gerald 
Published: January 2007

The supported methodology evolving in the SARA (System ARchitects' Apprentice) system creates a design frame-work on which increasingly powerful analytical tools are to be grafted. Control flow analyses and program verification tools have shown promise. However, in the realm of the complex systems which interest us there is a great deal of research and development to be done before we can count on the use of such powerful tools. We must always be prepared to resort to experiments for evaluation of proposed designs.
This paper describes a fundamental SARA tool, the graph model simulator. During top-down refinement of a design, the simulator is used to test consistency between the levels of abstraction. During composition, known building blocks are linked together and the composite graph model is tested relative to the lowest top-down model. Design of test environments is integrated with the multilevel design process. The SARA methodology is exemplified through design of a higher level building block to do a simple FFT.
Evaluation of concurrent physical database reorganization through simulation modeling
Authors: Söderlund Lars 
Published: January 2007

The performance of a database system commonly deteriorates due to degradation of the database's physical data structure. The structure degradation is a consequence of the normal operations of a general database management system.
When system performance has degraded below acceptable limits the database must be reorganized. In conventional, periodic reorganization the database, or part of it, is taken off line while the data structure is being reorganized.
This paper presents results from a study where it is shown that concurrent reorganization, i.e. a continous reorganization of the physical data structure while application processes have full access to the database, is an attractive alternative to conventional reorganization.
The paper also presents a solution to a methodological problem concerning the simulation of a system which has activities with extremely varying durations.
REDUCE/1700
Authors: Griss Martin L. , Kessler Robert R. 
Published: January 2007

The status of an ongoing micro-coded Algebra machine project is reviewed. We have implemented a LISP “machine” on the Burroughs B1726 computer, capable of supporting the REDUCE Algebra system. A portable version of this LISP machine (written in a portable implementation language, BIL), can be used to produce a compact and efficient LISP or REDUCE for smaller machines (it also serves as a bootstrapping kernel for larger machines).
In this paper, we summarize the current status of the MBALM/1700 project, aimed at producing a micro-coded LISP and Algebra System on the Burroughs B1726 computer.
Operational models for the evaluation of degradable computing systems
Authors: Wu L. T. 
Published: January 2007

Recent advances in multiprocessor technology have established the need for unified methods to evaluate computing systems performance and reliability. In response to this modeling need, this paper considers a general modeling framework which permits the modeling, analysis and evaluation of degradable computing systems. Within this framework, a simple and useful user-oriented performance variable is identified and shown to be a proper generalization of the traditional notions of system performance and reliability.
The modeling and evaluation methods considered in this paper provide a relatively straightforward approach for integrating reliability and availability measures with performance measures. The hierarchical decomposition approach permits the modeling and evaluation of a computing system's subsystems (e.g., hardware, software, peripherals, interfaces, user demand systems) as a whole rather than the traditional methods of evaluating these subsystems independently. Accordingly, it becomes possible to evaluate the performance of the system software and the reliability of the system hardware simultaneously in order to measure the effectiveness of the system design. Since the performance variable introduced permits the characterization of the system performance according to the user's view of the systems, the results obtained represent more accurate assessments of the system's ability to perform than the existing performance or reliability measures.
Importing theory "Z" to the software shop
Authors: Licker Paul S. 
Published: January 2007

Japanese management techniques have excited Western thought in recent years partly because they seem to promise relief from the "productivity crisis." Detractors have been quick to point out the lack of quick success, the enormous cultural content of these practices, and the difficulties in transferring organizational behaviour techniques from one culture to another. Proponents contend that the lessons, rather than the content of Japanese management techniques and their unique focus upon organizational process rather than upon production technique will provide the greatest benefit to Western business.
This paper explores the transferability of one form of Japanese management technique, Ouchi's Theory "Z", to the last bastion of unarticulated management--the software shop. While there are no documented efforts at such transfer, it is likely that this unlikely migration can take place painlessly over the next decade. In the exploration, numerous similarities between computer programmers in today's software shop and the emerging form of the twenty-first-century worker are pointed out. The lesson learned from this exercise will be appropriate to all knowledge workers as office automation reaches out into professional and managerial positions.
Issues limiting the acceptance of user interfaces using gesture input and handwriting character recognition (panel)
Authors: Sibert John , Buffa Michael G. , Crane Hewitt D. , Doster Wolfgang , Rhyne James , Ward Jean Renaerd 
Published: January 2007

Recently there has been increasing attention to character recognition/graphical user interfaces under the name of “gesture input”. This technique actually has a long history: “sketch recognition” interfaces of 15 or more years ago were highly praised [Applicon 73], and user interfaces using handwriting input before the wide use of text keyboards were one of the first research goals in computer science [Bledsoe 59]. The underlying character and symbol recognition technologies have been a major research area in their own right since the early 1950s [Suen 80].
The last two years have seen an upsurge in the number of developments in this area, both from commercial companies attempting to exploit new character and symbol recognition technologies, [CIC 85] [Pencept 84] [Cooper 82] and from researchers starting from fundamental questions in user interactions [Buxton 86] [Wolf 86]. However, one question still remains: “Why has this set of techniques had so little impact on user interface design practice, despite its long history and promise?” This panel discussion should give many answers to this question.
Panelists include the leading commercial developers of handwriting input products, well-known researchers in the psychological aspects of graphical user interactions, and representatives of the research community for character recognition.
The issue of supporting this type of interface is very timely: recent standardization efforts such as PHIGS and GKS for graphics interactions are known to have the unfortunate side effects of excluding some of the current user interface designs using this class of technology [10].
A Be´zier curve builder implemented in APL2
Authors: Tollet Gustav , Harrison Peter M. 
Published: January 2007

The Be´zier representation of curves is commonly used in computer graphics. A different, less advanced way of representing a curve is that of using a polyline, i.e., a sequence of short straight lines. This paper describes a “curve builder” that converts a polyline into a sequence of one or more Be´zier curves.
Part of the method is based on mathematical groundwork by Pat Beirne of Corel Systems Corporation, with extensions by the authors.
The project was implemented in APL and could not otherwise have been completed with the resources and time available.
Porting and optimising star
Authors: van Batenburg F. H. D. , Bos V. , Riethoven J. J. M. , Abrahams J. P. , Pley C. 
Published: January 2007

This paper has three main parts. The first part is a description of our project STAR. It explains what our program does and what makes it special compared to other similar programs.
The second part pertains to the porting of our program to other platforms. It enumerates the errors of our ways, how we struggled to overcome them and what we learned in the process.
The last part narrates our strategy to optimise the program. We will explain why we deviated from the general accepted strategy to optimise those parts with the highest potential gain.
Analytical models of combining Banyan networks
Authors: Merchant Arif 
Published: January 2007

We present in this paper an analytical model of a multistage combining Banyan network with output buffered switches, in hot-sport traffic. In a combining network, packets bound for the same destination are combined into one if they meet at a switch; this alleviates the problem of tree-saturation caused by hot-spot traffic. We model the flow processes in the network as Markov chains and recursively approximate the departure processes of each stage of the network in terms of the departure processes of the preceding stage. This model is used to predict the throughput of the combining network, and comparison with simulation results shows the prediction to be accurate.
A modified combining scheme based on low priorites for hot packets is proposed and analyzed. It is shown that this scheme yields substantial improvements in throughput over the standard combining scheme.
A comparison of object-oriented analysis and design methods (abstract)
Authors: Fowler Martin 
Published: January 2007

This tutorial shows how to look inside design and analysis methods to see how they differ, and more importantly, how they are the same. It examines several of the most well-known methods, including Booth, Coad/Yourdon, Odell/Martin, Rumbaugh, and Schlaer/Mellor, but its analysis techniques can be applied to any method.
In general, each method is made up of several techniques (e.g. ER modeling, state transition diagrams) each of which emphasizes a particular aspect of the system. These techniques can be classified as being for structural (data), behavioral architectural modeling. The tutorial shows the techniques each method uses and how different methods use different dialects of the same I techniques, varying the notation and introducing new concepts. It uses examples to show how the same system is expressed in different ways by the various methods. The tutorial also compares the design approach advocated by each method.
This tutorial will help you decide which method will work best for you. In addition, you will learn how ideas from different methods can be combined to better suit the system under analysis.
Specification techniques for object-oriented software (abstract)
Authors: Dodani Mahesh H. 
Published: January 2007

There are many techniques for specifying software. However, they are not usually presented in a way that is directly applicable to object-oriented software. This tutorial surveys both operational and descriptive specification techniques, shows how to use them in several popular object-oriented software engineering methods, and provides case studies of developing useful, formal specification mechanisms that are appropriate for object-oriented software engineering.
The tutorial first describes criteria for choosing specification mechanisms from both a theoretical (syntax and semantics, specifying properties, reasoning about properties, verification) and practical (ease of use, modularity, applicability, supporting tools) perspective. These criteria are then used to survey several popular operational (data flow diagrams, finite state machines, and petri nets) and descriptive (entity-relationship models, logic, and algebraic specifications) specification mechanisms. Finally it shows how to extend two of these techniques (algebraic specifications and finite state machines) so that they are suitable for object-oriented software engineering.
Schema updates for object-oriented database systems (abstract)
Authors: Zicari Roberto 
Published: January 2007

OODBMS are often used for complex data whose structure is likely to change over time, yet the problem of schema updates has not been completely solved by any commercial or research OODBMS. This tutorial describes the schema modification problem and why it is important, what is really offered by products, what a good solution would be like, and whether we are likely to see it soon.
The tutorial reviews several commercial OODBMS products that provide facilities for updating the schema, namely: Gemstone (Servio Corporation), ITASCA(Itasca), 02(02Technology), ObjectStore (ObjectDesign), Ontos (Ontologic) and Statice (Symbolics). It also describes the solutions proposed in some experimental research prototypes and the open problems that remain.
Applying text and graphic tools in parallel (abstract)
Authors: Coad Peter , Nicola Jill 
Published: January 2007

Which is bettertext or graphicsfor exploiting and communicating
object-oriented results? Both! To illustrate the desirability,
effectiveness, and impact of using both mediums, this demonstration
works through a small OOA/OOD model with text and graphicson two
large screens, side-by-side, in parallel. The demonstration
includes practical insights on how to use both text and graphics
for better developing and communicating object-oriented results. It
also includes a look at the theories which point to a dramatic need
for a more multi-faceted approach. Special emphasis is placed on
the theory of seven intelligenceslinguistic, mathematical/logical,
spatial, musical, body-kinesthetic, interpersonal, and
intrapersonal.
Two tools for visualizing objectstext (Smalltalk) and graphics
(from the ObjecThink Series)are applied side-by-side, in parallel.
Participants experience first-hand the needand the impactof
applying multimedia approaches to stimulate more effective object
think.
Graphical animation of object-oriented software designs (abstract)
Authors: Heikkinen Marko , Pulli Petri 
Published: January 2007

We have built an extension to a prototype CASE tool called
ESPEX, that makes it possible to execute graphically Wassermans
Object-Oriented Structured Design (OOSD) notation. The tool itself
is implemented in the Smalltalk 80 programming environment. The
tool contains a window-based menu-driven graph editor and an
integrated graph simulator with animation support. Animation means
that the movements of data items and messages between objects are
visualized on a workstation display.
We have implemented simulation for object instances. We are
using moving tokens with data values attached on top of them.
Tokens flow from objects to other objects, carrying the essential
data with them. The moving tokens indicate clearly the active parts
of the model, while the data values also make it possible to
visualize the actual computations that take place in the objects.
Another advantage of moving tokens is that it is possible to attach
time stamps to tokens. With the help of the time stamps it is
possible to simulate experimenting with animation techniques for
dynamic creation and deletion of objects.
We model objects hierarchically, so that an object can be
composed of other lower level objects. At the lowest level objects
are described with predicate/transition Petri nets, and the
computations with IPTBS Meta-IV, Smalltalk-80, or C.
The work presented demonstrates that it is possible and feasible
to animate object-oriented design notation using a token moving
approach. However, there is still much work to be done on the
animation of dynamic instantiations and deletion of objects. We
believe that graphical animation tools are the enabling technology
for teamwork and for conceptual communication in the future
concurrent engineering working environments.
The work presented in this demo was carried out in the IPTES
project. IPTBS is partially funded by the European Communities
under the ESPRIT programme.
Object-oriented engineering of distributed applications (abstract)
Authors: Muhlhauser Max , Heuser Lutz 
Published: January 2007

The Universities of Kaiserlautern and Karlsruhe are
cooperating with the CEC Karlsruhe, a research center of Digital
Equipment CmbH, in the area of software engineering for distributed
applications.

This demonstration will showcase DOCASE, a software engineering
environment for distributed applications, using object-oriented
technology. The demonstration will provide insight into the
methods, languages, tools and environments used in the life-cycle
of distributed applications. With the term distributed
applications, we put an emphasis on structured parallelism (which
comes more or less naturally with the logical structure and
inherent parallelism and distribution of an application), not so
much on the fine-grained parallelism exploited by applications such
as image processing etc.
With more and more complex (dynamic, multiparty, cooperative)
distributed applications to be developed in computer integrated
manufacturing, office automation, CSCW, and other domains, we think
that this topic is both very much up to date and a topic which is
not sufficiently taught.
The live demonstration will show a distributed application which
will allow researchers of arbitrary disciplines to coordinate their
work with other members of a research team. The underlying meta
model is generic and instantiated by developing a set of concrete
object types together with a GUI.
The object in perspective
Authors: Power June 
Published: January 2007

From the Conclusions

The philosophy of language has indicated that there are serious omissions in the Cartesian theory of categorisation; notably, that members of a category are related by family resemblances and not necessarily by shared properties between members of categories. As observed by Lakoff, these findings are also in conflict with other popular positions held in the Artificial Intelligence community which view human reason as completely abstract, as well as assuming that every cognitive process is algorithmic in nature; that thought is purely a matter of symbol manipulation [9]. The former of these does not agree with findings of categorisation phenomena which imply that basic level concepts are characterised by basic-level perception and imaging capacities. The problem for the latter position is that the only way it can make sense of the understanding of two different conceptual systems is by means of the translation of one into another, or the translation of both into a third system. Understanding in terms of experience does not eliminate such organisational differences, so this is a problem which needs to be addressed.
Self-organising activity will involve, minimally, the management of information, its representation both within a given organisation as well as across organisations and the effect of system evolution on the object. The object model, as currently based on the Cartesian view of categorisation, may not be sufficient for these requirements. Instead, it may need to accommodate what have been termed the holistic aspects of knowledge representation and categorisation. In any event, in order to define a set of requirements for self-organising architectures, we will need to bear in mind not only the object, but also what is implied by the object.
Parallel simulation of communicating finite state machines
Authors: Tropper Carl , Boukerche Azzedine 
Published: January 2007

We describe, in this paper, a synchronization/deadlock resolution mechanism for a network of communicating finite state machines implemented on a parallel machine. As it is message-based, it is appropriate for distributed memory machines.
The technique was inspired by a project at the Jet Propulsion laboratories whose goal is the specification and verification of the software used to control the interplanetary spacecraft operated by the laboratory.
The network of communicating finite state machines makes use of write messages to alter the value of the variables describing the finite state machines and read messages to determine the state of the variables. Since a blocking protocol is employed, it is possible for deadlocks to occur. Consequently, we describe deadlock resolution algorithms.
Our algorithms were implemented on an iPSC/2 hypercube, demonstrating good performance on a queueing network model.
A practical approach to the evaluation of microcode systems
Authors: Skibbe R. E. 
Published: January 2007

This paper describes a microcode-evaluation methodology. The supporting test tools were developed by the IBM General Products Division in Tucson, Arizona, to allow effective and comprehensive evaluations of microcode systems. The methodology has been used successfully by the Tucson Test Laboratory (TTL) during the past several years.
The evaluation methodology is characterized by an integrated application of static and dynamic analysis techniques. These two modes of analysis are complementary and they allow a level of automation that can significantly enhance the productivity of a testing organization through the systematic application of automated testing techniques. The methodology also establishes a discipline for the microcode-testing process that promotes a formal program of defect removal. Of course, improving the process of removing defects produces a corresponding enhancement in product quality.