bluuebunny/crossref_metadata_2025 huggingface dataset:
Real-life projects for students
Authors: Howard Daris
Published: November 2005

I've discovered that having students help me and my college with real-life projects is an effective learning experience. As with most two-year college instructors, I teach a heavy load - 15 credit hours a semester. In addition, I have been working to provide Internet tools and access for faculty and students. I do much of this work on my own time and at my own expense. When I tried using students to help me with my projects, the response was very positive. Many students love the thrill of a "real-life" project and tend to spend many more hours than they would on programs that they regard as just a college assignment. Following are some of the projects that I've assigned to my students. I would be interested to heart about projects that others have tried and about their successes and failures.
Educating educators
Authors: Luks Susan , Levy Suzanne Pawlan
Published: November 2005

We are Susan Luks, Assistant Professor of Computer and Information Science at University of Detroit Mercy in Michigan, and Suzanne Pawlan Levy, Instructor of Computer Science at Allan Hancock College in California. We are two women who teach programming languages in small institutions: two women who have remarkably similar stories to tell about our experiences of isolation and struggle that resulted from the addition of a course in Ada Programming in our institutions' curricula: two women who resolved our problems of stumbling (by different elements of chance) into the Ada community.
DOCASE
Authors: Seagren Jay
Published: November 2005

This paper summarizes a project called DOCASE which stands for Distribution and Objects in CASE. The objective of the project was to establish a method and the tools for object-oriented (00) distributed programming. That is to design object-based programs that are flexible in their execution on the new client server systems being developed today.
Degree program planned in computer user support
Authors: Beisse Fred
Published: November 2005

The Computer Information Technology (CIT) Department at Lane Community College is developing a two-year vocational/technical degree program to train Computer User Support Specialists. Financial support for the curriculum development is provided by a grant from the Regional Strategies Council, which encourages economic development projects in Oregon. The curriculum is being developed during the 1994-95 academic year.
One department's evolution
Authors: Oleks Judith C.
Published: November 2005

A ten-year anniversary is a good occasion to look back and ponder the evolution of my department at Bunker Hill Community College. When I first joined the Computer Programming Technology Department in September 1985, the main focus of course offerings was the Programming Technology option. This A.S. career option was the original Bunker Hill Community College computer major which had necessitated a computing department separate from the Business Department. This option offered students training in business programming leading to a level-entry job as a (COBOL) programmer in one of the Boston area's many data processing departments. At that time I was hired to teach courses that were offered as part of the department's newly created transfer option, an A.A. degree in Computer Science.
The programming languages REC and convert
Authors: McIntosh Harold V. , Cisneros Gerardo
Published: November 2005

Two symbol manipulation languages are presented. REC (an acronym for Regular Expression Compiler) is a very compact language possessing a simple control structure. C
ONVERT
is a pattern matching and substitution language well suited to problems whose solution may conveniently be expressed in terms of transformation rules. REC is useful when conciseness is required. such as for microcomputers with limited memory, interactive programming via the keyboard, and so on. Its present form was carefully chosen to facilitate the compilation of C
ONVERT
programs while still preserving a universal appearance. In turn, C
ONVERT
is a natural alternative to consider for an application which is already expressed in terms of transformation rules, as are many compilers, assemblers and symbol manipulation systems. This article primarily describes the appearance of these two languages, but some of the applications which they have been given are mentioned.
Inline expansion of SETL procedures
Authors: Hyun Kio C. , Doberkat Ernst-Erich
Published: November 2005

We report on an experiment in doing inline expansion of SETL procedures using the prototype of a preprocessor written in Franz LISP. This expansion facilitates in particular data flow analysis and enhances the quality of information which is available to the typefinding phase of the SETL optimizer.
The lion and the unicorn met PROLOG
Authors: Ramsey Bruce D.
Published: November 2005

A recent paper published in the Journal of Automated Reasoning, No. 1, 1985, described ways to apply automatic theorem-proving techniques to a logic puzzle. The PROLOG programming language pertains to automatic theorem-proving. That paper did not mention PROLOG, but we use PROLOG to slove the logic puzzle that paper discussed. We then compare our results with the results given in that paper.
A proposal for implementing the concurrent mechanisms of Ada
Authors: Zang Xiaolin
Published: November 2005

