bluuebunny/crossref_metadata_2025 huggingface dataset:
Building tailorable hypermedia systems
Authors: Grønbæk Kaj , Malhotra Jawahar
Published: November 2005

This paper discusses an approach for developing dynamically tailorable hypermedia systems in an object-oriented environment. The approach is aimed at making applications developed in compiled languages like Beta and C++ tailorable at run-time. The approach is based on use of: 1) a hypermedia application framework (DEVISE Hyper-media), and 2) an embeddable interpreter for the framework language. A specific hypermedia system is instantiated from the framework with the interpreter embedded in the executable. The specific hypermedia system has a number of “open points” which can be filled via the interpreter at run-time. These open points and the interpreter provide sufficient support to allow tailoring at run-time as well as compile-time. Among the types of tailoring supported are: 1) adding new media-types, 2) alternating editors for supported media-types, and 3) removing a supported media-type. The paper describes the framework and illustrates how the interpreter is integrated. It describes steps involved in tailoring a specific hypermedia system with a new drawing media-type, where graphical objects can be endpoints for links. Since the hypermedia framework uses a persistent object-store, a solution for handling persistent interpreted objects is presented. Finally, the approach is compared with other environments supporting tailoring.
A third-generation SELF implementation
Authors: Hölzle Urs , Ungar David
Published: November 2005

Programming systems should be both responsive (to support rapid development) and efficient (to complete computations quickly). Pure object-oriented languages are harder to implement efficiently since they need optimization to achieve good performance. Unfortunately, optimization conflicts with interactive responsiveness because it tends to produce long compilation pauses, leading to unresponsive programming environments. Therefore, to achieve good responsiveness, existing exploratory programming environments such as the Smalltalk-80 environment rely on interpretation or non-optimizing dynamic compilation. But such systems pay a price for their interactiveness, since they may execute programs several times slower than an optimizing system.

SELF-93 reconciles high performance with responsiveness by combining a fast, non-optimizing compiler with a slower, optimizing compiler. The resulting system achieves both excellent performance (two or three times faster than existing Smalltalk systems) and good responsiveness. Except for situations requiring large applications to be (re)compiled from scratch, the system allows for pleasant interactive use with few perceptible compilation pauses. To our knowledge, SELF-93 is the first implementation of a pure object-oriented language achieving both good performance and good responsiveness.

When measuring interactive pauses, it is imperative to treat multiple short pauses as one longer pause if the pauses occur in short succession, since they are perceived as one pause by the user. We propose a definition of
pause clustering
and show that clustering can make an order-of-magnitude difference in the pause time distribution.
Complex associations
Authors: Kristensen Bent Bruun
Published: November 2005

Objects model phenomena and a phenomenon is usually a component. Information characterizing a component is encapsulated and accessible only by its methods. The
relations
between components are modeled explicitly by means of associations or references. A relation is also a phenomenon and objects can model this type of phenomena too. Components are usually related conceptually in diverse and subtle ways: Some relations are implicitly given and some are local to other more basic relations. Such kinds of relations are important for understanding the organization and cooperation of objects and may be supported in object-oriented analysis, design, and programming: An
implicit association
describes a relation between an object and objects
local
to this
enclosing
object, and a
complex association
describes an explicit relation between
local
objects in different enclosing objects. Such associations are described by classes and the objects have the usual properties including methods and attributes.
Streamlining the project cycle with object-oriented requirements
Authors: Jordan Richard , Smilan Ruth , Wilkinson Alex
Published: November 2005

We have succeeded in streamlining the product development cycle by incorporating object-oriented technology into the requirements definition phase. We have developed a general format, supporting tools and a methodology for describing requirements in an object-oriented fashion. We have validated our approach by incorporating it into the new object-oriented methods being applied to our current project and observing the benefits that resulted. We describe the problems with our earlier requirements specifications which make them unsuitable for developing good object-oriented systems and then explain our approach which eliminates these pitfalls.
Timethread-role maps for object-oriented design of real-time-and-distributed systems
Authors: Buhr R. J. A. , Casselman R. S.
Published: November 2005

Object-oriented design methods and notations do not adequately address the concerns of real-time-and-distributed (RTD) systems. Issues critical to such systems, like performance, robustness, and concurrency are not seriously considered until detailed design. We propose an object-oriented approach that allows RTD design issues to be considered before detailed design. The approach revolves around
timethread-role maps
that present composite pictures of concurrent, interacting, end-to-end responsibility paths through a system. It is related to responsibility-driven design approaches, but extended for RTD systems. The paper illustrates by example how timethread-role maps can be used to explore, compare and explain different organizations for achieving the paths. The paper also illustrates how timethread-role maps may be used to represent dynamic structure.
Sifting out the gold
Authors: Agesen Ole , Ungar David
Published: November 2005

