Summary form only given. This talk explores what 21st century enterprise must do in order to survive the accelerated changes globally and compete effectively. There are three major aspects that an enterprise needs to follow, namely; 1. have the courage to do the right things, 2. have the capability to do things right; 3. have the will to change. We also discuss the concept of an Enterprise Clinic/spl trade/ as an implementation framework to help developing 21st century enterprises globally.

A basic set of principles from concurrent engineering is synthesized. These principles, when coupled with COSMOS, a management model, can be a very powerful tool in helping to reengineer the software development process. The combined model is applied to the system requirement phase, and a framework for software process reengineering is suggested.>

Many problems in the software industry today result from our ignorance that system development belongs to a class of problems that are "wicked" in nature. This paper discusses key attributes of wicked problems and suggests a basic set of principles based on experiences from good practices in the field to deal with the attributes of wicked problems. As a result of these principles, new process paradigms are needed. Automation of the alternative process and further research on downsizing mainframe applications to distributed applications are also discussed here.

A technique is described for software specification and verification of concurrent, distributed systems. The complete specification of a program is given in terms of a hierarchical structure of module specifications. Module external specifications are abstract; module internal specifications are descriptions of internal implementations, either in terms of submodules or actual code. The verification that an implementation satisfies its specification is language independent for the former and language dependent for the latter. Distinguishing the liveness properites provided by a module and the liveness properties required by a module (from its comodules) allows the specification and verification of a given module to be independent from the specification and verification of its comodules.

PSDL is a language for describing prototypes of real-time software systems. It is most useful for requirements analysis, feasibility studies, and the design of large embedded systems. PSDL has facilities for recording and enforcing timing constraints, and for modeling the control aspects of real-time systems using nonprocedural control constraints, operator abstractions, and data abstractions. The language has been designed for use with an associated prototyping methodology. PSDL prototypes are executable if supported by a software base containing reusable software components in an underlying programming language (e.g. Ada).>

SEES is a database system to support program testing. The program database is automatically created during the compilation of the program by a compiler built using the YACC compiler-compiler.

We propose a software life cycle which consists of two phases: rapid prototyping and automatic program generation. Software reusability holds the biggest leverage for both phases. This paper outlines the requirements for supporting this two-phase life-cycle using a software-base as an advanced software management system.

Computations of distributed systems are extremely difficult to specify and verify using traditional techniques because the systems are inherently concurrent, asynchronous, and nondeterministic. Furthermore, computing nodes in a distributed system may be highly independent of each other, and the entire system may lack an accurate global clock.

A new language concept–communication port (CP), is introduced for programming on distributed processor networks. Such a network can contain an arbitrary number of processors each with its own private storage but with no memory sharing. The processors must communicate via explicit message passing. Communication port is an encapsulation of two language properties: "communication non-determinism" and "communication disconnect time." It provides a tool for progranmers to write well-structured, modular, and efficient concurrent programs. A number of examples are given in the paper to demonstrate the power of the new concepts.

A methodology for designing parallel real time application software is proposed. Such programs can be designed using this methodology in a fashion analogous to the step-wise refinement [Wirth '71] design of sequential programs. A real time program is designed in detail to illustrate the feasibility of the approach. Language and implementation issues are also discussed.

A data base design methodology which utilizes multiple levels of design abstraction is outlined. An example of the design of conceptual, logical and physical data base structures utilizing this methodology is presented. The importance of a good conceptual schema model is emphasized and a two-step conceptual schema design process is proposed. The design of logical and physical schemas is illustrated for a CODASYL model environment, taking into consideration the 1978 CODASYL DDL and DSDL specifications.

In this paper, formal semantics of program constructs are defined by predicate transformer introduced by Dijkstra [3,4]. A predicate transformer is a mapping which transforms a set of states after the execution of a program to the set of all possible states before the execution of the same program. Thus, the concept of determinism no longer has its significance in this semantic context. Rather, the focus is on the nature of the computation, and hence the concept of iteration, and not how the program iterates, becomes a dominant concern here.

We will consider the inductive mechanisms in five techniques for verifying iterative/recursive program structures: inductive assertion, predicate transformers, subgoal induction, computation induction, and structural induction. We will discover that all five techniques can be justified by a single theorem about inductive proof techniques. We will also show that all five techniques face the problem of finding properties that will carry an induction. Such properties are called inductive sets. We will see that the inductive sets of the five techniques are easily related to one another and that a program proof by any of the techniques can be easily converted to a proof by any of the other techniques. Our conclusion is that computer programs simply are inductive definitions of the functions they compute. Induction is the only method by which they can be proved. The problems of induction are therefore unavoidable.

The authors investigate the strong verification of programs using the concept of predicate transformer introduced by Dijkstra (1974). They show that every do-while program has a loop invariant that is both necessary and sufficient proving strong verification. This loop invariant is shown to be the least fixpoint of a recursive function mapping predicates to predicates that is defined by the program and the postcondition.

Since the publication of the Curriculum 68 report of the ACM Committee [CUR 68], undergraduate computer science programs have undergone substantial changes. Notably, many courses previously taught at the graduate level have shifted down to the undergraduate level; new areas have developed and consolidated but were not covered by the ACM report. These facts make it necessary to revise and update the Curriculum 68 report. An important factor which could help the revision is the actual experience gained through the development of many new undergraduate computer science programs since the publication of Curriculum 68 report five years ago. More specifically, most recommendations of the ACM report contain just the subject areas to be taught. The actual teaching experiences of these courses have formulated certain basic philosophies and formats of presentation. It is helpful, in our opinion, to compare the merits of these philosophies and formats of presentation.

The concept of a pair algebra is extended so that it can be defined between similar relational systems. It is shown that when the relational systems under consideration are lattices a generalized pair algebra specializes to a pair algebra. Closure properties of generalized pair algebra are investigated and their applications to automata theory are considered.