bluuebunny/crossref_metadata_2025_split huggingface dataset:
Multivariable modelling for meta‐epidemiological assessment of the association between trial quality and treatment effects estimated in randomized clinical trials
Authors: Siersma V. , Als‐Nielsen B. , Chen W. , Hilden J. , Gluud L. L. , Gluud C. 
Published: November 2006

AbstractMethodological deficiencies are known to affect the results of randomized trials. There are several components of trial quality, which, when inadequately attended to, may bias the treatment effect under study. The extent of this bias, so far only vaguely known, is currently being investigated by ‘meta‐epidemiological’ re‐analysis of data collected as part of systematic reviews. As inadequate quality components often co‐occur, we maintain that the suspected biases must be evaluated simultaneously. Furthermore, the biases cannot safely be assumed to be homogeneous across systematic reviews. Therefore, a stable multivariable method that allows for heterogeneity is needed for assessing the ‘bias coefficients’. We present two general statistical models for analysis of a study of 523 randomized trials from 48 meta‐analyses in a random sample of Cochrane reviews: a logistic regression model uses the design of the trials as such to give estimates; a weighted regression model incorporates between‐trial variation and thus gives wider confidence intervals, but is computationally lighter and can be used with trials of more general design. In both models, heterogeneity in the bias coefficients can be incorporated in two ways. A stratification approach pools the estimates from models estimated on subgroups of the data. We explore stratification by reviews and by broad trial types, the latter of which gives larger subgroups of the data, circumventing instabilities. A multilevel approach also avoids instabilities and addresses the more fundamental problem of interpretation of the pooled multivariable effect in the presence of heterogeneity. Copyright © 2006 John Wiley & Sons, Ltd.
Software enhancement modelling
Authors: Jones C. 
Published: November 2006

AbstractSoftware projects often follow predictable patterns of usage, growth, and decay. Empirical observations of such patterns allow long‐range estimates of software enhancements to be carried out with reasonable accuracy. It is also possible to project the impact of deliberate interventions into normal growth and decay processes, such as the intermittent restructuring of ageing software. This report summarizes long‐range observations of the growth and decay patterns of software projects.
Specifications and reverse‐engineering
Authors: Brown Alan J. 
Published: November 2006

AbstractReverse‐engineering aims to develop high level descriptions of software from existing source code with the goal of facilitating future maintenance activities on this code. As small sections of code are individually amenable to formal analysis, the usual goal of this activity is to develop specifications and similar descriptions which are formally correct with respect to the source code. This paper presents a theoretical argument that for large systems this is impracticable and undesirable and that the emphasis of post hoc specification of software should move away from formal correctness and towards that of modelling the application domain.
Business domain knowledge libraries to support software maintenance activities
Authors: Mendes‐Moreira H. M. C. L. , Davies C. G. 
Published: November 2006

AbstractThe crisis in software development and maintenance has been widely stated. A great deal of effort has, and is, being made towards its solution (CSM 1985 to 1990). However, the problem persists and it is tending to get worse (Pressman, 1987). Considering the dimension of the software crisis, the authors believe that the solutions required must cover a wide spectrum.The software maintenance component of software development has been recognized as the main factor responsible for the actual crisis. Domain knowledge is a key to requirements recovery and, therefore, for software maintenance. However, it is usually difficult to assimilate because of its nature, its dispersion and the lack of availability of its sources.Commercial business software accounts for the vast majority of existing software and consequently the financial burden is high in maintaining such software. A proposal (purely theoretical) is postulated of a global system for business domain knowledge capture for future reuse. The aim is to make business knowledge maximally reusable by making it publicly accessible in a knowledge repository. The proposed system, the Business Knowledge Library System (BKLS), consists of two types of library:

A knowledge library per organization. This library stores knowledge relevant to the execution of that particular organization's activities, including application‐dependent knowledge to support the software maintenance process. Every kind of knowledge related to the organization, from its objectives to knowledge about its most elementary activities, would be deposited there.
Public business knowledge libraries with general business knowledge; this knowledge is a result of generalizations based on non‐confidential business knowledge from organizations. It is relevant for software maintenance, since it works as a context for the exploitation of applications‐dependent business knowledge.
A space‐efficient code generation scheme for BCPL
Authors: Agarwal Rakesh K. , Chanson Samuel T. 
Published: November 2006

AbstractThis paper presents a methodology in generating space‐efficient code for BCPL and BCPL‐like programming languages. An intermediate language called ICE was designed which, while preserving those program features salient to translation, also tries to minimize the number of instructions generated. This internal representation is then realized as an actual machine. The encoding scheme (called ES0) is based on usage frequencies of instructions and other real world constraints on machines such as word size and addressing space. Using a large sample of BCPL programs, it is shown that BCODE, which is a realization of OCODE (the intermediate language currently used for BCPL program translation), takes up an average of 32 per cent more space as compared to ICE/ES0.
Leave and recall: Primitives for procedural programming
Authors: Thimbleby Harold 
Published: November 2006