Integrated, dynamically-typed object-oriented programming environments offer many advantages, but have trouble producing small, self-contained applications. Recent advances in type inference have made it possible to build an application extractor for Self. The extractor was able to extract a medium-sized application in a few minutes. The extracted application runs in a tenth the space of the original environment. Except for extracting reflection and sends with computed selectors, the extractor runs without human intervention and fully preserves the behavior of the application.
Semantic locking in object-oriented database systems
Authors: Resende Rodolfo F. , Agrawal Divyakant , El Abbadi Amr
Published: November 2005

Object-oriented databases are being increasingly used to model non-standard applications that emphasize modularity, composition, and rapid prototyping. A semantic locking protocol is presented for transaction management for such object-oriented databases. In particular, the protocol incorporates the semantics of complex objects, nested executions and dynamic conflicts resulting from referentially shared objects.
Experience with representing C++ program information in an object-oriented database
Authors: Onodera Tamiya
Published: November 2005

Two major issues related to storing program information in an OODB are sharing and clustering. The former is important since it prevents the database from consuming excessive disk space, while the latter is crucial, since it keeps clients running without thrashing. In our database, objects are shared across multiple programs' translation units, and are clustered by combining three techniques, namely, birth-order, death-order, and sharing-oriented clusterings. An initial experiment shows that, for a medium-size application, the database consumes 3.5 times less disk space than in a conventional environment, and that the invocation of a client is almost instantaneous.
An extensible program representation for object-oriented software
Authors: Malloy Brian A. , McGregor John D. , Krishnaswamy Anand , Medikonda Murali
Published: November 2005

An extensible representation for object-oriented programs is presented. It is based on the concept of a program dependency graph and elaborated to include both control flow and data flow information. The representation takes advantage of the basic incremental philosophy of the object-oriented approach to develop a more compact representation that is useful with practical programs. The basic approach reported here provides a static view of an object-oriented program. The approach can be expanded to provide dynamic information for tools such as interactive debuggers and other runtime tools. The outline of this extension is also presented.
Comment on poor practice in coding examples
Authors: Weisert Conrad
Published: November 2005

What's more depressing than a programming instructor who presents "correct" examples based on bad practice? In
Bug Analysis of Pascal Programs
(April, 1994, p. 15) the author posed a simple student problem:
Rapid development of a source-level debugger for PowerPC microprocessors
Authors: Butt Farooq
Published: November 2005

As design cycle times in the computer industry decrease, it becomes increasingly important to have a fast, effective software-development environment quickly available so that software may be developed for emergent microprocessors well before general availability. This paper discusses how gdb (an industry-standard source-level debugger) was paired with a software microprocessor simulator for the Motorola PowerPC 601* and PowerPC 603* microprocessors in order to provide a seamless and highly productive compile-edit-debug environment from the time that the PowerPC instruction set was first announced through general availability.
Trap-driven simulation with Tapeworm II
Authors: Uhlig Richard , Nagle David , Mudge Trevor , Sechrest Stuart
Published: November 2005

Tapeworm II is a software-based simulation tool that evaluates the cache and TLB performance of multiple-task and operating system intensive workloads. Tapeworm resides in an OS kernel and causes a host machine's hardware to drive simulations with kernel traps instead of with address traces, as is conventionally done. This allows Tapeworm to quickly and accurately capture complete memory referencing behavior with a limited degradation in overall system performance. This paper compares trap-driven simulation, as implemented in Tapeworm, with the more common technique of trace-driven memory simulation with respect to speed, accuracy, portability and flexibility.
Logical objects with constraints
Authors: Xu Dianxiang , Zheng Guoliang
Published: November 2005

This paper presents a novel programming language called LOC (Logical Objects with Constraints), which combines logic programming and object-oriented programming paradigms. In LOC, logical objects are viewed as abstractions with state, constraints, behaviors and inheritance. It therefore supports such notions as inheritance, modularity and reusability, which have turned out to be extremely useful for large scale software systems. The operational interpretation defined in the style of natural semantics is simple and clear. The transformation of LOC into Prolog is also explored to indirectly illustrate the descriptive semantics.
Towards situation-oriented programming languages
Authors: Tin Erkan , Akman Varol , Ersan Murat
Published: November 2005

Recently, there have been some attempts towards developing programming languages based on situation theory. These languages employ situation-theoretic constructs with varying degrees of divergence from the ontology of the theory. In this paper, we review three of these programming languages.
Poor man's watchpoints
Authors: Copperman Max , Thomas Jeff
Published: November 2005