This paper proposes a scheme for implementing the communication and synchronization mechanisms of Ada. A minimum operating system kernel is assumed first. Then the primitives and data structures used to interpret the concurrent activities are described. Ada concurrent statements are translated into the calls to certain primitives. By properly explaining some details in it, the proposal can be implemented on various computer systems and supporting environments.
On typing in prolog
Authors: Brand Daniel
Published: November 2005

Frequently a domain of discourse can be described as a hierarchical structure. Then instead of using one place predicates to describe the type of a term one can associate types directly, and let the unification procedure take advantage of it. This prunes the search space without the use of the Cut operator.
APL compared with other languages according to Halstead's theory
Authors: De Kerf Joseph L. F.
Published: November 2005

Some ten years ago M. H. Halstead and his collaborators at Purdue University set up a theory allowing to measure the characteristics of software and their relations. One of these characteristics is the language level allowing to compare the respective effects of these languages on the productivity of programming. This language level has been evaluated for APL by the author (APL81) and by R. A. Mauri and A. H. Williams (APL82), the latter taking into account the distinction in APL between primitive functions and operators. The results are compared and some reflections are given.
Non-technical issues in acceptance of SILs
Authors: Dunn Dick
Published: November 2005

Technical issues in Systems Implementation Language (SIL) design are comparatively well understood. However, some major factors in the choice of a SIL for a given project are not related to the technical merits of the language. They are: availability of a "good" implementation, programmer trainability, and existence of a user community.
A note on the vector C language
Authors: Li Kuo-Cheng
Published: November 2005

The Vector C language was designed and implemented on the CDC Cyber 205 at Purdue University by the summer of 1984 [1,2,3]. Some modifications on the language syntax and enhancements in the compiler (mainly, vector descriptors, vector function calls, and vector macros) have been done here at the SCRI of FSU. Although this paper discusses the revisions of the language syntax defined in the previous paper [2], the key features of the Vector C language are also reviewed.
The case for simplified languages
Authors: Machanick Philip
Published: November 2005

A case is made for attempting to improve Pascal by reducing it in size and complexity, before additions are considered. Improvements are, in any case, best made by designing a completely new language. Some examples of possible improvements are given, based on observed deficiencies of Pascal from the point of view of teaching good programming techniques.
Adding meta rules to OPS5 a proposed extension
Authors: Rosenthal Don
Published: November 2005

OPS5 is a rule-based, non-procedural programming language rapidly gaining popularity. It is a pure "object level" programming language, as it provides the programmer with no control constructs. The approach taken when using OPS5 is to generate a rule base such that, during program execution the most appropriate rule will "select itself" and be applied at the appropriate time. Because production memory (the rule base) in OPS5 is strictly segregated from working memory (data) and the conflict set (currently applicable rules), an OPS5 program cannot direct the conflict resolution strategy of the interpreter. This can lead to situations where the OPS5 programmer may feel forced to write rules which "trick" the interpreter into boosting a rule's priority. Such artificial constructs are clearly harmful. An extension to OPS5 is proposed which allows the user to affect conflict resolution through the mechanism of meta-rules. A further refinement proposes implementing meta-rules via a programmable conflict resolution strategy. It is felt that these extensions represent a considerable enhancement of the expressiveness of the present language, with little modification to existing implementations. They are felt to be in keeping with the OPS5 programming style, and, in addition, would preserve compatibilty with existing OPS5 code.
An Accurate Instruction-Level Energy Consumption Model for Embedded RISC Processors
Authors: Lee Sheayun , Ermedahl Andreas , Min Sang Lyul , Chang Naehyuck
Published: November 2005

Energy consumption of software is becoming an increasingly important issue in designing mobile embedded systems where batteries are used as the main power source. As a consequence, recently, a number of promising techniques have been proposed to optimize software for reduced energy consumption. Such low-power software techniques require an energy consumption model that can be used to estimate or predict the energy consumed by software. We propose a technique to derive an accurate energy consumption model at the instruction level, combining an empirical method and a statistical analysis technique. The result of the proposed approach is given by a model equation that characterizes energy behavior of software based on the properties of the instructions. Experimental results show that the model equation can accurately estimate the energy consumption of random instruction sequences, with an average error of 2.5%
Combining Global Code and Data Compaction
Authors: De Sutter Bjorn , De Bus Bruno , De Bosschere Koen , Debray Saumya
Published: November 2005

