bluuebunny/crossref_metadata_2025 huggingface dataset:
REUSING SOLUTIONS IN SOFTWARE DESIGN ACTIVITY
Authors: Dètienne Françoise
Published: January 2007

This study is on code reuse in the software design activity. The data analysed in this paper were collected in an experiment
1
aimed at studying the activity of design with an object-oriented programming (OOP) language (Détienne, 1990). Four professional programmers were given two problems to solve and code with an OOP language. The material consisted of two management problems; the task domain was familiar to the subjects. The environment was composed of a basic editor and the 0
2
system (0. Deux et al., 1989) which is an object-oriented data base system. We collected the subjects-verbalizations, successive versions of programs under development, notes written during the realization of the task, the order in which the different traces of the activity were made, i.e., the order for writing notes and for coding programs with the verbalization recorded simultaneously.
SCREEN, PHONE, AND VOICE USER INTERFACES
Authors: Halstead-Nussloch Richard , Jacobson Mary , Chuongvan Chan
Published: January 2007

Office principles often have multiple ways to complete typical tasks. For example, scheduling can be done on a paper calendar, electronically, by phone store-and-forward, etc. Each of the ways has unique user-interface characteristics and limitations, as well as a set of economic costs and benefits. We recently completed a study where 18 users compared traditional screen-based, phone-based, and voice-activated interfaces to calendar facilities. The voice-activated and phone-based user interfaces showed the highest level of usability among the comparison set, showing significantly smaller times to complete tasks and assistance requirements than screen-based facilities. With respect to preference 75% percent of the users prefered using a voice-activated or phone-based system for the typical calendaring task of signing out of the office, while only 5% stated a preference for a screen-based system.
INTEREST DRIVEN EXPLORATION OF AN INFORMATION SPACE
Authors: Slack J. M. , Conati C.
Published: January 2007

This study will develop a model of the implementation process based on empirical evidence gathered from participants in that process as that process unfolds over a 12- to 18-month period. Previous research in organizational behavior and technology in organizations indicates that implementation may be a cyclical process of mutual adjustments of the organization to the technology and the technology to the organization. As a technology is found by members of the organization to be difficult to use or inadequate for their use, the design of that technology might be altered to render it more useable and useful. And, as that changed technology is put into use, alterations to the organization's structure might be required to optimize its use. It is this process of mutual adaptation which will serve as the focal point of this investigation.
Abstracts of CHI'91 interactive posters and short talks
Authors: Egan Dennis E.
Published: January 2007

The CHI '91 Conference held in New Orleans, April 28th May 2nd, took on the goal of including more late-breaking technical information than had been possible at previous CHI Conferences. CHI '91 scheduled a late (mid-January) deadline for authors to propose Interactive Posters or Short Talks. These formats are designed for the presentation of technical information even before it is "hot off the press" and ready to be archived as a regular paper. Posters are particularly well suited to visual displays of a variety of projects recently completed or still in progress. The Interactive Poster format encourages conversation and informal interaction between Poster authors and conferees. Short Talks, a new format for the CHI Conferences, present late-breaking information as a 10-minute talk included in the technical program.
Concurrent organizational objects
Authors: de Jong Peter
Published: January 2007

A concurrent organizational object, called the Ubik Configurator, is described. This object generalizes the Actor model to provide support for the following collections of Actors:
organizations
- referenced collections,
Sponsors
- executing collections,
message sets
- mail queue collections, and
active messages
- cooperative behavior on collections of Actors.
Implementing actor-based primitives on distributed-memory architectures
Authors: Di Santo Michele , Iannello Giulio
Published: January 2007

We are engaged in a research aiming to implement, on a highly-parallel distributed-memory architecture, a set of primitives based on the actor model. In this paper, the motivations and a number of preliminary results of the project are reported. Discussion is focused on implementation issues. The overall software architecture of the distributed run-time kernel is presented. Solutions to mail address representation and to distributed collection of garbage actors are briefly described.
Constraints in concurrent object-oriented environments
Authors: Laffra Chris , van den Bos Jan
Published: January 2007

A
constraint
is a numeric or geometric relationship between objects. Constraints have a declarative nature. Constraints are a natural way for describing relationships between objects. Combining constraint systems and object-oriented programming (OOP) appears hard. All existing systems implicitly compromise the encapsulation principle of OOP. This paper proposes a mechanism that provides for constraints in an object-oriented environment. Constraints are triggered by messages that are being sent to objects. Constraints are resolved through local propagation of known state. We claim that this is the most practical technique in a concurrent or parallel object environment. No compromise has been made to the OOP paradigm. Therefore a truly object-oriented approach to constraint programming is the result.
ObjVProlog-D: a reflexive object-oriented logic language for distributed computing
Authors: Malenfant J. , Lapalme G. , Vaucher J.
Published: January 2007