Bugs that result from corruption of program data can be very difficult to track down without specialized help from a debugger. If the debugger cannot help the user find the point at which data gets corrupted, the user may have a long iterative debugging task. If the debugger is able to stop execution of the program at the point where data gets corrupted, as with watchpoints (also known as data breakpoints), it may be a very simple task to find a data corruption bug. In this paper, we discuss a method of implementing watchpoints on a system without hardware watchpoint support. By instrumenting the program code to check memory accesses, and supplying an interface to the instrumentation in the debugger, we provide an efficient, general method of implementing watchpoints.
OVIDE
Authors: Mellier Pierre , Grize François
Published: November 2005

One of the sensitive points of application softwares is the programming of the user interface. In particular, the acquisition and the automatic validation of data capture demands great efforts and is rarely programmed in a satisfactory manner. Our research studies are based on the development of a theoretical data acquisition and validation model, as well as the fulfilment of these ideas using computer tools. This paper shows the different choices which we have studied and the tools we have developed to put these into effect. The tools we have created to take these considerations into account is called OVIDE and is perfectly integrated to the chosen development environment.
A name change from "COOL" 'to "ACOOL"
Authors: Maruyama Katsumi
Published: November 2005

We are very pleased that our manuscript "Concurrent object-oriented language COOL" was published in Vol. 29, No. 9 of "

ACM SIGPLAN
Notices

" in September, and that so many queries have been received about it.
Adding generic functions to Scheme
Authors: Tessman Thant
Published: November 2005

A generic function is a set of methods, all of which have equivalent semantics but each of which apply to different domains. This document describes how to augment the Scheme programming language with the capability to define multi-method generic functions. Also described are optimization issues and areas of potentially fruitful future exploration.
Efficient execution of programs with static semantics
Authors: Becker George , Murray Neil V.
Published: November 2005

An extension to single-threading (using each value exactly once) is presented that allows efficient execution of functional programs while maintaining their static semantics. This extension preserves the idea of only one, possibly modifying, use of a data item, and also allows any number of read-only uses. The inefficiency problem is overcome by imposing a restriction on function composition. The proposed method is based upon a static analysis of function definitions and calls. This analysis is linear in the size of function definitions, and additive between functions. Unlike approaches utilized in optimizing compilers, the proposed method can be applied even to large programs, and it guarantees the asymptotic complexity of corresponding imperative programs while obviating the need for garbage collection. An experimental functional programming language based on these ideas has been designed and implemented.
LISA
Authors: Mernik Marjan , Korbar Nikolaj , Žumer Viljem
Published: November 2005

In the paper a tool for automatic language implementation is described. From formal language definition LISA
1
produces efficient interpreters or compilers in C++. For lexical and syntax analysis well known formal methods: regular expressions and BNF are used. Semantics of the defined language is described with attribute grammars. LISA is a part of the ongoing effort to build an environment that supports experimentation in automatic language implementation for educational and industrial purposes.
Incremental computation of dominator trees
Authors: Sreedhar Vugranam C. , Gao Guang R. , Lee Yong-fong
Published: November 2005

Data flow analysis based on an incremental approach may require that the dominator tree be correctly maintained at all times. Previous solutions to the problem of incrementally maintaining dominator trees were restricted to reducible flowgraphs. In this paper we present a new algorithm for incrementally maintaining the dominator tree of an arbitrary flowgraph, either reducible or irreducible, based on a program representation called the DJ-graph. For the case where an edge is inserted, our algorithm is also faster than previous approaches (in the worst case). For the deletion case, our algorithm is likely to run fast on the average cases.
XIL and YIL
Authors: O'Brien Kevin , O'Brien Kathryn M. , Hopkins Martin , Shepherd Arvin , Unrau Ron
Published: November 2005

Typically, the choice of intermediate representation by a particular compiler implementation seeks to address a specific goal. The intermediate language of the TOBEY compilers, XIL, was initially chosen to facilitate the production of highly optimal scalar code, yet, it was easily extended to a higher level form YIL in order to support a new suite of optimizations which in most existing compilers are done at the level of source to source translation. In this paper we will discuss those design features of XIL that were important factors in the production of optimal scalar code. In addition we will demonstrate how the strength of the YIL abstraction lay in its ability to access the underlying low level representation.
A brief essay on capabilities
Authors: de Vivo Marco , de Vivo Gabriela O. , Gonzalez Luis
Published: November 2005

