bluuebunny/crossref_metadata_2025 huggingface dataset:
Encapsulation in object-oriented programs
Authors: Chen Jiun-Liang , Wang Feng-Jian
Published: November 2005

In stead of decomposing data and procedures, object-oriented (OO) programming encapsulates the both through an object. An object is instantiated from a class which defines attributes (related data) and methods (operational procedures). The definition of a class may be recursive since the class can encapsulate the instance(s) of another classes as its attributes. An object containing other objects is called a
complex
object. The form of a most primitive object, an object containing no other object, is nothing but a data entity and is called a
simple
object. Encapsulation solidates an object by hiding the details; it may also obstruct dependency analysis for complex objects by information hiding.
Déjà vu or returning to graduate school at age 52
Authors: Haiduk Paul
Published: November 2005

I am a Ph.D. dropout. In 1971, I left the University of Texas (UT) at Austin at the dissertation stage because of the financial constraints of having a young family. During my stay at UT, my interests changed from the study of Finance to Computer Science. I taught at Drake University in CIS and later at West Texas State University before taking my current position at Amarillo College in Texas. Among other responsibilities at Amarillo College, I have been coordinator of the Engineering Computer Science program.
A microcomputer hardware course
Authors: Peaslee Jayne
Published: November 2005

Microcomputer architecture is a strong thread in the fabric of computer science. Students need to comprehend the purpose and function of the integral parts of a microcomputer. During the 1970s and '80s, computer science stressed high-level procedural languages. Today, hardware technology plays a major role. What is the purpose of the BIOS chip? What is the difference between SIMMS and SIPPS memory? What is the function of an address bus?
Adventures in selecting course materials
Authors: Voegele Donald
Published: November 2005

You might think that finding and selecting a textbook for an introductory computing course is routine and simple. A normal scenario would be to survey and select a textbook via catalogues and bookstore visits and place a book order through your department a few months before it is needed. The bookstore would order the textbooks, and the correct quantity of books and materials would arrive in plenty of time before the course begins. In the event of a last minute teaching assignment, such as an instructor backing out of teaching a course, the scenario might be to place a rush order via the bookstore with special delivery instructions, and receive the materials within a few days.
We need to help unmotivated students
Authors: Packa Kim
Published: November 2005

Itasca Community College serves students from various backgrounds such as disabled, deaf, minority, and non-traditional. At Itasca, I tutor students in different computer program applications and processes. My main thrust is advising minority students, but the problem I have is an age old, world wide one.
Message from the chair of the TYC education committee
Authors: Klee Karl
Published: November 2005

The ACM Two-Year College Education Committee has begun a major new multi-year initiative to obtain a profile of the present situation at, and to develop guidelines and recommendations for, computing departments at two-year colleges. These guidelines will encompass more than curriculum. Included will be recommendations for faculty preparation and responsibilities, departmental organizations and administration, curriculum, supportservices, and student guidance and enrichment. These guidelines could also be the basis for implementing accreditation for computing departments at two-year colleges.
OOP
Authors: Charles Randy
Published: November 2005

The first part of the article focuses on the current development and maintenance procedures for designing and maintaining business applications versus the use of object-oriented programming approaches. The current method of starting new system design and programming from the ground up is compared to a hardware engineer visiting a beach to get a bucket of sand to begin manufacturing the required silicone chips for the engineer's applications. This type of effort appears ridiculous even though most non object-oriented software applications are developed in this fashion. By applying object-oriented philosophies and tools, many of the programming productivity problems would be at least partially solved.
A correct example of multiple inheritance
Authors: Eriksson Mikael
Published: November 2005

In [1] Wiener and Pinson gives an example of using multiple inheritance in C++. The example consists of three classes. The two classes Array and Integer are combined by multiple inheritance to form the class IntegerArray. In [1] it is claimed that this is an useful way of applying multiple inheritance.This article will discuss the meaning and use of inheritance and examine that proposition in the light of the discussion. Another example of multiple inheritance is given at the end of the article.
A self interpreter for BaLinda Lisp
Authors: Yuen C. K. , Wong W. F.
Published: November 2005

An intepreter for BaLinda Lisp, a parallel Lisp dialect designed for the Biddle machine[1], is presented. The intepreter is itself written in BaLinda Lisp, and is not at present executable. However, it constitutes a detailed specification of the language and a description of how to execute it, and will be used in subsequent implementations on Biddle and other computers. A number of system primitives required to implement the language have also been specified.
A brief survey of papers on scheduling for pipelined processors
Authors: Krishnamurthy Sanjay M.
Published: November 2005