Computers are increasingly being incorporated in devices with a limited amount of available memory. As a result research is increasingly focusing on the automated reduction of program size. Existing literature focuses on either data or code compaction or on highly language dependent techniques. This paper shows how combined code and data compaction can be achieved using a link-time code compaction system that reasons about the use of both code and data addresses. The analyses proposed rely only on fundamental properties of linked code and are therefore generally applicable. The combined code and data compaction is implemented in SQUEEZE, a link-time program compaction system, and evaluated on SPEC2000, MediaBench and C++ programs, resulting in total binary program size reductions of 23.6%-46.6%. This compaction involves no speed trade-off, as the compacted programs are on average about 8% faster.
A tool for simulation and fast prototyping of embedded control systems
Authors: Palopoli Luigi , Lipari Guiseppe , Abeni Luca , Di Natale Marco , Ancilotti Paolo , Conticelli Fabio
Published: November 2005

This paper presents a set of C++ libraries, called RTSIM, aimed at realizing a joint simulation of a continuous plant and of a real-time embedded controller. The libraries permit a separate specification of the functional behaviour of the controller and of the software platform to be used for its deployment. In particular, it is possible to provide an accurate modeling of the concurrent architecture of the control tasks and of the run-time support offered by the operating system for the real-time scheduling of the shared resources (CPU, memory buffers, network links). In this way, its is possible to compare different scheduling solutions by evaluating their simulated performance in the domain of the control application. Moreover, the tool can be utilized to tune up such design parameters as the activation frequencies of the tasks. The application of the tool is shown on a meaningful robotic case-study.
Morphable Cache Architectures
Authors: Kadayif I. , Kandemir M. , Vijaykrishnan N. , Irwin M. J. , Ramanujam J.
Published: November 2005

Computer architects have tried to mitigate the consequences of high memory latencies using a variety techniques. An example of these techniques is multi-level caches to counteract the latency that results from having a memory that is slower than the processor. Recent research has demonstrated that compiler optimizations that modify data layouts and restructure computation can be successful in improving memory system performance. However, in many cases, working with a fixed cache configuration prevents the application/compiler from obtaining the maximum performance. In addition, prompted by demands in portability, long battery life, and low-cost packaging, the computer industry has started viewing energy and power as decisive design factors, along with performance and cost. This makes the job of the compiler/user even more difficult as one needs to strike a balance between low power/energy consumption and high performance. Consequently, adapting the code to the underlying cache/memory hierarchy is becoming more and more difficult.

In this paper, we take an alternate approach and attempt to adapt the cache architecture to the software needs. We focus on array-dominated applications and measure the potential benefits that could be gained from a morphable (reconfigurable) cache architecture. Our results show that not only different applications work best with different cache configurations, but also that different loop nests in a given application demand different configurations. Our results also indicate that the most suitable cache configuration for a given application or a single nest depends strongly on the objective function being optimized. For example, minimizing cache memory energy requires a different cache configuration for each nest than an objective which tries to minimize the overall memory system energy. Based on our experiments, we conclude that fine-grain (loop nest-level) cache configuration management is an important step for a solution to the challenging architecture/software tradeoffs awaiting system designers in the future.
Software Pipelining Irregular Loops On the TMS320C6000 VLIW DSP Architecture
Authors: Granston Elana , Stotzer Eric , Zbiciak Joe
Published: November 2005

The TMS320C6000 architecture is a leading family of Digital Signal Processors (DSPs). To achieve peak performance, this VLIW architecture relies heavily on software pipelining. Traditionally, software pipelining has been restricted toregular(FOR) loops. More recently, software pipelining has been extended toirregular(WHILE) loops, but only on architectures that provide special-purpose hardware such as rotating (predicate and general-purpose) register files, specific instructions for filling/draining software pipelined loops, and possibly hardware support for speculative code motion. In contrast, the TMS320C6000 family has a limited, static register file and no specialized hardware beyond the ability to predicate instructions using a few static registers. In this paper, we describe our experience extending a production compiler for the TMS320C6000 family to software pipeline irregular loops. We discuss our technique for preprocessing irregular loops so that they can be handled by the existing software pipeliner. Our approach is much simpler than previous approaches and works very well in the presence of the DSP applications and the target architecture which characterize our environment. With this optimization, we achieve impressive speedups on several key DSP and non-DSP algorithms.
ILP-based Instruction Scheduling for IA-64
Authors: Kästner Daniel , Winkel Sebastian
Published: November 2005