In the course of the last three decades,
capabilities
have been successfully used to implement protection systems in multiples scenarios and platforms. Although the basic idea remains the same, a wide variety of techniques have been used in the implementation and administration of
capabilities
. As new paradigms emerged, the concept of
capabilities
has shown to scale very well with the change of models. As a matter of fact, several modern computational environments (particularly distributed ones) use some sort of
capabilities
as a protection mechanism. The goal of this paper is to review the main ideas related to
capabilities
as well as several of the approaches chosen in their implementation and use. This work is primarily intended as a support document for courses on operating systems and programming languages.
Reducing false sharing on shared memory multiprocessors through compile time data transformations
Authors: Jeremiassen Tor E. , Eggers Susan J.
Published: November 2005

We have developed compiler algorithms that analyze explicitly parallel programs and restructure their shared data to reduce the number of false sharing misses. The algorithms analyze per-process shared data accesses, pinpoint the data structures that are susceptible to false sharing and choose an appropriate transformation to reduce it. The transformations either group data that is accessed by the same processor or separate individual data items that are shared.

This paper evaluates that technique. We show through simulation that our analysis successfully identifies the data structures that are responsible for most false sharing misses, and then transforms them without unduly decreasing spatial locality. The reduction in false sharing positively impacts both execution time and program scalability when executed on a KSR2. Both factors combine to increase the maximum achievable speedup for all programs, more than doubling it for several. Despite being able to only approximate actual inter-processor memory accesses, the compiler-directed transformations always outperform programmer efforts to eliminate false sharing.
High performance synchronization algorithms for multiprogrammed multiprocessors
Authors: Wisniewski Robert W. , Kontothanassis Leonidas I. , Scott Michael L.
Published: November 2005

Scalable busy-wait synchronization algorithms are essential for achieving good parallel program performance on large scale multiprocessors. Such algorithms include mutual exclusion locks, reader-writer locks, and barrier synchronization. Unfortunately, scalable synchronization algorithms are particularly sensitive to the effects of multiprogramming: their performance degrades sharply when processors are shared among different applications, or even among processes of the same application. In this paper we describe the design and evaluation of scalable scheduler-conscious mutual exclusion locks, reader-writer locks, and barriers, and show that by sharing information across the kernel/application interface we can improve the performance of scheduler-oblivious implementations by more than an order of magnitude.
A pragmatic approach to C++, Eiffel and Ada 9X programming
Authors: de Vivo Gabriela O. , de Vivo Marco
Published: November 2005

Conceptualizing the world as a set of interacting objects, has ever been the main mechanism of perception associated with humankind. Therefore, the formulation of languages and modeling and design methods based on object orientation (OO) was just a matter of time. After that, a mutual feedback driven process lead to more and better implementations of OO languages as well as to proven OO based techniques for design and modeling. Of course the success of the whole model is related to the analysis of the adequacy of the actual OO languages for the implementation of OO designed systems. This paper reports the results of a simple experiment formulated to find some heuristics associated to the adequacy of the languages C++, Eiffel, and Ada 9X for the implementation of OO designed systems.
CONS should not CONS its arguments, part II
Authors: Baker Henry G.
Published: November 2005

Previous Schemes for implementing full tail-recursion when compiling into C have required some form of "trampoline" to pop the stack. We propose solving the tail-recursion problem in the same manner as Standard ML of New Jersey, by allocating all frames in the (garbage-collected) heap. The Scheme program is translated into continuation-passing style, so the target C functions never return. The C stack pointer then becomes the allocation pointer for a Cheney-style copying garbage collection scheme. Our Scheme can use C function calls, C arguments, C variable-arity functions, and separate compilation without requiring complex block-compilation of entire programs. Our C version of the "Boyer" benchmark is available at ftp://ftp.netcom.com/pub/hb/hbaker/cboyer13.c.
What is a procedure call?
Authors: Meek Brian L.
Published: November 2005

This third article in a series describing the language-independent work of the ISO/IEC JTC1/SC22 WG11 provides and introduction to the proposed ISQ/IEC 13886 standard, Language Independent Procedure Calling.
Introducing data decomposition into VDM for tractable development of programs
Authors: Lu Jian
Published: November 2005

Formal program development by VDM comprises not only data reifications from abstract model to concrete model but also suitable operation decompositions. Usually, these two kinds of development steps are done independently with the order of "operation decompositions after data reifications". Furthermore, data reifications and operation decompositions are based on the whole model because no model split is allowed. If, however, larger specifications are aimed at, it is very important to provide support for model split and suitably interweave it with data reification and operation decomposition. In this paper, we introduce a new concept---data decomposition which is based on the ideas of model split, modularisation and operation decomposition, and combine it with VDM to form a more general formal development method DD-VDM. As a result, a more flexible development strategy can be adopted and the development complexity can be effectively controlled.
Language constructs and transformation for hard real-time systems
Authors: Chung Tai M. , Dietz Hank G.
Published: November 2005