AbstractTwo primitives for structured programming are introduced. The primitives allow a generalized procedure entry and return similar to the ‘loop’ and ‘break’ statements found in many algorithmic languages for control in repetitive commands. Examples are given and the practicality of the primitives especially for interactive programming is stressed. Finally, the detailed implementation of the primitives is discussed; they may be implemented as procedures within an existing language.
Multiple precision floating‐point computation in FORTRAN
Authors: Verma S. B. , Sharan Maithili 
Published: November 2006

AbstractBy splitting the mantissa of a multiple precision number into BLOCKS of constant width, it has been shown that the precision of a computer can be increased to a degree as high as we please by merely developing a FORTRAN program that can force the computer to perform all arithmetical executions up to any desired number of significant decimal places. Some of the salient features of such a programming are summarized as follows:

It reduces inherent errors arising due to approximate nature of representing in some finite number of digits a number that cannot ordinarily be represented exactly in the number of digits available with the particular installation being used.
The working of the computer proceeds just as if it were a decimal computer. Naturally we should expect better results even for the same number of digits as the computer normally takes.
It takes due care of very low/high numbers occurring in intermediate calculations as one word space is being provided to store the exponent itself.
Being problem oriented in nature, the FORTRAN language is most commonly understood by a large section of programmers. It is mainly for this reason that although it requires comparatively more time and space, one can save one's own valuable time in learning complicated assembly languages which differ from computer to computer.
It can be easily extended to complex numbers.
Here we shall be mainly concerned with the implementation aspect of the program. As regards the variability of the precision, enough flexibility is given to control the precision by changing the size of the number designate arrays.
PBASIC — a verifier for BASIC
Authors: Hopkins T. R. 
Published: November 2006

AbstractThe increase in the number of available dialects of BASIC has lead to the usual difficulties encountered when transporting software. The proposed American National Standard Minimal BASIC represents a small but almost universal subset of all BASICs. PBASIC is a verifier for ANS Minimal BASIC. The verifier is itself written in PFORT, a portable subset of FORTRAN IV.
Coroutine behaviour and implementation
Authors: Pauli W. , Soffa M. L. 
Published: November 2006

AbstractAlgorithms using retentive control are currently being developed in operating systems, simulation, artificial intelligence and language implementation. This paper investigates two aspects of a form of retentive control, namely coroutines. The behaviour of coroutines and language primitives that express the operations on coroutines are explored by surveying the literature for coroutine usage. Secondly, the area of control implementation of coroutines is investigated by considering the Bobrow and Wegbreit spaghetti stack as a viable data structure for managing run‐time storage. Changes in the basic model of the spaghetti stack, tailoring its use in a strictly coroutine environment with subsequent implementation alternatives, are explored. An investigation through experimentation is made of the effect control‐related aspects of coroutines have on the revised spaghetti stack models. An analysis of the empirical results obtained provides a useful barometer for selecting appropriate storage management schemes based on coroutine design and usage.
A HELP system for the user community
Authors: Cox G. B. , Walsh B. C. 
Published: November 2006

AbstractInteractive computer guidance systems are discussed. The user interface of such systems and the computer resources required are examined for a large computer centre. The design and development of a Liverpool HELP system is discussed. The Liverpool HELP system, which is written entirely in GEORGE job control language, is shown to be an efficient and inexpensive solution to the provision of an on‐line enquiry service.
Modification of the Pascal‐P compiler for a single‐accumulator one‐address minicomputer
Authors: Cornelius B. J. , Robson D. J. , Thomas M. I. 
Published: November 2006

AbstractThis paper describes changes made to the Pascal‐P compiler in order to improve the efficiency of its implementation on a single‐accumulator one‐address computer, the PRIME 300. The aim of the project was to develop a true compiler rather than a threaded code or pure interpretation system. A comparison of timings for these three methods of implementing the Pascal‐P compiler is also presented.
Design considerations for array processing languages
Authors: Wetherell Charles 
Published: November 2006

AbstractThe Department of Energy (DoE) has a long history of large‐scale scientific calculation on the most advanced ‘number‐crunching’ computers. Recently, an effort to improve communications and software sharing among DoE laboratories has been underway. One result of this sharing is a project to design and implement a common language. That language turns out to be FORTRAN 77 significantly extended with new data structures, control structures and array processing. The data used to design the array processing feature is surprising and likely to be of use to others working in scientific language design; it is reported here so that others may profit from DoE's experience.
Axioms for user‐defined operators
Authors: Pyle I. C. 
Published: November 2006

