Document revision date: 30 March 2001

## OpenVMS Programming Concepts Manual

Previous | Contents | Index

## 1.3 Components of the OpenVMS Operating System

The OpenVMS operating system is a group of software programs (or images) that control computing operations. The base operating system is made up of core components and an array of services, routines, utilities, and related software. The OpenVMS operating system serves as the foundation from which all optional software products and applications operate. The services and utilities in the base OpenVMS operating system support functions such as system management, data management, and program development. Other integrated software that adds value to the system provides functions such as clustering and volume shadowing.

Optional software products, including application programs developed by OpenVMS programmers and other programmers, run on the core operating system. The OpenVMS system supports a powerful, integrated development environment with a wide selection of software development tools supplied by Compaq and other vendors. Application programs written in multiple languages provide computational, data-processing, and transaction-processing capabilities. Thousands of applications have been developed for OpenVMS systems by Compaq and independent software vendors.

Compatibility Between Software Versions

OpenVMS VAX and OpenVMS Alpha software exhibits compatibility from version to version:

- User-mode programs and applications created under earlier versions of OpenVMS VAX or OpenVMS Alpha run under subsequent versions with no change.
- Command procedures written under one version of OpenVMS continue to run under newer versions of the software.

OpenVMS software developed on VAX platforms can migrate easily to Alpha platforms (see Section 1.3.1.1):

- Most OpenVMS VAX images run under translation on OpenVMS Alpha systems.
- Most user-mode OpenVMS VAX sources can be recompiled, relinked, and run on an OpenVMS Alpha system without modification. Code that explicitly relies on the VAX architecture requires modification.

### 1.3.1 OpenVMS Systems on Multiple Platforms

The OpenVMS operating system is available on two hardware platforms:

- A complex instruction set computer (CISC) architecture based on the VAX architecture
- A reduced instruction set computer (RISC) architecture based on the Alpha architecture

The OpenVMS VAX operating system runs on the CISC platform, and the OpenVMS Alpha operating system runs on the RISC platform. The OpenVMS Alpha operating system is a port of the OpenVMS VAX operating system, not a redesign of the operating system.

A computing architecture provides a set of rules that determine how the computer actually works; for example, the architecture defines how the data is addressed and the instructions are handled.

The VAX architecture is a flexible CISC architecture that provides for 32-bit processing. The instruction set consists of a large number of instructions of variable length, some of which are complex. The 32-bit VAX architecture provides sufficient address space for current and future applications. The capabilities of OpenVMS on VAX processors will continue to be expanded.

The VAX architecture is used across the entire VAX family of systems. The use of a single, unifying, integrated VAX architecture with the OpenVMS software permits an application to be developed on a VAX workstation, prototyped on a small VAX system, and put into production on a large VAX processor. The advantage of the VAX system approach is that it enables individual solutions to be tailored and fitted easily into a larger, enterprisewide solution.

The Alpha architecture is a high-performance RISC architecture that can provide 64-bit processing on a single chip. The use of the RISC architecture in Alpha processors offers increased CPU performance. The instruction set consists of uniformly sized simple instructions that can be executed rapidly. The 64-bit capability is especially useful for applications that require high performance and very large addressing capacity.

The hardware designs of VAX and Alpha processors are inherently reliable and are particularly suitable for high-availability applications (such as dependable applications for mission-critical business operations and server applications for a wide variety of distributed client/server environments).

A move to the Alpha design from a VAX processor can take place whenever applications require the performance or capacity. Alpha processor support for the 64-bit addressing capability provides sufficient primary data storage for the most data-intensive applications and for applications that perform very large numbers of high-speed I/O operations. For example, Alpha processors are appropriate for graphics- or numeric-intensive software applications that involve imaging, multimedia, visualization, simulation, and modeling.

#### 1.3.1.1 System Compatibility and Program Portability Across Platforms

The OpenVMS Alpha operating system is compatible with OpenVMS VAX systems in terms of user, system manager, and programmer environments. For general users and system managers, OpenVMS Alpha has the same interfaces as OpenVMS VAX. Virtually all OpenVMS VAX system management utilities, command formats, and tasks are identical in the OpenVMS Alpha environment. Additionally, OpenVMS VAX and OpenVMS Alpha systems can coexist in the same networking environment and in the same VMScluster system.