The IA-64 architecture has been designed as a synthesis of VLIW and superscalar design principles. It incorporates typical functionality known from embedded processors as multiply/accumulate units and SIMD operations for 3D graphics operations. In this paper we present an ILP formulation for the problem of instruction scheduling for IA-64. In order to obtain a feasible schedule it is necessary to model the data dependences, resource constraints as well as additional encoding restrictions—the bundling mechanism. These different aspects represent subproblems that are closely coupled which gives the motivation for a modeling based on integer linear programming. The presented approach is divided in to two phases which allows us to compute mostly optimal solutions with acceptable computation time.
Constraint hierarchies
Authors: Borning Alan , Duisberg Robert , Freeman-Benson Bjorn , Kramer Axel , Woolf Michael
Published: November 2005

Constraints describe relations that must be maintained, and provide a useful tool for such applications as interactive simulations, algorithm animation, and graphical user interface construction. We describe a major overhaul and extension to the constraint satisfaction mechanism in ThingLab, a constraint-oriented simulation laboratory written in the Smalltalk-80 language. First, a specification is presented of
constraint hierarchies
. Such hierarchies include both required constraints and default constraints of differing strengths, thus adding considerable expressive power to the system. Second, an algorithm for satisfying constraint hierarchies is described. The new satisfier is substantially faster than the previous version, even though it also includes new functionality.
An information system based on distributed objects
Authors: Caplinger Michael
Published: November 2005

The
Telesophy system
is intended to provide transparent access to all of a community's online information. The scale of the system requires that it be distributed across many machines via a network; the multiple types and formats of the information require that it be a multimedia system. We describe a prototype that uses objects to represent, query, display, and edit information. A two-level storage system is used to store the objects on multiple servers; queries are processed by indexing servers layered on top of the storage system. New media types and new indexing schemes can be added simply by defining new classes within the existing framework.
Self: The power of simplicity
Authors: Ungar David , Smith Randall B.
Published: November 2005

Self is a new object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single construct. This permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. Finally, because Self does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures. Self's simplicity and expressiveness offer new insights into object-oriented computation.
Some experiments in object-oriented simulation
Authors: Bezivin Jean
Published: November 2005

Discrete event simulation has been a constant source of inspiration for language designers. The present interest in Object-Oriented Programming (O.O.P.) can be traced back to the Simula 67 language. In return, simulation languages are currently getting back many advantages from the ongoing research in O.O.P. One of the main present research trends is the possibility of concurrently executing a simulation program composed of a set of interacting and communicating objects. Conditions which will make this possible are discussed together with some induced problems. More precisely this paper presents some experiments in object-oriented simulation that reveal the great flexibility of the Smalltalk-80
1
programming system for building evaluation environments.
RAPID: Prototyping control panel interfaces
Authors: Freburger Karl
Published: November 2005

RAPID is a design environment to support human factors specialists in designing user interfaces for small control panels. RAPID permits modeling of both the appearance and behavior of operator interfaces. Its main goal is to allow exploration of a greater number of design alternatives by decreasing the time and effort required to generate and evaluate those alternatives. It is a graphically-based system intended to be used by non-programmers. RAPID is implemented in Smalltalk-80.
Producer: A tool for translating Smalltalk-80 to Objective-C
Authors: Cox Brad J. , Schmucker Kurt J.
Published: November 2005

Source to source translation tools provide a way of integrating the strengths of production programming environments like C/UNIX™ with rapid prototyping environments like Smalltalk-80™ into a comprehensive hybrid environment that spans more of the software development life-spiral than ever before. This paper describes a tool-assisted process for translating Smalltalk-80 programs into Objective-C™, and shows how the tool, called Producer, is used in practice. To assist others in using this translation tool, we have made Producer publicly available without charge on USENET.
Issues in the design of object-oriented database programming languages
Authors: Bloom Toby , Zdonik Stanley B.
Published: November 2005

We see a trend toward extending object-oriented languages in the direction of databases, and, at the same time, toward extending database systems with object-oriented ideas. On the surface, these two activities seem to be moving in a consistent direction. However, at a deeper level, we see difficulties that may inhibit their ending up at the same point. We feel that many of these difficulties are a result of the underlying assumptions that are inherent in the fields of programming language and database systems research. Many of these assumptions are historical and contribute to a set of cultural biases that often prevent the two communities from interacting as effectively as possible.