The ObjVProlog-D programming language extends logic programming with concepts of object-oriented and distributed programming, providing a semantically complete and coherent model inspired by ObjV-Lisp where metaclasses are treated as first-class entities. It is based on concurrent logic objects interacting through remote logic method calls. It preserves the Prolog don't know nondeterminism by implementing distributed backtracking to search for all solutions to goals. It uses asynchronous messages for communication and future logic variables for synchronization. Furthermore, its metaclass and reflexive features improve significantly the use of widespread metaprogramming techniques. ObjVProlog-D is implemented in Quintus Prolog and distributed applications have run on a network of workstations.
Actra—an industrial strength concurrent object-oriented programming system
Authors: McAffer Jeff , Duimovich John
Published: January 2007

There have been several proposals for Concurrent Object-Oriented Programming Systems (COOPS) [Agha, Wegner and Yonezawa 89]. Unfortunately, most of these proposals are not powerful enough to be used outside the laboratory, that is, they are not
industrial strength.
Rewriting as a unified model of concurrency
Authors: Meseguer José
Published: January 2007

The lecture given at the workshop was based on recent work published elsewhere [9, 10, 8, 7]. This abstract gives a brief description of the main results and ideas presented in that work, but does not provide any technical details; such details can be found in the papers mentioned above.
MELDing transactions and objects
Authors: Popovich Steven S. , Kaiser Gail E. , Wu Shyhtsun F.
Published: January 2007

MELD is an experimental object system under development at Columbia University. The object-oriented programming language supports classes, strong typing of instance variables, active values, multiple inheritance, and separate compilation of modular units called
features
that bundle together related classes and objects. These facilities were developed for an early version of MELD [3, 4], without persistence, concurrency or distribution.
The impact of selected concurrent language constructs on the Sam run-time system
Authors: Prelle Myra Jean , Wollrath Ann M. , Brando Thomas J. , Bensley Edward H.
Published: January 2007

We present an overview of a model of execution for concurrent object-oriented general-purpose computation, and a run-time system---SAM---that supports the model of execution. The basic model, which is transparent to the programmer, uses data-driven synchronization and speculative computation to obtain concurrency, and rollback to ensure correctness. We discuss extensions to the basic model that include two new kinds of objects, multifutures and guarded objects, and language constructs such as parallel-do and divide-and-conquer, as well as other constructs that allow the programmer to control how futures are processed. While all of these extensions appear useful, some can be integrated more naturally than others into the model of execution.
A concurrent object-oriented framework for the simulation of neural networks
Authors: Weitzenfeld A. , Arbib Michael A.
Published: January 2007

This paper discusses the issues in simulating neural networks using an object-oriented concurrent programming framework, based on our experience in developing two generations of the NSL (Neural Simulation Language) simulation system. The second generation simulation system, NSL 2.0, was designed and implemented utilizing object-oriented programming concepts. We close with future design and implementation directions.
A polynomial factorization challenge
Authors: von zur Gathen Joachim
Published: January 2007

In the early 1970s, a major paradigm shift took place in algorithms research, away from experimental results to asymptotic analysis. Knuth popularized the "Big O" notation, and Hopcroft says in his 1986 ACM Turing Award (with Robert Tarjan) address: "During the 1960s, research on algorithms had been very unsatisfying. A researcher would publish an algorithm in a journal along with execution times for a small set of sample problems, and then several years later, a second researcher would give an improved algorithm along with execution times for the same set of sample problems. The new algorithm would invariably be faster, since in the intervening years, both computer performance and programming languages had improved. The fact that the algorithms were run on different computers and programmed in different languages made me uncomfortable with the comparison. It was difficult to factor out both the effects of increased computer performance and the programming skills of the implementors---to discover the effects due to the new algorithm as opposed to its implementation. Furthermore, it was possible that the second researcher had inadvertently tuned his or her algorithm to the sample problems ... I set out to demonstrate that a theory of algorithm design based on worst-case asymptotic performance could be a valuable aid to the practitioner."
An overview of High Performance Fortran
Authors: Koelbel Charles
Published: January 2007

Since its introduction over three decades ago, Fortran has been the language of choice for scientific programming for sequential computers. Exploiting the full capability of modern architectures, however, increasingly requires more information than ordinary Fortran 77 or Fortran 90 programs provide. This information applies to such areas as• Opportunities for parallel execution• Type of available parallelism - MIMD, SIMD, or some combination• Allocation of data among individual processor memories• Placement of data within a single processor
Well … it isn't quite that simple
Authors: Corless Robert M. , Jeffrey David J.
Published: January 2007

