bluuebunny/crossref_metadata_2025 huggingface dataset:
Design and implementation of a dualband microwave filter using nonuniform lines
Authors: Huang Jhin‐Fang , Lyu Zong‐Min
Published: November 2006

In this article, we propose a mapping method in which the system function of filter in z‐domain is founded by discrete‐time domain techniques as well as by chain‐scatte ring matrices of various transmission‐lines is derived to fulfill a dualbandpass microwave filter based on equal‐length nonuniform coupled lines. A dualband filter with the desired bandwidth and low insertion loss is recognized by cascading bandpass and bandstop filters. The five‐order Butterworth bandstop filter, which uses a coupled‐serial‐shunted lines structure, causes the implantation and correct placement of the bandstop filter. The wide‐band bandpass filter is implemented by the five‐order Chebyshev Type II band‐pass filter, which uses serial lines and shunted stubs lines configuration. The design process is finished by using optimization algorithms to tune the values of characteristic impedances of each transmission‐line section. Experimental results significantly agree with the theoretical values. Measurement shows that the 3 dB passband widths are about 20% for the frequency of 2.45 GHz and 10% for the frequency of 5.25 GHz. The insertion loss is about 0.831 dB at the frequency of 2.38 GHz and 1.873 dB at the frequency of 5.216 GHz. © 2006 Wiley Periodicals, Inc. Microwave Opt Technol Lett 49: 210–215, 2007; Published online in Wiley InterScience (www.interscience.wiley.com). DOI 10.1002/mop.22075
Myasthenia gravis associated with HTLV‐I infection and atypical brain lesions
Authors: Lalive Patrice H. , Allali Gilles , Truffert André
Published: November 2006

We report a patient who experienced progressive diplopia and distal weakness of the upper limbs. Magnetic resonance imaging of the brain showed extensive white matter lesions and analysis of cerebrospinal fluid revealed acute human T‐lymphotropic virus type I (HTLV‐I) infection. Myasthenia gravis (MG) was evidenced by electromyography (EMG) and antibodies against acetylcholine receptor. This unusual case of MG associated with HTLV‐I infection and brain‐restricted lesions underscores the possible link between viruses and MG pathogenesis. Muscle Nerve, 2006
Influence of substituents on the infrared stretching frequencies of carbonyl group in esters of benzoic acid
Authors: Nummert Vilve , Travnikova Oksana , Vahur Signe , Leito Ivo , Piirsalu Mare , Mäemets Vahur , Koppel Ivar , Koppel Ilmar A.
Published: November 2006

Infrared spectra of 25 substituted phenyl esters of benzoic acid C6H5CO2C6H4‐X (XH, 3‐Cl, 3‐F, 3‐CN, 3‐NO2, 3‐CH3, 3‐OH, 3‐NH2, 4‐Cl, 4‐F, 4‐NO2, 4‐CN, 4‐OCH3, 4‐CH3, 4‐NH2, 2‐Cl, 2‐F, 2‐I, 2‐NO2, 2‐CF3, 2‐CN, 2‐CH3, 2‐OCH3, 2‐N(CH3)2, 2‐C(CH3)3), 8 alkyl benzoates C6H5CO2R (XCH3, CH2CH3, CH2Cl, CH2CN, CH2CCH, CH2CH2Cl, CH2CH2OCH3, CH2C6H5), and 22 phenyl esters of substituted benzoic acids X‐C6H4CO2C6H5 (X3‐Cl, 3‐NO2, 3‐CH3, 3‐N(CH3)2, 4‐F, 4‐Cl, 4‐Br, 4‐NO2, 4‐CH3, 4‐C(CH3)3, 4‐OCH3, 4‐NH2, 2‐Cl, 2‐F, 2‐Br, 2‐I, 2‐NO2, 2‐CN, 2‐CF3, 2‐CH3, 2‐OCH3, 2‐NH2) were recorded in tetrachloromethane in the region of 400–4000 cm−1. Carbonyl stretching frequencies νCO for meta‐ and para‐substituted phenyl esters of benzoic acid and phenyl esters of meta‐substituted benzoic acids were shown to correlate with the substituent constants σo. The influence of the through resonance effect on νCO was found to be important in the case of +R para substituents in the benzoyl part of phenyl benzoates as well. The carbonyl stretching frequencies of ortho derivatives in phenoxy part were shown to correlate with the inductive substituent constant σI only. In the benzoyl part of the esters the carbonyl stretching frequencies of cis and trans conformers (relative to the carbonyl group) of ortho derivatives were nicely described by dual parameter equations: (νCO)cis = (νCO)o + c1σI + c3 $E_{\rm s}^{\rm B} $and (νCO)trans = (νCO)o + c1σp+ + c3 $E_{\rm s}^{\rm B} $ (R = 0.99). The trans isomers of phenyl esters of ortho‐substituted benzoic acids showed direct resonance similar to that for para derivatives. The positive steric term found for both the cis and trans conformers could be considered as measure of the steric inhibition of resonance between the phenyl ring and the carboxy‐group caused by bulky ortho substituents. The existence of cis/trans conformations was supported by frequency calculations with Density Functional Theory (DFT) method at B3LYP/6‐311+G** level for the ortho‐substituted benzoates. In the case of alkyl benzoates good correlations of νCO values were obtained when both the Taft σ* and the steric $E_{\rm s}^{\rm B} $ constants were used. For meta‐ and para‐substituted phenyl benzoates s‐trans conformation where the plane of the benzene ring in the benzoyl part of the ester is coplanar with the carbonyl bond plane and the plane of the benzene ring in the phenoxy part is twisted nearly perpendicular relative to the carbonyl bond plane was supported. Copyright © 2006 John Wiley & Sons, Ltd.
Morphological mapping and analysis of poly[styrene‐b‐(ethylene‐co‐butylene)‐b‐styrene] and its clay nanocomposites by atomic force microscopy
Authors: Ganguly Anirban , De Sarkar M. , Bhowmick Anil K.
Published: November 2006