The purpose of this paper is to try to uncover some of the cultural presuppositions that have inhibited development of a fully integrated database programming language. We have identified database and language features that seem to be difficult to reconcile. We try to uncover the basic problems in these two areas that these features were intended to solve. In order to resolve these problems, we attempt to distinguish fundamental differences from historical artifacts.
IDEOSY
Authors: Giacalone Alessandro , Rinard Martin C. , Doeppner Thomas W.
Published: November 2005

IDEOSY is an experiment in the use of a formal semantics as the basis for a programming system and in use of an
ideographic
language as the primary means of user-computer communication. The important characteristics of our system are that it uses an ideographic syntax, has a syntax-directed editor, supports the definition of various equivalence properties and the proofs of such equivalence, and has an interpreter. It currently runs on Apollo workstations and on VAXes running Berkeley UNIX@ using any of a variety of high-resolution color displays.

Our formalism is based on Milner's Calculus of Communicating Systems (
CCS
) [1]. We have found CCS to be a convenient formalism for describing programs and have even used it for describing the UNIX operating system [2]. Its algebraic properties are very useful for building descriptions out of components and for proving the equivalence of descriptions. Since CCS is an operational semantics, we may directly interpret descriptions written in CCS.
Graphical program development with PECAN program development systems
Authors: Reiss Steven P.
Published: November 2005

This paper describes the user's view of the PECAN family of program development systems. PECAN is a program development system generator for algebraic programming languages. The program development systems it produces support multiple views of the user's program, its semantics, and its execution. The program views include a syntax-directed editor, a declaration editor, and a structured flow graph editor. The semantic views include expression trees, data type diagrams, flow graphs, and the symbol table. Execution views show the program in action and the stack contents as the program executes. PECAN is designed to make effective use of powerful personal machines with high-resolution graphics displays and is currently implemented on APOLLO workstations.
The synthesizer generator
Authors: Reps Thomas , Teitelbaum Tim
Published: November 2005

Programs are hierarchical compositions of formulae satisfying structural and extra-structural relationships. A program editor can use knowledge of such relationships to detect and provide immediate feedback about violations of them. The Synthesizer Generator is a tool for creating such editors from language descriptions. An editor designer specifies the desired relationships and the feedback to be given when they are violated, as well as a user interface; from the specification, the Synthesizer Generator creates a full-screen editor for manipulating programs in the language.
The program dependence graph in a software development environment
Authors: Ottenstein Karl J. , Ottenstein Linda M.
Published: November 2005

The internal program representation chosen for a software development environment plays a critical role in the nature of that environment. A form should facilitate implementation and contribute to the responsiveness of the environment to the user. The
program dependence graph (PDG)
may be a suitable internal form. It allows programs to be sliced in linear time for debugging and for use by language-directed editors. The slices obtained are more accurate than those obtained with existing methods because I/O is accounted for correctly and irrelevant statements on multi-statement lines are not displayed. The PDG may be interpreted in a data driven fashion or may have highly optimized (including vectorized) code produced from it. It is amenable to incremental data flow analysis, improving response time to the user in an interactive environment and facilitating debugging through data flow anomaly detection. It may also offer a good basis for software complexity metrics, adding to the completeness of an environment based on it.
The object management system of PCTE as a software engineering database management system
Authors: Gallo Ferdinando , Minot Regis , Thomas Ian
Published: November 2005

The PCTE project is specifying, designing and implementing a host structure for Software Engineering Environments. The host structure is designed to run on powerful, bitmap screen terminals connected to a local network. It features an Object Management System based on a Binary Entity-Relationship model that manages a database that is transparently distributed over the workstations connected to the network. Migration to this new hosting structure is facilitated by compatibility at the executable file level with Unix System V
*
.

This paper examines how the OMS corresponds to the requirements for Software Engineering databases.
An information workstation for software managers
Authors: Kret M A
Published: November 2005

In the complex and changing environment of software development, it is imperative that software managers have current and meaningful information to support decision making. This article discusses a system that draws information from all phases of the software life cycle and analyzes that data from a software manager's workstation. With the analysis tools available at the workstation and data extracted from the various phases of development, managers can begin to form a model of the software development life cycle and measure the success or failure of software projects in quantitative terms.
A case study of workstation usage during the early phases of the software development life cycle
Authors: Mital Rakesh M , Kim Marcia M , Berg Richard A
Published: November 2005

