This paper presents a programming model as explained in the paper's title. The model is an interesting attempt to combine a functional programming language with persistent objects and turn the combination into a parallel programming language. The main concepts of the language are class and object, where objects are instances of classes. Classes defined in a program may form hierarchies where one class is a subclass of another, and where subclasses inherit features of their superclasses. Classes may be generic, thus allowing for other classes to be different instantiations of the same generic class. A class defines a store and a number of methods. The store and methods are instantiated in objects of that class. The store is where data of the object reside persistently. The data may be accessed and altered by invocations of the object methods. Objects may use (i.e. invoke methods of) other objects. The model may be considered functional, because methods are pure functions, without any side effects. If a method is to access and/or alter the store of an object, the object must appear as an argument of the function. There are two sources of parallelism in PROOF. First, function arguments may be evaluated concurrently (fine grain parallelism). Without any side effects, the order of argument evaluations is arbitrary, including evaluation of all of them in parallel. That also includes functions, the arguments of which are lists of other functions, such as mappings and replications. Second, there may be several objects that are active simultaneously (coarse grain parallelism). They may invoke functions involving other objects, including cases when one object is manipulated through more than one function simultaneously. Semantics of PROOF, i.e. the meaning of its object and their methods, is defined so as to be independent of whether the actual evaluation takes place sequentially or concurrently. The paper shows that evaluation of objects and methods in PROOF is serializable. In the last 2 sections of the paper some information on the present stage of the development of PROOF is given, and some issues concerned with implementation of PROOF on a multiprocessor hardware are mentioned.