Atomic force microscopy was successfully applied for comprehensive nanoscale surface and bulk morphological characterization of thermoplastic elastomeric triblock copolymers: poly[styrene‐b‐(ethylene‐co‐butylene)‐b‐styrene] (SEBS) having different block lengths and their clay based nanocomposites. Commercially available Cloisite®20A and octadecyl (C18) ammonium ion modified montmorillonite clay (OC) prepared in our laboratory by cation exchange reaction were used. The phase detected images in the tapping mode atomic force microscopy exhibited a well‐ordered phase separated morphology consisting of bright nanophasic domains corresponding to hard component and darker domains corresponding to softer rubbery ethylene‐co‐butylene (PEB) lamella for all the neat triblock copolymers. This lamellar morphology gave a domain width of 19–23 nm for styrenic nanophase and 12–15 nm for ethylene‐co‐butylene phase of SEBS having end to mid block length ratio of 30:70 and block molecular weights of 8800–41,200–8800. On increasing the ratio of block lengths of the polymer matrix and the selectivity of the solvent toward the blocks used for casting, the morphological features of the resultant films altered along with change in domain thickness. The phase images showed position and distribution of the brightest clay stacks in the dark‐bright contrast of the base matrix of the nanocomposite. Exfoliated and intercalated‐exfoliated morphology obtained in the case of Cloisite®20A and OC‐based SEBS nanocomposites, respectively, is further supported by X‐ ray diffraction and transmission electron microscopy studies. The lamellar thickness of the soft phases widened to 50–75 nm, where the layered clay silicates (40–54 nm in length and 4–17 nm in width) were embedded in the soft rubbery phases in the block copolymeric matrix of the nanocomposite. The marginally thicker width of the hard styrenic phases and slightly shrinked width of the soft rubbery lamella can be observed from the regions where no nanofiller is present. Distinct differences in bulk morphologies of the nanocomposites prepared in the melt and the solution processes were obtained with nanocomposites. The presence of clay particles was evident from the almost zero pull‐off and snap‐in force in the force‐distance analysis of SEBS based nanocomposite. This analysis also revealed stronger tip interaction resulting in highest contact and adhesive forces with the softer PEB region relative to the harder PS region. © 2006 Wiley Periodicals, Inc. J Polym Sci Part B: Polym Phys 45: 52–66, 2007
Measurement of high frequency linear viscoelastic functions of a nitrile‐butadiene rubber compound by ultrasound spectroscopy
Authors: Alvarez Guillermo A. , Quintero Miguel W. , Eckert‐Kastner Susanne , Alshuth Thomas , Reinecke Helmut
Published: November 2006