AbstractSome programming languages allow the programmer to define operators. Algol‐68 allows user‐defined operator symbols with user‐defined priorities and user‐defined bodies; nevertheless the language rules insist on left‐to‐right evaluation of equal precedence operators. The new Department of Defense DoD language Ada allows the programmer to define new operators, but restricts them to language‐defined operator symbols with language‐defined priorities: in other words, only user‐defined bodies. The language rules concerning operators are therefore stronger, and imply properties of operators: ‘axioms’, which should apply even for use‐rdefined bodies. The paper discusses sensible constraints which should be accepted for user‐defined operatorsAn earlier version of this paper was presented at the IFIPWG2.4 (System Implementation Languages) meeting at Twente, June 1978. The author thanks members of WG2.4 for their comments.
.
NPP: An easy to implement preprocessor for text formatting
Authors: Barach David R. , Fram David M. 
Published: November 2006

AbstractThis paper describes our approach to the problem of specifying formatting information in computer‐based text processing. We distinguish between local and global formatting decisions, adopt natural conventions for representing each, and separate them. Our system, cast as a preprocessor to an available formatter, hides annoying formatter dependencies, and leads to a document representation which can be processed under several operating systems. After initially implementing our system, we produced a second version for another formatter/operating system in less than 2 man‐weeks.
A data‐directed approach to program construction
Authors: Cowan D. D. , Graham J. W. , Welch J. W. , Lucena C. J. P. 
Published: November 2006

AbstractThe present paper discusses a method of program construction based on the specification of the data types. The input and output data types and the mapping between them are specified at a high level of abstraction and this non‐procedural specification is used to develop a program schema. The data type and mapping specifications are modified to include a concrete representation of the data and these are used to expand the program schema into a program. A graphical representation for data and program specifications is also introduced and it is shown how this can simplify the techniques and be very useful in program construction. The method is illustrated by developing two programs—the line justifier program described by Gries and the bubblesort.
Ifs and thens: Is nesting just for the birds?
Authors: Green T. R. G. 
Published: November 2006

AbstractIt has become fashionable to criticize nested conditionals, which are supposed to tax the human mind, and to recommend that they should be ‘un‐nested’, turning if‐then‐if into if‐then‐else‐if. Experiment casts doubt on this, however, and suggests that indeed the unnested form is only slightly better in the best conditions and is much worse in unsuitable conditions. Rather than hypothesizing about how the programmer's mind works a much more important principle seems to be to provide perceptual cues that will make program structure manifest rather than latent.
An Algol 68 based algebraic manipulation system
Authors: Ince Darrel C. , Robson Keith 
Published: November 2006

AbstractAlthough the topic of algebraic manipulation by computer is an old one, it is still a characteristic of many algebraic manipulation systems that they often neglect the needs and characteristics of the end user. This paper describes an algebraic manipulation system, written in Algol 68, which attempts to remedy this state of affairs.
Parallel programming for a chess endgame database
Authors: Messerschmidt H. J. 
Published: November 2006

AbstractThis paper presents a parallel implementation in APL of an algorithm to set up a database for the KRK‐endgame in chess. It shows clearly the techniques necessary to achieve the parallelism and thereby proves that APL can be a valuable productivity increasing aid in this kind of Artificial Intelligence (AI)‐research. The complete APL‐functions are given in the Appendix.Both reversed pigeon hole and bit map techniques are used. Move generation is table driven with a new technique to cater for the blockage of sliding pieces like a rook. In order to maintain parallelism ‘if’ statements are avoided and extensive use is made of compression and identity elements.
A portable storage management system for the icon programming language
Authors: Hanson David R. 
Published: November 2006

AbstractIcon is a new programming language designed primarily for non‐numerical applications. Its roots are in SNOBOL4 and SL5; as in those languages, execution‐time flexibility is an important attribute of Icon, although some aspects of programs are bound at compile time to improve efficiency. Icon, which is implemented in Ratfor, is also intended to be portable and suitable for 16‐bit computers. The storage management system in Icon is designed to meet the goals of portability, flexibility and efficiency. This is accomplished by subdividing the storage management system into a set of type‐specific storage management subsystems. This paper describes the implementation of these subsystems, their interaction, and their performance.
Practical fast searching in strings
Authors: Horspool R. Nigel 
Published: November 2006

AbstractThe problem of searching through text to find a specified substring is considered in a practical setting. It is discovered that a method developed by Boyer and Moore can outperform even special‐purpose search instructions that may be built into the computer hardware. For very short substrings however, these special purpose instructions are fastest—provided that they are used in an optimal way.
Variable number of parameters in typed languages
Authors: Prasad V. R. 
Published: November 2006