For programmers, the OpenVMS Alpha software development environment involves the same programming interfaces and development tools as with OpenVMS VAX. Most OpenVMS VAX application programs, especially those written in higher level languages, can be recompiled and relinked and then run on OpenVMS Alpha. Alternatively, if recompilation is not practical or possible, you can use the DECmigrate for OpenVMS AXP layered product to translate user-mode OpenVMS VAX images to run on OpenVMS Alpha systems.

### 1.3.2 OpenVMS Computing Environments

The OpenVMS operating system provides an array of capabilities that support the full range of computing environments. A computing environment is made up of resources that are compatible with each other and all work together toward a common goal. In general, OpenVMS environments can supply the following kinds of capabilities (which can exist in any combination):

- Open system capabilities
- Distributed processing capabilities
- Production system capabilities
- System and network management capabilities

OpenVMS software capabilities include both the standardized features of open systems computing and the commercial-strength functionality of traditional OpenVMS systems. System and network management software provides for control of heterogeneous, integrated environments.

The following sections describe the capabilities supported in OpenVMS computing environments and summarizes the software resources available in each kind of environment.

#### 1.3.2.1 Open System Capabilities

OpenVMS offers the benefits of an open system environment, which permits both applications and users to move between systems. In addition, applications on different open systems can operate together.

The OpenVMS operating system makes available a set of services in an open domain, while still offering its traditional high-integrity computing services. Incorporation of open computing capabilities enhances the traditional feature-rich OpenVMS environment.

Software in the OpenVMS open systems environment enables the development and use of portable applications and consistent user interfaces and also permits systems to operate together. The keys to openness of OpenVMS systems are standard programming interfaces, standardized user interfaces, and standard protocols.

#### 1.3.2.2 Application Portability

Application portability is the capability to easily move an application from one system to another. Standard programming interfaces permit application and data portability. Portable applications written strictly to a suite of open specifications provide the following benefits:

- Applications can be written once and run on other open platforms that support the standards used in the applications.
- Users can access the wide range of applications available on open platforms.
- Applications can be supplied by different vendors.

Applications that are developed on the OpenVMS VAX or OpenVMS Alpha system and conform to open standards can be easily ported to other systems that conform to the same standard interfaces. Applications written in ISO and ANSI languages are portable to other systems. In addition, The Open Group/Motif graphical user interface supports application portability.

##### 1.3.2.2.1 Other Application Portability Features

Applications written in ISO/ANSI languages are easily portable to other platforms that support them. OpenVMS VAX and OpenVMS Alpha provide support for such languages as Ada, C, COBOL, and Fortran.

### 1.3.3 Distributed Computing Capabilities

In a distributed computing environment, an application is distributed over two or more systems or processors, each of which has its own autonomous operating environment. A distributed application is composed of separate modules, running on different systems, that communicate with each other by passing data between modules or by sharing access to files or databases. A distributed application must be able to coordinate its activities over a dispersed operating environment.

The distributed computing environment can consist of software located either in a single box or a single room or can comprise a worldwide network of computers. The systems in the distributed configuration can be uniprocessor, multiprocessor, or VMScluster systems; systems from different vendors can be included in the same configuration.

#### 1.3.3.1 Client/Server Style of Computing

One style of distributed computing that permits resource sharing between different systems is client/server computing. In the client/server environment, portions of an application are distributed across the network between servers and clients:

- A server is any system that provides a service or resource to other systems.
- The client is the system requesting the service.

This style of computing allows each portion of a distributed application to run in its own optimal environment. The whole application does not have to run on one centralized system (such as a mainframe system), but enterprisewide cohesiveness can still be maintained. For example, individuals or local offices, using their own computers and running software appropriate to their needs, can be linked to large computers or VMScluster systems in a network. A distributed computing system can function as though it were a single system that connects all parts of an enterprise. The client can have transparent access to the integrated resources of the enterprise.