The storage and loss components of the complex wave modulus, M*(ω), measured on a nitrile‐butadiene rubber compound (NBR‐DIN 53538) by ultrasound spectroscopy at a temperature of 293.2 K, were combined with the components of the complex shear modulus, G*(ω), measured on the same sample in a commercial Rheometric Scientific ARES instrument with torsion geometry at different frequencies and temperatures, and superposed in a master plot using the time–temperature superposition principle. From the combined measurements the components of the complex bulk modulus, K*(ω), were obtained by means of the exact formula M*(ω) = K*(ω) + (4/3)G*(ω). Some of the features of the complex bulk modulus reported in the literature for polymeric materials are confirmed for the NBR‐DIN mixture. The maxima in G″(ω) and K″(ω) are separated by more than one order of magnitude in the frequency scale and furthermore, the shapes of the peaks are different. The simple idea, that, for many polymers, the mechanisms for relaxation in shear and in bulk are of the same basic nature appears not to be supported by the present data. © 2006 Wiley Periodicals, Inc. J Polym Sci Part B: Polym Phys 45: 91–102, 2007
How a small change in retinal leads to G‐protein activation: Initial events suggested by molecular dynamics calculations
Authors: Crozier Paul S. , Stevens Mark J. , Woolf Thomas B.
Published: November 2006

Rhodopsin is the prototypical G‐protein coupled receptor, coupling light activation with high efficiency to signaling molecules. The dark‐state X‐ray structures of the protein provide a starting point for consideration of the relaxation from initial light activation to conformational changes that may lead to signaling. In this study we create an energetically unstable retinal in the light activated state and then use molecular dynamics simulations to examine the types of compensation, relaxation, and conformational changes that occur following the cis–trans light activation. The results suggest that changes occur throughout the protein, with changes in the orientation of Helices 5 and 6, a closer interaction between Ala 169 on Helix 4 and retinal, and a shift in the Schiff base counterion that also reflects changes in sidechain interactions with the retinal. Taken together, the simulation is suggestive of the types of changes that lead from local conformational change to light‐activated signaling in this prototypical system. Proteins 2007. © 2006 Wiley‐Liss, Inc.
Theoretical analysis of femtosecond fluorescence depletion spectra and vibrational relaxations of dye oxazine 750 and rhodamine 700 molecules in acetone solution
Authors: Dong Li‐Qing , Niu Kai , Cong Shu‐Lin
Published: November 2006

The fluorescence depletion spectra of oxazine 750 (OX750) and rhodamine 700 (LD700) molecules in acetone solution are calculated using the perturbative density operator method and the transient linear susceptibility theory. The calculated fluorescence depletion spectra of the dye OX750 and LD700 molecules agree well with the experimental results reported by Liu et al. The calculated decay time of the fluorescence depletion spectra due to the vibrational relaxation ranges from 300 to 450 fs, and the decay time resulting from the solvation effect is a few tens of picoseconds. The calculated vibrational relaxation rates are 4.3 and 4.9 ps−1 for the OX750 and LD700 molecules, respectively. The effects of temperature and probe pulse parameters on the fluorescence depletion spectra are also discussed. © 2006 Wiley Periodicals, Inc. Int J Quantum Chem, 2007
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

Methodological 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

Software 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

Reverse‐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

The 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

This 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

Two 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.
Software science and student programs
Authors: Johnston D. B. , Lister A. M.
Published: November 2006

We report on experiments conducted to investigate whether software science can be used as a basis for the automated grading of student programs.
Multiple precision floating‐point computation in FORTRAN
Authors: Verma S. B. , Sharan Maithili
Published: November 2006

By 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

The 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.
A device driver for display terminals
Authors: Coutant Cary A. , Fraser Christopher W.
Published: November 2006

The special editing ability of display terminals is seldom exploited outside of display‐based text editors. Tailoring a device driver in the operating system kernel to display terminals makes display editing available whenever the terminal is used and makes display editors simpler and terminal‐independent. This paper describes such a device driver.
Coroutine behaviour and implementation
Authors: Pauli W. , Soffa M. L.
Published: November 2006

Algorithms 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

Interactive 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

This 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

The 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.
Systems programming for data communications on minicomputers
Authors: Patel Ahmed , Purser Michael
Published: November 2006

This paper examines some of the special considerations which apply to the development of such software for minicomputers. These are treated under the following general categories:

loading and throughput

the external interfaces of the system software

the internal structure of the system software

developing the software

.
Axioms for user‐defined operators
Authors: Pyle I. C.
Published: November 2006

Some 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 operators

An 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

This 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

The 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

It 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

Although 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

This 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

Icon 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

The 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

This 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

Some 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

A 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

The 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

The 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

The 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.
Pascal for school and hobby use
Authors: Wilson I. R.
Published: November 2006