Present computer algebra systems base their interactive sessions on a very simple model of mathematical discourse. The user's input to the system is a line containing a mathematical expression (an operation, a formula, a set of equations, etc) and the system's response to the user is an output line which contains a mathematical expression similar to the input. There are many situations, however, in which this is too simple a model of mathematics. Algebra systems should be allowed to reply 'Well ... it isn't quite that simple'.
Object oriented graphics in APL2
Authors: Alfonseca Manuel
Published: January 2007

The paper describes a general and extensive graphic system in two or three dimensions, built in APL2 by means of the object-oriented programming paradigm. The system fully demonstrates the appropriateness of the language to develop real-life applications using the most advanced techniques of computer science.
Globally convergent polynomial iterative zero-finding using APL
Authors: Chen Tien Chi
Published: January 2007

We report the APL study of a global iteration theory for polynomial zero-finding, with the potential to converge from almost any point in the complex plane, as distinguished from classical, “neighborhood” theory requiring the starting guess to be close to the zero being sought. The iteration functions studied involve the function and its first two derivatives, evaluated at the guess Z
k
.

Using the symmetric cluster as a reference, we discovered Newton's method to be unsuitable, and the multiplicity-adjusted Laguerre formula deficient. But a new formula converges to symetric cluster zeros in just one iteration excepting for roundoff error, possesses cubic neighborhood convergence, and appears reliable for general polynomials. Roundoff errors are reduced through reasonable starting guesses. Reboundingby subclusters, a major cause of nonconvergence is resolved by a local polynomial approach. Most polynomials tested converge within a dozen iterations.
The CTalk programming language
Authors: Girardot Jean-Jacques
Published: January 2007

This document presents
CTalk
, which is a new programming language quite different from APL itself. CTalk is an attempt to combine the “best” features of APL, but also of other languages such as Lisp [9], and offer a language that looks “satisfactory” according to the criteria of the mainstream of computer science.

The most important features of CTalk are its syntax, which is very close to the one of the C programming language, the adoption of fundamental concepts that were missing in APL, such as lexical binding, but also the integration of a wide range of array operations that are borrowed from APL.

It is shown here that CTalk can be implemented more simply and more efficiently than APL, while keeping all the power of APL operations, and being an acceptable alternative to APL itself.
Left to its own devices, APL plots on the bus
Authors: Jones Curtis A.
Published: January 2007

The IEEE-488 General-Purpose Interface Bus is a convenient vehicle through which APL can run a variety of devices and computers. This paper shows how a PC can be used with APL as a device on the bus, in contrast to the PC's more usual role as system controller. As an example, an APL workspace that emulates an
x-y
plotter attached to the GPIB is shown. This illustrates the GPIB providing input to an APL workspace, and techniques by which APL can report the status of the device.
Cannibals and missionaries
Authors: Lim Ruby
Published: January 2007

This paper describes the game of Cannibals and Missionaries modelled using APL68000. It constitutes the original version of a student project report for a fourth-year mathematics course titled “Operations Research Modelling”.
Porting APL-programs via ASCII-transliteration
Authors: Mitlöhner Johann
Published: January 2007

A scheme for translating APL characters to ASCII text is introduced, and an APL application is developed which reads and writes objects to and from files using the scheme. The system is available freely for several APL dialects; it can be used to port APL applications across different environments. The translation scheme used is proposed as a standard for the ASCII representation of APL characters, and feedback on this scheme is invited.
Challenging the mathematics curriculum
Authors: Spunde Walter G.
Published: January 2007

Ready access to computing power through APL opens new avenues for mathematical experimentation and new strategies for developing concepts in the teaching of basic engineering mathematics. It is argued that the effective use of APL implies re-structuring of the curriculum and a revision of examination procedures.
WSDM
Authors: Surkan Alvin J.
Published: January 2007

A functional style application of APL notation succinctly describes the architecture and principles of operation of one kind of connection-based computer. In the future it is expected that these machines will have thousands of processors and large arrays of dynamic connections. APL programs running on von Neumann computers now provide precise descriptions of connection-based machines which are convenient for exploring the potential of connection-based computation. Experience with radically new structures and different principles of operation for neural network problem solving can be obtained using virtual machines provided by software. Virtual machines are described by functions programmed on conventional computers.

Two adaptive variants of the sparse distributed memory or SDM (Kanerva [1991]) show improved efficiency. The demonstrated superiority of Kanerva's new pattern weighting idea can be obtained by improved coding of the input patterns. This coding is done by generally defined preprocessing of features of representative binary input patterns. Transformed input patterns select addresses which pack distributed memories more efficiently.

Coding is done by first computing customized weight vectors for each input pattern vector. Individual weighting of each pattern leads to more uniform utilization of the addresses and their corresponding memory connection weights. The derived pattern weights improve discrimination between pairs of similar inputs with few significant differences. This paper is to provide the APL community access to a concise symbolic description of Kanerva's weighted SDM machine. APL's rich set of computer modeling and exposition tools have the potential of markedly accelerating software and hardware development for array-base connectionist computing.
Some proposals for APL2 specification of statistical algorithms
Authors: Thompson Norman
Published: January 2007