Any system can be a client or a server, and some systems may include both client software for certain applications and server software for other applications. Servers can be connected to many clients, and a client can be connected to more than one server at a time. (Client and server relationships may change frequently: at times it may not be possible to tell which is the client and which is the server.) In some cases, the application is stored on the server and run on the client, using the resources of the client. The user, who does not need to know what system is serving the application, can function in a familiar, local environment.

#### 1.3.3.2 OpenVMS Client/Server Capabilities

OpenVMS systems support a wide variety of client/server configurations. Clients requiring resources can be personal computers, workstations, point-of-sale devices, OpenVMS systems, or systems from other vendors that are running the appropriate client software. Users on client systems can use character-cell terminals or windowing desktops.

Servers fulfilling clients' requests can be located on OpenVMS systems or other operating systems running appropriate server software. OpenVMS servers, for example, can provide file access, printing, application services, communication services, and computing power as application engines to clients on desktop devices or in laboratories or factories. Client/server configurations permit the commercial-strength capabilities of OpenVMS host systems to be integrated with the personal-computing capabilities of desktop systems.

Middleware, which runs on OpenVMS and other systems from multiple vendors, can be used to tie together clients and servers. Middleware integrates various client and server systems through application, communication, data interchange, and multivendor support. Complex information-sharing environments involving PC clients and operating system servers are supported by PATHWORKS software.

An essential feature of the OpenVMS operating system is its support of a rich environment for developing software application programs. The programming software integrated in the OpenVMS system provides the tools required to effectively develop new software applications. You also have the option of using additional powerful tools to enhance the productivity of software development in the OpenVMS environment.

The following sections summarize the primary program development features available on all OpenVMS VAX and OpenVMS Alpha systems. The sections also introduce the OpenVMS programming environment and present brief functional descriptions of the OpenVMS programming tools.

## 1.4 The OpenVMS Programming Environment

The OpenVMS system supports a flexible programming environment that offers a wide range of tools and resources to support efficient program development. This robust OpenVMS programming environment permits the development of mixed-language application programs and portable programs, as well as application programs with distributed functions that run in client/server environments. This environment also provides tools that allow you to use the Web and other information technologies.

In the OpenVMS programming environment, you can use OpenVMS resources to perform the following tasks:

- Creating, controlling, and deleting processes
- Communicating with other components
- Sharing resources
- Implementing input/output procedures
- Using security features
- Managing memory
- Managing files
- Synchronizing events
- Providing for condition handling
- Calling utility routines

The components of an OpenVMS application are the main program, shared libraries, functional routines, and a user interface. Software tools that support development of applications in the OpenVMS programming environment include:

- Language compilers, interpreters, and assemblers
- Linkers and debuggers
- Text processors and other program development utilities
- Callable system routines such as run-time routines, system services, and other utility routines
- Record Management Services (RMS) routines and utilities

Optional software development tools that run on the OpenVMS system enhance programmer productivity, saving programming time and promoting the development of error-free code. OpenVMS supports optional integrated software products that enhance program development capabilities in an organization. These software development products can make use of middleware services that facilitate the development of applications for multivendor networks and for web-enabling tools to help develop client/server applications.

Middleware and Web-enabling tools allow you to access data and information by using the web. The various middleware and web-enabling tools perform the following:

- Provide web access to data
- Provide web access to applications
- Provide web tools for commercial web servers
- Provide other web tools including freeware

Middleware products and capabilities include Distributed Computing Environment (DCE), Common Object Model (COM), and Compaq Reliable Transaction Router (RTR). Web-enabling tools include Compaq DECforms Web Connector, and Compaq TP Web Connector. For more information about middleware and web-enabling tools, go to the following URL:

                   http://www.openvms.compaq.com/solutions/appdev.html

### 1.4.1 Programming to Standards

Coding of programs for the OpenVMS environment and for other environments involves conforming to software development standards. OpenVMS standards that define modular programming techniques and procedure calling and condition handling practices pertain to applications specific to OpenVMS. IEEE and international standards apply to applications developed on OpenVMS that are designed to run on other systems as well as on OpenVMS.

#### 1.4.1.1 Common Environment for Writing Code

