concurrent meld  our original goal was to design a programming language for writing software engineering environments. the most important requirements were reusability and the ability to integrate separately developed tools [1]. our scope was later expanded to general applications, and then to parallel and distributed systems. our current focus is on 'growing' distributed software environments and tools, that is, building a core environment or tool assuming a long-term evolution path.  meld is a multiparadigm language that combines object- oriented, macro dataflow, transaction processing and module interconnection styles of programming [2]. the most unusual aspect is the dataflow at the source level among the inputs and outputs of statements. classes may define constraints in addition to instance variables and methods, which are triggered by changes to instance variables and interleaved along with the statements of a method. meld's constraints are unidirectional, and similar in purpose to active values.  figure 1 gives a trivial example. when a message o is received by an instance of class c, the two statements in method o and any constraints affected by either statement are executed in dataflow order. this means that instance variable b is computed by o as a function of argument c, and only then the constraint recomputes a as a function of the new value of b. simultaneously with either of these computations, or before or after or in between, d is assigned to the result of a function of argument e; there is no data dependency between this statement and either the other statement in the method or the constraint.  meld's multiple paradigms lead to three granularities of concurrency:  statements from the macro dataflow for fine to medium grain concurrency within a method or among methods. this permits a smaller granularity than dataflow among the inputs and outputs of methods. atomic methods, which provide a low- level form of concurrency control, force a larger granularity.  objects for medium to large grain parallelism, with synchronous and asynchronous message passing among remote or local objects. many other concurrent object-oriented languages provide synchronous or asynchronous message passing, but not both.  atomic transactions for high- level concurrency control among users (including tools where interleaved operation is inappropriate). most other object-based systems provide only one form of concurrency control.  a method may be invoked synchronously or asynchronously. in the synchronous case, the caller waits for return with respect to its own thread of control. in the asynchronous case, the caller continues and the invocation creates a new thread of control. programs may involve an arbitrary number of threads created dynamically during program execution. several threads may operate within the same address space and one thread may, in effect, operate across multiple address spaces. in either case, the invoked method runs concurrently with any other methods currently active on the same object. these other methods may be reading and writing the same instance variables. the default synchronization among such methods is done by dataflow, as within a single method.  there is a serious problem with this approach. figure 2 operates as indicated if m and n happen to begin execution at exactly the same time, due to simultaneous arrival of messages m and n from other objects. d is computed from the value of c given as argument to n, b is computed from the new value of d, and a from the new value of b. however, if message n arrives a bit later than m, then b is computed from the old value of d, and then the new value of d is computed from the argument c and a is computed from the new value of b. both statements in n could be executed concurrently since there is no dataflow between them. on the other hand, if message m arrives a bit later than n, then b may be computed from either the old or new value of d and a may be computed from either the old or new value of b. this is obviously rather bewildering for the programmer, since it is necessary that the resulting computation be deemed 'correct' in all of these cases.  we support this is to permit maximum concurrency for those applications (and programmers!) that can handle the non-determinism. our intuition is that non- determinism will not be a problem in many cases. the programmer has in mind a parallel algorithm where he thinks in terms of the dataflow necessary to produce the correct solution. he typically uses a conventional language, such as fortran or c, to implement his algorithm. the parallelizing compiler must then uncover the parallelism again using dataflow techniques. we avoid this hide-and-seek by allowing the programmer to make the dataflow explicit.  there are many programs, however, written without cognizance of the dataflow. we also support these programmers with sequential blocks and atomic blocks. figure 3 shows method o of class c written as a sequential block rather than a parallel block (i.e., a parallel block is enclosed in curly braces and a sequential block in square brackets). in this example, all of method o executes in the order in which the statements are written. any constraints whose inputs are changed during the execution of o are triggered as before.  sequential blocks remove concurrency within methods, making them easier to write without the need for the single-assignment mindset, but do not affect concurrency among methods. figure 4 indicates the ordering if m and n happen to start at the same time. b is computed from the old value of d, a from the new value of b and then the new value of d from the argument c. but if there is a race condition, a may see the new value of b or b may see the new value of d, but not both.  in figure 5, method o executes atomically with respect to the receiver object. atomic blocks are indicated with parentheses. both b and d are updated, and only after o terminates is the constraint triggered. the two statements in o may themselves be executed in either sequential or dataflow order, since it is necessary to include them within an inner sequential or parallel block, not shown, if the atomic block is used. in this case it does not matter.  methods m and n are serialized in figure 6, so they appear atomic to each other. we currently support pessimistic concurrency control by locking the object at the computational grain size of individual methods, or a block within a method. we are integrating real transactions that cut across methods and objects/ we use distributed optimistic concurrency control with multiple versions, since we expect a majority of read-only transactions (in our primary application domain of distributed software development tools). atomic blocks using validation rather than locking will be surrounded by angle brackets rather than parentheses, and may be either sequential or parallel; begin_transaction, abort_transaction and commit_transaction statements are provided for transactions that begin in one method and may end in another according to circumstances determined at run-time.  g. e. kaiser