Most microprocessors introduced into the market in the past few years employ pipelining to enhance execution speed. Moreover, many of these processors use multiple pipelined functional units. This paper surveys several heuristics reported in the literature on the topic of code optimization and reordering for exploiting instruction level parallelism in pipelined processors. Five methods are described in detail and several others are briefly reviewed
Designing new languages or new language manipulation systems using ML
Authors: Jouvelot P.
Published: November 2005

The ML language and the denotational theory of programming languages fit together to yield a powerful tool in (new) language design. To effectively support this claim, we give a running definition of a simple Pascal-like programming language with a new and non-standard programming construct. All the provided exemples have been tested on a Unix-4.2BSD implementation of ML.
Strong typing and physical units
Authors: Männer R.
Published: November 2005

This paper proposes a syntactic extension of high level languages like PASCAL or ADA to allow the usage of physical quantities, i.e. numbers with units, instead of just numbers. It offers enhanced type checking for expressions and assignments during compilation time. Additionally, it allows problem oriented simple scaling of variables and local scale selection. Furthermore, it reduces the number of coding errors due to wrongly chosen scales. After a discussion of mutual relations between strong typing in programming languages and physical units, examples are shown to demonstrate the usefulness of the proposed extension. Finally a graph representation of the new syntactic elements is given.
Detection of deadlocks in multiprocess systems
Authors: Hunt J. G.
Published: November 2005

During the development of a recent project*, a number of problems were encountered with deadlocks. At the beginning of the next project*, a method was adopted to enable the detection of situations which might lead to deadlock. (The implementation used required a simple programming discipline to be observed, but could equally have been achieved by a minor extension to the language & compiler.) The attention that programmers were thus forced to pay to the problem meant that fewer deadlocks were designed & implemented; whilst the early detection of the few that did slip through meant that the correction was generally trivial both to implement & to test.
An alternative view of polymorphism
Authors: Harland David M. , Szyplewski Martyn W. , Wainwright John B.
Published: November 2005

We shall outline the traditional approaches to polymorphism, in the light of Strachey's original work, and languages in the style of RUSSELL, and review the implications for programming language design of the developing interest amongst theoreticians in this subject.It will be shown that the "parametric type-polymorphism" favoured by the majority of today's designers, is actually a very limited form of polymorphism, and we shall show how a much more general concept of polymorphism can be constructed by placing arbitrary constraints on abstract storage types.We will then investigate ways of employing these "guarded cells", outlining several possible applications.The essence of our proposal is that in any language in which there is an unfettered abstraction mechanism, and a sufficiently rich universe of discourse, including types which are properly manipulable values, many forms of polymorphism can be built as abstractions, and so need not be built directly into the fabric of that language. We interpret this to mean that polymorphism is not a major factor in programming language design, whereas we take the view that achieving maximum expressivity is crucial to a design.We shall conclude by relating our work to that of theoreticians in the field, and showing the implications of our proposal for program verification.
Issues in the Design of Adaptive Middleware Load Balancing
Authors: Othman Ossama , Schmidt Douglas C.
Published: November 2005

Load balancing middleware is used extensively to improve scalability and overall system throughput in distributed systems. Many load balancing middleware services are simplistic, however, since they are geared only for specic use-cases and environments. These limitations make it hard to use the same load balancing service for anything other than the distributed application it was designed for originally. This lack of generality forces continuous re-development of application-specic load balancing services. Not only does re-development increase deployment costs of distributed applications, but it also increases the potential of producing non-optimal load balancing implementations since proven load balancing service optimizations cannot be reused directly.This paper presents a set of load balancing service features that address many existing middleware load balancing service inadequacies, such as lack of server-side transparency, centralized load balancing, sole support for stateless replication, fixed load monitoring granularities, lack of fault tolerant load balancing, non-extensible load balancing algorithms, and simplistic replica management. All the capabilities described in this paper are currently under development for the next generation of middleware-based load balancing service distributed with our CORBA-compliant ORB (TAO).
Designing an Efficient and Scalable Server-side Asynchrony Model for CORBA
Authors: Brunsch Darrell , O'Ryan Carlos , Schmidt Douglas C.
Published: November 2005

