the heart of object-oriented concurrent programming  concurrency has been with us almost from the beginning of computing. managing and programming for concurrency is a difficult problem and various solutions have been suggested over the years. debates on message passing vs. remote procedure call, synchronous vs. asynchronous message passing, bounded vs. unbounded buffers, active vs. passive objects etc. still continue. no solution is entirely satisfactory. concurrent programming usually depends heavily on the nature of the problem at hand and the architecture of the target machine.  object-oriented programming brings new hope for a better solution for concurrent programming. it offers the potential of hiding the details of concurrency in high-level abstractions and using the modularity imposed by an object-oriented design to model the locality that is so important in distributed systems. however, much work in the area simply continues the debates mentioned above or investigates language design or extensions to existing languages. although it is important to select a good set of primitives for concurrent programming, the exact set that is used will not fundamentally alter the nature of the concurrent programming problem. continuing the above mentioned debate and trying out different combinations is unlikely to result in a major improvement.  these debates have very little to do with object-oriented programming. designing features for concurrency in oop languages is not much different from that of other kinds of languages---concurrency is orthogonal to oop at the lowest levels of abstraction. oop or not, all the traditional problems in concurrent programming still remain. however, at the highest levels of abstraction, oop can alleviate the concurrency problem for the majority of programmers by hiding the concurrency inside reusable abstractions.  the real issue in object-oriented concurrent programming is not how to introduce concurrency to oop but what oop brings to concurrent programming. the essence of oop is reusable abstractions. for example, the main contribution of oop to user interface design is that it allows a programmer to ignore i/o details and to focus on the high-level design of the user interface. in the same way, application programmers will not have to be experts in concurrent programming if they can reuse implementations of abstractions that encapsulate low-level details like partitioning, communication, and synchronization.  most programmers do not want to write concurrent programs, they just want to write programs that work and that are fast. concurrency is necessary both in real-time programming and in programming parallel computers. however, most programmers would prefer to program at a high enough level that they avoid having to be concerned with the low-level details of concurrency. obviously, someone must discover these high- level abstractions and implement them. but the majority of programmers will be free from the low-level details of concurrent programming and can concentrate on the high-level issues of designing algorithms.  work on data-parallel programming has resulted in a number of useful abstractions. the connection machine has spawned a number of them[1]. the paralation model[2] represents a collection of objects as a single entity. a programmer can specify the locality among constituent objects. paralations make good building blocks for the data parallelism style of programming. the concurrent data structures of william dally[3] also addresses data parallelism and is one of the few attempts we have seen at designing abstractions that use other kinds of parallelism, as well. however, most people working in the area of object- oriented concurrent programming rarely describe high-level abstractions.  the goal of our research is to discover a set of reusable abstractions that encapsulate the details of concurrency. for this scheme to be effective, the users of abstractions must not worry about synchronization among concurrent processes. the architecture of the target machine should be as transparent as possible. abstractions should be reusable in many applications.  it may not be possible to fully realize all our goals. some data abstractions are much easier to implement on some architectures than on others, so the target architecture will probably always have an influence on some applications. we may not discover a complete set of abstractions that cover every application. however, no software library is sufficient for every task; a library is enough if it helps solve a large fraction of our problems. even if different target architectures require different high-level abstractions to achieve the greatest performance, we will consider a library to be successful if the complexity of concurrent programming is confined to a few well defined places so that it can be easily managed and adapted to changing environments.  we are working with smalltalk-80 to find reusable abstractions in concurrent programming. smalltalk-80 provides an ideal environment for discovering abstractions, for organizing them, and for experimenting with them. one natural place to look for concurrency is the collection of data objects. smalltalk-80 includes two such classes, collection and stream. data parallelism is provided by subclasses of collection with concurrent implementations of the 'enumerating' protocol. parallelcollection presents a collection of objects like fortran-8x arrays and apl matrices. a programmer can view a parallelcollection as a single entity and express concurrent operations on it without worrying about the interactions among the elements of it. data-flow parallelism is provided by subclasses of stream with concurrent implementations.  various divide and conquer type algorithms can be abstracted as a workpool. multiple processes take out subproblems from a workpool and work on them. each process may generate more subproblems and put them back in the workpool. workpools are useful for graph search algorithms such as game playing and the traveling salesman problem. we also used it to implement a parallel dataflow analysis algorithm.  the abstractions that we discovered are very similar to those used by dally, although we did not learn about his work until recently. our favorite reason is that these abstractions are probably fundamental to parallel programming and would be discovered by anyone who approached the problem with the right attitude. a more likely reason is the common influence by smalltalk. we plan to look into other problem domains to find more reusable abstractions.  in conclusion, the most important aspect of object-oriented programming is its ability to support reusable abstraction. although most papers on the subject of object-oriented concurrent programming emphasize language models, there are probably a number of reusable abstractions that have been discovered by application programmers and left unpublicized. those abstractions should be publicized, discussed, and refined. object-oriented programming can make its biggest impact on concurrent systems by generating high-level abstractions that application programmers can use to build parallel systems more easily. we should concentrate more of our effort in finding these abstractions.  j. lim r. e. johnson