OpenVMS software programmers can write code in a common environment, following standard OpenVMS modular programming practices. This standard approach establishes the minimum criteria necessary to ensure the correct interface at the procedure level between software written by different programmers. If all programmers coding OpenVMS applications follow this standard approach, modular procedures added to a procedure library will not conflict with other procedures in the library. Standard modular programming practices apply to OpenVMS programs that have a public entry point. For details of this standard approach, see the Guide to Creating OpenVMS Modular Procedures.

#### 1.4.1.2 Common Language Environment

The OpenVMS system supports a common language environment, which permits using a mixture of languages in programming. A program written in any of the programming languages supported by OpenVMS can contain calls to procedures written in other supported languages. Mixed-language programming is possible because all supported languages adhere to the OpenVMS calling standard. This standard describes the techniques used by all supported languages for invoking routines and passing data between them. It also defines the mechanisms that ensure consistency in error and exception handling routines, regardless of the mix of programming languages. Information about the calling standard appears in the OpenVMS Calling Standard, and a description of how to use the calling interface is given in OpenVMS Programming Concepts Manual, Volume II.

## 1.5 OpenVMS Programming Software

This section describes the integrated programming tools available on the OpenVMS operating system to help implement software development.

The phases of a typical software development life cycle can include proposal of the concept; formulation of requirements and specifications for the software product; design, implementation, and testing of the software; and integration and maintenance of the product. Implementing the software product involves building and modifying source code modules and compiling, linking, and executing the resulting images. Testing involves refining code to optimize performance.

As part of the software development life cycle, OpenVMS operating system components and optional software products that run on OpenVMS are used to develop applications. Some of the major OpenVMS programming software components, such as editors and utilities, are listed in Table 1-2. Programming language software supported by OpenVMS is described in Section 1.5.2. Optional program development software tools that run on OpenVMS are described in Section 1.9.

Table 1-2 OpenVMS Programming Software
Type of Software | OpenVMS Software Components
--- | ---
Text processors | DEC Text Processing Utility/Extensible Versatile Editor (DECTPU/EVE) EDT Editor Text Editor and Corrector (TECO) vi, ed, and ex editors (POSIX) Compaq Language-Sensitive Editor for OpenVMS/Compaq Source Code Analyzer (LSE/SCA)
Major programming utilities | Linker OpenVMS Debugger Delta/XDelta Debugger OpenVMS Alpha System-Code Debugger 1
Other program development utilities | Command Definition utility Librarian utility Message utility Patch utility 2 SUMSLP utility National Character Set utility System Dump Analyzer 3 POSIX for OpenVMS utilities
Callable system routines | Run-time library routines System services Utility routines Record Management Services (RMS) routines and utilities

1Alpha specific.
2VAX specific.
3Different versions run on the VAX and Alpha platforms.

The commands used to invoke some of the programming utilities (for example, linker, debugger, LIBRARIAN) vary slightly for VAX and Alpha platforms.

### 1.5.1 Creating Program Source Files

OpenVMS text-processing utilities can be used to create and modify program source files. The DEC Text Processing Utility (DECTPU) is a high-performance text processor that can be used to create text-editing interfaces such as EVE. DECTPU includes a high-level procedure language with its own compiler and interpreter, as well as the customizable EVE editing interface. DECTPU features multiple buffers, windows, and subprocesses, and provides for text processing in batch mode. The EDT editor is an interactive text editor that provides editing in keypad and line modes. EDT supports multiple buffers, startup command files, and journaling. In general, the EVE editing interface offers more capability than EDT for complex editing tasks.

TECO is a traditional character-oriented text-editing program that runs under both OpenVMS VAX and OpenVMS Alpha. It can be used to edit program sources and other ASCII text.

The vi editor is a display-oriented interactive text editor used in the POSIX for OpenVMS environment. POSIX also supports the ed and ex editors.

Other optional tools for creating source files on OpenVMS systems are available separately or as part of the Compaq software development environment. The Compaq Language-Sensitive Editor/Compaq Source Code Analyzer for OpenVMS (LSE/SCA) provides a multilanguage, multivendor editor for program development and maintenance and also supplies cross-referencing features and the capability to analyze source code.

Previous | Next | Contents | Index

| privacy and legal statement |
5841PRO_001.HTML