Software engineers use specification languages to allow programmers to reason about programs and their correctness at any level of detail. The APL2 language and its data structures have some striking affinities with the apparatus needed to specify statistical algorithms and it seems reasonable to exploit these by defining a common standard, the adoption of which will greatly enhance the ability of statisticians to communicate algorithms both amongst themselves and in the world at large. This paper proposes some rules and conventions which might form the basis of such a standard and illustrates where there are particularly happy marriages between the requirements of specification of statistical algorithms and the language characteristics of APL2.
Performance analysis of dynamic finite versioning for concurrent transaction and query processing
Authors: Merchant Arif , Wu Kun-Lung , Yu Philip S. , Chen Ming-Syan
Published: January 2007

In this paper, we analyze the performance of dynamic finite versioning (DFV) schemes for concurrent transaction and query processing, where a finite number of consistent snapshots can be derived for query access. We develop analytical models based on a renewal process approximation to evaluate the performance of DFV using
M
≥ 2 snapshots. The storage overhead and obsolescence faced by queries are measured. Simulation is used to validate the analytical models and to evaluate the trade-offs between various starategies for advancing snapshots when
M
> 2.

The results show that (1) the analytical models match closely with simulation; 2) both the storage overhead and obsolescence are sensitive to the snapshot-advancing strategies, especially for
M
> 2 snapshots; and (3) generally speaking, increasing the number of snapshots demonstrates a trade-off between storage overhead and query obsolescence. For cases with skewed access or low update rates, a moderate increase in the number of snapshots beyond 2 can substantially reduce the obsolescence, while the storage overhead may increase only slightly, or even decrease in some cases. Moreover, for very low update rates, a large number of snapshots demonstrates a trade-off between storage overhead and query obsolescence. For cases with skewed access or low update rates, a moderate increase in the number of snapshots beyond 2 can substantially reduce the obsolescence, while the storage overhead may increase only slightly, or even decrease in some cases. Moreover, for very low update rates, a large number of snapshots can be used to reduce the obsolescence to almost zero without increasing the storage overhead.
Factors in the performance of the AN1 computer network
Authors: Owicki Susan S. , Karlin Anna R.
Published: January 2007

AN1 (formerly known as Autonet) is a local area network composed of crossbar switches interconnected by 100Mbit/second, full-duplex links. In this paper, we evaluate the performance impact of certain choices in the AN1 design. These include the use of FIFO input buffering in the crossbar switch, the deadlock-avoidance mechanism, cut-through routing, back-pressure for flow control, and multi-path routing. AN1's performance goals were to provide low latency and high bandwidth in a lightly loaded network. In this it is successful. Under heavy load, the most serious impediment to good performance is the use of FIFO input buffers. The deadlock-avoidance technique has an adverse effect on the performance of some topologies, but it seems to be the best alternative, given the goals and constraints of the AN1 design. Cut-through switching performs well relative to store-and-forward switching, even under heavy load. Back-pressure deals adequately with congestion in a lightly-loaded network; under moderate load, performance is acceptable when coupled with end-to-end flow control for bursts. Multi-path routing successfully exploits redundant paths between hosts to improve performance in the face of congestion.
Performance comparison of routing protocols using MaRS
Authors: Shankar A. Udaya , Alaettinoğlu Cengiz , Matta Ibrahim , Dussa-Zieger Klaudia
Published: January 2007

There are two approaches to adaptive routing protocols for wide-area store-and-forward networks: distance-vector and link-state. Distance-vector algorithms use
O(N x e)
storage at each node, whereas link-state algorithms use

O(N
2
)

, where
N
is the number of nodes in the network and
e
is the average degree of a node. The ARPANET started with a distance-vector algorithm (Distributed Bellman-Ford), but because of long-lived loops, changed to a link-state algorithm (SPF). We show, using a recently developed network simulator, MaRS, that a newly proposed distance-vector algorithm (ExBF) performs as well as SPF. This suggests that distance-vector algorithms are appropriate for very large wide-area networks.
Scheduling parallelizable tasks
Authors: Turek John , Wolf Joel L. , Pattipati Krishna R. , Yu Philip S.
Published: January 2007

In this paper we formulate the following natural multiprocessor scheduling problem: Consider a parallel system with
P
processors. Suppose that there are
N
tasks to be scheduled on this system, and that the execution time of each task
j
ε {1,…,
N
} is a nonincreasing function

t
j
(β
j
)

of the number of processors

β
j

ε {1,…,
P
} allotted to it. The goal is to find, for each task
j
, an allotment of processors

β
j