When the Asynchronous Method Invocation (AMI) model was introduced into the CORBA specification, client applications benefited from the ability to invoke non-blocking two-way requests. In particular, AMI improved the scalability of clients by removing the restrictions associated with Synchronous Method Invocations (SMI). Server request handling remained synchronous, however, which minimized the benefits of AMI for middle-tier servers, such as firewall gateways and front-end database servers.This paper describes our strategy for implementing a scalable server-side asynchrony model for CORBA. We first outline the key design challenges faced when developing an Asynchronous Method Handling (AMH) model for CORBA and then describe how we are resolving these challenges in TAO, our high-performance, real-time CORBA ORB. In general, AMH-based CORBA servers provide more scalability than existing concurrency models, with only a moderate increase in programming complexity. Although targeted for CORBA, similar techniques can also be used in other method-oriented middleware, such as COM+ and Java RMI.
Parametric Timing Analysis
Authors: Vivancos Emilio , Healy Christopher , Mueller Frank , Whalley David
Published: November 2005

Embedded systems often have real-time constraints. Traditional timing analysis statically determines the maximum execution time of a task or a program in a real-time system. These systems typically depend on the worst-case execution time of tasks in order to make static scheduling decisions so that tasks can meet their deadlines. Static determination of worst-case execution times imposes numerous restrictions on real-time programs, which include that the maximum number of iterations of each loop must be known statically. These restrictions can significantly limit the class of programs that would be suitable for a real-time embedded system. This paper describes work-in-progress that uses static timing analysis to aid in making dynamic scheduling decisions. For instance, different algorithms with varying levels of accuracy may be selected based on the algorithm's predicted worst-case execution time and the time allotted for the task. We represent the worst-case execution time of a function or a loop as a formula, where the unknown values affecting the execution time are parameterized. This
parametric timing analysis
produces formulas that can then be quickly evaluated at run-time so dynamic scheduling decisions can be made with little overhead. Benefits of this work include expanding the class of applications that can be used in a real-time system, improving the accuracy of dynamic scheduling decisions, and more effective utilization of system resources.
Teaching object-oriented programming with the KEE system
Authors: Kempf Renate , Stelzner Marilyn
Published: November 2005

Successful learning of an object-oriented programming style is greatly facilitated by a flexible, window-oriented interface and a “step-by-step” instructional methodology. Specifically, students can benefit from a learning sequence moving from working with object hierarchies to working with objects with behavior to more complex problems (conditional or sequential message passing, automation of behavior). Within each area in turn, a step-by-step approach of learning by conceptualization, learning by analogy, learning by experience, and learning by reinforcement is suggested. This is demonstrated using examples from the training of the KEE® Knowledge Engineering Environment™.
Parallel programming in a virtual object space
Authors: Lucco Steven E.
Published: November 2005

Sloop is a parallel language and environment that employs an object-oriented model for explicit parallel programming of MIMD multiprocessors. The Sloop runtime system transforms a network of processors into a
virtual object space
. A virtual object space contains a collection of objects that cooperate to solve a problem. Sloop encapsulates virtual object space semantics within the object type
domain
. This system-defined type provides an associative, asynchronous method by which one object gains access to another. It also provides an operation for specifying groups of objects that should, for efficiency, reside on the same physical processor, and supports exploitation of the topology of the underlying parallel machine. Domains also support the creation of
indivisible
objects, which provide implicit concurrency control. The encapsulation of these semantics within an object gives the programmer the power to construct an arbitrary hierarchy of virtual object spaces, facilitating debugging and program modularity. Sloop implementations are running on a bus-based multiprocessor, a hypercube multiprocessor, and on a heterogeneous network of workstations. The runtime system uses object relocation heuristics and coroutine scheduling to attain high performance.
Mentat: An object-oriented macro data flow system
Authors: Grimshaw Andrew S. , Liu Jane W. S.
Published: November 2005

Mentat is an object-oriented macro data flow system designed to facilitate parallelism in distributed systems. Its underlying model of computation is the macro data flow model. The Macro data flow model is similar to the traditional, large grain data flow model with two differences: (1) Some macro actors are persistent actors that maintain state information between firings; (2) Program graphs are dynamic. Macro data flow programs are represented by dynamic structures called future lists that may be constructed and modified at run time. This paper discusses the motivation of the macro data flow model; the relationship between objects, actors, and tokens; the use of future lists; extensions to the programming language C++ for writing macro data flow programs; and the structure of a virtual macro data flow machine for executing macro data flow programs.
An object-oriented design system shell
Authors: Diederich Jim , Milton Jack
Published: November 2005