This paper presents initial results in an ongoing study of workstation usage in a real, commercial software development environment. The methodology being supported is explained and the background for the project is presented. Predictions of the resources and schedule required is calculated using the COnstructive COst MOdel (COCOMO). Actual resources and schedule used to date are presented and shown to be quite favorable with respect to the model predictions. Further discussion of workstation usage and the impact on project performance is presented. Conclusions indicate that workstation use can be quite favorable on software development projects, but the workstations are still only automating the more mundane aspects of the requirements analysis and design phases.
Jasmine: a software system modelling facility
Authors: Marzullo Keith , Wiebe Douglas
Published: November 2005

Jasmine
is a programming-in-the-large system designed by the authors at Xerox Information Systems Division. Jasmine consists of workstation tools and network services that help programmers develop, release, and maintain large software systems. Jasmine has three primary parts:
(1)
system models
that describe the structure and versions of software,
(2)
context-relative, distributed naming of software components (supporting replication), and
(3)
a collection of tools that use (1) and (2) to manipulate software systems. We present an overview of these parts of Jasmine.
Efficient recompilation of module interfaces in a software development environment
Authors: Muller Hausi A , Hood Robert , Kennedy Ken
Published: November 2005

This paper presents
global interface analysis algorithms
that analyze and limit the effects of an editing change to a basic interface of a software system. The algorithms improve on the deficiencies of the traditional compilation rule found in strongly-typed, separately-compiled programming languages, which often forces the recompilation of modules that are not at all affected by a change to a basic interface. The algorithms assume a software development environment that provides efficient access to the compilation dependencies and the module interfaces of the components being implemented. The algorithms are designed to operate on recursive compilation dependencies since separate compilation of recursive inter-module dependencies can easily be implemented in such an environment.
Expression optimization using unary complement operators
Authors: Frailey Dennis J.
Published: November 2005

For purposes of code optimization there are two basic philosophies of expression analysis: one approach would attempt to do a relatively complete analysis, detecting all redundancies which are logically possible. The other approach would aim at those things which are easily detected and/or highly likely to occur. This paper gives a set of algorithms which derive from the latter philosophy but which are based on general properties rather than specific facts about a particular language or machine.

The first section of the paper gives details of a notation used for describing code and defining algorithms. The most significant feature of this notation is that it allows operands to be complemented by any number of “complement operators”. This is done because most of the algorithms make frequent use of the properties of such operators. The second section describes a canonical form for expressions and a series of algorithms based on this form and the properties of complement operators. There are various facets of compiler structure which might bear on the exact usage of these algorithms. Although such considerations are not part of the scope of this paper, occasional comments are made about the relationship of an algorithm to other parts of a compiler. The third section contains a discussion of how these algorithms would fit within an overall optimizer structure.
A formal approach to code optimization
Authors: Aho Alfred V. , Sethi Ravi , Ullman J. D.
Published: November 2005

We examine from a formal point of view some problems which arise in code optimization and present some of the results which can come from such an approach. Specifically, a set of transformations which characterize optimization algorithms for straight line code is presented. Then we present an algorithm which produces machine code for evaluating arithmetic expressions on machines with N ≥ 1 general purpose registers. We can prove that this algorithm produces optimal code when the cost criterion is the length of machine code generated.
CDC 6600/7600 optimization
Authors: Zwakenberg Richard G.
Published: November 2005

Efficient use of the CDC 6600/7600 computers requires maximum utilization of the parallelism (6600/7600) and pipeline (7600) features of the functional units and the ability to perform iterative execution within a minimal number of machine words (6600/7600).

Factors which must be taken into consideration when producing efficient object codes are: (1) The need for compression of code generated for loop structures, and (2) The criteria concerning instruction issue and execution times.

The addition of an optimization pass to the LRLTRAN compiler has allowed the LRLTRAN language programmer to attain the maximum potential speeds of the 6600/7600 computers.
Report of session on systems programming languages
Authors: Graham Robert M. , Freiburghouse Robert A.
Published: November 2005

Discussion in this session centered around two major topics: experience using a particular language for systems programming and features which are required or desirable in a systems programming language. In general, as one might expect, the users of a particular language were happy with that language and felt they had made the right choice, even though they were not completely satisfied. There seemed to be general agreement that a higher level language than machine language (assembly language) should be used for systems programming. There was considerable difference of opinion as to how high level the language should be. There was a similar difference of opinion as to what features are desirable, and even necessary, in a systems programming language. Although the session was organized so as to discuss the two major topics separately, there was considerable discussion of desirable and necessary language features mixed in with the discussion of experience with specific languages.