In practice, time critical portions of hard real-time systems are still implemented in low-level programming languages and manually tuned to meet all the timing requirements. Without a real-time language that supports an appropriate way of specifying timing constraints for a generic hard real-time systems, and high precision timing analysis that is transparent to users, the users will ever suffer from the complex coding and analysis, particularly for systems requiring fast turnaround responses.In this paper, we propose novel language constructs that can be added to any imperative programming language so that the extended language provides users a way to specify relative timing constraints between arbitrary operations at instruction-level. The compilation techniques unique to transformation of the proposed language are also presented as a part of CHaRTS, the Compiler for Hard Real-Time Systems, which generates a valid instruction sequence for a target execution model.
Performance analysis of embedded software using implicit path enumeration
Authors: Li Yau-Tsun Steven , Malik Sharad
Published: November 2005

Embedded computer systems are characterized by the presence of a processor running application specific dedicated software. A large number of these systems must satisfy real-time constraints. This paper examines the problem of determining the extreme (best and worst) case bounds on the running time of a given program on a given processor. This has several applications in the design of embedded systems with real-time constraints. An important aspect of this problem is determining which paths in the program are exercised in the extreme cases. The state of the art solution here relies on an
explicit
enumeration of program paths. This runs out of steam rather quickly since the number of feasible program paths is typically exponential in the size of the program. We present a solution for this problem that does not require an explicit enumeration of program paths, i.e., the paths are considered
implicitly
. This solution is implemented in the program cinderella
1
which currently targets a popular embedded processor --- the Intel i960. The preliminary results of using this tool are also presented here.
Supporting user-friendly analysis of timing constraints
Authors: Ko Lo , Whalley David B. , Harmon Marion G.
Published: November 2005

Real-time programmers have to deal with the problem of relating timing constraints associated with source code lines to sequences of machine instructions. This paper describes an interface that was developed to assist users in this task. Portions of programs can be quickly selected and the corresponding bounded times, source code lines, and machine instructions are automatically displayed. In addition, users are restricted to only selecting portions of the program for which timing bounds can be obtained. The result is a user-friendly interface that assists programmers in the analysis of timing constraints within a program.
Automatic generation of scheduling and communication code in real-time parallel programs
Authors: Bakkers André , Sunter Johan , Ploeg Evert
Published: November 2005

Inter-process communication and scheduling are notorious problem areas in the design of real-time systems. Using CASE tools, the system design phase will in general result in a system description in the form of parallel processes. Manual allocation of these processes to processors may result in error prone and/or slow communication code. Scheduling of the processes, necessary to meet timing constraints, is also a tedious task that takes many iterations. The described design tools result in code that is comparable in quality and performance with expert manual realization. Many network layers have been implemented to relieve the user from the low-level programming of communication software. However, the increase in user-friendliness is usually paid with performance degradation. The proposed approach combines user-friendliness with high performance by generating communication software that is tailor-made for the application. A similar approach is followed with the scheduling software. Schedulers in the form of a built-in a kernel are available all the time and cause overhead all the time. The proposed preprocessor tool generates scheduling software after analyzing the timing requirements of the particular application. This results in simple code for simple timing requirements and more complicated code for complex timing requirements. The tools have been implemented in Occam for use on a transputer. However, the results are valid for any distributed memory machine.
Editorial page
Authors: Campbell Robert D.
Published: November 2005

How long do you expect it will be before some college or university, together with a major publisher, packages a set of online curriculum materials that blows your socks off? We've seen textbooks grow into a forest of materials -- the textbook itself, a study guide, an instructor's manual, a set of transparencies, one or more test banks, etc. Will it really be much of a leap to package these materials into a spiffy distance-learning format? We've seen many colleges and universities offer courses, programs, and entire degree offerings in an online format. Is it much of a leap to imagine one aggressive school seeking to capture the market? We know that professional organizations frequently make recommendations on curricular guidelines; the more such guidelines are adopted the more the image of the organization is enhanced, which naturally leads to greater adoption of the guidelines. So is it much of a leap to imagine an organization officially endorsing one set of online curriculum materials, in exchange for, say a royalty fee paid for each student participant?
Bits and bytes
Authors: Klee Karl J.
Published: November 2005

CENTER FOR IP:
There is a Center for the History of Information Processing, the Charles Babbage Institute, sponsored by the University of Minnesota and the information processing community. The Center serves to
preserve and make accessible sources for the history of information processing
. Robert W. Seidel has served as Director since 93-94, and Bruce Bruemmer continues to serve as Archivist. The Center gathers, catalogs, and stores materials of historic value in the computing and information processing field, and makes the material available to investigators.
A framework for a student-centered approach to learning in an information system curriculum
Authors: Dunston G. Joyce , Gallardo Julio
Published: November 2005