We present a design system shell which can be used to experiment with principles of design and be used as a design tool where complex layers of information need to be specified about objects, such as in database design. The shell can be tailored to a variety of application areas. It is object-oriented in its implementation and structure. Objects and messages are used as the specification language. The basic ingredients of a rule-based production system are provided, with rules treated as objects and defined independently of the classes to which they are applied.
An object-oriented framework for interactive data graphics
Authors: Young Robert L.
Published: November 2005

Ida is an object-oriented framework for interactive data graphics. It can be used for independent data examination or integrated into application user interfaces. Ida's model of graphics is composed of five basic elements:
Presentations, Assemblies, Data Sources, Data Displays
, and
Scales
. Presentations and assemblies address display layout. A sharp distinction is maintained between drawing and the management of already drawn images. Data sources are responsible for drawing while data displays are image managers. Data displays are complex structures consisting of multiple layers that may be larger than the visible regions they underlie. Scales represent coordinate transformations. An object-oriented architecture proves valuable in supporting taxonomic hierarchies with inheritance, part-whole structures for composition, message passing implementation of graphic operations and late attribute binding.
Composite object support in an object-oriented database system
Authors: Kim Won , Banerjee Jay , Chou Hong-Tai , Garza Jorge F. , Woelk Darrel
Published: November 2005

Many applications in such domains as computer-aided design require the capability to define, store and retrieve as a single unit a collection of related objects known as a composite object. A composite object explicitly captures and enforces the IS-PART-OF integrity constraint between child and parent pairs of objects in a hierarchical collection of objects. Further, it can be used as a unit of storage and retrieval to enhance the performance of a database system.

This paper provides a formal definition of the semantics of composite objects within an object-oriented data model, and describes their use as units of integrity control, storage and retrieval, and concurrency control in a prototype object-oriented database system we have implemented.
Dimensions of object-based language design
Authors: Wegner Peter
Published: November 2005

The design space of object-based languages is characterized in terms of objects, classes, inheritance, data abstraction, strong typing, concurrency, and persistence. Language classes (paradigms) associated with interesting subsets of these features are identified and language design issues for selected paradigms are examined. Orthogonal dimensions that span the object-oriented design space are related to non-orthogonal features of real languages. The self-referential application of object-oriented methodology to the development of object-based language paradigms is demonstrated.

Delegation is defined as a generalization of inheritance and design alternatives such as non-strict, multiple, and abstract inheritance are considered. Actors and prototypes are presented as examples of classless (delegation based) languages. Processes are classified by their degree of internal concurrency. The potential inconsistency of object-oriented sharing and distributed autonomy is discussed, suggesting that compromises between sharing and autonomy will be necessary in designing strongly typed object-oriented distributed database languages.
Object-oriented development in an industrial environment
Authors: Jacobson Ivar
Published: November 2005

Object-oriented programming is a promising approach to the industrialization of the software development process. However, it has not yet been incorporated in a development method for large systems. The approaches taken are merely extensions of well-known techniques when 'programming in the small' and do not stand on the firm experience of existing developments methods for large systems. One such technique called block design has been used within the telecommunication industry and relies on a similar paradigm as object-oriented programming. The two techniques together with a third technique, conceptual modeling used for requirement modeling of information systems, have been unified into a method for the development of large systems.
Using objects to design and build radar ESM systems
Authors: Barry Brian M. , Altoft John R.
Published: November 2005

This paper describes the application of object-oriented programming to the design of a multiprocessor ESM testbed. The ESM testbed uses an object-oriented development environment which integrates Smalltalk and C language tools with the Harmony real-time operating system in a shared memory multiprocessor. All development for an application is done using personal computers which are themselves processors in the real-time testbed. We first discuss two aspects of the ESM testbed: a framework for investigating ESM signal processing algorithms based on an object-oriented emitter database and blackboard objects which implement probabilistic reasoning; and an object-oriented ESM simulation environment which illustrates the use of object-oriented techniques for the development of complex real-time systems. In the second part of the paper we describe our software engineering approach and tools. Throughout the paper, the role played by object-oriented programming in the design of hybrid multiprocessors is highlighted.
Maniplicons in ThinkerToy
Authors: Gutfreund Steven H.
Published: November 2005

ThinkerToy is a graphical environment for modeling decision support problems. It provides a tableau on which such problems as landscape planning, service scheduling, and statistical analysis can be modeled and analyzed. Normally, complex mathematical and statistical modeling techniques are needed to perform meaningful analysis. ThinkerToy uses graphical icons with concrete physical properties to replace mathematical relationships and properties. The key construct in this methodology is the ManiplIcon: an icon which is not just a pictorial representation, but also a semantic tool for building models which homorphically represent semi-structured problems.
BrouHaHa- A portable Smalltalk interpreter
Authors: Miranda Eliot
Published: November 2005