The session opened with a report by Bob Freiburghouse on the use of PL/I for implementation of Multics. "In general the project was successful. We're not about to switch to some other programming language. But we would like to enforce more discipline. I think we would like to recognize and enforce a subset of all this. He listed a number of key features, the most important of which was external procedures and external variables. Other important features included structured data with controlled packing, recursion, block structure, high level control statements, type checking, pointers and dynamic storage allocation, and
% include
. A few extensions were made to the language such as pointer valued functions, functions to construct and take apart pointers, P and V operations, and a notation for referencing Multics segments. In addition, a support routine called the
binder
was implemented. Using this routine one can combine a number of procedure and data segments into a single module. References to this module can be made using only designated names, all other names originally associated with the segments in the module will be hidden, that is, undefined outside the module.
Software design with invocation diagram
Authors: Denil N. J.
Published: November 2005

This paper describes a medium being developed for abstraction and expression of program structure. The medium is to be used to represent programs during the design process; It forms the basis for their implementation.

The following point of view is adopted. Program design is an iterative, trial-and-error process, in which a basic solution to part of the problem is refined, added to, and modified into a complete solution. The final result should be well-structured in the sense described by Dijkstra (1) in order for the designer to understand the program sufficiently to be confident in its correctness.
The need and techniques to obliterate control languages
Authors: Wiederhold Gio C. M.
Published: November 2005

Control language functions have greatly increased in recent times. Much of the increase is due to the fact that as new facilities were developed in operating systems no corresponding specifications were added to common programming languages. Programming languages did have statements that interfaced with input/output systems; these were also used to address problems of file and database management, as well as transfer of data between successive program segments.

Unfortunately the control languages that took on the control and data flow specifications developed in an
ad hoc
fashion with little concern for intersystem consistency. Their syntax is frequently infantile and many specifications are set by local default conditions. The result is that control languages present one of the major stumbling blocks in programming and severelyhinder transferability of programs.
The Paralyzer
Authors: Presberg David L.
Published: November 2005

The ILLIAC IV Fortran compiler's Parallelism Analyzer and Synthesizer (mnemonicized as the Paralyzer) detects computations in Fortran DO loops which can be performed in parallel. It is a step of the compiling process which lies between source language parsing and target code generation, and as such can be considered as a high-level optimization step specific to the ILLIAC architecture. The Paralyzer performs its transformations within the Intermediate Language tables of the compiler. The parallel execution constructs introduced into the user's program are those which can be expressed in the extended Fortran language, IVTRAN, the source language of the compiler [1]. With a decompiler from the Intermediate Language to IVTRAN source, the Paralyzer can act as a source-to-source translater.

Some pertinent characteristics of the ILLIAC IV motivate the parallelism detection methods employed by the Paralyzer. ILLIAC is in the general class of parallel processors known as array processors. That is to say, it performs identical computations in a lock-step, synchronous fashion over separate data streams. Its computational access to main memory is highly constrained: each of the 64 Processing Units can access directly only a private section of the whole memory. Data can be passed from one Processing Unit to another by a relatively expensive routing instruction. This is executed identically by all Processing Units and passes data a uniform end-around distance in the fixed ordering of the Processing Units. The machine executes most efficiently those computations which are element-by-element operations on vectors or arrays. Thus, the most fruitful sources of parallelism in Fortran programs intended for ILLIAC IV execution are DO loops containing array references with subscripts depending on the DO index variables.
Vector extensions to LRLTRAN
Authors: Zwakenberg R. G.
Published: November 2005

The CDC STAR-100 brings a new concept in computing to LLL. The STAR is a string(vector) - oriented machine that is most efficient when it performs the same operations on sequentially stored operands. This approach to computer design opens up new areas of problem-solving techniques. Some algorithms that are long and cumbersome on other machines can be easily and efficiently programmed on the STAR computer. The vector extensions described in this paper represent an attempt to expand LRLTRAN (a dialect of FORTRAN) into a useful computer language for the STAR. The additions will enable an LRLTRAN-language compiler to produce vector code and hence allow the programmer to access, via LRLTRAN, the powerful STAR hardware instructions.
Movement of implicit parallel and vector expressions out of program loops
Authors: Schneck Paul B.
Published: November 2005