, and, overall, a schedule assigning the tasks to the processors which minimizes the makespan, or latest task completion time. The so-called shelf strategy is commonly used for orthogonal rectangle packing, a related and classic optimization problem. The prime difference between the orthogonal rectangle problem and our own is that in our case the rectangles are, in some sense, malleable: The height of each rectangle is a nonincreasing function of its width. In this paper, we solve our multiprocessor scheduling problem exactly in the context of a shelf-based paradigm. The algorithm we give uses techniques from resource allocation theory and employs a variety of other combinatorial optimization techniques.
Performance analysis of communications in static interconnection networks
Authors: Meliksetian Dikran S. , Chen C. Y. Roger
Published: January 2007

We present a model, based on a network of

D
X
/D/1

queues, to predict the communication performance of static interconnection networks under various communication patterns. Our model predicts delay time distributions in the links as well as the first and second moments of the overall delay time of messages in the system. These predictions are verified by the results of simulations.
Temporal reasoning in Timegraph I–II
Authors: Gerevini Alfonso , Schubert Lenhart , Schaeffer Stephanie
Published: January 2007

We describe two temporal reasoning systems called Timegraph I and II, which can efficiently manage large sets of relations in the Point Algebra as well as metric information. Our representation is based on
timegraphs,
graphs partitioned into a set of chains on which the search is supported by a metagraph data structure. Timegraph I was originally developed by Taugher, Schubert and Miller in the context of story comprehension. Timegraph II provides useful extensions which makes the system more expressive in the representation of qualitative information and suitable for a larger class of applications. Experimental results show that our approach is very efficient, especially when the given relations admit representation as a collection of chains connected by relatively few cross-chain links.
Skills needed by user-centered design practitioners in real software development environments
Authors: Dayton Tom
Published: January 2007

User-centered design (UCD) of human-computer interfaces--including task flow and documentation---is gaining acceptance in software development organizations. But managers who want their organizations to start using UCD often do not know what characteristics to look for, in candidates for hiring or retraining to fill UCD roles; this article can help. It has the recommendations from participants in a CHI '92 conference workshop on this topic. The 16 workshop participants were UCD practitioners and managers from companies and a few universities across the United States, Canada, and Sweden. This article first describes some typical roles of UCD practitioners in software development organizations. There follows a list of attributes that UCD practitioners should have. Some attributes should be had by
all
practitioners, regardless of their subspecialties. The most important of those universal attributes are of three types: knowledge that can be acquired formally (e.g., of the human-computer interaction literature, cognitive processes, experimental design, rapid prototyping), skill that can be gotten from experience (e.g., estimating resources needed to do a job, commitment to users, understanding of the software development process, negotiating ability, enjoyment of working on teams, ability to really listen), and attributes that are harder to acquire (e.g., tenacity, flexibility). Every practitioner needs other characteristics as well, but their importances differ by the practitioners' subspecialties (e.g., a design team leader needs team management skills).
Report on the 1992 East-West international conference on human computer interaction
Authors: Grudin Jonathan , MacLean Allan , Overmyer Scott
Published: January 2007

The East-West International Conference on Human-Computer Interaction was held August 4--8, 1992 in St. Petersburg, Russia. The second conference in an annual series, it brought together researchers from the former USSR, Europe, the United States, Japan, and Australia. At the time of the 1991 conference, the USSR was still intact (by about two weeks). By 1992 it had become the Commonwealth of Independent States and the Baltic Republics (henceforth CIS/Baltic). The conference committee settled on the more stable (if not entirely accurate) designation "East-West" to characterize the communities that came together.
TEXT EDITING PERFORMANCE AS A FUNCTION OF TRAINING WITH COMMAND TERMS OF DIFFERING LENGTHS AND FREQUENCIES
Authors: Gunther Virginia A. L. , Burns Daniel J. , Payne David G.
Published: January 2007

There has been considerable controversy recently concerning the characteristics of computer command terms that affect the ease with which naive users acquire and learn to use these terms. Researchers have examined command words in terms of their "naturalness," semantic relation to the command function, specificity and/or obliqueness (as measured by users, designers and/ or experimenters), to name a few. (For illustrative research examples and a review of this literature, see Grudin and Barnard, 1984, Landauer, Galotti, and Hartwell, 1983, and Landauer and Galotti, 1984.) On the positive side, this research has helped bring into focus the need to consider how selection of command terms affects users' performance. On the negative side, however, there seems to be little agreement as to which, if any, of these factors really affects performance levels. This research was conducted to add to the empirical data base and to examine whether the findings from basic research on human memory can be used to predict performance in a real-world text editing task.
MENU STRUCTURE AND ORDERING OF MENU SELECTION
Authors: Schultz E. Eugene , Curran Patrick S.
Published: January 2007