This paper describes a solution to the problem of providing a Pascal compiler suitable for running on a low cost microprocessor system. On such machines, severe store constraints and lack of any usable backing store are imposed by cost limitation. General compiler organization techniques for store conservation are precluded and code compaction, for example, becomes relatively more important.
Implementing BCPL on the burroughs B6700
Authors: Lakos C. A.
Published: November 2006

This 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.
On the performance of COBOL programs in large vs. mini computers
Authors: Jalics Paul J.
Published: November 2006

The comparative performance characteristics of COBOL programs in a small versus large computer systems are investigated. The vehicle consists of a set of synthetic benchmark COBOL programs, each measuring a particular aspect of COBOL computations, data manipulation, and input/output is made on both a large scale computer (IBM 370/158) and a minicomputer (Texas Instruments TI980). Results of a number of such experiments are presented and comparisons made between results obtained from the two systems.
An assessment of a new technique for the representation of boolean matrices
Authors: Dodd W. P.
Published: November 2006

A general‐purpose method, based on a sparse matrix approach, is proposed for the representation of boolean matrices, and algorithms are presented both for representation formation and element access. The method is then compared with the bit‐map approach using the criteria of storage requirements, element access time, and execution time for logical operations on the whole matrix. Finally the conditions are discussed under which the proposed method may be profitably used in preference to the bit‐map approach.
Software segmented virtual memory
Authors: Baxter Anthony Q. , Hart Johnson M.
Published: November 2006

The techniques of paged virtual memory, commonly employed only in large operating systems, can be provided at the software level by a small collection of primitive procedures. This paper defines the primitives and their implementation. The techniques of applying software virtual memory are also discussed, and these techniques are useful for compilers, database systems, and other applications in which large amounts of random access memory are required. Other benefits of using software virtual memory are transportability, modularity in program design, implementation on mini and microcomputers, and improved speed performance over alternative approaches.
A contextual analysis of Pascal programs
Authors: Cook Robert P. , Lee Insup
Published: November 2006

More than 120,000 lines of Pascal programs, written by graduate students and faculty members, have been statically analysed to provide a better understanding of how the language is ‘really’ used. The analysis was done within twelve distinct contexts to discover differences in usage patterns among the various contexts. For example, it was found that 47 per cent of the operands in arguments lists were constants. The results are displayed as tables of frequency counts which show how often each construct is used within a context. Also, we have compared our findings to the results from studies of other languages, such as FORTRAN, SAL and XPL.
Pointer variables in concurrent Pascal
Authors: Ravn A. P.
Published: November 2006

Concurrent Pascal and similar languages are inefficient when used to program systems where processes exchange large messages. The inefficiencies, caused by copying of data, can be removed by introducing pointer variables, and this paper shows how this is done without allowing unrestricted sharing of variables. Pointer variables also give means to solve problems of dynamic resource allocation and dynamic addressing. Examples with performance figures for an actual implementation are given.
Message passing communication versus procedure call communication
Authors: Staunstrup Jqrgen
Published: November 2006

Communication by message passing or by procedure calls in one of the key issues when discussing languages for multiprogramming. The two languages Platon and Concurrent Pascal represent the different approaches which are contrasted by presenting a few programs written in both languages.
A programmable text editor
Authors: Fraser Christopher W.
Published: November 2006

While operating system command languages have improved in recent years, the advances have not yet been widely applied to other command interpreters. This paper describes an editor that has been given two features popular in operating system command languages — i/o redirection and programmable command files. The result is suited both to editing and to some repetitive reformatting tasks often solved by one‐shot, ad hoc programs. Examples display the utility of the extensions, and implications for still other command interpreters are discussed.
A tool to aid in the installation of complex software systems
Authors: Griswold Ralph E.
Published: November 2006

This paper describes a programming language, SIDL, in which various aspects of software installation can be modeled. SIDL supports hierarchical file systems, computers, and processes for executing programs to produce new programs and data. An example, illustrating the installation of Ratfor, and experience with the use of SIDL for describing the installation of a large software system are included.
Description of a menu creation and interpretation system
Authors: Heffler Michael
Published: November 2006

The Menu Creation and Interpretation System (MCIS) is a menu system development tool that can provide the high‐level control structure and the user interface for any application program or software system. MCIS simplifies the task of building menu‐driven systems while presenting a user interface that is easily learned and easy to use.