BrouHaHa is a portable implementation of the Smalltalk-80 virtual machine interpreter. It is a more efficient redesign of the standard Smalltalk specification, and is tailored to suit conventional 32 bit microprocessors. This paper presents the major design changes and optimization techniques used in the BrouHaHa interpreter. The interpreter runs at 30% of the speed of the Dorado on a Sun 3/160 workstation. The implementation is portable because it is written in C.
INSIST: Interactive Simulation in Smalltalk
Authors: van der Meulen Pieter S.
Published: November 2005

A functional simulator/editor for VLSI design has been implemented in the Smalltalk-80
1
system. Users can explore their designs in an highly interactive and graphical manner with “close-to-reality” tools. The traditional sequence of editing, compiling and simulating the circuit is avoided. During editing, functional Modules can immediately respond to new connections. The simulator, called INSIST, strongly supports hierarchical simulation and design up to gate level. Hardware descriptions of the design can be generated for other CAD systems. From these descriptions layout has been generated. A RISC chip was entered and simulated at three hierarchical levels containing more than 50 Modules.
Opus: A Smalltalk production system
Authors: Laursen Jane , Atkinson Robert
Published: November 2005

Opus is a tool for rule-based programming which integrates a production system paradigm with the Smalltalk-80 environment. Opus currently provides a data-driven production system that allows the programmer considerable freedom, including access to the full functionality of the Smalltalk-80 language, and the ability to match rules with arbitrary objects in the environment. We present the goals for the design, a description of the system and its implementation, and discuss issues raised by this approach.
Intermedia: A case study of the differences between relational and object-oriented database systems
Authors: Smith Karen E. , Zdonik Stanley B.
Published: November 2005

This paper compares two approaches to meeting the data handling requirements of Intermedia, a hypermedia system developed at the Institute for Research in Information and Scholarship at Brown University. Intermedia, though written using an object-oriented programming language, relies on a traditional relational database management system for data storage and retrieval. We examine the ramifications of replacing the relational database with an object-oriented database. We begin by describing the important characteristics each database system. We then describe Intermedia and give an overview of its architecture and its data handling requirements. We explain why and how we used a relational database management system and the problems that we encountered with this system. We then present the design of an object-oriented database schema for Intermedia and compare the relational and object-oriented database management system approaches
.
A law-based approach to object-oriented programming
Authors: Minsky Naftaly H. , Rozenshtein David
Published: November 2005

The central idea behind this paper is that the discipline governing the exchange of messages between objects should be specifiable by the programmer in the form of an explicit
law of the system
. We show how, starting from a very primitive foundation, which presumes neither encapsulation nor inheritance, one can establish various forms of both, as well as other useful disciplines, simply by means of appropriate laws.
A small contribution to editing with a syntax directed editor
Authors: Zelkowits Marvin V.
Published: November 2005

The simple design of a syntax directed editor has made them a popular research topic over the last few years; however, in practice little development time is spent in actually entering program text. Most of the effort is devoted to program maintenance. This means that the editor has to be able to handle changes easily - a task that most syntax editors handle poorly. This paper describes a syntax editor and outlines the features that make editing such programs practical. It includes a bottom up parser that is used in a variety of ways within the editor.
Computer-Aided Software Engineering in a distributed workstation environment
Authors: Leblang David B. , Chase Robert P.
Published: November 2005

Computer-Aided Software Engineering environments are becoming essential for complex software projects, just as CAD systems have become essential for complex hardware projects. DSEE, the DOMAIN Software Engineering Environment, is a distributed, production quality, software development environment that runs on Apollo workstations. DSEE provides source code control, configuration management, release control, advice management, task management, and user-defined dependency tracking with automatic notification.

DSEE incorporates some of the best ideas from existing systems. This paper describes DSEE, contrasts it other systems, and discusses some of the technical issues involved in the construction of a highly-reliable, safe, efficient, and distributed development environment.
A programming environment for a timeshared system
Authors: Gabriel Richard P. , Frost Martin E.
Published: November 2005

In 1968 the Stanford Artificial Intelligence Laboratory began to construct a programming environment from a PDP-10, a pre-TOPS-10 DEC
1
timesharing system, and some innovative terminal hardware. By now this has developed into a programming environment for a KL-10 that integrates our editor with various other system functions, especially the Lisp subsystem. We use the term 'SAIL' to refer to the Stanford A. I. Lab KL-10 computer running the WAITS timesharing system. [Harvey 1982]