This paper discusses the framework for a student-centered curriculum in information systems. The foundation of the curriculum rest on two popular instructional methods: collaborative learning and writing-to-learn. The framework is an outgrowth of current research findings and the Data Processing Department's ten year effort to meet today's educational challenges.
Multiple uses of Internet in the classroom
Authors: Petiprin Frank C.
Published: November 2005

One of the most exciting areas of computer science today is the evolving and expanding world of the Internet. I have been teaching mathematics, computer science, and/or robotics for over twenty-five years, and I am now incorporating this new technology into my courses and even setting up a World Wide Web (WWW) server. This article will help provide you with the means to do the same.
Managing object oriented projects (panel session)
Authors: Hill Laura , Rubin Kenny , Daniels John , Berman Charles , Coplien James , Johnson Doug
Published: November 2005

Projects using Object Oriented technology typically fall into one of two categories: either they are run with traditional project management techniques, or they are run by "technology experts" who don't use
any
project management techniques. This panel will attempt to give out some hints as to how to be more successful managing OO projects.Questions to be addressed include:• How is Object Oriented Project Management different? Is a "paradigm shift" required for project management?• What aspects of Object Oriented project management should be stressed? What are some tips, tricks or gotchas experienced by the panel members?• Does a project manager need to be more technical to lead an Object Oriented project? Should he/she have had previous experience with Object Oriented development?• What are some alternate organizational structures which would better support Object Oriented projects?• What is the nature of an Object Oriented life cycle and how is it different?• Is there a difference in techniques between different languages or between different domainsAudience members with relevant experience will be invited to sit on the panel in two "guest" seats.
Profile-guided receiver class prediction
Authors: Grove David , Dean Jeffrey , Garrett Charles , Chambers Craig
Published: November 2005

The use of dynamically-dispatched procedure calls is a key mechanism for writing extensible and flexible code in object-oriented languages. Unfortunately, dynamic dispatching imposes a runtime performance penalty. Some recent implementations of pure object-oriented languages have utilized profile-guided receiver class prediction to reduce this performance penalty, and some researchers have argued for applying receiver class prediction in hybrid languages like C++. We performed a detailed examination of the dynamic profiles of eight large object-oriented applications written in C++ and Cecil, determining that the receiver class distributions are
strongly peaked
and
stable
across both inputs and program versions through time. We describe techniques for gathering and manipulating profile information at varying degrees of precision, particularly in the presence of optimizations such as inlining. Our implementation of profile-guided receiver class prediction improves the performance of large Cecil applications by more than a factor of two over solely static optimizations.
How and why to encapsulate class trees
Authors: Riehle Dirk
Published: November 2005

A good reusable framework, pattern or module interface usually is represented by abstract classes. They form an abstract design and leave the implementation to concrete subclasses. The abstract design is instantiated by naming these subclasses. Unfortunately, this exposes implementation details like class names and class tree structures. The paper gives a rationale and a general metaobject protocol design that encapsulates whole class trees. Clients of an abstract design retrieve classes and create objects based on class semantics specifications. Using abstract classes as the only interface enhances information hiding and makes it easier both to evolve a system and to configure system variants.
Towards a methodology for explicit composition of metaobjects
Authors: Mulet Philippe , Malenfant Jacques , Cointe Pierre
Published: November 2005

Reflective programming languages are those where users' programs are allowed to customize in an organized way the behavior of the language to their own needs. For ten years now, most of the work on reflection revolved around the definition and the implementation of metaobject protocols which express this organization. No methodologies have been proposed for reflective programming
per se
. This paper proposes a first one aiming at the design of composable metaobjects. Given two independently developed reflective customizations, this methodology proposes principles to be observed in their design such that they can be composed using standard base-level aggregation or specialization. While this paper focuses on a simple MOP and illustrates the methodology on specific examples, this methodology can be generalized to other languages with different MOPs. For instance, we discuss how to adapt it to C
LOS
.
Release-to-release binary compatibility in SOM
Authors: Forman Ira R. , Conner Michael H. , Danforth Scott H. , Raper Larry K.
Published: November 2005

