A parallel program consists of many processes running on remote computers. A parallel program has control over its processes. A process is a sequential program in execution that is independent of other processes. In a multithreaded environment such as Java, a process is the actual program executed by one or more threads. The process maintains its program structure and state that are represented by objects and variables. A thread is a single flow of control that executes its instructions independently. A thread is scheduled to a processor. Thus, we can say that processes and threads are conceptually related. In the field of object-orientation, processes can be considered as active objects that have their own life.

As future enhancements to the system we can mention better strategy for dynamic resource allocation, object migration and fault tolerance. The current resource management is rather naive, since it does not take any relevant parameters into account (e.g. computational power, network bandwidth, load, or task size). The fault tolerance is currently limited to the system level. Faulty nodes are detected and removed from the system. However, the object migration, and evacuation in the event of failure are not implemented yet. Due to the JVM specification, a migrated object cannot be restarted from the last execution point transparently. For example, Ninflet requires explicit checkpointing by the programmer. It is the programmer's responsibility to skip over the executed operations when a Ninflet execution resumes from a snapshot state. Due to the partial implementation of the above features, the current implementation of Visper is more suitable for LAN environments.