By 'programming environment' we mean the mechanisms that allow a user to type text at his program or subsystem, and which manage output text.
2
We are talking about mechanical management of the interaction between user and program, not about any intelligent mediation. A good programming environment should be flexible enough to suit individuals, yet without requiring the mechanics of interaction to be re-learned for each new program.

In this paper we describe our programming environment, what makes it unique, and why we think that it is not necessary to move to personal computers for a very usable programming environment.
A cognitively-based methodology for designing languages/environments/methodologies
Authors: Soloway Elliot
Published: November 2005

In designing a programming language, programming environment, or programming methodology there are a whole lot of both implicit and explicit “shoulds.” By a “should” we mean the claim that the appropriate use of language/environment/methodology X will lead to good habits and result in good products. For example, ADA's commitment to strong typing and mechanisms for constructing data types implies that these components are good and should result in more effective programming. The top-down design methodology implies that designers should start at the specifications and refine downward; this process will result in a good design. Etectera. The problem is that it is not clear that the current crop of languages/environments/methodologies (L/E/M's) do result in more productive programming and design, and that the “shoulds” implied by them are really all that good ([7]).
Prototyping a project master database for software engineering environments
Authors: Penedo Maria H
Published: November 2005

Software Engineering Environments (SEE) have been determined as good means of increasing software productivity by shifting projects from the paper world into the automated world. An
environment database
has been identified as the core of any automated Software Engineering Environment. It should provide the means for accessing, storing and relating all the project's products, the means for automating the process by which these components are entered in this library, modified, controlled and disseminated, and the means for supporting “active databases
1
”. The inherent complexity of building such a database is widely recognized.

We have been studying issues associated with such an environment database, which we denote Project Master Data Base (PMDB), with the overall objective of defining, designing and developing a PMDB as an integrated part of a SEE. Due to the lack of explicit requirements for its design, a prototype of the PMDB was developed in order to gain information and experience on both the specifications of the PMDB itself and also on different implementation approaches. This paper discusses our prototyping exercise; it describes the prototype, how the problem reporting, evaluation, and tracking process was modeled, and some of the lessons learned as a result of this effort.
A programming environment for CSP
Authors: Delisle Norman , Schwartz Mayer
Published: November 2005

This paper describes a programming environment that supports the development and execution of CSP programs. The prototype environment is primarily intended as a vehicle for learning CSP. Its strengths include graphical animations that illustrate the interactions of CSP processes as they execute. Its main limitations are that CSP programs do not execute particularly fast and that true parallelism is not supported. Both the functionality of the CSP environment and its somewhat unusual multi-language implementation are discussed.
Experience with a data base of programs
Authors: Belkatir N , Estublier J
Published: November 2005

The Adele system was initially designed as a specialized data base of programs for an experimental Pascal environment, with a focus on configuration management. Later, it was redesigned as a general data base for large scale programs written in any language. The focus here was on side effect control and real problems of large industrial software products [Estublier84]. Then in a third stage Adele evolved into the kernel for programming environments and was developed as an industrial product, with emphasis on portability, flexibility, distribution, control of rights and on the structure of the software products [Belkhatir86]. This paper describes the experience gained in the use of the Adele data base of programs.
1
Dost: an environment to support automatic generation of user interfaces
Authors: Dewan Prasun , Solomon Marvin
Published: November 2005

This paper describes an environment that allows the user interface of an application to be generated automatically. The environment uses an approach based on the ideas of editor-oriented user interaction and object-oriented programming.
Control flow analysis
Authors: Allen Frances E.
Published: November 2005

Any static, global analysis of the expression and data relationships in a program requires a knowledge of the control flow of the program. Since one of the primary reasons for doing such a global analysis in a compiler is to produce optimized programs, control flow analysis has been embedded in many compilers and has been described in several papers. An early paper by Prosser [5] described the use of Boolean matrices (or, more particularly, connectivity matrices) in flow analysis. The use of “dominance” relationships in flow analysis was first introduced by Prosser and much expanded by Lowry and Medlock [6]. References [6,8,9] describe compilers which use various forms of control flow analysis for optimization. Some recent developments in the area are reported in [4] and in [7].

The underlying motivation in all the different types of control flow analysis is the need to codify the flow relationships in the program. The codification may be in connectivity matrices, in predecessor-successor tables, in dominance lists, etc. Whatever the form, the purpose is to facilitate determining what the flow relationships are; in other words to facilitate answering such questions as: is this an inner loop?, if an expression is removed from the loop where can it be correctly and profitably placed?, which variable definitions can affect this use?

