Susan, regular programs CAN and should be written that way. You can use code-reuse and modularity concepts in any language. Conventional OPM wisdom said that making calls was expensive, so it was better to write a 20,000 line program than to split it up functionally into several programs(*). Maybe when ILE came along with the claim that calls were faster and smaller programs were better, this old rule was thrown out and people felt free to write the smaller programs that good programming demands. (*)A good example of one of Knuth's laws, that premature optimization is the root of all evil. With an OPM single-entry-point program, it's more difficult (but in no way impossible) to say create an abstract data type. In ILE (RPG at least - I don't think COBOL has multiple entry points), you can do an ADT the usual way, with one module having procedures for create, init, destroy, doThis, doThat etc. In an OPM program, you could do the same thing but the interface would be uglier, since you'd have to set up the parameters for the program to handle the interfaces for all the functions. Or you'd have to have several programs all talking to each other, which makes it impossible to have a truly private implementation, and makes it difficult to change the internal implementation (for example, array vs file) once the programs are in use.
I know everyone doesn't think this way, but I think there's something about being able to code c eval x = someFunction(y) versus c call 'SOMEFUNC' c parm x c parm y or c move x somesubr1 c exsr somesubr c move somesubr2 y /copy somesubr that seems to make code-reuse more attractive. ADTs, modularity, and code-reuse aren't particularly OO anyway. "OO" usually entails inheritance and polymorphism. These are the OO-ish things that are difficult (but again, not impossible) to simulate using non-OO languages. Barbara