Toward megaprogramming

Abstract

Our goal in this paper is to develop an architecture and methodology for megaprogramming. We define {\em megaprogramming} as programming with very large modules called {\em megamodules} that capture the functionality of systems such as those used by banks, airline reservation systems, and city transportation systems. Megamodules are internally homogeneous, independently maintained systems whose life cycle is managed by a software community with its own goals, knowledge base, and programming traditions. We use the term `ontology'' to denote the declared entities that may meaningfully be used within a megamodule and their internal operations. A problem to be dealt with is the interaction of ontologies. Computations using megamodules are described by {\em megaprograms,} written in a {\em megaprogramming language.} We are concerned with interfaces of individual megamodules and with the megaprogramming language for megamodule management. Each megamodule must describe its externally accessible data structures and operations; descriptions are stored in libraries, called megamodule repositories, that have certain data dictionary facilities. Megaprogramming languages provide more flexible module management than traditional methods of combining modules, and in particular may perform transduction between modules on a variety of computer systems. Modules will have different data representations. Databases may be supported within megamodules with complete autonomy. They are not directly accessed by megaprograms. Some megamodules may share databases and use their facilities to resolve conflicts due to concurrent access. Input-output for human clients is generally performed by specialized modules. Megaprogramming allows us to think in terms of larger abstractions than traditional programming, and is a form of component-based programming in the large. It has the potential of substantially increasing modeling power and software productivity because its powerful encapsulation allows very large software systems to be managed as collections of megamodules. Programming within a megamodule can be handled by traditional techniques for programming, while interaction of megamodules is governed by megaprogramming protocols.