The breadth/depth trade-off in menu structure refers to advantages and disadvantages of menu breadth (having fewer levels/pages of menu selections with more selections per level) and depth (having more levels/pages with fewer selections per level). Several studies (Snowberry, Parkinson & Sisson, 1983; Landauer & Nachbar, 1985) demonstrate enhanced user performance with increased breadth. However, other studies (Miller, 1981; Kiger, 1984; Tullis, 1985) fail to show an advantage in user performance with increased depth. Complicating the breadth/depth issue is the issue of the ordering of selections within each menu level. Snowberry et al. found superiority of breadth only with consistent ordering of selections within levels. Card (1982) reported that alphabetical ordering of selections is superior to functional ("logical") ordering, which in turn is superior to random ordering.
Usability inspection methods
Authors: Mack Robert , Nielsen Jakob
Published: January 2007

Usability inspection methods, based on informed intuition s about interface design quality, hold promise of providing faster, more cost-effective ways to generate usability evaluations, compared to empirical user evaluation methods . Examples of inspection methods include heuristic evaluation (Nielsen & Molich, 1990), usability walkthroughs (Bias, 1991 ; Karat & Bennett, 1991a, 1991b), cognitive walk -throughs (Lewis, Polson, Wharton & Reiman, 1990), and applications of guidelines in walkthroughs (Jeffries, Miller, Wharton, & Uyeda, 1991). These methods have been used in development for some time in one form or another (perhap s by other names), often because there is simply no alternative like user testing. Usability inspection methods have been an object of research in the last two years or so . Progress has been made in refining methods, and understanding their role i n usability engineering.
The OO software development process (abstract)
Authors: de Champeaux Dennis
Published: January 2007

A 92 Vancouver, British Columbia, Canada 5 - 10 October 1992
Addendum to the Proceedings Panel Report- The 00 Software
Development Process Report by: Dennis de Champeaux HP-Labs Members
of the panel Dermis de Champeaux, HP-Lab, moderator Bob Balzer,
Information Sciences Institute Dave Bulman, Pragmatics Kathleen
Culver-Lozo, AT&T Bell Laboratories Ivar Jacobson, Objectory
Stephen J. Mellor, Project Technology Pankaj Garg, HP-Lab,
co-organizer of the panel Aim of the panel Improving development
processes is a key issue for the software community in general. The
literature gives us some guidance with respect to major activities
of the development process. The waterfall, spiral and fountain
model all agree upon distinctions such as: requirements capture,
analysis, design, implementation, testing, maintenance. They also
agree in that they do not provide a finer granularity of the inside
activities of analysis and design. We postulate that this omission
is a key inhibitor to a more widespread acceptance of the 00
paradigm by project managers. They do not know how to plan a
non-trivial 00 software development project. The purpose of this
panel was to take the first steps towards developing such process
models. More 5-10 October 1992 -61- specifically the panelists have
been asked to address the following questions (among others): . Can
you envision a generic OOA/ OOD development process? If so what are
the major steps and deliverables of these steps. If not, why not? l
If a software development organization had to choose between either
doing a paradigm shift to 00, or improving its rating on the SE1
maturity scale what would you recommend? What are the relationships
between the two? Qualify, if necessary, the answer with respect to
an extant maturity level. It turned out that these, and the other
questions, were quite hard for the panellists. Hence, we envision a
follow on panel in the future where these topics will be raised
again. In addition to this panel, I organized in 1992, workshops on
00 process: one at ECOOP and one also at OOPSLA. All the events had
in common that the presenterslpanelists had hardly anything to say
about process. The most tangible contributions were modest
extensions of the standard macro process: requirements capture,
analysis, design, implementation, test, maintenance, enhanced, of
course, by the recommendation to iterate. Addendum to the
Proceedings Hence, although the panel had lively exchanges, I
refrain from giving the details because I do not feel that the
state of the art was advanced. Instead I would like to point the
reader to a report that proposes some details on the 00 analysis
and design process: Dennis de Champeaux, Towards an 00 SW
Development Process, HP-Labs Tech Report HPL-92-149, November 1992.
[The contributors Doug Lea, Penelope Faure, and Mohammed Fayad
could not be listed as authors for legal reasons.] For a copy
contact: HP-Labs/ Technical Publications Dept./ 1501 Page Mill Rd
Palo Alto, CA 94304 (415) 857 4573 OOPSLA92 -62 - Vancouver,
British Columbia
Iterative development/OO
Authors: Coplien J. O. , Hutz Susana , Marykuca Brent
Published: January 2007

A combined workshop drawing on the faculties of the established “The Bottom Line: Using Object-Oriented Development in the Commercial Environment” workshop and the new “Development Processes for Use of the Object Paradigm” covered issues of process, architecture, and tool support for iterative development. Keynote talks described:

Discussion on architecture, tools and reuse, and management techniques followed. Key areas of consensus included the multidimensionality of architecture, the inadequacy of class models alone to encapsulate change, the importance of tool support, and the need for local standards such as “software backplanes.”
An object-oriented environment for specification and concurrent execution of genetic algorithms
Authors: Lemarchand L. , Plantec A. , Pottier B. , Zanati S.
Published: January 2007

Genetic algorithms (GA) mimic natural reproduction to search for complex problem solutions. Their principles are shortly explained. A point of interest is the regular and repetititve structure of computation involving communication, data exchanges, and control phases. Interaction with presentation and analysis tools is also a requirement. This make sense for the definition of a general framework allowing fast building of parallel applications in an object-oriented system. A GA workbench is developed using the Smalltalk-80 system with parallel machine code generation in mind.
Integration of different system engineering methods using an object-oriented model
Authors: Clausen Horst D. , Hofmann Anton , Pawlitzek Gabriele H.
Published: January 2007

The development of large, complex systems consisting of both hardware and software normally involves several companies and/or development teams for the development of the different subsystems forming the entire system. Depending on the kind of subsystem to be developed, these different development teams normally use different system engineering methodologies and/or tool sets to produce their subsystems. However, the usage of different methodologies and tools makes technical management and quality assurance for the entire development effort a difficult task. Therefore the development as well as the maintenance of future systems with their increasing size and complexity requires a common frame for the entire system development and maintenance effort covering different kinds of subsystems, like graphical user interfaces, database systems, expert systems, real-time systems, and so on. This common frame should support the separate and independent development of the different subsystems by different subcontractors using different system engineering methods, the integration of these subsystems to the entire system as well as the maintenance of the entire system. A hierarchical object-oriented model for the encapsulation and integration of different system engineering methods can serve as this common frame, providing traceability from the system requirements model to the implemented system while giving each subsystem development team full scope in choosing the system engineering method most suitable for a specific subsystem. The approach underlying this object-oriented model is the encapsulation of the different subsystems in “high-level objects,” which can be either further decomposed into “high-level object” or described in more detail using any appropriate system engineering method. The integration of these “high-level objects” to the entire system is supported by a “definition object” on each layer of each system engineering models and the different “high-level objects.”
Operations and collections; some architectural choices
Authors: Desmond L. , Anderson D. B.
Published: January 2007

We want to talk about the importance of low-level software architectures and how to use them. In order to do this we look at the example of carrying out operations on elements in a collection. We look at the possible solutions and the properties of each of these solutions.
Types for the working programmer (abstract)
Authors: Black Andrew
Published: January 2007

There has been recent progress in understanding types for object-oriented languages, but most of it has had little or no impact on real programmers. This tutorial aims to extract from the confusion those topics that are important to programmers who must use or choose an object-oriented language. The tutorial explains the role of types in object-oriented languages, what types can do for programmers, and how the trend towards distributed and heterogeneous systems and object-oriented databases influences what it means for a program to be type-correct.

The tutorial describes the difference between objects and values, what types are and why they are good for you, what refinement and subtyping are, what problems they solve, and what problems they do not; why contravariance isnt an unnatural act; why inheritance is a relationship between programs, not between classes.

By the end of the tutorial, you will understand how abstract concepts like subtyping can help you solve practical problems such as deciding when one piece of code can be substituted for another.
Advanced CLOS and meta-object protocols (abstract)
Authors: White Jon L.
Published: January 2007

One of the important characteristics of CLOS is its dynamic flexibility to change descriptions, programs, and even data objects on the fly. A typical CLOS system is implemented by a set of meta-objects, which can be changed by the programmer, essentially letting you create a new language. Thus, CLOS is a reflective programming language.

The main purpose of this tutorial is to teach you how to put a meta-object protocol to a practical use. In addition to describing the implementation of a typical CLOS system and discussing the various issues raised by the book Art of the Meta-Object Protocol, it gives practical examples of meta-object extensions including techniques for making user-defined metaclasses, for making alternations to SLOT-VALUE so that certain slots can be persistent, and for making metaclasses whose classes automatically keep a table of all their instances.

The tutorial is aimed at the CLOS programmer or the programming language expert who would like to learn more about reflective programming using a meta-object protocol. The emphasis is on practical uses of a meta-object protocol, not on the philosophy of reflection.
Introduction to object-oriented database management systems (abstract)
Authors: Maier David
Published: January 2007

This tutorial begins by explaining object-oriented database management systems (OODBMS) in terms of what is the value added beyond record-oriented database systems and object-oriented programming languages. It presents most of the current commercial OODBMS and several advanced prototypes with particular attention to distinguishing them in their data models, application interfaces and system architectures. It will also contrast the OODBMS approach with extended relational systems. A goal of the tutorial is to give participants an appreciation for the consequences of design choices made in the different systems. It concludes with a critique of current market offerings, and suggests there are significant regions of the design space to explore, and needs of advanced applications that are still largely unmet by any database product.