Human factors considerations have been stressed in the system design. A user is able to jump from one menu to another, obtain help whenever it is needed, and easily recover from errors. Menu systems created with MCIS are extensible and easily modified, enabling them to meet changing user needs. In addition, through the specification of user profiles, menu systems can be customized to meet the needs of individual users.

MCIS is written in the C programming language under the UNIX

Unix is a trademark of Bell Laboratories.

operating system. It can be used in any environment that includes a C compiler and the UNIX standard I/O library.
Extending the power of Pascal's external procedure mechanism
Authors: Tsin Yung H.
Published: November 2006

The CDC Pascal 6000–3.4 compiler allows external procedures to be designed and compiled separately. Such a mechanism strongly enhances the extensibility of the language. However, the external procedures are restricted to having ‘fixed’ parameter list only and is therefore unsuitable for designing I/O routines. This paper describes a cheap way to release the restriction thereby extending the power of the external procedure mechanism significantly. The method is to include a new compiler option, called the Z option, to the existing Pascal compiler. The Z option allows a user to breach the strong binding between format and actual parameters while not diminishing program reliability. The main advantage is that the I/O system can now be isolated from the compiler. I/O features can be added and removed easily as with other library routines.
Meta: A language system for bitslice applications
Authors: Witsel Willem Maarten
Published: November 2006

Bitslice technology is a widely used method for building microprogrammable bitslice processors. Manufacturer supplied language tools required for the production of the microcode, however, are usually too expensive. The Meta system, described in this paper, provides the necessary language facilities at minimal cost, making it ideal for small bitslice projects.

The concept of the Meta system is very simple: a description of the datapath structure and the information processing capabilities of the bitslice processor is written using the four basic operations of the Meta language. Meta uses this description to generate a translator for machine‐oriented microprogramming language. This offers the programmer a tool for implementing microprogrammed functions.

Because of the simplicity of the Meta system, language translators can be built in a very short period of time.
The software engineering of a microcomputer application system
Authors: Gomaa H. , Lui J. , Woo P.
Published: November 2006

A system development methodology is outlined before describing its application to the development of a microcomputer system. Structured analysis techniques were used for determining the information flow through the system. The system was then structured into modules using structured design and information hiding techniques. The detailed design of the system was described in pseudocode. The system was coded in assembler supplemented by a set of structured programming macros. A systematic bottom‐up testing procedure was adopted for system integration.
The STAB multiprocessing environment for CYBA‐M
Authors: Artym Richard
Published: November 2006

Multi‐Thread STAB is an implementation of the notional STAB stack machine1,2 on the CYBA‐M multi‐microprocessor.3–5 Designed expressly for the study of synchronization and performance issues within multiprocessing, the MTS system comprises a highly interactive user interface and multiple program‐gated clocks which, respectively, control and monitor the execution of a STAB kernel. This provides a flexible high‐level environment within which multiple processor STAB programs may be run and analysed in terms of effective concurrency, sequential flow of control and interprocessor synchronization.

The MTS kernel is a re‐entrant STAB interpreter which can simultaneously support any number of 8080 processors, thereby implementing a notional STAB multiprocessor. The STAB processors communicate by access to common global data structures, and primitive binary semaphore operations are available to provide both simple and conditional mutual exclusion in critical regions. Any of the proposed schemes for controlled process interaction6–10 may be implemented on the basis of these fundamental means for communication and synchronization. This provides a useful framework within which general high level multiprocessing control structures may be investigated, and also allows special structures to be created for optimized harnessing of concurrency in specific areas of applications research.
Two examples of block structuring
Authors: Tennent R. D.
Published: November 2006

This article defends the concept of block structure using two examples that have previously been discussed in a recent article by D. R. Hanson and in textbooks by Wirth and Brinch Hansen. It is shown that effective use of block structuring makes it possible to combine the advantages of the nested versions in the textbooks and Hanson's linear versions, calling into question the disadvantages attributed to the block structure concept by these and other authors.
Specifications: Formal and informal—a case study
Authors: Gehani Narain
Published: November 2006

Formal specifications (algebraic) are given for an informally specified small subsystem of the Change Management Automatic Build System. A comparison of the two specifications shows that although informal specifications are easier to read, the formal specifications are clearer, specify operation domains precisely, define the interaction between the operations, show the incompleteness of the informal specifications and are devoid of implementation details. The formal specifications pointed to the need of a function not in the subsystem whose inclusion would improve the system design. This inclusion is now being considered. However, the use of algebraic specifications requires practice and experience. Although the formal specification of large systems is somewhat impractical at the moment, experience in using formal specifications can lead to better informal specifications.