a strongly typed persistent object store  if we examine present day computer systems we find many dichotomies and discontinuities in their design. we contend that the present dependence on a plethora of mechamisms increases the cost of understanding and maintaining software for even the simplest of activities. it is important to remove this incoherence now since it is placing a considerable overhead on the users and developers of computer systems. we report on our current research on programming languages and environments and propose a persistent information space architecture (pisa) capable of integrating all activities.  we have identified the following problems faced by users of current systems which when negated become requirements of modern systems in order to achieve simplicity and integration. these are controlling complexity, orthogonal persistence, controlled system evolution, protection of data and concurrent computation. we do not regard this list as exhaustive.  the complexity of the system must be kept under control, so that developers and users can concentrate on the application rather than the complexity of the system. this depends on establishing consistent rules which apply throughout the design and being parsimonious in the introduction of new concepts into these designs.  the discontinuity between the method of using data that is short term and manipulated by program and long term data that is manipulated by the file system or dbms causes unnecessary complexity. we have defined the persistence of data to be the length of time for which the data exists and is useable. we aspire to systems where the use of data is independent of its persistence.  the uses of data (including program) are neither limited nor predictable. it is necessary to support the construction of unanticipated software systems or databases which make use of pre-existing data (or program) even when the data and program were defined independently of one another. for large scale, widely or continuously used systems any alteration to part of the system should not require total rebuilding. we require a mechanism which will allow the programmer to control the units of reconstruction.  some large bodies of data are inherently valuable. it is necessary to protect them from misuse from hardware and software failure. this implies both a type and protection system to meet all users needs together with recovery mechanisms to limit the losses due to component failure.  a large body of data requires a community effort for its construction and maintenance. any useful body of data is likely to be of concurrent interest to many users, probably in dispersed geographic locations. different models of concurrency and transactions may have to be accommodated by the underlying mechanism.  we have designed and implemented the language ps-algol as a testbed for experiments on the above requirements. we report here on some results and propose further experiments in the search for better programming systems.  central to our aim of building a total system capable of providing for all programming activity in an integrated manner is our persistent information space. this space is made up of objects which may be simple or highly structured and are part of the universe of discourse defined by the type system of the pisa architecture. the type system must therefore be rich enough to satisfy all our requirements. this we recognise as a research challenge.  the information is persistent; the programmer has no knowledge of where the data resides. this may be locally in main store or disk, or remotely in non- local stores. the programmer is relieved of the burden of organising the physical storage of data in the system and presented with a conceptually simple model of data. the mechanisms for binding in the persistent information space are those of the name space together with those used for introducing names in the architecture language.  at present we feel that it is premature to construct mechanisms and protocols for concurrency and transactions. we subscribe to the view that it is more sensible to build in a primitive for synchronization and a mechanism for specifying non-deterministic parallel computation and to construct the required protocols out of them by layers of abstraction. the reason for this is that although all of the protocols may be built out of the primitives it is not obvious that they form a hierarchy. at a lower level the persistent information space is supported by a stable store mechanism for reliability. the stable store may be distributed over many storage devices and processors and it is currently the focus of some research to build such a system.  the approach proposed is to design the environment and the language as a coherent whole. the initial steps outlined in this paper are sketches of the way certain facilities, such as flexible binding, reliable and long term storage currently provided by the operating system may be profitably specified as part of a language. elsewhere we publish work where we demonstrate that this approach is feasible.  malcolm p. atkinson alan dearle ronald morrison