This tutorial is designed both for those considering investing in OODBs and those who just want to understand the technology. It assumes knowledge of object-oriented programming concepts, and some familiarity with conventional database systems, particularly relational databases.
Evaluating reusable class libraries (abstract)
Authors: Korson Timothy
Published: January 2007

Object-oriented technology not only affects the way we design individual applications, it holds the potential of ushering in the software industrial revolution. A key to the success of object technology is the widespread availability of high quality class libraries. These class libraries are the re-usable parts of the software industry.

This tutorial teaches how to evaluate object-oriented libraries. The same criteria can be used for selecting commercial libraries or for designing libraries for use in-house. The tutorial also describes practical criteria for specifying and cataloging in-house corporate software libraries. In addition to these technical criteria, the tutorial also shows you the corporate infrastructure that is necessary for enabling large scale reuse.
Object engineering (abstract)
Authors: Ballard R. Stonewall
Published: January 2007

Converting an object-oriented design into class definitions in an object-oriented language often requires many engineering decisions. It is easy to make these decisions incorrectly for languages that give the programmer a lot of control over data representation, such as C++. This tutorial covers low-level issues in building extensible and evolvable programs, issues that are important if you want to build well-balanced abstractions. It describes how to use multiple inheritance properly in spite of the compiler, when to use forwarding instead of inheritance, how to encapsulate state, and when to use references instead of copying objects.

This tutorial teaches how to convert object-oriented designs into code that is easy to extend and reuse. Many of the issues are more interesting to C++ programmers than Smalltalk programmers, and C++ is the language used for examples, but most of the issues are language independent.
Teaching object-oriented programming and design (abstract)
Authors: McKim James C.
Published: January 2007

A course in object-oriented programming and design oriented paradigm, namely that it promotes reuse, should address the claims made for the object- models the problem space, facilitates maintenance, incorporates changes easily, and shortens the development lifecycle. One way (perhaps the only way) for students to test such claims is to build a small but high quality product as part of the course.

This tutorial shows how to have students in a conventional computer science program build such a product, and addresses such issues as how to pick good projects, whether and how students should work together in teams, how to keep students on schedule, and how to divide a project into a sequence of deliverables within the context of a one semester course.

The tutorial also describes how to scale back the approach so that students in short courses, common in industry, can get maximum benefit in the limited time that is allowed.
A case study of domain analysis
Authors: Fowler Martin , Cairns Thomas
Published: January 2007

Three years ago the UK National Health Service decided to develop a generic model to describe all aspects of its management and operation. Several projects were launched to describe the health care process using the object-oriented modeling technique Ptech (now published by James Martin and Jim Odell). One of these projects, the Cosmos project, produced the Cosmos Clinical Process Model (or CCPM), which describes the medical record. The CCPM contains approximately 70 object types in a highly abstract structure describing clinical procedures, observations, evidence and assessment, accountabilities and contracts, care planning, and clinical knowledge. The model has gained widespread interest in both the UK and Europe and will be used as the focus for a number of EEC sponsored projects, and is taking a leading standardization role in Europe.

The CCPM is an example of the result of domain analysis. Its use of abstractions, some of which are applicable outside health care, and its use of an operational/knowledge divide can guide those working on large-scale generic models in other areas. The tutorial describes the relationship between generic and specific models since these issues are key in the acceptance of a highly generic application area model by those with specific applications to develop. The question of adapting an object-oriented method for particular needs is also addressed.
The analysis and design of distributed systems (abstract)
Authors: Aksit Mehmet
Published: January 2007

The design of distributed object-oriented systems involves a number of considerations that rarely arise in sequential object-oriented design or in non-object-oriented languages. The tutorial describes analysis and design techniques for data abstraction, inheritance, delegation, persistence, atomicity, concurrency, synchronization, and coordinated behavior in a distributed object-oriented framework. Special attention will be paid to the uniform integration of these concepts with the object-oriented paradigm. Discussions will be accompanied by examples that arose from constructing such systems.
Constraint-based languages and systems (abstract)
Authors: Freeman-Benson Bjorn , Boming Alan
Published: January 2007

A constraint is a relation that should be satisfied, for example, that a line remain horizontal, that a resistor in an electrical circuit simulation obey Ohms Law, or that the height of a bar in a bar chart be proportional to some number in an application program. Constraints have been used in a variety of languages and systems, particularly in user interface tool kits, in planning and scheduling, and in simulation. They provide an intuitive declarative style of programming that integrates well with object-oriented systems.

This tutorial teaches what constraints are, how to use them in applications such as user interfaces, how to implement them (including how to implement constraint hierarchies), and how to embed them in object-oriented and logic programming languages. You dont have to know anything about constraints, but it would be helpful to have a strong background in programming languages.