In this paper the basic control flow relationships are expressed in a directed graph. Various graph constructs are then found and shown to codify interesting global relationships.
Report of evening session protection
Authors: Neumann Peter G.
Published: November 2005

The session began late following an almost three hour dinner for some of us! (Southern hospitality?) Discussion centered on access control mechanisms in operating systems and/or in languages, weaknesses in the state of the art, and desirabilities for secure systems.

Should protection be specifiable within the base language of a system? Jack Dennis: a resounding “yes”. It is highly desirable to associate protection with accessing. (There was some disagreement here). Barbara Liskov: Some help obtainable from type checking during compilation where privileges can be specified at compile time. (Beware of subsequent modifications). Gio Wiederhold: Subsets of types can be useful here.
System correctness
Authors: Ballard Alan , Tsichritzis Dennis
Published: November 2005

There is no question that reliability is an important factor in the production and life cycle of software. Logical correctness is the first step towards achieving reliability. While operating systems may be too large to prove correct, in view of the current state of the art, there are often key algorithms and critical properties which are good candidates.

A precise statement of the properties, assumptions, and theorems involved greatly influences the reliability of the program. As a side benefit we get a tremendous understanding of the operation of the programs while trying to prove their correctness. By the time we have stated formally all the properties, assertions and theorems involved, the program is sufficiently analyzed informally to ensure its correctness for all practical purposes.
Semantic aspects of concurrent processes
Authors: Belpaire Gérald , Wilmotte Jean Pierre
Published: November 2005

In the literature on parallel processes, most of the specific 'parallel' features of programming languages are designed to fit and to solve only one specific class of problems of concurrent processes. For that reason, they usually provide a, fairly good and comprehensive definition of the problem but the real solution is left to the final implementation
Hierarchical language definition
Authors: Bochmann Gregor V.
Published: November 2005

This paper describes a project for the hierarchical definition and implementation of languages. In the spirit of structured programming [1] and in analogy to the hierarchical construction of operating systems [2,3] we define high level languages, which are suitable for the design of operating and other software systems, in several levels of abstraction. In particular, we describe in this paper how an intermediate, machine independent basic language can be used to express the actions of a given high level language in terms of simple actions of the basic language. In conjunction with a translator writing system, this allows a
compact and readable
formal definition of the
syntax and semantics
[4,5] of the high level language, which is in fact a description of the compiler which translates this language into the basic language. This definition is independent of a particular computer, however, an implementation of the basic language must be furnished. We intend to use the basic language to describe modules which are embedded in a general system for multiple processes. The language consists of a kind of macro instructions most of which can be implemented in a straight forward manner. Some more complicated instructions, such as primitives for inter-process communication, can be implemented through a hierarchical construction process [2,3] as indicated in section III (see also figure 1).
Reflections on a language designed to write an operating system
Authors: Clark B. L. , Horning J. J.
Published: November 2005

Project SUE is writing an extensible time-sharing operating system for the IBM System/360 using a high-level System Language designed especially for the purpose. This paper expresses opinions on the crucial issues in the design of such a language, based on the Project SUE experience.
The grok project data structures and process communication
Authors: Jensen Peter
Published: November 2005

An overview of the structured data types proposed for the grok language is given. The proposal represents a uniform approach to arrays, records and procedures by regarding them as specialized occurences of the same underlying structure. Structures are partitioned into three classes according to the number of references pointing to the structure at the same time, and we show how this may be utilised in synchronization of parallel processes. The well known producer-consumer example illustrates this.
SPIL
Authors: Liskov Barbara H. , Smith Leroy A.
Published: November 2005

Structured programming is gaining wide acceptance as a technique for increasing the reliability and understandability of software. Nowhere is the need for better software felt more keenly than in the area of systems programming. In the near future it is likely that systems will be programmed in structured programming languages, just as systems have been programmed in higher level languages in the past.

This paper describes SPIL: a structured programming language intended to be used for system design and implementation. The paper discusses how the objectives of structured programming and system programming may be realized in a programming language, and delineates the influence of the objectives on the design of SPIL. The most important features of the language are briefly described. The paper concludes by evaluating SPIL as a language for system design and implementation.
A programming language family for the navy AADC
Authors: Miller James S.
Published: November 2005

