COBOL Newsletter
Issue 4 IBM Santa Teresa Lab
November, 1995
This newsletter is written by the IBM COBOL development team.
This is our ASCII text version of our published document.
Articles in this issue:
IBM's New COBOL products Land!
A Few Words from the OO team
IBM's New COBOL for MVS & VM
Faster/better/smaller LE shipped!
IBM's Host Debug Tool!
Gimme Speed!
Report Writer -- Big News
Go with the FLOW
Tips & Hints
IBM's new COBOL products land at a store near you!
---------------------------------------------------------------
Today, IBM announces delivery of its most sweeping COBOL
enhancements in a decade!
IBM VisualAge for COBOL for OS/2
IBM COBOL for MVS & VM Release 2
IBM COBOL Set for AIX
With the addition of object-oriented extensions, and a visual
development environment, IBM VisualAge for COBOL for OS/2 helps
you build applications for host, workstation or advanced
client/server applications. These COBOL enhancements are also
available on the AIX and MVS platforms. IBM VisualAge for COBOL
for OS/2 revitalizes your dependable COBOL applications by
extending COBOL to your OS/2 workstation.
With IBM VisualAge for COBOL for OS/2, you can use your
existing COBOL skill base to upgrade your applications and
expand them to other platforms. As a direct result, you can
save money and increase productivity by reducing the need to
retrain your employees.
VisualAge for COBOL for OS/2 is an ideal, cost-effective
solution that offers the following enhancements to COBOL:
OBJECT - ORIENTED LANGUAGE EXTENSIONS
-- COBOL programmers can create objects in a language they
already know, reducing a long learning curve
-- 32-bit implementation
-- Direct-to-SOM implementation
CLIENT/SERVER ENABLERS
-- Run COBOL programs on your OS/2 desktop, while your data
remains on the host
-- Easily access remote data from DB2, CICS, VSAM/SAM MVS files
and OS/400 Record Files
-- Works with MQSeries for OS/2 using MQSeries Three Tier for OS/2
-- Complies with ISO and ANSI COBOL standards
IMPROVED PRODUCTIVITY AND EASE-OF-USE
-- A rich set of tools help you easily take advantage of these
COBOL enhancements
COBOL FAMILY OVERVIEW
Today IBM is announcing three new COBOL products on OS/2, AIX
and MVS & VM, breathing new vitality into the business language
of choice. IBM has dramatically enhanced COBOL with visual
development tools (OS/2), object-oriented extensions, and
powerful client/server support across a wide variety of platforms.
The enhancements in IBM VisualAge for COBOL for OS/2 also offer
exceptional gains in productivity and flexibility. With
desktop-based visual development tools, programmers can begin
applications by creating graphical user interfaces (GUIs). To
put substance behind the GUIs, the visual tools and data utility
functions allow rapid development to create business logic and
access databases, VSAM files, and transaction-processing systems.
With IBM's COBOL Family, COBOL programmers can use their expertise
to create advanced client/server applications, allowing host COBOL
applications to move to the desktop, while data remains on the host.
IBM VisualAge for COBOL for OS/2
IBM VisualAge for COBOL for OS/2 provides the COBOL programmer
with 32-bit Direct-to-SOM based, object-oriented support on the
OS/2 operating system. In addition, a COBOL application
development environment is provided that is designed
specifically to handle client/server, mission-critical,
line-of-business applications through visual development.
IBM VisualAge for COBOL for OS/2 also gives the COBOL programmer
a set of high-productivity, OS/2-based power tools for the
development of applications targeting OS/2 execution systems.
LOCAL AND REMOTE DATA ACCESS:
IBM VisualAge for COBOL for OS/2 provides local and remote data
access to data including:
IBM SMARTdata UTILITIES (TM) (SdU) which provides:
-- Record-oriented file access through standard COBOL I/O
statements to local OS/2 VSAM files, remote MVS VSAM, SAM, PDS,
and PDSE files
-- Remote OS/400 Record Files
-- Remote CICS managed VSAM files on MVS using CICS/DDM
-- A full set of data conversion API's for converting single,
double and mixed byte character strings, numerics and complex
structured records
-- A full set of SMARTsort API's for sorting, copying, and
merging record and byte files located locally or remotely
-- Direct access to data managed by BTRIEVE
-- Support for local and remote DB2 data access using DB2 for OS/2
-- Support for local and remote CICS data access using CICS for
OS/2 or CICS Client for OS/2.
VISUAL GUI DESIGNER:
The visual GUI designer provides capabilities to allow the
building of complex CUA (TM) compliant screens.
The visual interface (GUI work screen) that creates the GUI
code, is an easy-to-use, intuitive tool for creating graphical
interfaces, eliminating the need for in-depth GUI development
knowledge. Programmers can create applications by selecting
controls from the control palette, moving them onto the design
editor, thereby providing an integrated "what you see is what
you get" (WYSIWYG) user interface.
Either during or after this brief development process,
developers may build the application by coding in COBOL logic
with COBOL sensitive edit/compile/debug tools.
WORKFRAME:
IBM WorkFrame/2 provides seamless integration of all the
components included in the IBM VisualAge for COBOL for OS/2
product.
WorkFrame is a highly configurable, project-oriented application
development environment for use on OS/2 and is specifically
designed to take full advantage of the features offered by OS/2.
When used as the integration medium for application development
tools, the fully configurable IBM WorkFrame increases the
effectiveness of these tools as agents for enhancing user
productivity. IBM WorkFrame organizes the programmer's
workplace by grouping files into logical units or projects.
As an organizer, IBM WorkFrame:
Adapts to the user's project organization environment instead of
the project organization having to fit into the WorkFrame defined
environment.
Sets up projects to consist of source and object files spanning
multiple directories, and one target directory.
Associates each project with multiple actions, including
compiling, debugging, making, linking, browsing, profiling /
analyzing, and preprocessing. As a tool integrator, multiple
developers can now work concurrently on a single project by
plugging in their own source control system.
CONTEXT SENSITIVE EDITOR:
The LPEX Editor is a language-sensitive, color editor which
supports COBOL.
The LPEX Editor can be used to create and edit many types of
text files, including program source and documentation. By
automatically parsing COBOL source code, LPEX distinguishes
between language constructs. For instance, language keywords,
comments, string literals, and numbers are displayed using
distinctive fonts and colors. Developers can quickly find items
they are looking for in their source code.
Using LPEX, developers can:
-- Be made aware of some syntax errors when the source code is
created
-- Use multiple windows to display several documents or to
display more than one view of the same document
-- Dynamically configure LPEX to be a multiple-window or
single-window tool
-- Select a block of text and move or copy it between documents
-- Cut and paste to a shell or another application
-- Undo previous changes to a document
Developers can customize and extend virtually every aspect of
this programmable editor. LPEX is designed to be extended through
dynamic link libraries; there is no proprietary extension language
to learn.
With the LPEX application programming interface (API), developers
can write powerful extensions to the editor using C and C++.
In addition, LPEX provides a rich command language that developers
can use to create or modify editor functions.
Developers can:
-- Define their own fonts and colors
-- Modify the editor action key layout
-- Add menus to perform frequently used commands (menu
definitions can be applied on a filename extension basis)
-- Write their own editor commands
INTERACTIVE DEBUG TOOL FOR OS/2 (IDBUG):
The debug tool supplied with IBM VisualAge for COBOL for OS/2
provides source level debugging built around a set of core
functions designed to let users quickly and efficiently control
execution, and analyze data.
Users can:
-- Display and change variables
-- Display and change storage
-- Display and change the processor registers
-- Display the call stack
-- Add and delete simple and complex breakpoints
-- Control the execution of multiple threads
View source code as a listing, disassembly or mixed
CICS for OS/2 Version 3.0 transactions built with IBM VisualAge
for COBOL for OS/2 can be debugged interactively.
For PM application programming support synchronous and
asynchronous modes gives users two ways to debug PM applications.
The application windows can be managed concurrently with the debug
tool windows.
PERFORMANCE TUNING:
Execution trace analysis and performance tuning is provided
through the IBM Performance Analyzer. It is designed to help
users tune and understand their programs by monitoring program
execution and generating a function-by-function trace of the
run. This trace can subsequently be examined by utility
programs that graphically display the execution trace. Not only
does the analyzer trace procedures in the EXE file, but it
traces the entry points to system calls and application DLLs.
DATA ASSISTANT / TRANSACTION ASSISTANT:
Data Assistant simplifies the process of constructing
syntactically correct, embedded SQL statements. It gives you a
graphical view of your relational database, allows you to map
COBOL data structures to the database and generate SQL
statements into your source file.
Transaction Assistant enables non-CICS COBOL applications to
access CICS transactions.
OPEN ENTERPRISE:
IBM VisualAge for COBOL for OS/2 supports the high subset of
American National Standards Institute (ANSI) COBOL (ANSI X3.23-1985)
and International Standards Organization (ISO) COBOL (ISO 1989:1985),
as well as the Intrinsic Function Module for COBOL (ANSI X3.23a-1989
and ISO 1989/Amendment 1).
PUBLICATIONS
The following publications can be ordered from Copenhagen and
Mechanicsburg after planned availability. To order, contact
your IBM representative or call 1-800-879-2755.
Title Order Number
Language Reference SC26-4769
Programming Guide SC26-8419
Getting Started GC26-8421
VSAM in a Distributed Environment SC26-7063
Data Description and Conversion SC26-7091
DD&C A Data Language Reference SC26-7092
SMARTsort for OS/2 and AIX SC26-7099
CONSULTING AND SERVICES
IBM will provide the following services, for an additional
charge, when the product becomes generally available:
APPLICATION DEVELOPMENT ENVIRONMENT ASSESSMENT
IBM consultants will assess the client's application development
environment and recommend plans to maximize effectiveness. IBM
consultants will also assess the client environment's readiness
to implement new technologies such as workstation development,
object-oriented COBOL, and/or client/server. An implementation
plan with recommendations is provided.
AD ENVIRONMENT ASSESSMENT: (IBM COBOL for MVS & VM)
Assess the client's capability to migrate to new technologies
such as workstation COBOL, object-oriented COBOL and/or
client/server.
COBOL MIGRATION ASSESSMENT: (IBM COBOL for MVS & VM)
Assist the client in planning a smooth migration from an IBM
legacy COBOL environment to one that takes advantage of new
technology found in the IBM COBOL family of products.
QUICK START: (IBM VisualAge for COBOL for OS/2)
Install and configure the development environment for the IBM
VisualAge for COBOL for OS/2 product and demonstrate the
functional capability of this product.
PROOF OF CONCEPT: (IBM COBOL for MVS & VM, IBM VisualAge for COBOL
for OS/2, IBM COBOL Set for AIX)
Design, develop and demonstrate a sample application using the
new IBM COBOL technology. An installation and rollout plan with
recommendations is provided.
MIGRATION SERVICES: (IBM COBOL for MVS & VM, IBM VisualAge for COBOL
for OS/2, IBM COBOL Set for AIX)
-- Leverage the experience of IBM's consultants to help ensure a
smooth migration to the IBM COBOL product, whether on the host
or on the workstation. On the 370/390 host platform, IBM will
provide assistance in migrating from down-level COBOL systems to
IBM COBOL for MVS & VM.
-- On the OS/2 platform, IBM will provide assistance in
migrating from Micro Focus** COBOL on OS/2 to IBM VisualAge for
COBOL for OS/2. This service will be available on a limited
basis at product availability. Micro Focus** COBOL applications
that are not compliant with existing COBOL ANSI standards may
not be eligible for this service.
-- On the AIX platform, similar migration services from Micro
Focus** COBOL on AIX to IBM COBOL Set for AIX will be available
on limited basis in late fourth quarter 1995. Micro Focus**
COBOL applications that are not compliant with existing COBOL
ANSI standards may not be eligible for this service.
CUSTOMIZED EDUCATION: (IBM COBOL for MVS & VM, IBM VisualAge
for COBOL for OS/2, IBM COBOL Set for AIX)
-- A customized training plan is derived from the client's
training requirements relative to a particular technology
transition. Customized education and knowledge transfer is
provided using experienced professionals, workshops and
consultants.
-- To receive a brochure containing more information on services
available for IBM's New COBOL Family, call 1 800 IBM-3333,
extension STAR 703. To arrange for an IBM representative to
discuss your specific COBOL service requirements, contact your
local IBM Marketing Representative or call 1- 800 IBM-4YOU.
** Trademark Micro Focus
DISPLAYABLE SOFTCOPY PUBLICATIONS:
-- IBM VisualAge for COBOL for OS/2 manuals are offered in
displayable softcopy form in INF format. The displayable
manuals are part of the basic machine-readable material. The
files are shipped on CD-ROM. Terms and conditions for use of the
machine-readable files are shipped with the files.
SOURCE FILE PUBLICATIONS:
-- IBM VisualAge for COBOL for OS/2 manuals are offered in
POSTSCRIPT format and INF format as part of the basic
machine-readable material. These files may be used to create
unmodified printed copies of the manuals. Terms and conditions
for use of the machine-readable files are shipped with the files.
EDUCATION SUPPORT
IBM will offer a new course to teach users about the new
object-oriented COBOL products. The class is called
Object-Oriented COBOL Programming Workshop.
This course is designed for the experienced COBOL programmer who
wishes to learn object-oriented programming in the COBOL
language. Through the use of lectures and hands-on lab
exercises, programmers learn to use the new object-oriented
COBOL syntax and to compile and run object-oriented COBOL
programs.
In addition to this new course, IBM will offer customized
education for the COBOL Solution family of products. For more
detailed information about available training, please call 1-800
IBM-TEACh.
You may request a free copy of the following announcement
letters from your IBM marketing representative, or by calling
1-800-IBM-3333, ask for extension STAR703:
IBM VisualAge for COBOL for OS/2 (295-453)
IBM COBOL for MVS & VM Release 2 (295-457)
IBM COBOL Set for AIX (295-452)
A Few Words from the OO Team
----------------------------------------
With the new release of IBM COBOL for MVS & VM, Version 1
Release 2, we are introducing object-oriented capability into
the COBOL language; this capability is also available on the
OS/2 and AIX platforms.
With this enhanced functionality you will be able to exploit the
benefits of object-oriented programming from a proven, robust,
business-oriented language. This is not a new language or new
compiler, but rather extensions built upon IBM's proven compiler
and runtime technologies.
The object-oriented language extensions provide a rich object
model that will allow you to write pure object-oriented
applications; however, since they are an extension to the base
COBOL language you will also be able to develop hybrid
applications which mix object-oriented and procedural
components. Thus you can move into the object-oriented world
either as quickly or gradually as you desire.
Another benefit of adding the object-oriented extensions to the
COBOL language is that you retain full access to existing COBOL
data and existing COBOL applications from your new
object-oriented applications.
COBOL's object-oriented support is based on IBM's System Object
Model (SOM) technology and allows for the direct creation of and
access to SOM objects via native COBOL language syntax. Through
this support COBOL programmers have access to the expanding set
of SOM-based frameworks.
The object-oriented language extensions include new class
definition syntax and a new INVOKE verb; these extensions are
based on a subset of the evolving new ISO and ANSI COBOL
standards.
Additional support includes features such as recursion, support
for long and mixed-case program names, object-oriented type
checking, and IDL generation. We encourage you to explore these
new features either as part of your new application development
or as part of enhancements to your existing applications.
IBM's NEW COBOL for MVS & VM (New Name for IBM COBOL/370 )
-----------------------------------------------------------------
IBM COBOL for MVS & VM revitalizes your dependable COBOL
applications by adding object-oriented language extensions.
COBOL for MVS & VM lets you create advanced client/server
applications when used with IBM VisualAge for COBOL for OS/2 or
IBM COBOL Set for AIX. Enhanced COBOL object-oriented language
is also available on the OS/2 and AIX platforms.
With COBOL for MVS & VM, you can use your existing skill base to
upgrade your applications and expand them to other platforms.
As a direct result, you will save money and increase
productivity by reducing the need to retrain your employees.
IBM COBOL for MVS & VM is an ideal, cost-effective solution that
offers the following enhancements to COBOL:
OBJECT - ORIENTED LANGUAGE EXTENSIONS
-- COBOL programmers can create objects in a language they
already know, reducing the long learning curve required
to learn a new object-oriented language.
-- Define and access System Object Model (SOM) objects directly
in COBOL syntax.
-- Object-oriented language extensions are a subset of the
evolving ISO and ANSI COBOL Standards.
CLIENT/SERVER ENABLERS
-- Run server COBOL programs on your host system that are
developed using IBM COBOL for MVS & VM with client
programs on IBM VisualAge for COBOL for OS/2 or IBM
COBOL Set for AIX.
-- Run production COBOL programs on your host with GUI
front-end COBOL code on OS/2.
-- Develop COBOL applications almost anywhere you want, and
then compile and run them anywhere you need them.
IMPROVED INTEROPERABILITY WITH C AND C++
-- Provides ability to pass parameters by value and to call C
functions that have function return values
-- Null-terminated literal strings can be used in COBOL and
passed to C routines
-- "Pragmaless" inter - language communications
IMPROVED PRODUCTIVITY AND EASE-OF-USE
-- A rich set of tools help you easily take advantage of
these COBOL enhancements
-- Complementary team-oriented tools allow your groups of
developers to coordinate their efforts
IBM COBOL for MVS & VM Release 2 features a mainframe
interactive debug tool. The debug tool allows programmers to
debug their applications as they are executing in their
native host environments. The mainframe interactive Debug Tool
is offered along with the COBOL compiler in a Full Function
Offering. An Alternate Function Offering is available for
customers who do not wish to receive the Debug Tool with this
product.
HIGHLIGHTS
IBM COBOL FOR MVS & VM:
Brings object-oriented programming to the MVS COBOL programmer
Enables COBOL access to existing SOM class libraries
Extends COBOL to the client/server environment
Improved interoperability with C and C++
Includes the mainframe interactive Debug Tool
COBOL programmers can create objects in a language they
already know, reducing the long learning curve required to learn
a new object-oriented language
Saves you time and money by:
-- Taking advantage of the current skill base in your organization
-- Preserving accessibility to your current COBOL-formatted data
Increases ease-of-use with a variety of development tools
DESCRIPTION
The IBM COBOL family is designed to provide a way to leverage
programmers' COBOL skills on to the client/server environment
with object-oriented capability, tools to support
existing and new COBOL applications, and visual GUI support.
Productivity gains are possible with the support of reuse
through object-oriented technology, the GUI Designer,
available with IBM VisualAge for COBOL for OS/2, and the
workbench tools.
With the new tools and object-oriented support these new COBOL
products contain, today's IBM COBOL programmer can realize
substantial productivity gains.
IBM COBOL for MVS & VM Release 2 brings object-oriented
programming to the MVS COBOL programmer. The Direct-to-SOM
compiler enables the creation of and access to SOM objects via
native COBOL language syntax (see SOMobjects (TM) for MVS U.S.
Software Announcement 294-637 dated October 4, 1994). SOM is a new
object-oriented technology for building and manipulating class
libraries. IBM COBOL programmers will be able to both access
and develop SOM class libraries with native COBOL syntax. This
capability also allows access to SOM objects implemented in
other languages, in addition to full interoperability with
existing COBOL applications and data.
The following new features of IBM COBOL for MVS & VM Release 2
are MVS specific:
- COBOL compiler with object-oriented language extensions based
on the evolving ISO and ANSI COBOL Standards.
- Support for the direct creation of SOM objects on the host via
native COBOL language syntax.
- Optional SOM IDL generation.
- Access to existing SOM-based class libraries.
The following new features and enhancements to IBM COBOL for MVS
& VM Release 2 are available on both MVS and VM:
- Improved interoperability with C and C++
- Source level compatibility with IBM VisualAge COBOL for OS/2
and IBM COBOL Set for AIX (except for platform-specific
language extensions)
- Source and object compatibility with IBM COBOL/370 and VS COBOL II
- Support for recursive calls
- Long and mixed case program names
- Performance enhancements.
For object-oriented applications, customers must also order
SOMobjects for MVS (5696-822).
IBM COBOL for MVS & VM Release 2 supports the high subset of
American National Standards Institute (ANSI) COBOL (ANSI
X3.23-1985) and International Standards Organization (ISO) COBOL
(ISO 1989:1985), as well as the Intrinsic Function Module for
COBOL (ANSI X3.23a-1989 and ISO 1989/Amendment 1). This product
meets the specifications of Federal Information Processing
Standards (FIPS) Publication 21-3 COBOL, and provides IBM
extensions to these standards.
MOVING THE HOST TO THE WORLD OF OBJECTS
Host-based COBOL moves to the leading edge of application
development productivity with the addition of object-oriented
technology to the MVS COBOL environment. Object-oriented
extensions let you encapsulate data and functions into objects
that can be re-used for other applications, rather than
developing new code.
The object-oriented language extensions in IBM COBOL for MVS &
VM (under MVS only) are based on the emerging ISO and ANSI COBOL
standards and are natural syntax extensions to COBOL -- not a
new language. These are the same object-oriented extensions you
get with IBM VisualAge for COBOL for OS/2 and IBM COBOL Set for
AIX, so you can develop object-oriented based host applications
on the desktop.
These extensions implement a complete object-oriented paradigm
that allows you to define object classes, instantiate objects
and have objects inherit characteristics from other classes of
objects.
You can use IBM's new COBOL products to create language-neutral
SOM objects that interoperate with objects created in other SOM
based object-oriented languages, ensuring the utility of your
objects for a long time to come. These products all feature
Direct-to-SOM capability.
The combination of object-oriented language extensions and SOM
class libraries provides an easy way to reuse code and develop
higher quality applications that can be ready for production in
less time.
SOLID PROGRAMMING SUPPORT
The IBM COBOL for MVS & VM compiler adds new function and builds
on previous functions.
The IBM COBOL for MVS & VM Release 2 compiler significantly
improves the interoperability between COBOL and C/C++. This
release provides users with the ability to pass parameters by
value and the ability to call C functions that have function
return values. Additionally, null terminated literal strings
can be used in COBOL and passed to C service routines. COBOL
now supports both defining and calling programs with long and
mixed-case names. Finally, calls between COBOL and C no longer
require special pragma source statements in the C program
("pragmaless" interlanguage communication).
IBM COBOL for MVS & VM also allows you to simplify common
programming tasks. For example, you can use the COBOL CALL
statement to take advantage of IBM Language Environment for MVS
& VM services for everything from storage management to
condition handling.
The condition handling support enables you to write programs in
which error handling is done in a separate routine that is
invoked only when needed. And you no longer have to write the
error-handling routines in Assembler; with Language Environment,
you can write them in COBOL.
IBM COBOL for MVS & VM is supported by IBM Language Environment
for MVS & VM Release 5, the common language environment for
running applications written in COBOL, PL/I, FORTRAN and C.
IBM Language Environment for MVS & VM thus allows you to enhance
an application written in COBOL by adding a FORTRAN routine or
Language Environment-enabled PL/I or C routine.
IBM COBOL for MVS & VM also offers support for recursive program
invocation in COBOL, structured programming language support,
improved interoperability with other languages, and improved
dynamic CALL performance.
These and many other features help make your COBOL development
more effective.
READY FOR THE YEAR 2000?
COBOL provides intrinsic functions that return and manipulate
four-digit 2 year dates.
For your applications that use two-digit year data, IBM COBOL
for MVS & VM and Language Environment for MVS & VM give you
efficient ways to accommodate the year 2000 with minimal changes
to code and no change to data. Language Environment for MVS &
VM can interpret a two-digit year as four-digits, allowing you
to use existing data without modification and allowing your
applications to run into the 21st century.
But don't wait until 1999. Prepare for the year 2000 today!
BRING YOUR HOST ENVIRONMENT UP TO SPEED
IBM COBOL for MVS & VM gives you an excellent migration path
from OS/VS COBOL and VS COBOL II. Most of your current programs
will continue to run without modification, while you selectively
update existing applications to take advantage of advanced
functions.
By migrating to IBM COBOL for MVS & VM, you get beyond the
24-bit addressing limitation and get virtual storage constraint
relief, which is of special interest to OS/VS COBOL users.
This improvement is important if you want to maximize the
efficiency of your host as an effective server.
SUBSYSTEMS AND DATABASES
IBM COBOL for MVS & VM Release 2 programs will run with DB2,
CICS, and IMS. Object-oriented COBOL programs will run with DB2
but will require an enabling PTF for DB2. This PTF will allow
EXEC SQL statements to be coded inside COBOL class definitions.
Object-oriented COBOL programs will run under CICS with some
restrictions. These programs may make calls to other programs
that contain an EXEC CICS statement and vice versa. However,
EXEC CICS statements cannot be directly used inside class
definitions at this time. Object-oriented COBOL programs will
run under IMS/ESA, with some special considerations.
MAINFRAME INTERACTIVE DEBUG TOOL OPTIONAL FEATURE
The mainframe interactive Debug Tool featured in IBM COBOL for
MVS & VM Release 2 will allow programmers to debug their
applications as they are executing in their native host
environment, such as CICS, IMS/ESA, and DB2. The Debug Tool
features functions such as step mode, breakpoints, monitor,
frequency analysis, and dynamic patching. It supports debugging
of procedural COBOL applications, as well as object-oriented
COBOL, PL/I and C/C++ applications.
The debug session may also be recorded in a log file, allowing
the programmer to replay the session. When used this way, the
Debug Tool might assist in capturing test cases for future
program validation or to further isolate a problem within an
application. This allows programmers to ensure that the
application is tested properly in the host environment before
the application is put into production.
The mainframe interactive Debug Tool is offered along with the
COBOL compiler in a Full Function Offering. An Alternate
Function Offering is available for customers who do not wish to
receive the Debug Tool with this product. The Full Function
offering of IBM C/C++ for MVS/ESA Version 3 and IBM PL/I for MVS
& VM V1R1.1, also contain the Debug Tool.
Existing CODE/370 Debug Tool users or users who currently have
the Full Function version of the PL/I or C/C++, can order an
upgrade that will provide the support for IBM COBOL for MVS & VM
Release 2 under their existing Debug Tool feature.
PART OF YOUR COMPLETE DEVELOPMENT ENVIRONMENT
IBM COBOL for MVS & VM is part of a large family of compatible
compilers, application development tools, and maintenance tools.
IBM offers solid IBM COBOL compilers for OS/2, AIX, VSE, and
AS/400, in addition to MVS and VM.
You can also take advantage of IBM's extensive suite of COBOL
maintenance tools to improve your existing applications. These
tools assist with source code conversion from older ANSI
standards to ANSI 1985 COBOL syntax; code analysis, reporting,
and restructuring; CICS macro-level source conversion; Report
Writer code support; testing; and parts cataloging.
IBM COBOL for MVS & VM provides the functionality needed to take
host programming into the future. For both existing and new
applications, this IBM COBOL package gives you powerful ways
to boost your programming productivity.
Faster/Better/Smaller LE!
-----------------------------
IBM Language Environment (R) for MVS & VM Release 5 continues to
provide a common set of services in a single run-time
environment.
Additional support for emerging application development
technologies such as object-oriented, distributed client/server,
and open standards simultaneously enhances the run-time
environment. IBM Language Environment for MVS & VM Release 5:
-- Adds run-time support for IBM COBOL for MVS & VM Release 2.
(IBM COBOL provides object-oriented COBOL language extensions
and client/server enablers.)
-- Below-the-line storage usage of Language Environment (LE)
Here is the good news! In Language Environment for MVS & VM
Version 1 Release 5, the amount of below-the-line storage has
been reduced significantly. This reduction was accomplished by
restructuring and moving some internal initialization routines
to above-the-line storage.
Storage used when running a minimal COBOL/370 program on MVS
with the IBM supplied defaults:
Below Above
------------ ------------
LE 1.3 1132K 156K
LE 1.4 552K 316K
LE 1.5 268K 928K
-------------------------------------------------
Language Environment was not able to completely move all these modules
above the line. This is primarily due to the current design of
Language Environment to support AMODE24 applications.
Enhances Language Environment's open capabilities with support
for XPG4 in OpenEdition (TM) MVS/ESA (TM), support for POSIX**
in OpenEdition for VM/ESA (R), and support for PL/I POSIX
toleration.
Offers FORTRAN compatibility support that allows object modules
produced by various FORTRAN compilers to be link-edited and run
under MVS with Language Environment. There are restrictions on
the use of some previously existing functions. With the
addition of FORTRAN compatibility support in Language
Environment, interlanguage communication (ILC) is possible, with
some restrictions, between FORTRAN routines compiled with any
of the supported FORTRAN compilers and C/C++, COBOL, or PL/I
routines.
Contains COBOL and FORTRAN support of VSAM Record Level Sharing
as well as enhancements for improved performance and storage
relief, particularly for C POSIX applications.
IBM Language Environment for MVS & VM Release 5 provides the
required run-time environment for applications generated with
the following high-level language products:
IBM COBOL for MVS & VM
IBM COBOL/370 (TM)
IBM C/C++ for MVS/ESA
IBM PL/I for MVS & VM
IBM SAA AD/Cycle C/370 (TM)
Refer to Software Announcement 295-457, dated October 24, 1995
for additional information on IBM COBOL for MVS & VM Release 2.
AVAILABILITY DATE: September 29, 1995
(R) Registered trademark of International Business Machines
Corporation
(TM) Trademark of International Business Machines Corporation
** Company, product, or service name may be a trademark or
service mark of others.
IBM's Host Debug Tool now with OO support!
-----------------------------------------------------
Are you interested in doing source level debugging with one of
the best kept secrets in the System/390 world? How about
debugging those JES batch jobs running in the background
interactively and being able to step through them as they
execute? You can also debug DB2 Stored Procedures. How about a
common user interface for all your debugging needs, whether it
be CICS, MVS/Batch, IMS, or DB/2 applications? Don't worry
about having to teach your programmers two or three different
tools. Best of all, you don't get charged for each
environment separately. You get all of this for one low price!
The MFI prices are only $120 to $732 per month (depending on
processor size.)
The Debug Tool allows you to debug the Language Environment for
MVS & VM (LE) versions of COBOL, PL/I and C/C++. Support is
included for several pre-LE versions of COBOL and PL/I as long
as the object is re-linked with the LE runtime libraries. That
provides an excellent migration tool for you as you consider
moving from older versions of those languages into the new world
of Language Environment.
In a frantic effort to increase programmer productivity, the
industry has seen new programming techniques and tools
introduced including the following:
- Object-Oriented Languages
- GUI Programming Interfaces
- Debug Tools
Of the three listed, debug tools have clearly received the least
attention. Yet there is no single tool that will provide a
greater and more immediate productivity increase for both
development and maintenance programmers.
The Debug Tool is available as an integrated Edit, Compile, and
Debug shell (CODE/370) or as a host debug-only feature of the
latest COBOL or object-oriented COBOL, PL/I and C/C++ compilers.
CODE/370 provides integrated tools for developing, porting, and
maintaining application programs. These facilities help
application programmers use their time effectively, while
protecting customer investments in current compiler technology.
Debug Tool provides facilities for debugging and testing
COBOL/370, C/370, and PL/I programs at a source level. By
running your application with the LE "TEST" option, you alert
Debug Tool that you may be requiring its service sometime during
the run of your application. You can bring it up at program
initialization and then step through your application as you
direct from the beginning, or provide some initial commands to
bring up the Debug Tool when a certain load module is loaded or
compile unit is entered. You can arrange to run your
application and invoke the Debug Tool dynamically when an error
condition occurs, for example, an error that would normally
cause an abend.
The Debug Tool displays a source level view of the point of
failure, and provides facilities for diagnosing and correcting
the problem. You can make adjustments and re-execute the code
that previously failed without leaving the debug session.
No longer do you have to spend hours analyzing dumps to figure
out where and why the application failed.
When the Debug Tool is running and the source or listing data
files are available, each instruction is highlighted as it is
executed. There are over 16 different ways (called
breakpoints) of stopping your application due to various
situations and having the Debug Tool step in to perform
diagnostic work for you.
For example, you have a variable that is getting overlaid by
someone but you can't figure out how. Simply set an "AT CHANGE
x" breakpoint on that variable and let Debug Tool stop execution
for you whenever the variable gets changed. Anytime you stop
with one of the breakpoints, you can provide a whole series of
commands for Debug Tool to execute to list variables, change
their values, or to set additional breakpoints. For COBOL and
C, you also have the capability of executing your own code
dynamically from the command line using the Debug Tool command
language.
As the programmer, you have control over how you want to use the
Debug Tool. The Debug Tool is available through a mainframe
interface terminal, such as an IBM 3270 terminal, or 3270
emulation (the MFI Debug Tool), or through the optional
edit/compile/debug programmable workstation environment (the PWS
Debug Tool). This workstation interface is only available when
ordered as a CODE/370 feature. When ordered via one of the LE
compilers, only the MFI interfaces is provided. It's your
choice.
Now, let's go over in just a bit more detail some of the
functionality that the Debug Tool provides for you:
Debugging in a host environment: Debug Tool lets you debug an
application as it is executed in the host environment (such as
CICS, IMS, or DB2). Debugging and testing occur in the
application's host environment. Your interface to the Debug
Tool can be host (3270) full screen or on an OS/2 (WARP)
workstation GUI. It's your choice, but regardless of which one
you select, it works for all your host environments.
Source level debug: You can monitor source code for C/370, or a
compiler listing for COBOL/370 or PL/I during program execution.
Single-step debugging: To focus on a problem area, you can step
line by line through the execution of an application. For
example, when an application stops for a breakpoint, you can
carefully examine each line that follows. Single-step debugging,
along with the ability to set dynamic breakpoints, allows you to
monitor, interrupt, and continue through the flow of the program
to identify errors easily.
Dynamic breakpoints: You can set breakpoints in an application
program, monitor variables for changes, and watch for specified
exceptions and conditions during program execution. For
example, you can arrange to have an application break when a
specific variable or location in storage is changed. You can
set, change, and remove breakpoints as you go through the
application. You do not need to know where you want to break
before you start.
Session logging: Each debug session can be logged in a file,
for editing or replaying. This allows you to replay the actions
taken in a session to pinpoint errors in an application.
Testing tool: The Debug Tool is a test tool in addition to
being an interactive and batch debug tool. By using the session
logging feature as you debug code, you save the results of your
session for use as input to a future Debug Tool session. As
your code becomes stable, you can begin building up suites of
testcase logs that are nothing more than a command stream of
Debug Tool commands that can be processed as if you were
entering the commands interactively from the display. The
resulting Debug Tool log can then be compared with a "golden"
copy to assure no code breakage has occurred as a result of
changes to your application.
The Debug Tool itself has been tested using this technique and
allows for a large regression bucket of testcases to be built
up over time. These testcases can be made available to
developers to run as changes are made. They act as a regression
test that can quickly identify code breakage when it occurs
during development as opposed to after it has been placed into
production.
Debug mixed-language programs: Along with Language Environment,
Debug Tool supports seamless debugging of mixed-language programs
on the System/390 platform. This includes applications written in
all three supported languages (COBOL, C/C++, and PL/I). Other
language modules, such as Assembler, cannot be debugged at the
source level but are tolerated if present.
Extensive command set: The Debug Tool has a rich command
language, part of which has the semantics of the language of the
compile unit currently being debugged. This takes advantage of
your language experience and makes you productive with the
product almost immediately. As mentioned earlier, this command
language allows you to write calls directly to your compiled
code. For example, if you are unit testing a subroutine, using
the command language you can repeatedly call a compiled routine
providing different values for input parameters and then listing
key variables to make sure the routine is working as designed,
all within one debugging session and without having to write
"scaffolding" code to put the routine through it's various paces.
You can use the commands to alter the value of variables and
structures as well as change the flow of control of the
application.
Program frequency: The Debug Tool can count each executable
statement and keep track of that over the course of the
application execution. This provides a mechanism to let you
know what code paths have been tested (and how often) during
that test run.
Program information: The Debug Tool can display program and
environment information. You can display, monitor, and alter
program variables or storage in real time. You can also check
how your application was compiled, and look at its structure.
The CODE/370 Debug Tool supports the following products. In
addition, the CODE/370 editor provides limited support for these
products:
IBM COBOL for MVS & VM Release 2
IBM COBOL/370 Version 1 Release 1
IBM VS COBOL II Version 1 Releases 3.1, 3.2, and 4.0
IBM C/C++ for MVS/ESA
IBM C/370 Version 1 Release 2
IBM PL/I for MVS & VM Version 1 Release 1
OS PL/I Version 2 Releases 1, 2, and 3
So, what are you waiting for?!? Get on board. Don't be the
last one on your block to experience the fun of debugging with
the IBM Debug Tool! Trust us. You'll get a lot of product for
a relatively low investment. Check it out.
Gimme Speed!
-----------------
IBM COBOL development has yet again improved the performance of
COBOL dynamic calls, and static calls as well, with Language
Environment for MVS & VM Release 5.
These improvements are outlined in the following chart: COBOL R2
= IBM COBOL for MVS & VM Release 2, and LE R4(5) = IBM Language
Environment for MVS & VM Release 4(5).
For MVS batch dynamic CALL Literal (e.g. CALL "sub1") see note 1.
COBOL R2 & LE R4 is 10% to 20% faster than VS COBOL II Rel 4.
COBOL R2 & LE R5 is 30% faster than VS COBOL II Rel 4.
For MVS batch dynamic CALL identifier (e.g. CALL sub1) see note 2.
COBOL R2 & LE R4 is 20% to 45% faster than VS COBOL II Rel 4.
COBOL R2 & LE R5 is 30% to 55% faster than VS COBOL II Rel 4.
For MVS batch static CALL literal (e.g. CALL "sub1") see note 2.
COBOL R2 & LE R4 is 20% to 25% faster than VS COBOL II Rel 4.
COBOL R2 & LE R5 is 30% to 35% faster than VS COBOL II Rel 4.
Note 1: The percentages represent the cpu time for the overhead
of calling from 1 up to 60 unique subprograms.
Note 2: The percentages represent the cpu time for the overhead
of calling from 1 up to 99 unique subprograms.
Report Writer - Big News!
------------------------------
Much has happened in recent years to report writer, both in the
forthcoming ANSI COBOL Standard and in product availability, and
some news of it is long overdue. Even if you haven't ever used
it, read on: you may be doing all your millennium printouts with it!
Report Writer in the Standard.
In the new ISO COBOL draft, report writer is back in the main
chapters rather than in an optional section. This draft is the
basis for the future ISO / ANSI COBOL '97 standard which has no
optional parts. In addition, ISO has re-written the report
writer definition in a more readable form and have extended the
facilities quite considerably. But for some slight syntax
changes, the current report writer product offers all these
features (see later) as well as preserving your investment in
older COBOL code.
The most notable of the many new capabilities in the Standard
are:
Tables: you can repeat lines and columns to print a table of
data items; the spacing can be regular or irregular; you can SUM
vertically and horizontally; Conditional items: you can code a
condition on any LINE or COLUMN to control what gets printed;
Variable columns: columns need not be in a fixed horizontal
position; (they can also be RIGHT or CENTER); Brevity: you can
skip much of the unneeded verbiage (PICTURE is assumed with
VALUE, COL stands for COLUMN, + for PLUS, and so on);
Behind-the-scenes checks: totals are checked for overflow,
columns for overlap.
Product news.
The COBOL Report Writer Precompiler has been available for MVS
and VM since 1986 and for VSE since 1991. The design of the
precompiler emphasizes retention of the report writer syntax
rather than permanent conversion.
In fact, recent releases can be invoked directly by the current
compilers for MVS, VM and VSE, so you get your object file and a
single listing in one step. (This is quite similar to the method
used by OS/VS COBOL and DOS/VS COBOL, except that their
"precompiler" was part of the compiler product.) The
precompiler still supports the ANS'68 syntax used in your older
source programs, but it is based on the ANSI'85 standard
supported by current IBM compilers, and can therefore take
advantage of their 31-bit addressing capability. In addition,
it anticipates the enhancements expected in the next standard
(see above) and adds some very pleasant extensions of its own,
including:
Print styles: you can take advantage of "underscoring" and other
features of the 3800 printer; 2-up, 3-up printing: you can print
whole blocks of lines side-by-side across the page;cascading
totals: you can define one control footing for several control
break levels; multiple-choice: you can specify several alternate
values or source items depending on different conditions;
variable-length items: you can "squeeze out" spaces or zeros from
print columns and display them in free format; new clauses: WRAP,
MULTIPLE PAGE, PRESENT AFTER NEW PAGE are fairly self-explanatory;
page buffer: you can "hold" each page while returning to earlier
lines; print file handlers: you can direct report output through
you own special software routines; user-written functions: you can
develop your own routines to access print items which have a special
format such as irregular dates or special access requirements such
as database or OO.
If you are a current user on MVS or VM, your current release is
1.4.0. On VSE, a new release 1.4.1 that runs with COBOL for VSE
is planned for later this year. They all have essential
maintenance updates. If you are not receiving these, please
contact the author (below) or your IBM technical rep.
If you are not a user, you could start by obtaining the
publications separately via your usual IBM publications ordering
hot-line, or ask your local rep about the products numbered
below.
Available publications:
Programmer's Manual SC26-4301
This is a very readable manual, with a gold-mine of useful
examples; it even incorporates a "Gentle Introduction" and a
diskette that performs a colorful and detailed presentation.
Installation and Operation for MVS/CMS SC26-4302. This
combines technical information on both these platforms.
Installation and Operation for VSE SC26-4864. This is needed
for VSE users in place of the above.
Product Numbers:
5798-DYR is the Precompiler and run-time Library. (Note: The
run-time library is not required if your source programs stay
within the ANS'68 or ANS'74 standards)
5798-DZX is the Library only for an additional run-time processor.
If you need any more information or have any difficulty in
obtaining any of the publications or product details, the author
will be glad to help at any of the following contact points:
Email: CPUSED6 at WINMVC or GBIBMJPG at IBMMAIL
Phone: 0181-540-8409 (in UK) or 206-725-7431 (call-forward in
US/Canada)
Fax: 0181-543-4408 (in UK)
Mail: SPC Systems Ltd., 69 Merton Hall Road, Wimbledon, London
SW19 3PX, UK. attn: John R. Piggott.
Go with the FLOW!
-----------------------
Do you miss the FLOW option of IBM's OS/VS COBOL? You can get
the same function using existing language in COBOL/370!
Check this out:
CONFIGURATION SECTION.
SOURCE-COMPUTER. IBM-370
WITH DEBUGGING MODE.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
DATA DIVISION.
FILE SECTION.
WORKING-STORAGE SECTION.
PROCEDURE DIVISION.
DECLARATIVES.
COBOL-DEBUG SECTION.
USE FOR DEBUGGING
ON ALL PROCEDURES.
COBOL-FLOW-PARA.
DISPLAY DEBUG-LINE
DEBUG-NAME.
END DECLARATIVES.
Or you could use an equivalent EXEC CICS statement, like this,
in place of your DISPLAY statement:
EXEC CICS WRITEQ TD QUEUE(CESE)
FROM(DEBUG-ITEM).
Add a SOURCE COMPUTER paragraph with the WITH
DEBUGGING MODE clause, and the single DECLARATIVE SECTION above,
and that's it for source changes! Direct your DISPLAY output to
SYSDBOUT(to mimic OS/VS COBOL) using the OUTDD(SYSDBOUT)
compiler option. (At execution you can use the MSGFILE run-time
option to do this as well.) At execution time, specify the
DEBUG run-time option, and you will get the same list of
executed procedures as you would have with OS/VS COBOL and the
FLOW compiler option! And with EXEC CICS WRITEQ you can get
FLOW-like output on CICS too!
Tips & Hints:
----------------
Some tips and hints for IBM VisualAge for COBOL for OS/2:
Before you get too involved in figuring out how that new
VisualAge COBOL product works, we thought you would appreciate
some helpful Hints and Tips from the development team. This
list is intended to make VisualAge COBOL work for you and do
make your work easier. This first series of VisualAge COBOL
Hints and Tips is designed for the first time users. Later
editions will reveal more details about the product once you
have had time to work with it.
Installation:
1. If you plan to install VisualAge COBOL on FAT drives, be
aware that FAT takes additional space for the catalog. If you
are attempting to install this product on a drive with just
enough bytes for the product you will probably run out of space
during the install. We recommend allowing 20% (or more) of the
space requested by the install program for FAT overhead. Also,
if this drive stores your SWAPPER.DAT file, be aware that the
swapper can grow during installation or if you are running other
applications while the install is executing. If you are
installing the product on an HPFS drive, the exact number of
bytes specified by the install is what will be used on your drive.
2. To avoid problems, make sure when the install program ends
that you pay attention to the messages. The product install is
not complete until you re-boot. During this re-boot, the final
steps of the install are completed and CONFIG.SYS changes are
activated. Make sure the messages all say successful. For more
information, the Getting Started book describes a file called
IWZINST.LOG, which contains all these install messages, in case
you miss them.
IBM VisualAge for COBOL for OS/2:
1. The concept of a project can be difficult to grasp the first
time. Let us just explain that as a default, our project actions
(the ones on the Project pull-down) are designed to support one
.CBL file and one executable (.DLL or .EXE) per project, which
may not work for your environment. You can set up your projects
as you wish for your needs. Just make sure you pay particular
attention to the Settings and the Tool Setup for your projects.
You also have the capability of creating your own MAKE files.
2. Another hint about projects, they are grouped into three main
types: GUI projects - projects that use the VisualAge COBOL GUI
Designer to generate Graphical User Interfaces; Non-GUI or COBOL
projects - a typical COBOL program (like the ones you have
written in the past); and if you install the Remote Edit/Compile
(Beta) components, you will get a third project type for
accessing applications residing on MVS.
3. It is impossible in this short space to talk about the entire
product. We suggest checking out the on-line documentation.
There is a lot of good information to be found by
double-clicking on the icons and folders for the Information
Notebook, Task Helper, README, and Books.
General:
1. For those of you interested in the Remote Edit/Compile (Beta)
component - you will need to have the Full Function feature of
the IBM COBOL for MVS & VM Release 2 (new name for IBM
COBOL/370) product installed on your host machine. In addition,
COBOL for MVS provides a Debug Tool to allow debugging on the
host. Another tip here: Getting all this to work will require
you to set up an APPC connection.
This collection of special hints and informative tips has been
gathered from our development team as we use and build the
product. Let us know what you think of these ideas. We would
also like to know any favorite tips you have that others would
appreciate. Please see the information at the end of this
newsletter for instructions on how to send us your favorites.
Survey and Address Information:
-----------------------------------------------------------------
We'd like to hear back from you regarding whether or not you
felt this newsletter was helpful. We also welcome articles
from customers for future newsletters. We have allowed space
for your comments and address information. This information
must be filled in and faxed to IBM at 408-463-2425 in order for
future releases of the newsletter to be mailed to you. If you
have done so already, you need not do so again. We hope you
have found this useful and we look forward to tailoring this
document to your needs in the future.
General Note:
IBM's VisualAge products and services are not associated with
or sponsored by Visual Edge Software, Ltd.
Comments:
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
Address Information:
Name: _______________________________
Company: ____________________________
Address1: ____________________________
Address2: ____________________________
Address3: ____________________________
State/Country _________________________
PostalCode: __________________________
Phone: ______________________________
Fax: ________________________________
ATTN: IBM Corporation
Team COBOL
Room E462
Ps. You can find the IBM COBOL Family on the World Wide Web by
starting at the IBM Software Home Page
(http://www.software.ibm.com), search on the keyword, GoCOBOL.