SOM (IBM's System Object Model) removes a major impediment to reuse in Object-Oriented Programming by facilitating the programming of release-to-release binary compatible class libraries. This is accomplished by supporting a large number of compatibility preserving transformations. Taken together these transformations compose a discipline for programming evolving class libraries.
Bits and bytes
Authors: Little Joyce Currie
Published: November 2005

The Computer Professionals for Social Responsibility (CPSR) has a new LISTSERV for uniting people all over the world who want to talk about issues involving computing and societal impact. The LISTSERV is predominately in English because it's the lingua franca of the Net. Issues being discussed include security, decency, privacy, law, national identification efforts, international communication, and matters of computer systems development. To join the discussion, write to listserv@cpsr.org with a blank subject line and the command SUBSCRIBE CPSR-GLOBAL Firstname Lastname, where Firstname and Lastname are replaced by your own first and last name.
Interactive video advising
Authors: Janik Carol
Published: November 2005

The World-Wide-Web is a good source to find out about some of the new things that are going on at community colleges. That's how I learned about the video advising system at Pima Community College in Tuczon, Arizona. I followed up with a call to Steven Ford (SMFORD@Pimacc.Pima.edu). Steven helped to write the front end program for their video advising system.
Access
in Seattle
Authors: Sherwood Marian
Published: November 2005

Jamestown Community College offers a two-course sequence in Microcomputer Applications through which our students gain an in-depth knowledge of PC-based word processing, spreadsheets, and database management. Throughout both courses, the integration of these packages is stressed. In the second course, the students are expected to design and build an application system for a small business that utilizes advanced features of each software package. The major focus of the second course is on database design and programming. Prior to the fall 1995 semester, both courses were taught using WordPerfect 6.0, Lotus 1-2-3 release 5, and dBASE 5.0. However Microsoft Office has come to dominate the PC office application market in our immediate and surrounding communities. Accordingly, we switched this fall to Microsoft Office for both courses.
A new approach for efficient implementation of ADA multi-tasking
Authors: Li Gansheng
Published: November 2005

A new approach to implement Ada multi-tasking with all tasks in a program sharing a single stack in running environment is presented. Compared with the approach of implementing a 'cactus' stack for Ada runtime memory management in which each task has its own stack but high overhead has to be paid for task context switching. The new approach presented in this paper saves runtime storage space and reduces the overhead for task context switching.
A new methodology of data dependence analysis for parallelizing C++
Authors: Genjiang Zhu , Li Xie , Zhongxiu Sun
Published: November 2005

This paper details parallelism detection in NUAPC[4], an automatically parallelizing compiler based on C++. Two kinds of parallelism, i.e. the inter- and intra-object parallelism, are introduced in NUAPC. The paper presents the method for seeking these parallelism based on the key structures
Conflict Set
and
Method Reference Vector
, and proposes a new theoretical formation for expressing and performing data dependence analysis in object-oriented program paradigm. Data dependence involving inherited data and function members are also discussed.
An approach to executable specifications, based on formal source_to_source conversion
Authors: Xinger Zhang
Published: November 2005

The paper proposes a new technique for executable specifications, which directly converts a specification into a program in a programming language by taking advantage of the idea of source_to_source conversion which is based on the rules defined formally and the canonical abstract syntax trees. The technique and the corresponding supporting system possess the following virtues: supporting rapid prototyping and getting the effects of prototypes well.
Efficient context-sensitive pointer analysis for C programs
Authors: Wilson Robert P. , Lam Monica S.
Published: November 2005

This paper proposes an efficient technique for context-sensitive pointer analysis that is applicable to real C programs. For efficiency, we summarize the effects of procedures using
partial transfer functions
. A partial transfer function (PTF) describes the behavior of a procedure assuming that certain alias relationships hold when it is called. We can reuse a PTF in many calling contexts as long as the aliases among the inputs to the procedure are the same. Our empirical results demonstrate that this technique is successful—a single PTF per procedure is usually sufficient to obtain completely context-sensitive results. Because many C programs use features such as type casts and pointer arithmetic to circumvent the high-level type system, our algorithm is based on a low-level representation of memory locations that safely handles all the features of C. We have implemented our algorithm in the SUIF compiler system and we show that it runs efficiently for a set of C benchmarks.
APT
Authors: Pingali Keshav , Bilardi Gianfranco
Published: November 2005

The
control dependence
relation is used extensively in restructuring compilers. This relation is usually represented using the
control dependence graph
; unfortunately, the size of this data structure can be quadratic in the size of the program, even for some structured programs. In this paper, we introduce a data structure called the
augmented post-dominator tree (APT)
which is constructed in space and time proportional to the size of the program, and which can answer control dependence queries in time proportional to the size of the output. Therefore,
APT
is an
optimal representation of control dependence
. We also show that using
APT
, we can compute SSA graphs, as well as sparse dataflow evaluator graphs, in time proportional to the size of the program. Finally, we put
APT
in perspective by showing that it can be viewed as a factored representation of control dependence graph in which
filtered search
is used to answer queries.
Efficient building and placing of gating functions
Authors: Tu Peng , Padua David
Published: November 2005

In this paper, we present an almost-linear time algorithm for constructing Gated Single Assignment (GSA), which is SSA augmented with gating functions at ø-nodes. The gating functions specify the control dependences for each reaching definition at a ø-node. We introduce a new concept of
gating path
, which is path in the control flow graph from the immediate dominator
u
of a node
v
to
v
, such that every node in the path is dominated by
u
. Previous algorithms start with ø-function placement, and then traverse the control flow graph to compute the gating functions. By formulating the problem into gating path construction, we are able to identify not only a ø-node, but also a gating path expression which defines a gating function for the ø-node.
Scheduling and mapping
Authors: Altman Erik R. , Govindarajan R. , Gao Guang R.
Published: November 2005

Recently, software pipelining methods based on an ILP (Integer Linear Programming) framework have been successfully applied to derive rate-optimal schedules for architectures involving clean pipelines - pipelines without structural hazards. The problem for architectures beyond such clean pipelines remains open. One challenge is how, under a unified ILP framework, to simultaneously represent resource constraints for unclean pipelines, and the assignment or mapping of operations from a loop to those pipelines. In this paper we provide a framework which does exactly this, and in addition constructs rate-optimal software pipelined schedules. The proposed formulation and a solution method have been implemented and tested on a set of 1006 loops taken from various scientific and integer benchmark suites. The formulation found a rate-optimal schedule for 75% of the loops, and required a median time of only 2 seconds per loop on a Sparc 10/30.
Improving balanced scheduling with compiler optimizations that increase instruction-level parallelism
Authors: Lo Jack L. , Eggers Susan J.
Published: November 2005

Traditional list schedulers order instructions based on an optimistic estimate of the load latency imposed by the hardware and therefore cannot respond to variations in memory latency caused by cache hits and misses on non-blocking architectures. In contrast, balanced scheduling schedules instructions based on an estimate of the amount of instruction-level parallelism in the program. By scheduling independent instructions behind loads based on what the program can provide, rather than what the implementation stipulates in the best case (i.e., a cache hit), balanced scheduling can hide variations in memory latencies more effectively.

Since its success depends on the amount of instruction-level parallelism in the code, balanced scheduling should perform even better when more parallelism is available. In this study, we combine balanced scheduling with three compiler optimizations that increase instruction-level parallelism: loop unrolling, trace scheduling and cache locality analysis. Using code generated for the DEC Alpha by the Multiflow compiler, we simulated a non-blocking processor architecture that closely models the Alpha 21164. Our results show that balanced scheduling benefits from all three optimizations, producing average speedups that range from 1.15 to 1.40, across the optimizations. More importantly, because of its ability to tolerate variations in load interlocks, it improves its advantage over traditional scheduling. Without the optimizations, balanced scheduled code is, on average, 1.05 times faster than that generated by a traditional scheduler; with them, its lead increases to 1.18.
Bits and bytes
Authors: Little Joyce Currie
Published: November 2005

REMEMBRANCE TO GRACE MURRAY HOPPER:
The U.S. Navy has paid great respect to Grace Murray Hopper, a real legend in the computing industry. They christened the guided missile destroyer
Hopper
(DDG 70) at the Bath Iron Works in Maine on January 6. Grace's sister, Mary Murray Westcote, was present at the ceremony as a sponsor.
Team projects in systems analysis and design
Authors: Brown Sandra , Nettnin Patricia
Published: November 2005

An integral part of the AAS degree in Computer Information Systems (CIS) is a course entitled
Systems Analysis and Design
. At Finger Lakes Community College, we have had great success with implementing a student team project approach to the course. The approach has been very effective in that it allows us to augment and reinforce an extensive amount of comprehensive material learned in the standard lecture and textbook. The approach also promotes team dynamics and group problem-solving skills that are desperately needed by the CIS graduate in the workplace. This paper discusses the advantages to student learning via the team approach in a Systems Analysis and Design course. The approach, logistics, activities, and benefits will be addressed.
A new wave in software certification
Authors: Reilly Virginia A.
Published: November 2005

In this day of heightened awareness in licensing, copyright infringement, and software piracy, the need for tools and guidance to "get legal" has been herd. The Software Publishers Association (SPA), the principal trade association of the PC software industry, has responded by creating two certification programs: the
Certified Software Manager
and the
World Wide Web Certification Program
. The
Certified Software Manager
is a new computer specialty that concentrates on copyright law, software audits, license compliance, piracy, and software asset management.
Professional certification through ICCP
Authors: Little Joyce Currie
Published: November 2005

This article deals with professional and entry-level certification through the examination programs of the Institute for Certification of Computing Professionals (ICCP). The material is organized by frequently-asked questions (FAQs).