AbstractThis paper investigates the ways and uses of permitting a variable number of routine parameters in typed high‐level languages. The problem is first introduced through the notions: optional parameters, multiple parameters and polymorphic parameters. The optional parameter mechanism is motivated by the advantages of the conventional practice of omitting certain actual parameters in routine calls as permitted in some low‐level languages. The multiple parameter mechanism facilitates restructuring of routine definitions so that multiple calls to the same routine can be replaced by a single call. The polymorphic parameter mechanism permits routine definitions which can operate on different types of data. These three notions together provide a powerful means of permitting a variable number of parameters in typed languages. The power of the mechanism is illustrated by a specific application: if such a mechanism is introduced in Pascal, the language definition can be completely freed from the need for predefining files and the standard input/output routines, at the same time retaining most of its programming convenience.
Interrupts
Authors: Hunt J. G. 
Published: November 2006

AbstractSome recent papers have included eulogies of the PDP‐11 architecture, and of its interrupt mechanism in particular. This is dangerous if it is to set a standard for the coming decade. This note presents the view that all interrupts should be serviced by dedicated processes. However, the feasibility of this is determined by machine architectures, not just by the hardware interrupt mechanism itself.Considering first the well‐known PDP‐11, we then summarize the origin and function of interrupts before stating a philosophy for interrupt‐handling. It is then shown, with reference to the PDP‐11, how not only the interrupt mechanism but also features such as stacks and procedure mechanisms may affect this philosophy. We conclude by suggesting alternative architectural features to unify interrupts, procedure calls, process invocations, and interprocess communication, as will be required for the support of recent and future languages.
Pretty‐printing of trees
Authors: Vaucher Jean G. 
Published: November 2006

AbstractA pleasing layout of printed tree structures is difficult to achieve automatically. The paper points out three main problems. First, the horizontal position of a node on the printed page depends on global consideration of the position of other nodes; secondly, the physical characteristics of printers require scanning the tree in left‐to‐right top‐to‐bottom sequence; finally, page overflow for wide trees must be handled. These problems are illustrated by analysing the shortcomings of a simple printing algorithm. A suitable general binary tree printing algorithm is presented and its adaptation to other types of trees is shown.
SATHE: Some aspects of an ALGOL implementation
Authors: Aretz F. E. J. Kruseman , van de Snepscheut J. L. A. , Grasdijk H. , Smeets J. M. H. 
Published: November 2006

AbstractThe development of a compiler for a dialect of ALGOL 60 is described. The emphasis is on the strategies used in the detection and smooth recovery from errors in the input text. These strategies are independent of both the language implemented and the implementation language. The user's view is such that he sees an ALGOL machine: the user is addressed in a language he is familiar with, using notions from the programming language and his particular program only.
Page replacement algorithm for large‐array manipulation
Authors: Muramatsu Hiroshi , Negishi Hiroaki 
Published: November 2006

AbstractThe Least Recently Used (LRU) method is the technique that is most often used for a page replacement algorithm. However, LRU may not be an effective method for some large‐array manipulation. A method for solving this problem is presented in this paper. In this method, the Operating System (OS) automatically detects loops that are not suitable for the LRU method. There is no necessity to modify application programs nor any additional overhead as long as sufficient real memory is provided. Therefore this method is most suitable for practical use. It functions on the basis of information about the relationship between the working set size and the window size, and indication of whether the detected page fault is caused by an instruction fetch or an operand fetch, etc. The results of experiments and improvements are also shown.
Interpretation and code generation based on intermediate languages
Authors: Kornerup Peter , Kristensen Bent Bruun , Madsen Ole Lehrmann 
Published: November 2006

AbstractThe possibility of supporting high level languages through intermediate languages to be used for direct interpretation and as intermediate forms in compilers is investigated. An accomplished project in the construction of an interpreter and a code generator using one common intermediate form is evaluated. The subject is analysed in general, and a proposal for an improved design scheme is given.
Implementing BCPL on the burroughs B6700
Authors: Lakos C. A. 
Published: November 2006

AbstractThis paper investigates the problems of implementing the programming language BCPL on the Burroughs B6700 computer. The problem is unusual because of BCPL's typeless nature and unstructured view of memory in contrast to the B6700's typed and highly structured memory. The proposals are compared with the implementation distributed by the University of Warwick. It is shown that a less awkward implementation is possible if one is primarily guided by the requirements of the language rather than conventional practice on the target machine. It is advocated that in producing the intermediate language form of a source program, the more structuring information which is discarded the more the possible implementation problems which may arise.