The concept of “interference” is introduced and related to the problem of transforming implicit parallel and vector operations to an explicit form. Statement types and constructs which cause interference are identified. Programming techniques which avoid use of potentially interfering statements result in programs which are better suited for operation on parallel and vector processors.

The analysis of the inhibiting effect of interfering statements on the motion of parallel and vector expressions has been implemented and demonstrated as an addition to an existing compiler which recognizes parallelism implicit in current serial programs.
Array reference operations
Authors: Hext J. B.
Published: November 2005

An examination is made of the different ways in which APL and ALGOL 68 refer to cross-sections or other subsets of an array. It is noted that APL allows a variety of reference operations but no reference variables; on the other hand, ALGOL 68 has reference variables and parameters, but only one array operation. Two kinds of array reference are distinguished - the linear and the nonlinear - and a proposal is made for representing a linear reference by a simple form of descriptor, suitable for processing in hardware. The reference operations are then divided into those which give linear results and those which give non-linear. By retaining only the linear ones, it is possible to combine the main advantages of the APL and ALGOL 68 operations into a single system. A discussion is given of some of the issues involved, including those of dynamic types and bounds.
Managing the development of reliable software
Authors: Williams R. D.
Published: November 2005

This paper discusses the serious need for improved management methods and software development technology to support the production of truly reliable software and presents experience gained on TRW's Site Defense Program in addressing that need.

The basic theme is simply this: We have attempted to achieve a better understanding of how to specify, design, build and validate reliable software; we have translated that understanding into an integrated and exceptionally disciplined software development methodology; we have used, evaluated and refined the methodology enough to recognize and report substantial early success and continuing progress toward that goal.
An assessment of the programming language PASCAL
Authors: Wirth Niklaus
Published: November 2005

The programming language PASCAL is assessed in the light of “reliable programming” and with the background of five years of experience with the language. Some features are selected to point out remaining problems, either inherent or specific, from which some guidelines for the design or choice of languages for reliable programming are derived. Among the discussed features are the concept of data type, the sequential file structure, and the type union.
Reliable hardware-software architecture
Authors: Wulf William A.
Published: November 2005

This paper deals with the problem of reliability in a hardware/software system. More specifically it deals with the strategy used to achieve reliability in a particular hardware/software system built by the author and his colleagues at Carnegie-Mellon University. Rather than dealing with the myriad details of the reliability aspects of this systems, the paper focuses on the design philosophy which aims at keeping the system operational even though the underlying hardware may be malfunctioning. This philosophy is essentially an extension of the 'modular' programming methodology, advocated by Parnas and others, to include dynamic error detection and recovery.
Maintenance of the computer sciences teleprocessing system
Authors: Bucher D.E. W.
Published: November 2005

This paper describes the maintenance and enhancement of the Computer Sciences Teleprocessing System (CSTS) and its component processors. CSTS is the system offered by the INFONET Division of Computer Sciences Corporation to provide nationwide conversational and batch teleprocessing service. In the first section, the organization of the project personnel and major activities of project departments are described. The second section describes the process by which functional enhancements and error corrections are implemented. The final section describes testing techniques and procedures used during implementation.

The project staff is organized into implementation departments and service departments. Implementation departments develop new features of the system, corrections to errors, and improvements in system operation, especially in reduction of software overhead. Implementation departments are organized by system software functions such as operating system (device control, task management, and file management), language processors and data management systems, communications software, and applications. The service departments are system integration, performance analysis, product management and system test. The functions performed by these departments are described. Also described are the system evolution conferences and the periodic review of enhancements by a Change Advisory Board.

During the development of a new version of the system, effective tracking of the status of changed modules is essential. The data base and process used to track new features, error corrections and changed component modules are described. The flow of implemented changes through system integration and system test is delineated, as is the development and verification of change documentation for users, administrators and operations personnel.

The final section of the paper describes the design and documentation of test programs and the organization of test sets. Effective test operations are achieved by using self-checking tests as well as automated test operation and verification. Tests for compliance with functional specifications and for conformity to internal design are described.
Testing large software with automated software evaluation systems
Authors: Ramamoorthy C. V. , Ho S. F.
Published: November 2005

In the past few years, research has been actively carried out in an attempt to improve the quality and reliability of large scale software systems. Although progress has been made on the formal proof of program correctness, proving large scale software systems correct by formal proof is still many years away. Automated software tools have been found to be valuable in improving software reliability and attacking the high cost of software systems. This paper attempts to describe some main features of automated software tools and some software evaluation systems that are currently available.