The U.S. Navy is sponsoring the development of a modern-technology computer system known as the All-Applications Digital Computer (AADC). Originally intended for avionics purposes alone, the promising success of the program so far has led to a broadening of its objectives. The impact of the operational system will occur over the 1975-1985 time period. If the costs of the hardware prove to be as low as predicted, not only will new applications be likely users of AADCs, but some degree of retrofitting may be expected as well.
Towards the formal description of operating systems
Authors: Neuhold E. J.
Published: November 2005

For a number of widely used programming languages formal descriptions of their semantic have been presented /1,2/. In addition, formal description techniques have been applied to investigate programming languages and to achieve completeness and correctness proofs for algorithms and language implementations /3,4,5/. The formal description of operating systems did not achieve the same kind of success. This is partially due to the large size of currently used operating systems, but also to the difficulties encountered in understanding operating systems to a depth comparable to our understanding of programming languages. To provide a formal description of the mechanisms investigated so far /6,7,8/ and to allow a study of their interactions in a formally defined environment, it is our feeling that a concentrated effort to formally describe the semantic of a complete existing or planned operating systems should be undertaken.
A SIMPL distributed operating system and its formal definition
Authors: Noonan R. , Basili V. , Hamlet R. , Lay M. , Mills D. , Turner J. , Zelkowitz M.
Published: November 2005

In recent years there has been a phenomenal growth of interest in networks of computers sharing both data and programs. For example, Cmdr. Grace Hopper has advocated a hierarchical network of minicomputers to perform the data processing function in which the tasks to be done would be distributed over the network, with only summary or extract information being passed from one level to another. While the hardware exists to build such a network, the software mechanisms to effectively (from both a time and cost viewpoint) control such a network have not yet been developed.

At the Computer Science Center of the University of Maryland a distributed operating system, which is independent of the specific number and hardware of the particular computers it is running on, is being developed and implemented. Supporting this project is the development of two linguistic tools: the design and implementation of a systems programming language called SIMPL and the use of formal semantics in the specification of both SIMPL and the distributed operating system. So far, each of these three elements has had a considerable effect on the others.
Extensible control structures
Authors: Prenner Charles J.
Published: November 2005

A considerable amount of programming language research has been directed towards the development of
extensible
languages. Typically, these languages allow
data type
extensions, in which new data types are constructed in terms of built-in or previously defined ones, and
syntax
extensions, which allow the programmer to express himself in a more convenient notation than that of the base language. For the past few years the author has been experimenting with a third axis of extensibility, namely,
control
extensions - the introduction of non-standard control structures into programming languages.

By non-standard control structures we refer to any one of a set of facilities which have appeared as specialized extensions to existing languages. These include non-deterministic algorithms, backtracking, parallel processing, co-routines, simulation primitives, synchronization operations, and the like. Numerous papers describe how one or more of the above can he added to some language (usually ALGOL-60). However, there have been relatively few studies of either the effects of the extensions on the language as a whole or the possibility of obtaining all of these extensions in a unified way from a common base.
A method for the description and analysis of complex software systems
Authors: Riddle William E.
Published: November 2005

This paper outlines a modeling scheme and associated method of analysis which are particularly useful during the design of complex software systems since they facilitate an iterative design methodology and provide feedback to help guide the creation of the final design. The process oriented modeling scheme is outlined first and a brief indication is given of how it may be easily and naturally used in a top-down elaboration of a system's design. Then the method of analysis is outlined and shown to provide a procedure for deriving algebraic descriptions of a system's internal behavior which may be used to check whether or not the system is correct in the sense that it exhibits desirable behavior and does not exhibit undesirable behavior. This paper necessarily gives only a brief overview of the description shceme and method of analysis and full details may be found in [1] and [2].
On programming parallel computers
Authors: Lamport Leslie
Published: November 2005

In this paper, I will make some general observations about how computers should be programmed, and how programs should be compiled. I will restrict my attention to programming computers to solve numerical analysis problems, although most of my remarks can be applied to other problem areas as well. My primary concern is for large parallel computers. However, I will show that parallelism is not a major issue, and I will not restrict the discussion to any single type of computer architecture.

The paper is a very general one, and I will make few specific proposals for language or compiler design. Instead, I will examine the fundamental nature of the programming/compiling process, how this process is done now, and how it should be done in the future. Few of my observations will be new or original. However, a careful analysis will lead to a somewhat surprising conclusion: a higher level programming language is needed both to reduce programming costs and also to obtain more efficient programs. The analysis will also provide some useful ideas for designing a higher level language and compiling efficient code from it.